VirtualBox

Changeset 2557 in vbox for trunk/src/VBox/Devices/PC/BIOS


Ignore:
Timestamp:
May 9, 2007 1:03:02 PM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
21015
Message:

Fixed and simplified BIOS int15 mouse service. Avoids spurious
scancode generation.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/PC/BIOS/rombios.c

    r2535 r2557  
    890890static void           bios_printf();
    891891
    892 static Bit8u          inhibit_mouse_int_and_events();
    893 static void           enable_mouse_int_and_events();
    894892static Bit8u          send_to_mouse_ctrl();
    895893static Bit8u          get_mouse_data();
    … …  
    18231821
    18241822    /* send cmd: scan code convert, disable mouse, enable IRQ 1 */
    1825     outb(0x60, 0x61);
     1823    outb(0x60, 0x65);
    18261824
    18271825    /* Wait until buffer is empty */
    … …  
    40714069  Bit16u mouse_driver_seg;
    40724070  Bit16u mouse_driver_offset;
    4073   Bit8u  comm_byte, prev_command_byte;
     4071  Bit8u  mouse_cmd;
    40744072  Bit8u  ret, mouse_data1, mouse_data2, mouse_data3;
    40754073
    … …  
    40894087      // 80/86: mouse service not implemented
    40904088
     4089      if (regs.u.r8.al > 7) {
     4090BX_DEBUG_INT15("unsupported subfn\n");
     4091        // invalid function
     4092        SET_CF();
     4093        regs.u.r8.ah = 1;
     4094        break;
     4095      }
     4096
     4097      // Valid subfn; disable AUX input and IRQ12, assume no error
     4098      set_kbd_command_byte(0x65);
     4099      CLEAR_CF();
     4100      regs.u.r8.ah = 0;
     4101
    40914102      switch (regs.u.r8.al) {
    40924103        case 0: // Disable/Enable Mouse
    4093 BX_DEBUG_INT15("case 0:\n");
    4094           switch (regs.u.r8.bh) {
    4095             case 0: // Disable Mouse
    4096 BX_DEBUG_INT15("case 0: disable mouse\n");
    4097               inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    4098               ret = send_to_mouse_ctrl(0xF5); // disable mouse command
    4099               if (ret == 0) {
    4100                 ret = get_mouse_data(&mouse_data1);
    4101                 if ( (ret == 0) || (mouse_data1 == 0xFA) ) {
    4102                   CLEAR_CF();
    4103                   regs.u.r8.ah = 0;
    4104                   return;
    4105                   }
    4106                 }
    4107 
    4108               // error
    4109               SET_CF();
    4110               regs.u.r8.ah = ret;
    4111               return;
     4104BX_DEBUG_INT15("case 0: ");
     4105          if (regs.u.r8.bh > 1) {
     4106            BX_DEBUG_INT15("INT 15h C2 AL=0, BH=%02x\n", (unsigned) regs.u.r8.bh);
     4107            // invalid subfunction
     4108            SET_CF();
     4109            regs.u.r8.ah = 1;
     4110            break;
     4111          }
     4112          mouse_flags_2 = read_byte(ebda_seg, 0x0027);
     4113          if ( (mouse_flags_2 & 0x80) == 0 ) {
     4114            BX_DEBUG_INT15("INT 15h C2 Enable/Disable Mouse, no far call handler\n");
     4115            SET_CF();
     4116            regs.u.r8.ah = 5; // no far call installed
     4117            break;
     4118            }
     4119          if (regs.u.r8.bh == 0) {
     4120BX_DEBUG_INT15("Disable Mouse\n");
     4121            mouse_cmd = 0xF5;   // disable mouse command
     4122          } else {
     4123BX_DEBUG_INT15("Enable Mouse\n");
     4124            mouse_cmd = 0xF4;   // enable mouse command
     4125          }
     4126
     4127          ret = send_to_mouse_ctrl(mouse_cmd);  // disable mouse command
     4128          if (ret == 0) {
     4129            ret = get_mouse_data(&mouse_data1);
     4130            if ( (ret == 0) || (mouse_data1 == 0xFA) ) {
     4131              // success
    41124132              break;
    4113 
    4114             case 1: // Enable Mouse
    4115 BX_DEBUG_INT15("case 1: enable mouse\n");
    4116               mouse_flags_2 = read_byte(ebda_seg, 0x0027);
    4117               if ( (mouse_flags_2 & 0x80) == 0 ) {
    4118                 BX_DEBUG_INT15("INT 15h C2 Enable Mouse, no far call handler\n");
    4119                 SET_CF();  // error
    4120                 regs.u.r8.ah = 5; // no far call installed
    4121                 return;
    4122                 }
    4123               inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    4124               ret = send_to_mouse_ctrl(0xF4); // enable mouse command
    4125               if (ret == 0) {
    4126                 ret = get_mouse_data(&mouse_data1);
    4127                 if ( (ret == 0) && (mouse_data1 == 0xFA) ) {
    4128                   enable_mouse_int_and_events(); // turn IRQ12 and packet generation on
    4129                   CLEAR_CF();
    4130                   regs.u.r8.ah = 0;
    4131                   return;
    4132                   }
    4133                 }
    4134               SET_CF();
    4135               regs.u.r8.ah = ret;
    4136               return;
    4137 
    4138             default: // invalid subfunction
    4139               BX_DEBUG_INT15("INT 15h C2 AL=0, BH=%02x\n", (unsigned) regs.u.r8.bh);
    4140               SET_CF();  // error
    4141               regs.u.r8.ah = 1; // invalid subfunction
    4142               return;
     4133              }
    41434134            }
     4135
     4136          // interface error
     4137          SET_CF();
     4138          regs.u.r8.ah = 3;
    41444139          break;
    41454140
     4141        case 5: // Initialize Mouse
     4142          // Valid package sizes are 1 to 8
     4143          if ( (regs.u.r8.bh < 1) || (regs.u.r8.bh > 8) ) {
     4144            SET_CF();
     4145            regs.u.r8.ah = 2; // invalid input
     4146            break;
     4147          }
     4148          mouse_flags_2 = read_byte(ebda_seg, 0x0027);
     4149          mouse_flags_2 = (mouse_flags_2 & 0xf8) | (regs.u.r8.bh - 1);
     4150          write_byte(ebda_seg, 0x0027, mouse_flags_2);
     4151          // fall through!
     4152
    41464153        case 1: // Reset Mouse
    4147         case 5: // Initialize Mouse
    41484154BX_DEBUG_INT15("case 1 or 5:\n");
    4149           if (regs.u.r8.al == 5) {
    4150             if (regs.u.r8.bh != 3) {
    4151               SET_CF();
    4152               regs.u.r8.ah = 0x02; // invalid input
    4153               return;
    4154             }
    4155 #ifndef VBOX
    4156             mouse_flags_2 = read_byte(ebda_seg, 0x0027);
    4157             mouse_flags_2 = (mouse_flags_2 & 0x00) | regs.u.r8.bh;
    4158             mouse_flags_1 = 0x00;
    4159             write_byte(ebda_seg, 0x0026, mouse_flags_1);
    4160             write_byte(ebda_seg, 0x0027, mouse_flags_2);
    4161 #endif /* !VBOX */
    4162           }
    4163 
    4164           inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    4165 #ifdef VBOX
    4166           /* Moved here to eliminate the race with the IRQ12 handler
    4167            * concurrently accessing the EBDA values. It also makes no
    4168            * sense to reset the mouse and leave the mouse flags as is. */
    4169           mouse_flags_2 = read_byte(ebda_seg, 0x0027);
    4170           if (regs.u.r8.al == 5)
    4171             mouse_flags_2 = (mouse_flags_2 & 0x00) | regs.u.r8.bh;
    4172           mouse_flags_1 = 0x00;
     4155          // clear current package byte index
     4156          mouse_flags_1 = read_byte(ebda_seg, 0x0026);
     4157          mouse_flags_1 = mouse_flags_1 & 0xf8;
    41734158          write_byte(ebda_seg, 0x0026, mouse_flags_1);
    4174           write_byte(ebda_seg, 0x0027, mouse_flags_2);
    4175 #endif /* VBOX */
    41764159          ret = send_to_mouse_ctrl(0xFF); // reset mouse command
    41774160          if (ret == 0) {
    … …  
    41804163            if (mouse_data3 == 0xfe) {
    41814164              SET_CF();
    4182               return;
     4165              regs.u.r8.ah = 4; // resend
     4166              break;
    41834167            }
    41844168            if (mouse_data3 != 0xfa)
    … …  
    41894173                ret = get_mouse_data(&mouse_data2);
    41904174                if ( ret == 0 ) {
    4191                   // turn IRQ12 and packet generation on
    4192                   enable_mouse_int_and_events();
    4193                   CLEAR_CF();
    4194                   regs.u.r8.ah = 0;
     4175                  // success
    41954176                  regs.u.r8.bl = mouse_data1;
    41964177                  regs.u.r8.bh = mouse_data2;
    4197                   return;
     4178                  break;
    41984179                  }
    41994180                }
    … …  
    42014182            }
    42024183
    4203           // error
     4184          // interface error
    42044185          SET_CF();
    4205           regs.u.r8.ah = ret;
    4206           return;
     4186          regs.u.r8.ah = 3;
     4187          break;
    42074188
    42084189        case 2: // Set Sample Rate
    … …  
    42184199            default: mouse_data1 = 0;
    42194200          }
    4220 #ifdef VBOX
    4221           comm_byte = inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    4222 #endif /* VBOX */
    42234201          if (mouse_data1 > 0) {
    42244202            ret = send_to_mouse_ctrl(0xF3); // set sample rate command
    … …  
    42274205              ret = send_to_mouse_ctrl(mouse_data1);
    42284206              ret = get_mouse_data(&mouse_data2);
    4229               CLEAR_CF();
    4230               regs.u.r8.ah = 0;
     4207              // success
    42314208            } else {
    4232               // error
     4209              // interface error
    42334210              SET_CF();
    4234               regs.u.r8.ah = UNSUPPORTED_FUNCTION;
     4211              regs.u.r8.ah = 3;
    42354212            }
    42364213          } else {
    4237             // error
     4214            // invalid input
    42384215            SET_CF();
    4239             regs.u.r8.ah = UNSUPPORTED_FUNCTION;
     4216            regs.u.r8.ah = 2;
    42404217          }
    4241 #ifdef VBOX
    4242           set_kbd_command_byte(comm_byte); // restore IRQ12 and serial enable
    4243 #endif /* VBOX */
    42444218          break;
    42454219
    … …  
    42514225          //      2 = 100 dpi, 4 counts per millimeter
    42524226          //      3 = 200 dpi, 8 counts per millimeter
    4253 #ifdef VBOX
    4254           comm_byte = inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    42554227          if (regs.u.r8.bh < 4) {
    42564228            ret = send_to_mouse_ctrl(0xE8); // set resolution command
    … …  
    42634235              if (mouse_data1 != 0xfa)
    42644236                BX_PANIC("Mouse status returned %02x (should be ack)\n", (unsigned)mouse_data1);
    4265               CLEAR_CF();
    4266               regs.u.r8.ah = 0;
     4237              // success
    42674238            } else {
    4268               // error
     4239              // interface error
    42694240              SET_CF();
    4270               regs.u.r8.ah = UNSUPPORTED_FUNCTION;
     4241              regs.u.r8.ah = 3;
    42714242            }
    42724243          } else {
    4273             // error
     4244            // invalid input
    42744245            SET_CF();
    4275             regs.u.r8.ah = UNSUPPORTED_FUNCTION;
     4246            regs.u.r8.ah = 2;
    42764247          }
    4277           set_kbd_command_byte(comm_byte); // restore IRQ12 and serial enable
    4278 #else
    4279           CLEAR_CF();
    4280           regs.u.r8.ah = 0;
    4281 #endif /* VBOX */
    42824248          break;
    42834249
    42844250        case 4: // Get Device ID
    42854251BX_DEBUG_INT15("case 4:\n");
    4286 #ifdef VBOX
    4287           comm_byte = inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    4288 #else /* !VBOX */
    4289           inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    4290 #endif /* !VBOX */
    42914252          ret = send_to_mouse_ctrl(0xF2); // get mouse ID command
    42924253          if (ret == 0) {
    42934254            ret = get_mouse_data(&mouse_data1);
    42944255            ret = get_mouse_data(&mouse_data2);
    4295             CLEAR_CF();
    4296             regs.u.r8.ah = 0;
    42974256            regs.u.r8.bh = mouse_data2;
     4257            // success
    42984258          } else {
    4299             // error
     4259            // interface error
    43004260            SET_CF();
    4301             regs.u.r8.ah = UNSUPPORTED_FUNCTION;
     4261            regs.u.r8.ah = 3;
    43024262          }
    4303 #ifdef VBOX
    4304           set_kbd_command_byte(comm_byte); // restore IRQ12 and serial enable
    4305 #endif /* VBOX */
    43064263          break;
    43074264
    … …  
    43104267          switch (regs.u.r8.bh) {
    43114268            case 0: // Return Status
    4312               comm_byte = inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    43134269              ret = send_to_mouse_ctrl(0xE9); // get mouse info command
    43144270              if (ret == 0) {
    … …  
    43234279                      ret = get_mouse_data(&mouse_data3);
    43244280                      if ( ret == 0 ) {
    4325                         CLEAR_CF();
    4326                         regs.u.r8.ah = 0;
    43274281                        regs.u.r8.bl = mouse_data1;
    43284282                        regs.u.r8.cl = mouse_data2;
    43294283                        regs.u.r8.dl = mouse_data3;
    4330                         set_kbd_command_byte(comm_byte); // restore IRQ12 and serial enable
    4331                         return;
     4284                        // success
     4285                        break;
    43324286                        }
    43334287                      }
    … …  
    43364290                }
    43374291
    4338               // error
     4292              // interface error
    43394293              SET_CF();
    4340               regs.u.r8.ah = ret;
    4341               set_kbd_command_byte(comm_byte); // restore IRQ12 and serial enable
    4342               return;
     4294              regs.u.r8.ah = 3;
     4295              break;
    43434296
    43444297            case 1: // Set Scaling Factor to 1:1
    43454298            case 2: // Set Scaling Factor to 2:1
    4346               comm_byte = inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    43474299              if (regs.u.r8.bh == 1) {
    43484300                ret = send_to_mouse_ctrl(0xE6);
    … …  
    43544306                ret = (mouse_data1 != 0xFA);
    43554307              }
    4356               if (ret == 0) {
    4357                 CLEAR_CF();
    4358                 regs.u.r8.ah = 0;
    4359               } else {
    4360                 // error
     4308              if (ret != 0) {
     4309                // interface error
    43614310                SET_CF();
    4362                 regs.u.r8.ah = UNSUPPORTED_FUNCTION;
     4311                regs.u.r8.ah = 3;
    43634312              }
    4364               set_kbd_command_byte(comm_byte); // restore IRQ12 and serial enable
    43654313              break;
    43664314
    43674315            default:
    43684316              BX_PANIC("INT 15h C2 AL=6, BH=%02x\n", (unsigned) regs.u.r8.bh);
     4317              // invalid subfunction
     4318              SET_CF();
     4319              regs.u.r8.ah = 1;
    43694320            }
    43704321          break;
    … …  
    43814332            if ( (mouse_flags_2 & 0x80) != 0 ) {
    43824333              mouse_flags_2 &= ~0x80;
    4383               inhibit_mouse_int_and_events(); // disable IRQ12 and packets
    43844334              }
    43854335            }
    … …  
    43894339            }
    43904340          write_byte(ebda_seg, 0x0027, mouse_flags_2);
    4391           CLEAR_CF();
    4392           regs.u.r8.ah = 0;
    43934341          break;
    43944342
    43954343        default:
    4396 BX_DEBUG_INT15("case default:\n");
    4397           regs.u.r8.ah = 1; // invalid function
     4344          BX_PANIC("INT 15h C2 default case entered\n");
     4345          // invalid subfunction
    43984346          SET_CF();
     4347          regs.u.r8.ah = 1;
    43994348        }
     4349BX_DEBUG_INT15("returning cf = %u, ah = %02x\n", (unsigned)GET_CF(), (unsigned)regs.u.r8.ah);
     4350      // Re-enable AUX input and IRQ12
     4351      set_kbd_command_byte(0x47);
    44004352      break;
    44014353
    … …  
    48354787
    48364788  Bit8u
    4837 inhibit_mouse_int_and_events()
    4838 {
    4839   Bit8u command_byte, prev_command_byte;
    4840 
    4841   // Turn off IRQ generation and aux data line
    4842   if ( inb(0x64) & 0x02 )
    4843     BX_PANIC(panic_msg_keyb_buffer_full,"inhibmouse");
    4844   outb(0x64, 0x20); // get command byte
    4845   while ( (inb(0x64) & 0x01) != 0x01 );
    4846   prev_command_byte = inb(0x60);
    4847   command_byte = prev_command_byte;
    4848   //while ( (inb(0x64) & 0x02) );
    4849   if ( inb(0x64) & 0x02 )
    4850     BX_PANIC(panic_msg_keyb_buffer_full,"inhibmouse");
    4851   command_byte &= 0xfd; // turn off IRQ 12 generation
    4852   command_byte |= 0x20; // disable mouse serial clock line
    4853   outb(0x64, 0x60); // write command byte
    4854   outb(0x60, command_byte);
    4855   return(prev_command_byte);
    4856 }
    4857 
    4858   void
    4859 enable_mouse_int_and_events()
    4860 {
    4861   Bit8u command_byte;
    4862 
    4863   // Turn on IRQ generation and aux data line
    4864   if ( inb(0x64) & 0x02 )
    4865     BX_PANIC(panic_msg_keyb_buffer_full,"enabmouse");
    4866   outb(0x64, 0x20); // get command byte
    4867   while ( (inb(0x64) & 0x01) != 0x01 );
    4868   command_byte = inb(0x60);
    4869   //while ( (inb(0x64) & 0x02) );
    4870   if ( inb(0x64) & 0x02 )
    4871     BX_PANIC(panic_msg_keyb_buffer_full,"enabmouse");
    4872   command_byte |= 0x02; // turn on IRQ 12 generation
    4873   command_byte &= 0xdf; // enable mouse serial clock line
    4874   outb(0x64, 0x60); // write command byte
    4875   outb(0x60, command_byte);
    4876 }
    4877 
    4878   Bit8u
    48794789send_to_mouse_ctrl(sendbyte)
    48804790  Bit8u sendbyte;
    … …  
    49144824  if ( inb(0x64) & 0x02 )
    49154825    BX_PANIC(panic_msg_keyb_buffer_full,"setkbdcomm");
    4916   outb(0x64, 0xD4);
    49174826
    49184827  outb(0x64, 0x60); // write command byte
    … …  
    51665075  write_byte(ebda_seg, 0x28 + index, in_byte);
    51675076
    5168   if ( (index+1) >= package_count ) {
     5077  if ( index >= package_count ) {
    51695078BX_DEBUG_INT74("int74_function: make_farcall=1\n");
    51705079    status = read_byte(ebda_seg, 0x0028 + 0);
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette