qemu/roms/seabios/src/mouse.c

   1 // 16bit code to handle mouse events.
   2 //
   3 // Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
   4 // Copyright (C) 2002  MandrakeSoft S.A.
   5 //
   6 // This file may be distributed under the terms of the GNU LGPLv3 license.
   7
   8 #include "biosvar.h" // GET_EBDA
   9 #include "bregs.h" // struct bregs
  10 #include "hw/ps2port.h" // ps2_mouse_command
  11 #include "hw/usb-hid.h" // usb_mouse_command
  12 #include "output.h" // dprintf
  13 #include "stacks.h" // stack_hop_back
  14 #include "util.h" // mouse_init
  15
  16 void
  17 mouse_init(void)
  18 {
  19     if (! CONFIG_MOUSE)
  20         return;
  21     dprintf(3, "init mouse\n");
  22     // pointing device installed
  23     set_equipment_flags(0x04, 0x04);
  24 }
  25
  26 static int
  27 mouse_command(int command, u8 *param)
  28 {
  29     if (usb_mouse_active())
  30         return usb_mouse_command(command, param);
  31     return ps2_mouse_command(command, param);
  32 }
  33
  34 #define RET_SUCCESS      0x00
  35 #define RET_EINVFUNCTION 0x01
  36 #define RET_EINVINPUT    0x02
  37 #define RET_EINTERFACE   0x03
  38 #define RET_ENEEDRESEND  0x04
  39 #define RET_ENOHANDLER   0x05
  40
  41 // Disable Mouse
  42 static void
  43 mouse_15c20000(struct bregs *regs)
  44 {
  45     int ret = mouse_command(PSMOUSE_CMD_DISABLE, NULL);
  46     if (ret)
  47         set_code_invalid(regs, RET_ENEEDRESEND);
  48     else
  49         set_code_success(regs);
  50 }
  51
  52 // Enable Mouse
  53 static void
  54 mouse_15c20001(struct bregs *regs)
  55 {
  56     u16 ebda_seg = get_ebda_seg();
  57     u8 mouse_flags_2 = GET_EBDA(ebda_seg, mouse_flag2);
  58     if ((mouse_flags_2 & 0x80) == 0) {
  59         set_code_invalid(regs, RET_ENOHANDLER);
  60         return;
  61     }
  62
  63     int ret = mouse_command(PSMOUSE_CMD_ENABLE, NULL);
  64     if (ret)
  65         set_code_invalid(regs, RET_ENEEDRESEND);
  66     else
  67         set_code_success(regs);
  68 }
  69
  70 static void
  71 mouse_15c200XX(struct bregs *regs)
  72 {
  73     set_code_unimplemented(regs, RET_EINVFUNCTION);
  74 }
  75
  76 // Disable/Enable Mouse
  77 static void
  78 mouse_15c200(struct bregs *regs)
  79 {
  80     switch (regs->bh) {
  81     case 0x00: mouse_15c20000(regs); break;
  82     case 0x01: mouse_15c20001(regs); break;
  83     default:   mouse_15c200XX(regs); break;
  84     }
  85 }
  86
  87 // Reset Mouse
  88 static void
  89 mouse_15c201(struct bregs *regs)
  90 {
  91     u8 param[2];
  92     int ret = mouse_command(PSMOUSE_CMD_RESET_BAT, param);
  93     if (ret) {
  94         set_code_invalid(regs, RET_ENEEDRESEND);
  95         return;
  96     }
  97     regs->bl = param[0];
  98     regs->bh = param[1];
  99     set_code_success(regs);
 100 }
 101
 102 // Set Sample Rate
 103 static void
 104 mouse_15c202(struct bregs *regs)
 105 {
 106     static u8 VAR16 sample_rates[7] = {10, 20, 40, 60, 80, 100, 200};
 107     if (regs->bh >= ARRAY_SIZE(sample_rates)) {
 108         set_code_invalid(regs, RET_EINVINPUT);
 109         return;
 110     }
 111     u8 mouse_data1 = GET_GLOBAL(sample_rates[regs->bh]);
 112     int ret = mouse_command(PSMOUSE_CMD_SETRATE, &mouse_data1);
 113     if (ret)
 114         set_code_invalid(regs, RET_ENEEDRESEND);
 115     else
 116         set_code_success(regs);
 117 }
 118
 119 // Set Resolution
 120 static void
 121 mouse_15c203(struct bregs *regs)
 122 {
 123     // BH:
 124     //      0 =  25 dpi, 1 count  per millimeter
 125     //      1 =  50 dpi, 2 counts per millimeter
 126     //      2 = 100 dpi, 4 counts per millimeter
 127     //      3 = 200 dpi, 8 counts per millimeter
 128     if (regs->bh >= 4) {
 129         set_code_invalid(regs, RET_EINVINPUT);
 130         return;
 131     }
 132     u8 param = regs->bh;
 133     int ret = mouse_command(PSMOUSE_CMD_SETRES, &param);
 134     if (ret)
 135         set_code_invalid(regs, RET_ENEEDRESEND);
 136     else
 137         set_code_success(regs);
 138 }
 139
 140 // Get Device ID
 141 static void
 142 mouse_15c204(struct bregs *regs)
 143 {
 144     u8 param[2];
 145     int ret = mouse_command(PSMOUSE_CMD_GETID, param);
 146     if (ret) {
 147         set_code_invalid(regs, RET_ENEEDRESEND);
 148         return;
 149     }
 150     regs->bh = param[0];
 151     set_code_success(regs);
 152 }
 153
 154 // Initialize Mouse
 155 static void
 156 mouse_15c205(struct bregs *regs)
 157 {
 158     if (regs->bh != 3) {
 159         set_code_invalid(regs, RET_EINTERFACE);
 160         return;
 161     }
 162     u16 ebda_seg = get_ebda_seg();
 163     SET_EBDA(ebda_seg, mouse_flag1, 0x00);
 164     SET_EBDA(ebda_seg, mouse_flag2, regs->bh);
 165
 166     // Reset Mouse
 167     mouse_15c201(regs);
 168 }
 169
 170 // Return Status
 171 static void
 172 mouse_15c20600(struct bregs *regs)
 173 {
 174     u8 param[3];
 175     int ret = mouse_command(PSMOUSE_CMD_GETINFO, param);
 176     if (ret) {
 177         set_code_invalid(regs, RET_ENEEDRESEND);
 178         return;
 179     }
 180     regs->bl = param[0];
 181     regs->cl = param[1];
 182     regs->dl = param[2];
 183     set_code_success(regs);
 184 }
 185
 186 // Set Scaling Factor to 1:1
 187 static void
 188 mouse_15c20601(struct bregs *regs)
 189 {
 190     int ret = mouse_command(PSMOUSE_CMD_SETSCALE11, NULL);
 191     if (ret)
 192         set_code_invalid(regs, RET_ENEEDRESEND);
 193     else
 194         set_code_success(regs);
 195 }
 196
 197 // Set Scaling Factor to 2:1
 198 static void
 199 mouse_15c20602(struct bregs *regs)
 200 {
 201     int ret = mouse_command(PSMOUSE_CMD_SETSCALE21, NULL);
 202     if (ret)
 203         set_code_invalid(regs, RET_ENEEDRESEND);
 204     else
 205         set_code_success(regs);
 206 }
 207
 208 static void
 209 mouse_15c206XX(struct bregs *regs)
 210 {
 211     set_code_unimplemented(regs, RET_EINVFUNCTION);
 212 }
 213
 214 // Return Status & Set Scaling Factor...
 215 static void
 216 mouse_15c206(struct bregs *regs)
 217 {
 218     switch (regs->bh) {
 219     case 0x00: mouse_15c20600(regs); break;
 220     case 0x01: mouse_15c20601(regs); break;
 221     case 0x02: mouse_15c20602(regs); break;
 222     default:   mouse_15c206XX(regs); break;
 223     }
 224 }
 225
 226 // Set Mouse Handler Address
 227 static void
 228 mouse_15c207(struct bregs *regs)
 229 {
 230     struct segoff_s farptr = SEGOFF(regs->es, regs->bx);
 231     u16 ebda_seg = get_ebda_seg();
 232     u8 mouse_flags_2 = GET_EBDA(ebda_seg, mouse_flag2);
 233     if (! farptr.segoff) {
 234         /* remove handler */
 235         if ((mouse_flags_2 & 0x80) != 0) {
 236             mouse_flags_2 &= ~0x80;
 237             mouse_command(PSMOUSE_CMD_DISABLE, NULL);
 238         }
 239     } else {
 240         /* install handler */
 241         mouse_flags_2 |= 0x80;
 242     }
 243     SET_EBDA(ebda_seg, mouse_flag2, mouse_flags_2);
 244     SET_EBDA(ebda_seg, far_call_pointer, farptr);
 245     set_code_success(regs);
 246 }
 247
 248 static void
 249 mouse_15c2XX(struct bregs *regs)
 250 {
 251     set_code_unimplemented(regs, RET_EINVFUNCTION);
 252 }
 253
 254 void
 255 handle_15c2(struct bregs *regs)
 256 {
 257     //debug_stub(regs);
 258
 259     if (! CONFIG_MOUSE) {
 260         set_code_invalid(regs, RET_EUNSUPPORTED);
 261         return;
 262     }
 263
 264     switch (regs->al) {
 265     case 0x00: mouse_15c200(regs); break;
 266     case 0x01: mouse_15c201(regs); break;
 267     case 0x02: mouse_15c202(regs); break;
 268     case 0x03: mouse_15c203(regs); break;
 269     case 0x04: mouse_15c204(regs); break;
 270     case 0x05: mouse_15c205(regs); break;
 271     case 0x06: mouse_15c206(regs); break;
 272     case 0x07: mouse_15c207(regs); break;
 273     default:   mouse_15c2XX(regs); break;
 274     }
 275 }
 276
 277 void VISIBLE16
 278 invoke_mouse_handler(void)
 279 {
 280     if (!CONFIG_MOUSE)
 281         return;
 282     if (need_hop_back()) {
 283         extern void _cfunc16_invoke_mouse_handler(void);
 284         stack_hop_back(0, 0, _cfunc16_invoke_mouse_handler);
 285         return;
 286     }
 287     ASSERT16();
 288     u16 ebda_seg = get_ebda_seg();
 289     u16 status = GET_EBDA(ebda_seg, mouse_data[0]);
 290     u16 X      = GET_EBDA(ebda_seg, mouse_data[1]);
 291     u16 Y      = GET_EBDA(ebda_seg, mouse_data[2]);
 292
 293     struct segoff_s func = GET_EBDA(ebda_seg, far_call_pointer);
 294     dprintf(16, "mouse farcall s=%04x x=%04x y=%04x func=%04x:%04x\n"
 295             , status, X, Y, func.seg, func.offset);
 296
 297     asm volatile(
 298         "pushl %%ebp\n"
 299         "sti\n"
 300
 301         "pushl %0\n"
 302         "pushw %w1\n"  // status
 303         "pushw %w2\n"  // X
 304         "pushw %w3\n"  // Y
 305         "pushw $0\n"   // Z
 306         "lcallw *8(%%esp)\n"
 307         "addl $12, %%esp\n"
 308
 309         "cli\n"
 310         "cld\n"
 311         "popl %%ebp"
 312         : "+a"(func.segoff), "+c"(status), "+d"(X), "+b"(Y)
 313         :
 314         : "edi", "esi", "cc", "memory");
 315 }
 316
 317 void
 318 process_mouse(u8 data)
 319 {
 320     if (!CONFIG_MOUSE)
 321         return;
 322
 323     u16 ebda_seg = get_ebda_seg();
 324     u8 mouse_flags_1 = GET_EBDA(ebda_seg, mouse_flag1);
 325     u8 mouse_flags_2 = GET_EBDA(ebda_seg, mouse_flag2);
 326
 327     if (! (mouse_flags_2 & 0x80))
 328         // far call handler not installed
 329         return;
 330
 331     u8 package_count = mouse_flags_2 & 0x07;
 332     u8 index = mouse_flags_1 & 0x07;
 333     SET_EBDA(ebda_seg, mouse_data[index], data);
 334
 335     if ((index+1) < package_count) {
 336         mouse_flags_1++;
 337         SET_EBDA(ebda_seg, mouse_flag1, mouse_flags_1);
 338         return;
 339     }
 340
 341     SET_EBDA(ebda_seg, mouse_flag1, 0);
 342     invoke_mouse_handler();
 343 }