arch/i386-pc/drivers/mouse.hidd/drv_ps2.c

   1 /*
   2     Copyright © 1995-2010, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: PS/2 mouse driver.
   6     Lang: English.
   7 */
   8
   9 /****************************************************************************************/
  10
  11 #include <asm/speaker.h>
  12 #include <proto/exec.h>
  13 #include <proto/utility.h>
  14 #include <proto/oop.h>
  15 #include <oop/oop.h>
  16
  17 #include <exec/alerts.h>
  18 #include <exec/memory.h>
  19
  20 #include <hidd/hidd.h>
  21 #include <hidd/mouse.h>
  22 #include <devices/inputevent.h>
  23
  24 #include <SDI/SDI_interrupt.h>
  25
  26 #include "mouse.h"
  27
  28 #define DEBUG 0
  29 #include <aros/debug.h>
  30
  31 /****************************************************************************************/
  32
  33 #ifdef HiddMouseAB
  34 #undef HiddMouseAB
  35 #endif
  36 #define HiddMouseAB     (MSD(cl)->hiddMouseAB)
  37
  38 /* defines for buttonstate */
  39
  40 #define LEFT_BUTTON     1
  41 #define RIGHT_BUTTON    2
  42 #define MIDDLE_BUTTON   4
  43
  44 /****************************************************************************************/
  45
  46 #define TIMER_RPROK 3599597124UL
  47
  48 int mouse_wait_for_input(void);
  49
  50 /****************************************************************************************/
  51
  52 int mouse_ps2reset(struct mouse_data *);
  53
  54 /****************************************************************************************/
  55
  56 static ULONG usec2tick(ULONG usec)
  57 {
  58     ULONG ret;
  59     ULONG prok = TIMER_RPROK;
  60     asm volatile("movl $0,%%eax; divl %2":"=a"(ret):"d"(usec),"m"(prok));
  61     return ret;
  62 }
  63
  64 static void mouse_usleep(LONG usec)
  65 {
  66     int oldtick, tick;
  67     usec = usec2tick(usec);
  68
  69     outb(0x80, 0x43);
  70     oldtick = inb(0x42);
  71     oldtick += inb(0x42) << 8;
  72
  73     while (usec > 0)
  74     {
  75         outb(0x80, 0x43);
  76         tick = inb(0x42);
  77         tick += inb(0x42) << 8;
  78
  79         usec -= (oldtick - tick);
  80         if (tick > oldtick) usec -= 0x10000;
  81         oldtick = tick;
  82     }
  83 }
  84
  85 unsigned char handle_mouse_event(void)
  86 {
  87     unsigned char status = mouse_read_status();
  88     unsigned int work = 10000;
  89
  90     while (status & KBD_STATUS_OBF)
  91     {
  92         mouse_read_input();
  93
  94         status = mouse_read_status();
  95         if(!work--)
  96         {
  97             //printf(KERN_ERR "pc_keyb: controller jammed (0x%02X).\n",status);
  98             break;
  99         }
 100     }
 101     return status;
 102 }
 103
 104 /*
 105  * Wait until we can write to a peripheral again. Any input that comes in
 106  * while we're waiting is discarded.
 107  */
 108 void mouse_wait(void)
 109 {
 110     ULONG timeout = 1000; /* 1 sec should be enough */
 111
 112     do
 113     {
 114         unsigned char status = handle_mouse_event();
 115         if (! (status & KBD_STATUS_IBF))
 116             return;
 117
 118         mouse_usleep(1000);
 119         timeout--;
 120     } while (timeout);
 121 }
 122
 123 void mouse_write_cmd(int cmd)
 124 {
 125     mouse_wait();
 126     mouse_write_command(KBD_CTRLCMD_WRITE_MODE);
 127     mouse_wait();
 128     mouse_write_output(cmd);
 129 }
 130
 131 void mouse_write_ack(int val)
 132 {
 133     mouse_wait();
 134     mouse_write_command(KBD_CTRLCMD_WRITE_MOUSE);
 135     mouse_wait();
 136     mouse_write_output(val);
 137     mouse_wait_for_input();
 138 }
 139
 140 void mouse_write_noack(int val)
 141 {
 142     mouse_wait();
 143     mouse_write_command(KBD_CTRLCMD_WRITE_MOUSE);
 144     mouse_wait();
 145     mouse_write_output(val);
 146 }
 147
 148 void mouse_write_output_w(int data)
 149 {
 150     mouse_wait();
 151     mouse_write_output(data);
 152 }
 153
 154 void mouse_write_command_w(int data)
 155 {
 156     mouse_wait();
 157     mouse_write_command(data);
 158 }
 159
 160 #define KBD_NO_DATA     (-1)
 161 #define KBD_BAD_DATA    (-2)
 162
 163 int mouse_read_data(void)
 164 {
 165     LONG        retval = KBD_NO_DATA;
 166     UBYTE       status;
 167
 168     status = mouse_read_status();
 169     if (status & KBD_STATUS_OBF)
 170     {
 171         UBYTE   data = mouse_read_input();
 172
 173         retval = data;
 174         if (status & (KBD_STATUS_GTO | KBD_STATUS_PERR))
 175             retval = KBD_BAD_DATA;
 176     }
 177
 178     return retval;
 179 }
 180
 181 int mouse_clear_input(void)
 182 {
 183     int maxread = 100, code, lastcode = KBD_NO_DATA;
 184     UBYTE status;
 185
 186     do
 187     {
 188         status = mouse_read_status();
 189         if ((code = mouse_read_data()) == KBD_NO_DATA)
 190             break;
 191         if (!(status & KBD_STATUS_MOUSE_OBF))
 192             lastcode = code;
 193     } while (--maxread);
 194
 195     return lastcode;
 196 }
 197
 198 int mouse_wait_for_input(void)
 199 {
 200     ULONG timeout = 1000;
 201
 202     do
 203     {
 204         int retval = mouse_read_data();
 205         if (retval >= 0)
 206             return retval;
 207         mouse_usleep(1000);
 208     } while(--timeout);
 209     return -1;
 210 }
 211
 212 /****************************************************************************************/
 213
 214 AROS_INTH1(mouse_ps2int,struct mouse_data *, data)
 215 {
 216     AROS_INTFUNC_INIT
 217
 218     struct pHidd_Mouse_Event    *e = &data->u.ps2.event;
 219     UWORD                       buttonstate;
 220     WORD                        work = 10000;
 221     UBYTE                       info, mousecode, *mouse_data;
 222
 223     info = mouse_read_status();
 224
 225     for(; ((info = mouse_read_status()) & KBD_STATUS_OBF) && work; work--)
 226     {
 227         if (!(info & KBD_STATUS_MOUSE_OBF))
 228         {
 229             /*
 230             ** Data from keyboard. Hopefully this gets through to keyboard interrupt
 231             ** if we break out of for loop here :-\
 232             */
 233             break;
 234         }
 235
 236         mousecode = mouse_read_input();
 237
 238         if (info & (KBD_STATUS_GTO | KBD_STATUS_PERR))
 239         {
 240             /* Ignore errors and messages for keyboard -> eat status/error byte */
 241             continue;
 242         }
 243
 244         /* Mouse Packet Byte */
 245
 246         mouse_data = data->u.ps2.mouse_data;
 247
 248         data->u.ps2.expected_mouse_acks = 0;
 249         mouse_data[data->u.ps2.mouse_collected_bytes] = mousecode;
 250
 251         /* Packet validity check. Bit 3 of first mouse packet byte must be set */
 252
 253         if ((mouse_data[0] & 8) == 0)
 254         {
 255             data->u.ps2.mouse_collected_bytes = 0;
 256             continue;
 257         }
 258
 259         data->u.ps2.mouse_collected_bytes++;
 260
 261         if (data->u.ps2.mouse_collected_bytes != data->u.ps2.mouse_packetsize)
 262         {
 263             /* Mouse Packet not yet complete */
 264             continue;
 265         }
 266
 267         /* We have a complete mouse packet :-) */
 268
 269         data->u.ps2.mouse_collected_bytes = 0;
 270
 271         /*
 272          * Let's see whether these data can be right...
 273          *
 274          * D7 D6 D5 D4 D3 D2 D1 D0
 275          * YV XV YS XS  1  M  R  L
 276          * X7 .  .  .  .  .  .  X1   (X)
 277          * Y7 .  .  .  .  .  .  Y1   (Y)
 278          *
 279          * XV,YV : overflow in x/y direction
 280          * XS,YS : most significant bit of X and Y: represents sign
 281          * X,Y   : displacement in x and y direction (8 least significant bits).
 282          *
 283          * X, XS, Y and YS make up two 9-bit two's complement fields.
 284          */
 285
 286     #if 0
 287         D(bug("Got the following: 1. byte: 0x%x, dx=%d, dy=%d\n",
 288               mouse_data[0],
 289               mouse_data[1],
 290               mouse_data[2]));
 291     #endif
 292
 293         e->x = mouse_data[1];
 294         e->y = mouse_data[2];
 295
 296         if (mouse_data[0] & 0x10) e->x -= 256;
 297         if (mouse_data[0] & 0x20) e->y -= 256;
 298
 299         /* dy is reversed! */
 300         e->y = -(e->y);
 301
 302         if (e->x || e->y)
 303         {
 304             e->button   = vHidd_Mouse_NoButton;
 305             e->type     = vHidd_Mouse_Motion;
 306
 307             data->mouse_callback(data->callbackdata, e);
 308         }
 309
 310         buttonstate = mouse_data[0] & 0x07;
 311
 312         if ((buttonstate & LEFT_BUTTON) != (data->buttonstate & LEFT_BUTTON))
 313         {
 314             e->button = vHidd_Mouse_Button1;
 315             e->type   = (buttonstate & LEFT_BUTTON) ? vHidd_Mouse_Press : vHidd_Mouse_Release;
 316
 317             data->mouse_callback(data->callbackdata, e);
 318         }
 319
 320         if ((buttonstate & RIGHT_BUTTON) != (data->buttonstate & RIGHT_BUTTON))
 321         {
 322             e->button = vHidd_Mouse_Button2;
 323             e->type   = (buttonstate & RIGHT_BUTTON) ? vHidd_Mouse_Press : vHidd_Mouse_Release;
 324
 325             data->mouse_callback(data->callbackdata, e);
 326         }
 327
 328         if ((buttonstate & MIDDLE_BUTTON) != (data->buttonstate & MIDDLE_BUTTON))
 329         {
 330             e->button = vHidd_Mouse_Button3;
 331             e->type = (buttonstate & MIDDLE_BUTTON) ? vHidd_Mouse_Press : vHidd_Mouse_Release;
 332
 333             data->mouse_callback(data->callbackdata, e);
 334         }
 335
 336         data->buttonstate = buttonstate;
 337
 338     #if INTELLIMOUSE_SUPPORT
 339         /* mouse wheel */
 340         e->y = (mouse_data[3] & 8) ? (mouse_data[3] & 15) - 16 : (mouse_data[3] & 15);
 341         if (e->y)
 342         {
 343             e->x = 0;
 344             e->type  = vHidd_Mouse_WheelMotion;
 345             e->button = vHidd_Mouse_NoButton;
 346
 347             data->mouse_callback(data->callbackdata, e);
 348         }
 349     #endif
 350
 351     } /* for(; ((info = mouse_read_status()) & KBD_STATUS_OBF) && work; work--) */
 352
 353     if (!work)
 354     {
 355         D(bug("mouse.hidd: controller jammed (0x%02X).\n", info));
 356     }
 357
 358     return FALSE;
 359
 360     AROS_INTFUNC_EXIT
 361 }
 362
 363 /****************************************************************************************/
 364
 365 int test_mouse_ps2(OOP_Class *cl, OOP_Object *o)
 366 {
 367     struct mouse_data *data = OOP_INST_DATA(cl, o);
 368     struct Library *kbd_hidd;
 369     struct Interrupt    *irq;
 370     int result;
 371
 372     /* Test for a PS/2 controller */
 373     if ((kbd_hidd = OpenLibrary("kbd.hidd", 0)) == NULL)
 374         return 0;
 375     CloseLibrary(kbd_hidd);
 376
 377     irq = &data->u.ps2.irq;
 378
 379     irq->is_Node.ln_Type = NT_INTERRUPT;
 380     irq->is_Node.ln_Pri  = 127;
 381     irq->is_Node.ln_Name = "PS/2 mouse class irq";
 382     irq->is_Code         = (VOID_FUNC)mouse_ps2int;
 383     irq->is_Data         = (APTR)data;
 384
 385     AddIntServer(INTB_KERNEL + 12, irq);
 386
 387     Disable();
 388     result = mouse_ps2reset(data);
 389     Enable();
 390
 391     /* If mouse_ps2reset() returned non-zero value, there is vaild PS/2 mouse */
 392     if (result)
 393     {
 394         return 1;
 395     }
 396     /* Either no PS/2 mouse or problems with it */
 397     /* Remove mouse interrupt */
 398     RemIntServer(INTB_KERNEL + 12, irq);
 399
 400     /* Report no PS/2 mouse */
 401     return 0;
 402 }
 403
 404 void dispose_mouse_ps2(OOP_Class *cl, OOP_Object *o) {
 405 struct mouse_data *data = OOP_INST_DATA(cl, o);
 406
 407    RemIntServer(INTB_KERNEL + 12, &data->u.ps2.irq);
 408 }
 409
 410 /****************************************************************************************/
 411
 412 void getps2State(OOP_Class *cl, OOP_Object *o, struct pHidd_Mouse_Event *event)
 413 {
 414 #if 0
 415 struct mouse_data *data = OOP_INST_DATA(cl, o);
 416 UBYTE ack;
 417
 418 /* The following doesn't seem to do anything useful */
 419         mouse_write(KBD_OUTCMD_DISABLE);
 420         /* switch to remote mode */
 421         mouse_write(KBD_OUTCMD_SET_REMOTE_MODE);
 422         /* we want data */
 423         ack = data->u.ps2.expected_mouse_acks+1;
 424         mouse_write(KBD_OUTCMD_READ_DATA);
 425         while (data->u.ps2.expected_mouse_acks>=ack)
 426                 mouse_usleep(1000);
 427         /* switch back to stream mode */
 428         mouse_write(KBD_OUTCMD_SET_STREAM_MODE);
 429         mouse_write(KBD_OUTCMD_ENABLE);
 430 #endif
 431 }
 432
 433 /****************************************************************************************/
 434
 435 static int detect_aux()
 436 {
 437     int loops = 10;
 438     int retval = 0;
 439
 440     mouse_wait();
 441
 442     mouse_write_command(KBD_CTRLCMD_WRITE_AUX_OBUF);
 443
 444     mouse_wait();
 445     mouse_write_output(0x5a);
 446
 447     do
 448     {
 449         unsigned char status = mouse_read_status();
 450
 451         if (status & KBD_STATUS_OBF)
 452         {
 453             (void) mouse_read_input();
 454             if (status & KBD_STATUS_MOUSE_OBF)
 455             {
 456                 retval = 1;
 457             }
 458             break;
 459         }
 460
 461         mouse_usleep(1000);
 462
 463     } while (--loops);
 464
 465     D(bug("PS/2 Auxilliary port %sdetected\n", retval ? "" : "not "));
 466     return retval;
 467 }
 468
 469 /****************************************************************************************/
 470
 471 static int query_mouse(UBYTE *buf, int size, int timeout)
 472 {
 473     int ret = 0;
 474
 475     do
 476     {
 477         UBYTE status = mouse_read_status();
 478
 479         if (status & KBD_STATUS_OBF)
 480         {
 481             UBYTE c = mouse_read_input();
 482
 483             if ((c != KBD_REPLY_ACK) && (status & KBD_STATUS_MOUSE_OBF))
 484             {
 485                 buf[ret++] = c;
 486             }
 487         }
 488         else
 489         {
 490             mouse_usleep(1000);
 491         }
 492
 493     } while ((--timeout) && (ret < size));
 494
 495     return ret;
 496
 497 }
 498
 499 /****************************************************************************************/
 500
 501 static int detect_intellimouse(void)
 502 {
 503     UBYTE id = 0;
 504
 505     /* Try to switch into IMPS2 mode */
 506
 507     mouse_write_ack(KBD_OUTCMD_SET_RATE);
 508     mouse_write_ack(200);
 509     mouse_write_ack(KBD_OUTCMD_SET_RATE);
 510     mouse_write_ack(100);
 511     mouse_write_ack(KBD_OUTCMD_SET_RATE);
 512     mouse_write_ack(80);
 513     mouse_write_ack(KBD_OUTCMD_GET_ID);
 514     mouse_write_noack(KBD_OUTCMD_GET_ID);
 515
 516     query_mouse(&id, 1, 20);
 517
 518     return ((id == 3) || (id == 4)) ? id : 0;
 519 }
 520
 521 /****************************************************************************************/
 522
 523 #define AUX_INTS_OFF (KBD_MODE_KCC | KBD_MODE_DISABLE_MOUSE | KBD_MODE_SYS | KBD_MODE_KBD_INT)
 524 #define AUX_INTS_ON  (KBD_MODE_KCC | KBD_MODE_SYS | KBD_MODE_MOUSE_INT | KBD_MODE_KBD_INT)
 525
 526 /****************************************************************************************/
 527
 528 int mouse_ps2reset(struct mouse_data *data)
 529 {
 530     /*
 531      * The commands are for the mouse and nobody else.
 532      */
 533
 534     mouse_write_command_w(KBD_CTRLCMD_MOUSE_ENABLE);
 535
 536     /*
 537      * Check for a mouse port.
 538      */
 539     if (!detect_aux())
 540         return 0;
 541
 542     /*
 543      * Unfortunately on my computer these commands cause
 544      * the mouse not to work at all if they are issued
 545      * in a different order. So please keep it that way.
 546      * - Stefan
 547      */
 548
 549     /*
 550      * Turn interrupts off and the keyboard as well since the
 551      * commands are all for the mouse.
 552      */
 553     mouse_write_cmd(AUX_INTS_OFF);
 554     mouse_write_command_w(KBD_CTRLCMD_KBD_DISABLE);
 555
 556     /* Reset mouse */
 557     mouse_write_ack(KBD_OUTCMD_RESET);
 558     mouse_wait_for_input();    /* Test result (0xAA) */
 559     mouse_wait_for_input();    /* Mouse type */
 560
 561     data->u.ps2.mouse_protocol = PS2_PROTOCOL_STANDARD;
 562     data->u.ps2.mouse_packetsize = 3;
 563
 564 #if INTELLIMOUSE_SUPPORT
 565     if (detect_intellimouse())
 566     {
 567         data->u.ps2.mouse_protocol = PS2_PROTOCOL_INTELLIMOUSE;
 568         data->u.ps2.mouse_packetsize = 4;
 569     }
 570 #endif
 571
 572     /*
 573      * Now the commands themselves.
 574      */
 575     mouse_write_ack(KBD_OUTCMD_SET_RATE);
 576     mouse_write_ack(100);
 577     mouse_write_ack(KBD_OUTCMD_SET_RES);
 578     mouse_write_ack(2);
 579     mouse_write_ack(KBD_OUTCMD_SET_SCALE11);
 580
 581     /* Enable Aux device (and re-enable keyboard) */
 582
 583     mouse_write_command_w(KBD_CTRLCMD_KBD_ENABLE);
 584     mouse_write_ack(KBD_OUTCMD_ENABLE);
 585     mouse_write_cmd(AUX_INTS_ON);
 586
 587     /*
 588      * According to the specs there is an external
 589      * latch that holds the level-sensitive interrupt
 590      * request until the CPU reads port 0x60.
 591      * If this is not read then the mouse does not
 592      * work on my computer.- Stefan
 593      */
 594
 595     mouse_read_data();
 596
 597     D(bug("[Mouse] Found and initialized PS/2 mouse!\n"));
 598
 599     return 1;
 600 }
 601
 602 /****************************************************************************************/