开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
usbKeyboardLib.c
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：60k
源码类别：

VxWorks

开发平台：

C/C++

usbKeyboardLib.c：源码内容
  1. /* usbKeyboardLib.c - USB keyboard class drive with vxWorks SIO interface */
  3. /* Copyright 2000-2002 Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 01g,08may02,wef  Add ioctl to set keyboard mode to return raw scan codes - 
  9.  SPR #70988. 
  10. 01f,29oct01,wef  Remove automatic buffer creations and repalce with OSS_MALLOC.
  11. 01e,18sep01,wef  merge from wrs.tor2_0.usb1_1-f for veloce
  12. 01d,03jul01,jsv  Re-wrote key tracking logic to fix issue with extra chars
  13.                  when shift is released before the desired shifted key.
  14.                  Made typematic setting globals so they can be modified.
  15.                  Fixed typematic task, not calling callback after queueing
  16.                  chars.
  17.                  Added support of extended keycodes.
  18.                  Fixed shifted key operation when CAPSLOCK is on.
  19. 01c,22jan01,wef  fix tab stops.
  20. 01b,20mar00,rcb  Re-write code to fetch maxPacketSize from endpoint descriptor
  21.    on machines which don't support non-aligned word access.
  22.    Allocate "report" structure separately from SIO_CHAN in order
  23.    to avoid cache problems on MIPS platform.
  24. 01a,27jul99,rcb  written.
  25. */
  27. /*
  28. DESCRIPTION
  30. This module implements the USB keyboard class driver for the vxWorks operating
  31. system.  This module presents an interface which is a superset of the vxWorks
  32. SIO (serial IO) driver model.  That is, this driver presents the external APIs
  33. which would be expected of a standard "multi-mode serial (SIO) driver" and
  34. adds certain extensions which are needed to address adequately the requirements
  35. of the hot-plugging USB environment.
  37. USB keyboards are described as part of the USB "human interface device" class
  38. specification and related documents.  This driver concerns itself only with USB
  39. devices which claim to be keyboards as set forth in the USB HID specification
  40. and ignores other types of human interface devices (i.e., mouse).  USB
  41. keyboards can operate according to either a "boot protocol" or to a "report
  42. protocol".  This driver enables keyboards for operation using the boot
  43. protocol.
  45. As the SIO driver model presents a fairly limited, byte-stream oriented view of
  46. a serial device, this driver maps USB keyboard scan codes into appropriate
  47. ASCII codes.  Scan codes and combinations of scan codes which do not map to the
  48. ASCII character set are suppressed.
  50. Unlike most SIO drivers, the number of channels supported by this driver is not
  51. fixed. Rather, USB keyboards may be added or removed from the system at any
  52. time.  This creates a situation in which the number of channels is dynamic, and
  53. clients of usbKeyboardLib.c need to be made aware of the appearance and 
  54. disappearance of channels.  Therefore, this driver adds an additional set of
  55. functions which allows clients to register for notification upon the insertion
  56. and removal of USB keyboards, and hence the creation and deletion of channels.
  58. This module itself is a client of the Universal Serial Bus Driver (USBD).  All
  59. interaction with the USB buses and devices is handled through the USBD.
  62. INITIALIZATION
  64. As with standard SIO drivers, this driver must be initialized by calling
  65. usbKeyboardDevInit().  usbKeyboardDevInit() in turn initializes its 
  66. connection to the USBD and other internal resources needed for operation.  
  67. Unlike some SIO drivers, there are no usbKeyboardLib.c data structures which need 
  68. to be initialized prior to calling usbKeyboardDevInit().
  70. Prior to calling usbKeyboardDevInit(), the caller must ensure that the USBD
  71. has been properly initialized by calling - at a minimum - usbdInitialize().
  72. It is also the caller's responsibility to ensure that at least one USB HCD
  73. (USB Host Controller Driver) is attached to the USBD - using the USBD function
  74. usbdHcdAttach() - before keyboard operation can begin. However, it is not 
  75. necessary for usbdHcdAttach() to be alled prior to initializating usbKeyboardLib.c.
  76. usbKeyboardLib.c uses the USBD dynamic attach services and is capable of 
  77. recognizing USB keboard attachment and removal on the fly.  Therefore, it is 
  78. possible for USB HCDs to be attached to or detached from the USBD at run time
  79. - as may be required, for example, in systems supporting hot swapping of
  80. hardware.
  82. usbKeyboardLib.c does not export entry points for transmit, receive, and error
  83. interrupt entry points like traditional SIO drivers.  All "interrupt" driven
  84. behavior is managed by the underlying USBD and USB HCD(s), so there is no
  85. need for a caller (or BSP) to connect interrupts on behalf of usbKeyboardLib.c.
  86. For the same reason, there is no post-interrupt-connect initialization code
  87. and usbKeboardLib.c therefore also omits the "devInit2" entry point.
  90. OTHER FUNCTIONS
  92. usbKeyboardLib.c also supports the SIO ioctl interface.  However, attempts to
  93. set parameters like baud rates and start/stop bits have no meaning in the USB
  94. environment and will be treated as no-ops.  
  97. DATA FLOW
  99. For each USB keyboard connected to the system, usbKeyboardLib.c sets up a
  100. USB pipe to monitor input from the keyboard.  Input, in the form of scan codes,
  101. is translated to ASCII codes and placed in an input queue.  If SIO callbacks
  102. have been installed and usbKeyboardLib.c has been placed in the SIO "interrupt" 
  103. mode of operation, then usbKeyboardLib.c will invoke the "character received"
  104. callback for each character in the queue.  When usbKeyboardLib.c has been placed
  105. in the "polled" mode of operation, callbacks will not be invoked and the 
  106. caller will be responsible for fetching keyboard input using the driver's
  107. pollInput() function.
  109. usbKeyboardLib.c does not support output to the keyboard.  Therefore, calls to
  110. the txStartup() and pollOutput() functions will fail.  The only "output" 
  111. supported is the control of the keyboard LEDs, and this is handled internally
  112. by usbKeyboardLib.c.
  114. The caller needs to be aware that usbKeyboardLib.c is not capable of operating
  115. in a true "polled mode" as the underlying USBD and USB HCD always operate in
  116. an interrupt mode.  
  119. TYPEMATIC REPEAT
  121. USB keyboards do not implement typematic repeat, and it is the responsibility
  122. of the host software to implement this feature.  For this purpose, this module
  123. creates a task called typematicThread() which monitors all open channels and
  124. injects repeated characters into input queues as appropriate.
  127. INCLUDE FILES:
  128. sioLib.h usbKeyboardLib.h
  129. */
  132. /* includes */
  134. #include "vxWorks.h"
  135. #include "string.h"
  136. #include "sioLib.h"
  137. #include "errno.h"
  138. #include "ctype.h"
  140. #include "usb/usbPlatform.h"
  141. #include "usb/ossLib.h"  /* operations system srvcs */
  142. #include "usb/usb.h" /* general USB definitions */
  143. #include "usb/usbListLib.h" /* linked list functions */
  144. #include "usb/usbdLib.h" /* USBD interface */
  145. #include "usb/usbLib.h"  /* USB utility functions */
  146. #include "usb/usbHid.h"  /* USB HID definitions */
  147. #include "drv/usb/usbKeyboardLib.h" /* our API */
  150. /* defines */
  152. #define KBD_CLIENT_NAME "usbKeyboardLib"    /* our USBD client name */
  154. #define KBD_Q_DEPTH 8     /* Max characters in keyboard queue */
  156. #define ISEXTENDEDKEYCODE(keyCode)          (keyCode & 0xFF00)
  157. #define ISALPHASCANCODE(scanCode)           ( (scanCode >= 0x04) && (scanCode <= 0x1D) )
  158. #define ISNUMERICSCANCODE(scanCode)         ( (scanCode >= 0x1E) && (scanCode <= 0x27) )
  159. #define ISKEYPADSCANCODE(scanCode)          ( (scanCode >= 0x53) && (scanCode <= 0x63) )
  160. #define ISKEYPADEXTSCANCODE(scanCode)       ( (scanCode >= 0x59) && (scanCode <= 0x63) )
  161. #define ISFUNCTIONSCANCODE(scanCode)        ( (scanCode >= 0x3A) && (scanCode <= 0x45) )
  162. #define ISOTHEREXTENDEDSCANCODE(scanCode)   ( (scanCode >= 0x49) && (scanCode <= 0x52) )
  163. #define ISEXTENDEDSCANCODE(scanCode, modifiers)                                 
  164.                 ( (modifiers & MOD_KEY_ALT) && ISALPHASCANCODE(scanCode) )      
  165.                 || ISFUNCTIONSCANCODE(scanCode)                                 
  166.                 || ISOTHEREXTENDEDSCANCODE(scanCode)
  168. /* If your hardware platform has problems sharing cache lines, then define
  169.  * CACHE_LINE_SIZE below so that critical buffers can be allocated within
  170.  * their own cache lines.
  171.  */
  173. #define CACHE_LINE_SIZE     16
  176. /* typematic definitions */
  178. #define TYPEMATIC_NAME     "tUsbKbd"
  181. /* typedefs */
  183. /*
  184.  * ATTACH_REQUEST
  185.  */
  187. typedef struct attach_request
  188.     {
  189.     LINK reqLink;     /* linked list of requests */
  190.     USB_KBD_ATTACH_CALLBACK callback; /* client callback routine */
  191.     pVOID callbackArg; /* client callback argument */
  192.     } ATTACH_REQUEST, *pATTACH_REQUEST;
  195. /* USB_KBD_SIO_CHAN is the internal data structure we use to track each USB
  196.  * keyboard.
  197.  */
  199. typedef struct usb_kbd_sio_chan
  200.     {
  201.     SIO_CHAN sioChan; /* must be first field */
  203.     LINK sioLink;         /* linked list of keyboard structs */
  205.     UINT16 lockCount; /* Count of times structure locked */
  207.     USBD_NODE_ID nodeId; /* keyboard node Id */
  208.     UINT16 configuration; /* configuration/interface reported as */
  209.     UINT16 interface; /* a keyboard by this device */
  211.     BOOL connected;         /* TRUE if keyboard currently connected */
  213.     USBD_PIPE_HANDLE pipeHandle;/* USBD pipe handle for interrupt pipe */
  214.     USB_IRP irp;         /* IRP to monitor interrupt pipe */
  215.     BOOL irpInUse;         /* TRUE while IRP is outstanding */
  216.     pHID_KBD_BOOT_REPORT pBootReport;/* Keyboard boot report fetched thru pipe */
  218.     char inQueue [KBD_Q_DEPTH]; /* Circular queue for keyboard input */
  219.     UINT16 inQueueCount; /* count of characters in input queue */
  220.     UINT16 inQueueIn; /* next location in queue */
  221.     UINT16 inQueueOut; /* next character to fetch */
  223.     UINT32 typematicTime; /* time current typematic period started */
  224.     UINT32 typematicCount; /* count of keys injected */
  225.     UINT16 typematicChar;  /* current character to repeat */
  227.     int mode;         /* SIO_MODE_INT or SIO_MODE_POLL */
  229.     STATUS (*getTxCharCallback) (); /* tx callback */
  230.     void *getTxCharArg;  /* tx callback argument */
  232.     STATUS (*putRxCharCallback) (); /* rx callback */
  233.     void *putRxCharArg;  /* rx callback argument */
  235.     /* Following variables used to emulate certain ioctl functions. */
  237.     int baudRate;         /* has no meaning in USB */
  239.     /* Following variables maintain keyboard state */
  241.     BOOL capsLock;         /* TRUE if CAPLOCK in effect */
  242.     BOOL scrLock;         /* TRUE if SCRLOCK in effect */
  243.     BOOL numLock;         /* TRUE if NUMLOCK in effect */
  245.     UINT16 activeScanCodes [BOOT_RPT_KEYCOUNT];
  247.     int scanMode; /* raw or ascii */
  249.     } USB_KBD_SIO_CHAN, *pUSB_KBD_SIO_CHAN;
  252. /* forward static declarations */
  254. LOCAL int usbKeyboardTxStartup (SIO_CHAN * pSioChan);
  255. LOCAL int usbKeyboardCallbackInstall (SIO_CHAN *pSioChan, int callbackType,
  256.     STATUS (*callback)(), void *callbackArg);
  257. LOCAL int usbKeyboardPollOutput (SIO_CHAN *pSioChan, char   outChar);
  258. LOCAL int usbKeyboardPollInput (SIO_CHAN *pSioChan, char *thisChar);
  259. LOCAL int usbKeyboardIoctl (SIO_CHAN *pSioChan, int request, void *arg);
  261. LOCAL VOID usbKeyboardIrpCallback (pVOID p);
  264. /* locals */
  266. LOCAL UINT16 initCount = 0; /* Count of init nesting */
  268. LOCAL MUTEX_HANDLE kbdMutex;    /* mutex used to protect internal structs */
  270. LOCAL LIST_HEAD sioList; /* linked list of USB_KBD_SIO_CHAN */
  271. LOCAL LIST_HEAD reqList; /* Attach callback request list */
  273. LOCAL USBD_CLIENT_HANDLE usbdHandle; /* our USBD client handle */
  275. LOCAL THREAD_HANDLE typematicHandle;/* task used to generate typematic repeat */
  276. LOCAL BOOL killTypematic; /* TRUE when typematic thread should exit */
  277. LOCAL BOOL typematicExit; /* TRUE when typematic thread exits */
  280. /* Channel function table. */
  282. LOCAL SIO_DRV_FUNCS usbKeyboardSioDrvFuncs =
  283.     {
  284.     usbKeyboardIoctl,
  285.     usbKeyboardTxStartup,
  286.     usbKeyboardCallbackInstall,
  287.     usbKeyboardPollInput,
  288.     usbKeyboardPollOutput
  289.     };
  292. /* ASCI definitions */
  294. #define SHIFT_CASE_OFFSET   ('a' - 'A')
  295. #define CTRL_CASE_OFFSET    64 /* diff between 'A' and CTRL-A */
  297. #define BS     8 /* backspace, CTRL-H */
  298. #define DEL     BS /* delete key */
  299. #define TAB     9 /* tab, CTRL-I */
  300. #define CR     13 /* carriage return, CTRL-M */
  301. #define ESC     27 /* escape */
  304. /* Scan code lookup table and related constants. */
  306. #define ASCII_MIN         0x0000
  307. #define ASCII_MAX         0x007f
  309. #define CAPLOCK          0x39
  310. #define CAPLOCK_LOCKING      0x82
  311. #define NUMLOCK          0x53
  312. #define NUMLOCK_LOCKING  0x83
  313. #define SCRLOCK          0x47
  314. #define SCRLOCK_LOCKING  0x84
  316. #define NOTKEY         0
  318. #define isAscii(a)  ((a) <= ASCII_MAX)
  321. /* NOTE: The following scan code tables are populated only so far as is useful
  322.  * in order to map the ASCI character set.  Also, the following two tables must
  323.  * remain exactly the same length.
  324.  */
  326. LOCAL UINT16 scanCodes [] =
  327.     {
  328.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, 'a',    'b',    'c',    'd',    /* 0 - 7 */
  329.     'e',    'f',    'g',    'h',    'i',    'j',    'k',    'l',    /* 8 - 15 */
  330.     'm',    'n',    'o',    'p',    'q',    'r',    's',    't',    /* 16 - 23 */
  331.     'u',    'v',    'w',    'x',    'y',    'z',    '1',    '2',    /* 24 - 31 */
  332.     '3',    '4',    '5',    '6',    '7',    '8',    '9',    '0',    /* 32 - 39 */
  333.     CR,     ESC,    DEL,    TAB,    ' ',    '-',    '=',    '[',    /* 40 - 47 */
  334.     ']',    '\',   '#',    ';',    ''',   '`',    ',',    '.',    /* 48 - 55 */
  335.     '/',    NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 56 - 63 */
  336.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 64 - 71 */
  337.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, DEL,    NOTKEY, NOTKEY, NOTKEY, /* 72 - 79 */
  338.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, '/',    '*',    '-',    '+',    /* 80 - 87 */
  339.     CR,     '1',    '2',    '3',    '4',    '5',    '6',    '7',    /* 88 - 95 */
  340.     '8',    '9',    '0',    '.',    '|',    NOTKEY, NOTKEY, '=',    /* 96 - 103 */
  341.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 104 - 111 */
  342.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 112 - 119 */
  343.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 120 - 127 */
  344.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, ',',    '=',  NOTKEY, /* 128 - 135 */
  345.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 136 - 143 */
  346.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 144 - 151 */
  347.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 152 - 159 */
  348.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 160 - 167 */
  349.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 168 - 175 */
  350.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 176 - 183 */
  351.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 184 - 191 */
  352.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 192 - 199 */
  353.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 200 - 207 */
  354.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 208 - 215 */
  355.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 216 - 223 */
  356.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 224 - 231 */
  357.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 232 - 239 */
  358.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 240 - 247 */
  359.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY  /* 248 - 255 */
  360.     };
  363. LOCAL UINT16 scanCodesShift [] =
  364.     {
  365.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, 'A',    'B',    'C',    'D',    /* 0 - 7 */
  366.     'E',    'F',    'G',    'H',    'I',    'J',    'K',    'L',    /* 8 - 15 */
  367.     'M',    'N',    'O',    'P',    'Q',    'R',    'S',    'T',    /* 16 - 23 */
  368.     'U',    'V',    'W',    'X',    'Y',    'Z',    '!',    '@',    /* 24 - 31 */
  369.     '#',    '$',    '%',    '^',    '&',    '*',    '(',    ')',    /* 32 - 39 */
  370.     CR,     ESC,    DEL,    TAB,    ' ',    '_',    '+',    '{',    /* 40 - 47 */
  371.     '}',    '|',    '~',    ':',    '"',    '~',    '<',    '>',    /* 48 - 55 */
  372.     '?',    NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 56 - 63 */
  373.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 64 - 71 */
  374.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, DEL,    NOTKEY, NOTKEY, NOTKEY, /* 72 - 79 */
  375.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, '/',    '*',    '-',    '+',    /* 80 - 87 */
  376.     CR,     '1',    '2',    '3',    '4',    '5',    '6',    '7',    /* 88 - 95 */
  377.     '8',    '9',    '0',    '.',    '|',    NOTKEY, NOTKEY, '=',    /* 96 - 103 */
  378.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 104 - 111 */
  379.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 112 - 119 */
  380.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 120 - 127 */
  381.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, ',',    '=',  NOTKEY, /* 128 - 135 */
  382.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 136 - 143 */
  383.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 144 - 151 */
  384.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 152 - 159 */
  385.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 160 - 167 */
  386.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 168 - 175 */
  387.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 176 - 183 */
  388.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 184 - 191 */
  389.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 192 - 199 */
  390.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 200 - 207 */
  391.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 208 - 215 */
  392.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 216 - 223 */
  393.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 224 - 231 */
  394.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 232 - 239 */
  395.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, /* 240 - 247 */
  396.     NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY, NOTKEY  /* 248 - 255 */
  397.     };
  400. #define SCAN_CODE_TBL_LEN   (sizeof (scanCodes) / sizeof (UINT16))
  402. /*  IBM Extended keycodes.
  403.     Char.     Hex Pair       Char.    Hex Pair
  404.     ALT-A     (0x00,0x1e)    ALT-B    (0x00,0x30)
  405.     ALT-C     (0x00,0x2e)    ALT-D    (0x00,0x20)
  406.     ALT-E     (0x00,0x12)    ALT-F    (0x00,0x21)
  407.     ALT-G     (0x00,0x22)    ALT-H    (0x00,0x23)
  408.     ALT-I     (0x00,0x17)    ALT-J    (0x00,0x24)
  409.     ALT-K     (0x00,0x25)    ALT-L    (0x00,0x26)
  410.     ALT-M     (0x00,0x32)    ALT-N    (0x00,0x31)
  411.     ALT-O     (0x00,0x18)    ALT-P    (0x00,0x19)
  412.     ALT-Q     (0x00,0x10)    ALT-R    (0x00,0x13)
  413.     ALT-S     (0x00,0x1a)    ALT-T    (0x00,0x14)
  414.     ALT-U     (0x00,0x16)    ALT-V    (0x00,0x2f)
  415.     ALT-W     (0x00,0x11)    ALT-X    (0x00,0x2d)
  416.     ALT-Y     (0x00,0x15)    ALT-Z    (0x00,0x2c)
  417.     PgUp      (0x00,0x49)    PgDn     (0x00,0x51)
  418.     Home      (0x00,0x47)    End      (0x00,0x4f)
  419.     UpArrw    (0x00,0x48)    DnArrw   (0x00,0x50)
  420.     LftArrw   (0x00,0x4b)    RtArrw   (0x00,0x4d)
  421.     F1        (0x00,0x3b)    F2       (0x00,0x3c)
  422.     F3        (0x00,0x3d)    F4       (0x00,0x3e)
  423.     F5        (0x00,0x3f)    F6       (0x00,0x40)
  424.     F7        (0x00,0x41)    F8       (0x00,0x42)
  425.     F9        (0x00,0x43)    F10      (0x00,0x44)
  426.     F11       (0x00,0x85)    F12      (0x00,0x86)
  427.     ALT-F1    (0x00,0x68)    ALT-F2   (0x00,0x69)
  428.     ALT-F3    (0x00,0x6a)    ALT-F4   (0x00,0x6b)
  429.     ALT-F5    (0x00,0x6c)    ALT-F6   (0x00,0x6d)
  430.     ALT-F7    (0x00,0x6e)    ALT-F8   (0x00,0x6f)
  431.     ALT-F9    (0x00,0x70)    ALT-F10  (0x00,0x71)
  432.     ALT-F11   (0x00,0x8b)    ALT-F12  (0x00,0x8c)
  433. */
  435. LOCAL UINT16 extendedAlphaKeyCodes [] =
  436.     {
  437.         0x1e, 0x30, 0x2e, 0x20, 0x12, 0x21, 0x22, 0x23,
  438.         0x17, 0x24, 0x25, 0x26, 0x32, 0x31, 0x18, 0x19,
  439.         0x10, 0x13, 0x1a, 0x14, 0x16, 0x2f, 0x11, 0x2d,
  440.         0x15, 0x2c
  441.     };
  443. LOCAL UINT16 extendedOtherKeyCodes [] =
  444.     {
  445.         0x52, 0x47, 0x49, 0x53, 0x4f, 0x51, 0x4d ,0x4b, 0x50,
  446.         0x48,
  447.     };
  449. LOCAL UINT16 extendedFunctionKeyCodes [] =
  450.     {
  451.         0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42,
  452.         0x43, 0x44, 0x85, 0x86
  453.     };
  455. LOCAL UINT16 extendedAltFunctionKeyCodes [] =
  456.     {
  457.         0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
  458.         0x70, 0x71, 0x8b, 0x8c
  459.     };
  461. LOCAL UINT16 extendedKeypadKeyCodes [] =
  462.     {
  463.         0x4F, 0x50, 0x51, 0x4B, 0x00, 0x4D, 0x47, 0x48,
  464.         0x49, 0x52, 0x53
  465.     };
  467. /* globals */
  469. unsigned int TYPEMATIC_DELAY  = 500;    /* 500 msec delay */
  470. unsigned int TYPEMATIC_PERIOD = 66;     /* 66 msec = approx 15 char/sec */
  473. /***************************************************************************
  474. *
  475. * cvtScanCodeToKeyCode - converts scan code to key code if possible
  476. *
  477. * <scanCode> is the scan code to be interpreted and <modifiers> is the 
  478. * current state of the keyboard modifies (e.g., SHIFT).  
  479.     *
  480. * RETURNS: ASCII code if mapping exists, CAPLOCK, SCRLOCK, NUMLOCK, or
  481. *      NOTKEY if no mapping.
  482. */
  484. LOCAL UINT16 cvtScanCodeToKeyCode
  485.     (
  486.     pUSB_KBD_SIO_CHAN pSioChan,
  487.     UINT16 scanCode,
  488.     UINT16 modifiers
  489.     )
  491.     {
  493.     /* Translate keypad keys. */
  495.     if( ISKEYPADSCANCODE(scanCode) )
  496. {
  498.         if( !!(modifiers & MOD_KEY_SHIFT) ^ !!(pSioChan->numLock) )
  499.             return( scanCodes [scanCode] );
  501.         if( ISKEYPADEXTSCANCODE(scanCode) )
  502.     {
  504.             /* If the table contains 0 (like entry for keypad '5') 
  505.      * return NOTKEY. 
  506.      */
  508.             if(extendedKeypadKeyCodes[scanCode-0x59] == 0) 
  509. return(NOTKEY);
  511.             return(0xFF00 | extendedKeypadKeyCodes[scanCode-0x59]);
  512.     }
  513.         return( scanCodes [scanCode] );
  514. }
  516.     /* Translate extended keys. */
  518.     if( ISALPHASCANCODE(scanCode) && (modifiers & MOD_KEY_ALT) )
  519.         return(0xFF00 | extendedAlphaKeyCodes[scanCode-0x04]);
  521.     if( ISOTHEREXTENDEDSCANCODE(scanCode) )
  522.         return(0xFF00 | extendedOtherKeyCodes[scanCode-0x49]);
  524.     if( ISFUNCTIONSCANCODE(scanCode) && (modifiers & MOD_KEY_ALT) )
  525.         return(0xFF00 | extendedAltFunctionKeyCodes[scanCode-0x3A]);
  527.     if( ISFUNCTIONSCANCODE(scanCode))
  528.         return(0xFF00 | extendedFunctionKeyCodes[scanCode-0x3A]);
  530.     /* Translate the scan code into a preliminary ASCII code */
  532.     if (scanCode < SCAN_CODE_TBL_LEN)
  533. {
  534.         /* Translate alpha keys */
  536.         if( ISALPHASCANCODE(scanCode) )
  537.     {
  538.             if( modifiers & MOD_KEY_CTRL )
  539.                 return( scanCodesShift [scanCode] - CTRL_CASE_OFFSET);
  541.             if( !!(modifiers & MOD_KEY_SHIFT) ^ !!(pSioChan->capsLock) )
  542.                 return( scanCodesShift [scanCode] );
  544.             else
  545.                 return( scanCodes [scanCode] );
  546.     }
  548.         /* Translate non-alpha keys */
  550.         if ((modifiers & (MOD_KEY_SHIFT | MOD_KEY_CTRL)) != 0)
  551.          return( scanCodesShift [scanCode] );
  553.         else
  554.         return( scanCodes [scanCode] );
  555. }
  557.     return(NOTKEY);
  558.     }
  561. /***************************************************************************
  562. *
  563. * isKeyPresent - determines if a key is present in an array of keys
  564. *
  565. * RETURNS: TRUE if <key> is present in the <keyArray> passed by the
  566. * caller, else returns FALSE.
  567. */
  569. LOCAL BOOL isKeyPresent
  570.     (
  571.     pUINT16 pKeyArray,
  572.     UINT16 key
  573.     )
  575.     {
  576.     UINT16 i;
  578.     for (i = 0; i < BOOT_RPT_KEYCOUNT; i++)
  579. if (key == pKeyArray [i])
  580.     return TRUE;
  582.     return FALSE;
  583.     }
  586. /***************************************************************************
  587. *
  588. * setLedReport - Issues a SET_REPORT to change a keyboard's LEDs
  589. *
  590. * RETURNS: N/A
  591. */
  593. LOCAL VOID setLedReport
  594.     (
  595.     pUSB_KBD_SIO_CHAN pSioChan,
  596.     UINT8 ledReport
  597.     )
  599.     {
  601.     UINT8 * pLedReport = OSS_CALLOC (sizeof (UINT8));
  603.     if (pLedReport == NULL)
  604. return;
  606.     *pLedReport = ledReport;
  608.     usbHidReportSet (usbdHandle, 
  609.      pSioChan->nodeId, 
  610.      pSioChan->interface, 
  611.      USB_HID_RPT_TYPE_OUTPUT,      
  612.      0, 
  613.      pLedReport, 
  614.      sizeof (ledReport));
  616.     OSS_FREE (pLedReport);
  617.     }
  620. /***************************************************************************
  621. *
  622. * changeKeyState - changes keyboard state
  623. *
  624. * <key> is CAPLOCK, SCRLOCK, or NUMLOCK.  If <key> is not already 
  625. * active, then, toggle the current keyboard state for the corresponding item.
  626. *
  627. * RETURNS: N/A
  628. */
  630. LOCAL VOID changeKbdState
  631.     (
  632.     pUSB_KBD_SIO_CHAN pSioChan,
  633.     UINT16 scanCode,  /* not used */
  634.     pBOOL pKeyState
  635.     )
  637.     {
  638.     UINT8 ledReport;
  640.     /* The scancode is newly active, toggle the corresponding keyboard state. */
  642.     *pKeyState = !(*pKeyState);
  645.     /* Update the keyboard LEDs */
  647.     ledReport = (pSioChan->capsLock) ? RPT_LED_CAPS_LOCK : 0;
  648.     ledReport |= (pSioChan->scrLock) ? RPT_LED_SCROLL_LOCK : 0;
  649.     ledReport |= (pSioChan->numLock) ? RPT_LED_NUM_LOCK : 0;
  651.     setLedReport (pSioChan, ledReport);
  653.     }
  655. /***************************************************************************
  656. *
  657. * interpScanCode - interprets keyboard scan code
  658. *
  659. * Interprets the <scanCode> according to the <modifiers>.  This function
  660. * handles any special requirements, such as turning an LED ON or OFF in
  661. * response to a keypress.
  662. *
  663. * RETURNS: N/A.
  664. */
  666. LOCAL void interpScanCode
  667.     (
  668.     pUSB_KBD_SIO_CHAN pSioChan,
  669.     UINT16 scanCode,
  670.     UINT16 modifiers
  671.     )
  673.     {
  675.     /* If the key is already active, ignore it. */
  677.     if (isKeyPresent (pSioChan->activeScanCodes, scanCode))
  678.         return;
  680.     /* Determine if special handling is required for the key */
  682.     switch (scanCode)
  683. {
  684.         case CAPLOCK:   /* key is CAPLOCK */
  685.         case CAPLOCK_LOCKING:   /* key is CAPLOCK */
  687.         changeKbdState (pSioChan, scanCode, &pSioChan->capsLock);
  688.         break;
  690.         case SCRLOCK:   /* key is SCRLOCK */
  691.         case SCRLOCK_LOCKING:   /* key is SCRLOCK */
  693.         changeKbdState (pSioChan, scanCode, &pSioChan->scrLock);
  694.         break;
  696.         case NUMLOCK:   /* key is NUMLOCK */
  697.         case NUMLOCK_LOCKING:   /* key is NUMLOCK */
  699.         changeKbdState (pSioChan, scanCode, &pSioChan->numLock);
  700.         break;
  702.         case NOTKEY:    /* no valid scan code mapping */
  703.         default: /* an ASCII character */
  705.     break;
  706. }
  707.     }
  710. /***************************************************************************
  711. *
  712. * putInChar - puts a character into channel's input queue
  713. *
  714. * RETURNS: N/A
  715. */
  717. LOCAL VOID putInChar
  718.     (
  719.     pUSB_KBD_SIO_CHAN pSioChan,
  720.     char putChar
  721.     )
  723.     {
  724.     if (pSioChan->inQueueCount < KBD_Q_DEPTH)
  725. {
  726. pSioChan->inQueue [pSioChan->inQueueIn] = putChar;
  728. if (++pSioChan->inQueueIn == KBD_Q_DEPTH)
  729.     pSioChan->inQueueIn = 0;
  731. pSioChan->inQueueCount++;
  732. }
  733.     }
  736. /***************************************************************************
  737. *
  738. * nextInChar - returns next character from input queue
  739. *
  740. * Returns the next character from the channel's input queue and updates
  741. * the queue pointers.  The caller must ensure that at least one character
  742. * is in the queue prior to calling this function.
  743. *
  744. * RETURNS: next char in queue
  745. */
  747. LOCAL char nextInChar
  748.     (
  749.     pUSB_KBD_SIO_CHAN pSioChan
  750.     )
  752.     {
  753.     char inChar = pSioChan->inQueue [pSioChan->inQueueOut];
  755.     if (++pSioChan->inQueueOut == KBD_Q_DEPTH)
  756. pSioChan->inQueueOut = 0;
  758.     pSioChan->inQueueCount--;
  760.     return inChar;
  761.     }
  764. /***************************************************************************
  765. *
  766. * updateTypematic - generates typematic characters for channel if appropriate
  767. *
  768. * RETURNS: N/A
  769. */
  771. LOCAL VOID updateTypematic
  772.     (
  773.     pUSB_KBD_SIO_CHAN pSioChan
  774.     )
  776.     {
  777.     UINT32 diffTime;
  778.     UINT32 repeatCount;
  781.     /* If the given channel is active and a typematic character is
  782.      * indicated, then update the typematic state.
  783.      */
  786.     if (pSioChan->connected && pSioChan->typematicChar != 0)
  787. {
  789.         diffTime = OSS_TIME () - pSioChan->typematicTime;
  791.         /* If the typematic delay has passed, then it is time to start
  792.          * injecting characters into the queue.
  793.          */
  795.         if (diffTime >= TYPEMATIC_DELAY)
  796.     {
  797.     diffTime -= TYPEMATIC_DELAY;
  798.     repeatCount = diffTime / TYPEMATIC_PERIOD + 1;
  800.     /* Inject characters into the queue.  If the queue is
  801.      * full, putInChar() dumps the character, but we increment
  802.      * the typematicCount anyway.  This keeps the queue from
  803.      * getting too far ahead of the user. 
  804.      */
  806.     while (repeatCount > pSioChan->typematicCount)
  807. {
  808. if( ISEXTENDEDKEYCODE(pSioChan->typematicChar) )
  809.     {
  810.     if(pSioChan->inQueueCount < KBD_Q_DEPTH-1)
  811. {
  812. putInChar (pSioChan, (char) 0);
  813. putInChar (pSioChan, 
  814.    (char) pSioChan->typematicChar & 0xFF);
  815. }
  816.     }
  817. else
  818.     {
  819.     putInChar (pSioChan, pSioChan->typematicChar);
  820.     }
  821. pSioChan->typematicCount++;
  822. }
  824.     /* invoke receive callback */
  826.     while (pSioChan->inQueueCount > 0 &&
  827.     pSioChan->putRxCharCallback != NULL &&
  828.     pSioChan->mode == SIO_MODE_INT)
  829. {
  830.                 (*pSioChan->putRxCharCallback) (pSioChan->putRxCharArg, 
  831. nextInChar (pSioChan));
  832. }
  833.     }
  834. }
  835.     }
  838. /***************************************************************************
  839. *
  840. * interpKbdReport - interprets USB keyboard BOOT report
  841. *
  842. * Interprets a keyboard boot report and updates channel state as
  843. * appropriate.  Operates in one of two modes: ASCII or RAW.  In ASCII mode
  844. * it inserts the ascii character into the character buffer and implements
  845. * typematic repeat.  In RAW mode it always inserts the modifier byte
  846. * regardless of change, it inserts any keypresses that are currently active
  847. * and it inserts a terminating byte of 0xff into the charater buffer.
  848. *
  849. * RETURNS: N/A
  850. */
  852. LOCAL VOID interpKbdReport
  853.     (
  854.     pUSB_KBD_SIO_CHAN pSioChan
  855.     )
  857.     {
  858.     pHID_KBD_BOOT_REPORT pReport = pSioChan->pBootReport;
  859.     UINT16 keyCode;
  860.     UINT16 newTypematicChar;
  861.     UINT16 activeCount;
  862.     UINT16 i;
  864.     /* 
  865.      * interpret each key position in a keyboard boot report 
  866.      * (handles CAPS/SCROLL/NUM lock). 
  867.      */
  869.     for (i = 0; i < BOOT_RPT_KEYCOUNT; i++)
  870.         interpScanCode (pSioChan, pReport->scanCodes [i], pReport->modifiers);
  872.     /* Raw mode has been set, handle accordingly */
  874.     if (pSioChan->scanMode == SIO_KYBD_MODE_RAW)
  875. {
  876. /* The first byte is any modifier keys, CTRL, SHIFT, ALT, GUI */
  878. putInChar (pSioChan, pReport->modifiers);
  879. for (i = 0; i < BOOT_RPT_KEYCOUNT; i++)
  880.     if (pReport->scanCodes [i])
  881.     /* Any depressed keys */
  883.     putInChar (pSioChan, pReport->scanCodes [i]);
  885. /* trailing byte */
  887. putInChar (pSioChan, 0xff);
  888.      }
  890.     /* then pSioChan->scanMode must = SIO_KYBD_MODE_ASCII */
  892.     else 
  893. {
  894. /* insert newly activated keys into the input queue for the keyboard */
  896. newTypematicChar = 0;
  897. activeCount = 0;
  899. for (i = 0; i < BOOT_RPT_KEYCOUNT; i++)
  900.     {
  901.     if (pReport->scanCodes [i])
  902. {
  903. keyCode = cvtScanCodeToKeyCode (pSioChan, 
  904. pReport->scanCodes [i], 
  905. pReport->modifiers);
  907. if (!isKeyPresent (pSioChan->activeScanCodes, 
  908.    pReport->scanCodes [i]))
  909.     {
  910.     /* If there is room in the input queue, enqueue the key,
  911.      * else discard it.
  912.      * For extended keyCodes, make sure there is room for two 
  913.      * chars - the 0 and the ext key. 
  914.      */
  915.     if( ISEXTENDEDKEYCODE(keyCode) )
  916. {
  917. if(pSioChan->inQueueCount < KBD_Q_DEPTH-1)
  918.     {
  919.     putInChar (pSioChan, (char) 0);
  920.     putInChar (pSioChan, (char) keyCode & 0xFF);
  921.     }
  922. }
  923.     else
  924. {
  925. if(keyCode)
  926.     putInChar (pSioChan, (char) keyCode & 0xFF);
  927. }
  928.     }
  929. newTypematicChar = keyCode;
  930. activeCount++;
  932. }
  933.     }
  935.     /* 
  936.      * If newTypematicChar is 0, then no keys were received in 
  937.      * this report - so no keys are being held down.  If 
  938.      * newTypematicChar matches the previous typematic char, 
  939.      * then allow the typematic timer to continue.  If 
  940.      * newTypematicChar is different (but non-zero), then start 
  941.      * a new timer.  In all cases, only one key may be active 
  942.      * for typematic repeat to be enabled. 
  943.      */
  945.     if (activeCount != 1)
  946. newTypematicChar = 0;
  948.     if (newTypematicChar != pSioChan->typematicChar)
  949. {
  950. pSioChan->typematicChar = newTypematicChar;
  952. if (newTypematicChar != 0)
  953.     {
  954.     pSioChan->typematicTime = OSS_TIME ();
  955.     pSioChan->typematicCount = 0;
  956.     }
  957. }
  958.     updateTypematic (pSioChan);
  960. }
  962.     /* invoke receive callback */
  964.     while (pSioChan->inQueueCount > 0 &&
  965.            pSioChan->putRxCharCallback != NULL &&
  966.            pSioChan->mode == SIO_MODE_INT)
  967. {
  968.         (*pSioChan->putRxCharCallback) (pSioChan->putRxCharArg, 
  969. nextInChar (pSioChan));
  970. }
  972.     /* 
  973.      * Copy the current list of active keys to the channel 
  974.      * structure, overwriting the previous list.
  975.      */
  977.     for (i = 0; i < BOOT_RPT_KEYCOUNT; i++)
  978. pSioChan->activeScanCodes [i] = pReport->scanCodes [i];
  980.     }
  983. /***************************************************************************
  984. *
  985. * usbKeyboardIoctl - special device control
  986. *
  987. * This routine is largely a no-op for the usbKeyboardLib.  The only ioctls
  988. * which are used by this module are the SIO_AVAIL_MODES_GET and SIO_MODE_SET.
  989. *
  990. * RETURNS: OK on success, ENOSYS on unsupported request, EIO on failed
  991. * request.
  992. */
  994. LOCAL int usbKeyboardIoctl
  995.     (
  996.     SIO_CHAN *pChan,     /* device to control */
  997.     int request, /* request code */
  998.     void *someArg /* some argument */
  999.     )
  1001.     {
  1002.     pUSB_KBD_SIO_CHAN pSioChan = (pUSB_KBD_SIO_CHAN) pChan;
  1003.     int arg = (int) someArg;
  1005.     switch (request)
  1006. {
  1007. case SIO_BAUD_SET:
  1009.     /* baud rate has no meaning for USB.  We store the desired 
  1010.      * baud rate value and return OK.
  1011.      */
  1013.     pSioChan->baudRate = arg;
  1014.     return OK;
  1017. case SIO_BAUD_GET:
  1019.     /* Return baud rate to caller */
  1021.     *((int *) arg) = pSioChan->baudRate;
  1022.     return OK;
  1025. case SIO_MODE_SET:
  1027.     /* Set driver operating mode: interrupt or polled */
  1029.     if (arg != SIO_MODE_POLL && arg != SIO_MODE_INT)
  1030. return EIO;
  1032.     pSioChan->mode = arg;
  1033.     return OK;
  1036. case SIO_MODE_GET:
  1038.     /* Return current driver operating mode for channel */
  1040.     *((int *) arg) = pSioChan->mode;
  1041.     return OK;
  1044. case SIO_AVAIL_MODES_GET:
  1046.     /* Return modes supported by driver. */
  1048.     *((int *) arg) = SIO_MODE_INT | SIO_MODE_POLL;
  1049.     return OK;
  1052. case SIO_OPEN:
  1054.     /* Channel is always open. */
  1056.     return OK;
  1059.          case SIO_KYBD_MODE_SET:
  1060.              switch (arg)
  1061.                  {
  1062.                  case SIO_KYBD_MODE_RAW:
  1063.                  case SIO_KYBD_MODE_ASCII:
  1064.                      break;
  1066.                  case SIO_KYBD_MODE_UNICODE:
  1067.                      return ENOSYS; /* usb doesn't support unicode */
  1068.                  }
  1069.              pSioChan->scanMode = arg;
  1070.              return OK;
  1073.          case SIO_KYBD_MODE_GET:
  1074.              *(int *)someArg = pSioChan->scanMode;
  1075.              return OK;
  1078.          case SIO_KYBD_LED_SET:
  1079.     {
  1080.     UINT8 ledReport;
  1081.  
  1082.     /*  update the channel's information about the LED state */
  1084.     pSioChan->numLock = (arg & SIO_KYBD_LED_NUM) ? SIO_KYBD_LED_NUM : 0;
  1086.     pSioChan->capsLock = (arg & SIO_KYBD_LED_CAP) ? 
  1087. SIO_KYBD_LED_CAP : 0;
  1088.     pSioChan->scrLock = (arg & SIO_KYBD_LED_SCR) ? 
  1089. SIO_KYBD_LED_SCR : 0;
  1091.     /* 
  1092.      * We are relying on the SIO_KYBD_LED_X macros matching the USB
  1093.      * LED equivelants.
  1094.      */
  1096.     ledReport = arg;
  1098.     /* set the LED's */
  1100.     setLedReport (pSioChan, ledReport);
  1101.      
  1102.     return OK;
  1103.     }
  1107.          case SIO_KYBD_LED_GET:
  1108.      {
  1109.      int tempArg;
  1111.           tempArg = (pSioChan->capsLock) ? SIO_KYBD_LED_CAP : 0;
  1112.           tempArg |= (pSioChan->scrLock) ? SIO_KYBD_LED_SCR : 0;
  1113.           tempArg |= (pSioChan->numLock) ? SIO_KYBD_LED_NUM : 0;
  1115.      *(int *) someArg = tempArg;
  1117.              return OK;
  1119.      }
  1121. case SIO_HW_OPTS_SET:   /* optional, not supported */
  1122. case SIO_HW_OPTS_GET:   /* optional, not supported */
  1123. case SIO_HUP: /* hang up is not supported */
  1124. default:     /* unknown/unsupported command. */
  1126.     return ENOSYS;
  1127. }
  1128.     }
  1131. /***************************************************************************
  1132. *
  1133. * usbKeyboardTxStartup - start the interrupt transmitter
  1134. *
  1135. * The USB keyboard SIO driver does not support output to the keyboard.
  1136. *
  1137. * RETURNS: EIO
  1138. */
  1140. LOCAL int usbKeyboardTxStartup
  1141.     (
  1142.     SIO_CHAN *pChan /* channel to start */
  1143.     )
  1145.     {
  1146.     return EIO;
  1147.     }
  1150. /***************************************************************************
  1151. *
  1152. * usbKeyboardCallbackInstall - install ISR callbacks to get/put chars
  1153. *
  1154. * This driver allows interrupt callbacks for transmitting characters
  1155. * and receiving characters.=
  1156. *
  1157. * RETURNS: OK on success, or ENOSYS for an unsupported callback type.
  1158. */ 
  1160. LOCAL int usbKeyboardCallbackInstall
  1161.     (
  1162.     SIO_CHAN *pChan,     /* channel */
  1163.     int callbackType,     /* type of callback */
  1164.     STATUS (*callback) (),  /* callback */
  1165.     void *callbackArg     /* parameter to callback */
  1166.     )
  1168.     {
  1169.     pUSB_KBD_SIO_CHAN pSioChan = (pUSB_KBD_SIO_CHAN) pChan;
  1171.     switch (callbackType)
  1172. {
  1173. case SIO_CALLBACK_GET_TX_CHAR:
  1174.     pSioChan->getTxCharCallback = callback;
  1175.     pSioChan->getTxCharArg = callbackArg;
  1176.     return OK;
  1178. case SIO_CALLBACK_PUT_RCV_CHAR:
  1179.     pSioChan->putRxCharCallback = callback;
  1180.     pSioChan->putRxCharArg = callbackArg;
  1181.     return OK;
  1183. default:
  1184.     return ENOSYS;
  1185. }
  1186.     }
  1189. /***************************************************************************
  1190. *
  1191. * usbKeyboardPollOutput - output a character in polled mode
  1192. *
  1193. * The USB keyboard SIO driver does not support output to the keyboard.
  1194. *
  1195. * RETURNS: EIO
  1196. */
  1198. LOCAL int usbKeyboardPollOutput
  1199.     (
  1200.     SIO_CHAN *pChan,
  1201.     char outChar
  1202.     )
  1204.     {
  1205.     return EIO;
  1206.     }
  1209. /***************************************************************************
  1210. *
  1211. * usbKeyboardPollInput - poll the device for input
  1212. *
  1213. * RETURNS: OK if a character arrived, EIO on device error, EAGAIN
  1214. * if the input buffer if empty, ENOSYS if the device is interrupt-only.
  1215. */
  1217. LOCAL int usbKeyboardPollInput
  1218.     (
  1219.     SIO_CHAN *pChan,
  1220.     char *thisChar
  1221.     )
  1223.     {
  1224.     pUSB_KBD_SIO_CHAN pSioChan = (pUSB_KBD_SIO_CHAN) pChan;
  1225.     int status = OK;
  1228.     /* validate parameters */
  1230.     if (thisChar == NULL)
  1231.         return EIO;
  1234.     OSS_MUTEX_TAKE (kbdMutex, OSS_BLOCK);
  1236.     /* Check if the input queue is empty. */
  1238.     if (pSioChan->inQueueCount == 0)
  1239.         status = EAGAIN;
  1240.     else
  1241. {
  1242. /* Return a character from the input queue. */
  1244. *thisChar = nextInChar (pSioChan);
  1245. }
  1247.     OSS_MUTEX_RELEASE (kbdMutex);
  1249.     return status;
  1250.     }
  1253. /***************************************************************************
  1254. *
  1255. * initKbdIrp - Initialize IRP to listen for input on interrupt pipe
  1256. *
  1257. * RETURNS: TRUE if able to submit IRP successfully, else FALSE
  1258. */
  1260. LOCAL BOOL initKbdIrp
  1261.     (
  1262.     pUSB_KBD_SIO_CHAN pSioChan
  1263.     )
  1265.     {
  1266.     pUSB_IRP pIrp = &pSioChan->irp;
  1268.     /* Initialize IRP */
  1270.     memset (pIrp, 0, sizeof (*pIrp));
  1272.     pIrp->userPtr = pSioChan;
  1273.     pIrp->irpLen = sizeof (*pIrp);
  1274.     pIrp->userCallback = usbKeyboardIrpCallback;
  1275.     pIrp->timeout = USB_TIMEOUT_NONE;
  1276.     pIrp->transferLen = sizeof (HID_KBD_BOOT_REPORT);
  1278.     pIrp->bfrCount = 1;
  1279.     pIrp->bfrList [0].pid = USB_PID_IN;
  1280.     pIrp->bfrList [0].pBfr = (pUINT8) pSioChan->pBootReport;
  1281.     pIrp->bfrList [0].bfrLen = sizeof (HID_KBD_BOOT_REPORT);
  1284.     /* Submit IRP */
  1286.     if (usbdTransfer (usbdHandle, pSioChan->pipeHandle, pIrp) != OK)
  1287. return FALSE;
  1289.     pSioChan->irpInUse = TRUE;
  1292.     return TRUE;
  1293.     }
  1296. /***************************************************************************
  1297. *
  1298. * usbKeyboardIrpCallback - Invoked upon IRP completion/cancellation
  1299. *
  1300. * Examines the cause of the IRP completion.  If completion was successful,
  1301. * interprets the USB keyboard's boot report and re-submits the IRP.
  1302. *
  1303. * RETURNS: N/A
  1304. */
  1306. LOCAL VOID usbKeyboardIrpCallback
  1307.     (
  1308.     pVOID p     /* completed IRP */
  1309.     )
  1311.     {
  1312.     pUSB_IRP pIrp = (pUSB_IRP) p;
  1313.     pUSB_KBD_SIO_CHAN pSioChan = pIrp->userPtr;
  1316.     OSS_MUTEX_TAKE (kbdMutex, OSS_BLOCK);
  1318.     /* Was the IRP successful? */
  1320.     if (pIrp->result == OK)
  1321. {
  1322. /* Interpret the keyboard report */
  1324. interpKbdReport (pSioChan);
  1325. }
  1328.     /* Re-submit the IRP unless it was canceled - which would happen only
  1329.      * during pipe shutdown (e.g., the disappearance of the device).
  1330.      */
  1332.     pSioChan->irpInUse = FALSE;
  1334.     if (pIrp->result != S_usbHcdLib_IRP_CANCELED)
  1335. initKbdIrp (pSioChan);
  1337.     OSS_MUTEX_RELEASE (kbdMutex);
  1338.     }
  1341. /***************************************************************************
  1342. *
  1343. * typematicThread - Updates typematic state for each active channel
  1344. *
  1345. * RETURNS: N/A
  1346. */
  1348. LOCAL VOID typematicThread
  1349.     (
  1350.     pVOID param  /* param not used by this thread */
  1351.     )
  1353.     {
  1354.     pUSB_KBD_SIO_CHAN pSioChan;
  1357.     while (!killTypematic)
  1358. {
  1359.         OSS_MUTEX_TAKE (kbdMutex, OSS_BLOCK);
  1361.         /* Walk the list of open channels and update the typematic
  1362.          * state for each.
  1363.          */
  1365.         pSioChan = usbListFirst (&sioList);
  1367.         while (pSioChan != NULL)
  1368.     {
  1369.     updateTypematic (pSioChan);
  1370.     pSioChan = usbListNext (&pSioChan->sioLink);
  1371.     }
  1373.         OSS_MUTEX_RELEASE (kbdMutex);
  1375.         OSS_THREAD_SLEEP (TYPEMATIC_PERIOD);
  1376. }
  1378.     typematicExit = TRUE;
  1380.     }
  1383. /***************************************************************************
  1384. *
  1385. * configureSioChan - configure USB keyboard for operation
  1386. *
  1387. * Selects the configuration/interface specified in the <pSioChan>
  1388. * structure.  These values come from the USBD dynamic attach callback,
  1389. * which in turn retrieved them from the configuration/interface
  1390. * descriptors which reported the device to be a keyboard.
  1391. *
  1392. * RETURNS: TRUE if successful, else FALSE if failed to configure channel
  1393. */
  1395. LOCAL BOOL configureSioChan
  1396.     (
  1397.     pUSB_KBD_SIO_CHAN pSioChan
  1398.     )
  1400.     {
  1401.     pUSB_CONFIG_DESCR pCfgDescr;
  1402.     pUSB_INTERFACE_DESCR pIfDescr;
  1403.     pUSB_ENDPOINT_DESCR pEpDescr;
  1404.     UINT8 * pBfr;
  1405.     UINT8 * pScratchBfr;
  1406.     UINT16 actLen;
  1407.     UINT16 ifNo;
  1408.     UINT16 maxPacketSize;
  1410.     if ((pBfr = OSS_MALLOC (USB_MAX_DESCR_LEN)) == NULL)
  1411. return FALSE;
  1413.     /* Read the configuration descriptor to get the configuration selection
  1414.      * value and to determine the device's power requirements.
  1415.      */
  1417.     if (usbdDescriptorGet (usbdHandle, 
  1418.    pSioChan->nodeId,
  1419.    USB_RT_STANDARD | USB_RT_DEVICE, 
  1420.    USB_DESCR_CONFIGURATION, 
  1421.    0, 
  1422.    0,
  1423.    USB_MAX_DESCR_LEN, 
  1424.    pBfr, 
  1425.    &actLen) 
  1426.  != OK)
  1427. {
  1428. OSS_FREE (pBfr);
  1429. return FALSE;
  1430. }
  1433.     if ((pCfgDescr = usbDescrParse (pBfr, 
  1434.     actLen, 
  1435.     USB_DESCR_CONFIGURATION)) 
  1436. == NULL)
  1437.         {
  1438.         OSS_FREE (pBfr);
  1439. return FALSE;
  1440. }
  1442.     /* Look for the interface indicated in the pSioChan structure. */
  1444.     ifNo = 0;
  1446.     /* 
  1447.      * usbDescrParseSkip() modifies the value of the pointer it recieves
  1448.      * so we pass it a copy of our buffer pointer
  1449.      */
  1451.     pScratchBfr = pBfr;
  1453.     while ((pIfDescr = usbDescrParseSkip (&pScratchBfr,
  1454.   &actLen,
  1455.   USB_DESCR_INTERFACE)) 
  1456.     != NULL)
  1457. {
  1458. if (ifNo == pSioChan->interface)
  1459.     break;
  1460. ifNo++;
  1461. }
  1463.     if (pIfDescr == NULL)
  1464.         {
  1465.         OSS_FREE (pBfr);
  1466. return FALSE;
  1467. }
  1470.     /* Retrieve the endpoint descriptor following the identified interface
  1471.      * descriptor.
  1472.      */
  1474.     if ((pEpDescr = usbDescrParseSkip (&pScratchBfr, 
  1475.        &actLen, 
  1476.        USB_DESCR_ENDPOINT))
  1477.   == NULL)
  1478. {
  1479. OSS_FREE (pBfr);
  1480. return FALSE;
  1481. }
  1484.     /* Select the configuration. */
  1486.     if (usbdConfigurationSet (usbdHandle, 
  1487.       pSioChan->nodeId,
  1488.       pCfgDescr->configurationValue, 
  1489.       pCfgDescr->maxPower * USB_POWER_MA_PER_UNIT) 
  1490.     != OK)
  1491.         {
  1492.         OSS_FREE (pBfr);
  1493.         return FALSE;
  1494.         }
  1496.     /* Select interface 
  1497.      * 
  1498.      * NOTE: Some devices may reject this command, and this does not represent
  1499.      * a fatal error.  Therefore, we ignore the return status.
  1500.      */
  1502.     usbdInterfaceSet (usbdHandle, 
  1503.       pSioChan->nodeId, 
  1504.       pSioChan->interface, 
  1505.       pIfDescr->alternateSetting);
  1508.     /* Select the keyboard boot protocol. */
  1510.     if (usbHidProtocolSet (usbdHandle, 
  1511.    pSioChan->nodeId,
  1512.    pSioChan->interface, 
  1513.    USB_HID_PROTOCOL_BOOT) 
  1514.  != OK)
  1515.         {
  1516.         OSS_FREE (pBfr);
  1517.         return FALSE;
  1518.         }
  1522.     /* Set the keyboard idle time to infinite. */
  1524.     if (usbHidIdleSet (usbdHandle, 
  1525.        pSioChan->nodeId,
  1526.        pSioChan->interface, 
  1527.        0 /* no report ID */, 
  1528.        0 /* infinite */) 
  1529.     != OK)
  1530.         {
  1531.         OSS_FREE (pBfr);
  1532.         return FALSE;
  1533.         }
  1537.     /* Turn off LEDs. */
  1539.     setLedReport (pSioChan, 0);
  1542.     /* Create a pipe to monitor input reports from the keyboard. */
  1544.     maxPacketSize = *((pUINT8) &pEpDescr->maxPacketSize) |
  1545.     (*(((pUINT8) &pEpDescr->maxPacketSize) + 1) << 8);
  1547.     if (usbdPipeCreate (usbdHandle, 
  1548. pSioChan->nodeId,     
  1549. pEpDescr->endpointAddress, 
  1550. pCfgDescr->configurationValue,    
  1551. pSioChan->interface, 
  1552. USB_XFRTYPE_INTERRUPT, 
  1553. USB_DIR_IN,    
  1554. maxPacketSize, 
  1555. sizeof (HID_KBD_BOOT_REPORT), 
  1556. pEpDescr->interval, 
  1557. &pSioChan->pipeHandle) 
  1558.      != OK)
  1559.         {
  1560.         OSS_FREE (pBfr);
  1561.         return FALSE;
  1562.         }
  1566.     /* Initiate IRP to listen for input on interrupt pipe */
  1568.     if (!initKbdIrp (pSioChan))
  1569.         {
  1570.         OSS_FREE (pBfr);
  1571.         return FALSE;
  1572.         }
  1574.     OSS_FREE (pBfr);
  1577.     return TRUE;
  1578.     }
  1581. /***************************************************************************
  1582. *
  1583. * destroyAttachRequest - disposes of an ATTACH_REQUEST structure
  1584. *
  1585. * RETURNS: N/A
  1586. */
  1588. LOCAL VOID destroyAttachRequest
  1589.     (
  1590.     pATTACH_REQUEST pRequest
  1591.     )
  1593.     {
  1594.     /* Unlink request */
  1596.     usbListUnlink (&pRequest->reqLink);
  1598.     /* Dispose of structure */
  1600.     OSS_FREE (pRequest);
  1601.     }
  1604. /***************************************************************************
  1605. *
  1606. * destroySioChan - disposes of a USB_KBD_SIO_CHAN structure
  1607. *
  1608. * Unlinks the indicated USB_KBD_SIO_CHAN structure and de-allocates
  1609. * resources associated with the channel.
  1610. *
  1611. * RETURNS: N/A
  1612. */
  1614. LOCAL VOID destroySioChan
  1615.     (
  1616.     pUSB_KBD_SIO_CHAN pSioChan
  1617.     )
  1619.     {
  1620.     /* Unlink the structure. */
  1622.     usbListUnlink (&pSioChan->sioLink);
  1625.     /* Release pipe if one has been allocated. Wait for the IRP to be
  1626.      * cancelled if necessary.
  1627.      */
  1629.     if (pSioChan->pipeHandle != NULL)
  1630. usbdPipeDestroy (usbdHandle, pSioChan->pipeHandle);
  1632.     while (pSioChan->irpInUse)
  1633. OSS_THREAD_SLEEP (1);
  1636.     /* Release structure. */
  1638.     if (pSioChan->pBootReport != NULL)
  1639. OSS_FREE (pSioChan->pBootReport);
  1641.     OSS_FREE (pSioChan);
  1642.     }
  1645. /***************************************************************************
  1646. *
  1647. * createSioChan - creates a new USB_KBD_SIO_CHAN structure
  1648. *
  1649. * Creates a new USB_KBD_SIO_CHAN structure for the indicated <nodeId>.
  1650. * If successful, the new structure is linked into the sioList upon 
  1651. * return.
  1652. *
  1653. * <configuration> and <interface> identify the configuration/interface
  1654. * that first reported itself as a keyboard for this device.
  1655. *
  1656. * RETURNS: pointer to newly created structure, or NULL if failure
  1657. */
  1659. LOCAL pUSB_KBD_SIO_CHAN createSioChan
  1660.     (
  1661.     USBD_NODE_ID nodeId,
  1662.     UINT16 configuration,
  1663.     UINT16 interface
  1664.     )
  1666.     {
  1667.     pUSB_KBD_SIO_CHAN pSioChan;
  1668.     UINT16 i;
  1671.     /* Try to allocate space for a new keyboard struct */
  1673.     if ((pSioChan = OSS_CALLOC (sizeof (*pSioChan))) == NULL)
  1674.      return NULL;
  1676.     if ((pSioChan->pBootReport = OSS_CALLOC (sizeof (*pSioChan->pBootReport)))
  1677.       == NULL)
  1678. {
  1679. OSS_FREE (pSioChan);
  1680. return NULL;
  1681. }
  1683.     pSioChan->sioChan.pDrvFuncs = &usbKeyboardSioDrvFuncs;
  1684.     pSioChan->nodeId = nodeId;
  1685.     pSioChan->connected = TRUE;
  1686.     pSioChan->mode = SIO_MODE_POLL;
  1687.     pSioChan->scanMode = SIO_KYBD_MODE_ASCII;
  1689.     pSioChan->configuration = configuration;
  1690.     pSioChan->interface = interface;
  1692.     for (i = 0; i < BOOT_RPT_KEYCOUNT; i++)
  1693. pSioChan->activeScanCodes [i] = NOTKEY;
  1696.     /* Try to configure the keyboard. */
  1698.     if (!configureSioChan (pSioChan))
  1699. {
  1700. destroySioChan (pSioChan);
  1701. return NULL;
  1702. }
  1705.     /* Link the newly created structure. */
  1707.     usbListLink (&sioList, pSioChan, &pSioChan->sioLink, LINK_TAIL);
  1709.     return pSioChan;
  1710.     }
  1713. /***************************************************************************
  1714. *
  1715. * findSioChan - Searches for a USB_KBD_SIO_CHAN for indicated node ID
  1716. *
  1717. * RETURNS: pointer to matching USB_KBD_SIO_CHAN or NULL if not found
  1718. */
  1720. LOCAL pUSB_KBD_SIO_CHAN findSioChan
  1721.     (
  1722.     USBD_NODE_ID nodeId
  1723.     )
  1725.     {
  1726.     pUSB_KBD_SIO_CHAN pSioChan = usbListFirst (&sioList);
  1728.     while (pSioChan != NULL)
  1729. {
  1730. if (pSioChan->nodeId == nodeId)
  1731.     break;
  1733. pSioChan = usbListNext (&pSioChan->sioLink);
  1734. }
  1736.     return pSioChan;
  1737.     }
  1740. /***************************************************************************
  1741. *
  1742. * notifyAttach - Notifies registered callers of attachment/removal
  1743. *
  1744. * RETURNS: N/A
  1745. */
  1747. LOCAL VOID notifyAttach
  1748.     (
  1749.     pUSB_KBD_SIO_CHAN pSioChan,
  1750.     UINT16 attachCode
  1751.     )
  1753.     {
  1754.     pATTACH_REQUEST pRequest = usbListFirst (&reqList);
  1756.     while (pRequest != NULL)
  1757. {
  1758. (*pRequest->callback) (pRequest->callbackArg, 
  1759.        (SIO_CHAN *) pSioChan, 
  1760.        attachCode);
  1762. pRequest = usbListNext (&pRequest->reqLink);
  1763. }
  1764.     }
  1767. /***************************************************************************
  1768. *
  1769. * usbKeyboardAttachCallback - called by USBD when keyboard attached/removed
  1770. *
  1771. * The USBD will invoke this callback when a USB keyboard is attached to or
  1772. * removed from the system.  <nodeId> is the USBD_NODE_ID of the node being
  1773. * attached or removed. <attachAction> is USBD_DYNA_ATTACH or USBD_DYNA_REMOVE.
  1774. * Keyboards generally report their class information at the interface level,
  1775. * so <configuration> and <interface> will indicate the configuratin/interface
  1776. * that reports itself as a keyboard.  Finally, <deviceClass>, <deviceSubClass>,
  1777. * and <deviceProtocol> will identify a HID/BOOT/KEYBOARD device.
  1778. *
  1779. * NOTE: The USBD will invoke this function once for each configuration/
  1780. * interface which reports itself as a keyboard.  So, it is possible that
  1781. * a single device insertion/removal may trigger multiple callbacks.  We
  1782. * ignore all callbacks except the first for a given device.
  1783. *
  1784. * RETURNS: N/A
  1785. */
  1787. LOCAL VOID usbKeyboardAttachCallback
  1788.     (
  1789.     USBD_NODE_ID nodeId, 
  1790.     UINT16 attachAction, 
  1791.     UINT16 configuration,
  1792.     UINT16 interface,
  1793.     UINT16 deviceClass, 
  1794.     UINT16 deviceSubClass, 
  1795.     UINT16 deviceProtocol
  1796.     )
  1798.     {
  1799.     pUSB_KBD_SIO_CHAN pSioChan;
  1802.     OSS_MUTEX_TAKE (kbdMutex, OSS_BLOCK);
  1804.     /* Depending on the attach code, add a new keyboard or disabled one
  1805.      * that's already been created.
  1806.      */
  1808.     switch (attachAction)
  1809. {
  1810. case USBD_DYNA_ATTACH:
  1812.     /* A new device is being attached.  Check if we already 
  1813.      * have a structure for this device.
  1814.      */
  1816.     if (findSioChan (nodeId) != NULL)
  1817. break;
  1819.     /* Create a new structure to manage this device.  If there's
  1820.      * an error, there's nothing we can do about it, so skip the
  1821.      * device and return immediately. 
  1822.      */
  1824.     if ((pSioChan = createSioChan (nodeId, configuration, interface)) == NULL)
  1825. break;
  1827.     /* Notify registered callers that a new keyboard has been
  1828.      * added and a new channel created.
  1829.      */
  1831.     notifyAttach (pSioChan, USB_KBD_ATTACH);
  1833.     break;
  1836. case USBD_DYNA_REMOVE:
  1838.     /* A device is being detached. Check if we have any
  1839.      * structures to manage this device.
  1840.      */
  1842.     if ((pSioChan = findSioChan (nodeId)) == NULL)
  1843. break;
  1845.     /* The device has been disconnected. */
  1847.     pSioChan->connected = FALSE;
  1849.     /* Notify registered callers that the keyboard has been
  1850.      * removed and the channel disabled. 
  1851.      *
  1852.      * NOTE: We temporarily increment the channel's lock count
  1853.      * to prevent usbKeyboardSioChanUnlock() from destroying the
  1854.      * structure while we're still using it.
  1855.      */
  1857.     pSioChan->lockCount++;
  1859.     notifyAttach (pSioChan, USB_KBD_REMOVE);
  1861.     pSioChan->lockCount--;
  1863.     /* If no callers have the channel structure locked, destroy
  1864.      * it now.  If it is locked, it will be destroyed later during
  1865.      * a call to usbKeyboardUnlock().
  1866.      */
  1868.     if (pSioChan->lockCount == 0)
  1869. destroySioChan (pSioChan);
  1871.     break;
  1872. }
  1874.     OSS_MUTEX_RELEASE (kbdMutex);
  1875.     }
  1878. /***************************************************************************
  1879. *
  1880. * doShutdown - shuts down USB keyboard SIO driver
  1881. *
  1882. * <errCode> should be OK or S_usbKeyboardLib_xxxx.  This value will be
  1883. * passed to ossStatus() and the return value from ossStatus() is the
  1884. * return value of this function.
  1885. *
  1886. * RETURNS: OK, or ERROR per value of <errCode> passed by caller
  1887. */
  1889. LOCAL STATUS doShutdown
  1890.     (
  1891.     int errCode
  1892.     )
  1894.     {
  1895.     pATTACH_REQUEST pRequest;
  1896.     pUSB_KBD_SIO_CHAN pSioChan;
  1899.     /* Kill typematic thread */
  1901.     if (typematicThread != NULL)
  1902. {
  1903. killTypematic = TRUE;
  1905. while (!typematicExit)
  1906.     OSS_THREAD_SLEEP (1);
  1908. OSS_THREAD_DESTROY (typematicHandle);
  1909. }
  1912.     /* Dispose of any outstanding notification requests */
  1914.     while ((pRequest = usbListFirst (&reqList)) != NULL)
  1915. destroyAttachRequest (pRequest);
  1918.     /* Dispose of any open keyboard connections. */
  1920.     while ((pSioChan = usbListFirst (&sioList)) != NULL)
  1921. destroySioChan (pSioChan);
  1922.     
  1924.     /* Release our connection to the USBD.  The USBD automatically 
  1925.      * releases any outstanding dynamic attach requests when a client
  1926.      * unregisters.
  1927.      */
  1929.     if (usbdHandle != NULL)
  1930. {
  1931. usbdClientUnregister (usbdHandle);
  1932. usbdHandle = NULL;
  1933. }
  1936.     /* Release resources. */
  1938.     if (kbdMutex != NULL)
  1939. {
  1940. OSS_MUTEX_DESTROY (kbdMutex);
  1941. kbdMutex = NULL;
  1942. }
  1945.     return ossStatus (errCode);
  1946.     }
  1949. /***************************************************************************
  1950. *
  1951. * usbKeyboardDevInit - initialize USB keyboard SIO driver
  1952. *
  1953. * Initializes the USB keyboard SIO driver.  The USB keyboard SIO driver
  1954. * maintains an initialization count, so calls to this function may be
  1955. * nested.
  1956. *
  1957. * RETURNS: OK, or ERROR if unable to initialize.
  1958. *
  1959. * ERRNO:
  1960. *
  1961. *   S_usbKeyboardLib_OUT_OF_RESOURCES
  1962. *   S_usbKeyboardLib_USBD_FAULT
  1963. */
  1965. STATUS usbKeyboardDevInit (void)
  1966.     {
  1967.     /* If not already initialized, then initialize internal structures
  1968.      * and connection to USBD.
  1969.      */
  1971.     if (initCount == 0)
  1972. {
  1973. /* Initialize lists, structures, resources. */
  1975. memset (&sioList, 0, sizeof (sioList));
  1976. memset (&reqList, 0, sizeof (reqList));
  1977. kbdMutex = NULL;
  1978. usbdHandle = NULL;
  1979. typematicHandle = NULL;
  1980. killTypematic = FALSE;
  1981. typematicExit = FALSE;
  1984. if (OSS_MUTEX_CREATE (&kbdMutex) != OK)
  1985.     return doShutdown (S_usbKeyboardLib_OUT_OF_RESOURCES);
  1988. /* Initialize typematic repeat thread */
  1990. if (OSS_THREAD_CREATE (typematicThread, 
  1991.        NULL, 
  1992.        OSS_PRIORITY_LOW,
  1993.        TYPEMATIC_NAME, 
  1994.        &typematicHandle) 
  1995.      != OK)
  1996.     return doShutdown (S_usbKeyboardLib_OUT_OF_RESOURCES);
  1999. /* Establish connection to USBD */
  2001. if (usbdClientRegister (KBD_CLIENT_NAME, &usbdHandle) != OK ||
  2002.     usbdDynamicAttachRegister (usbdHandle, 
  2003.        USB_CLASS_HID,
  2004.        USB_SUBCLASS_HID_BOOT, 
  2005.        USB_PROTOCOL_HID_BOOT_KEYBOARD,
  2006.        usbKeyboardAttachCallback) 
  2007.      != OK)
  2008. {
  2009. return doShutdown (S_usbKeyboardLib_USBD_FAULT);
  2010. }
  2011. }
  2013.     initCount++;
  2015.     return OK;
  2016.     }
  2019. /***************************************************************************
  2020. *
  2021. * usbKeyboardDevShutdown - shuts down keyboard SIO driver
  2022. *
  2023. * RETURNS: OK, or ERROR if unable to shutdown.
  2024. *
  2025. * ERRNO:
  2026. *   S_usbKeyboardLib_NOT_INITIALIZED
  2027. */
  2029. STATUS usbKeyboardDevShutdown (void)
  2030.     {
  2031.     /* Shut down the USB keyboard SIO driver if the initCount goes to 0. */
  2033.     if (initCount == 0)
  2034. return ossStatus (S_usbKeyboardLib_NOT_INITIALIZED);
  2036.     if (--initCount == 0)
  2037. return doShutdown (OK);
  2039.     return OK;
  2040.     }
  2043. /***************************************************************************
  2044. *
  2045. * usbKeyboardDynamicAttachRegister - Register keyboard attach callback
  2046. *
  2047. * <callback> is a caller-supplied function of the form:
  2048. *
  2049. * .CS
  2050. * typedef (*USB_KBD_ATTACH_CALLBACK) 
  2051. *     (
  2052. *     pVOID arg,
  2053. *     SIO_CHAN *pSioChan,
  2054. *     UINT16 attachCode
  2055. *     );
  2056. * .CE
  2057. *
  2058. * usbKeyboardLib will invoke <callback> each time a USB keyboard
  2059. * is attached to or removed from the system.  <arg> is a caller-defined
  2060. * parameter which will be passed to the <callback> each time it is
  2061. * invoked.  The <callback> will also be passed a pointer to the 
  2062. * SIO_CHAN structure for the channel being created/destroyed and
  2063. * an attach code of USB_KBD_ATTACH or USB_KBD_REMOVE.
  2064. *
  2065. * RETURNS: OK, or ERROR if unable to register callback
  2066. *
  2067. * ERRNO:
  2068. *   S_usbKeyboardLib_BAD_PARAM
  2069. *   S_usbKeyboardLib_OUT_OF_MEMORY
  2070. */
  2072. STATUS usbKeyboardDynamicAttachRegister
  2073.     (
  2074.     USB_KBD_ATTACH_CALLBACK callback, /* new callback to be registered */
  2075.     pVOID arg     /* user-defined arg to callback */
  2076.     )
  2078.     {
  2079.     pATTACH_REQUEST pRequest;
  2080.     pUSB_KBD_SIO_CHAN pSioChan;
  2081.     int status = OK;
  2084.     /* Validate parameters */
  2086.     if (callback == NULL)
  2087. return ossStatus (S_usbKeyboardLib_BAD_PARAM);
  2090.     OSS_MUTEX_TAKE (kbdMutex, OSS_BLOCK);
  2093.     /* Create a new request structure to track this callback request. */
  2095.     if ((pRequest = OSS_CALLOC (sizeof (*pRequest))) == NULL)
  2096. status = S_usbKeyboardLib_OUT_OF_MEMORY;
  2097.     else
  2098. {
  2099. pRequest->callback = callback;
  2100. pRequest->callbackArg = arg;
  2102. usbListLink (&reqList, pRequest, &pRequest->reqLink, LINK_TAIL);
  2105. /* Perform an initial notification of all currrently attached
  2106.  * keyboard devices.
  2107.  */
  2109. pSioChan = usbListFirst (&sioList);
  2111. while (pSioChan != NULL)
  2112.     {
  2113.     if (pSioChan->connected)
  2114. (*callback) (arg, (SIO_CHAN *) pSioChan, USB_KBD_ATTACH);
  2116.     pSioChan = usbListNext (&pSioChan->sioLink);
  2117.     }
  2118. }
  2120.     OSS_MUTEX_RELEASE (kbdMutex);
  2122.     return ossStatus (status);
  2123.     }
  2126. /***************************************************************************
  2127. *
  2128. * usbKeyboardDynamicAttachUnregister - Unregisters keyboard attach callback
  2129. *
  2130. * This function cancels a previous request to be dynamically notified for
  2131. * keyboard attachment and removal.  The <callback> and <arg> paramters must
  2132. * exactly match those passed in a previous call to 
  2133. * usbKeyboardDynamicAttachRegister().
  2134. *
  2135. * RETURNS: OK, or ERROR if unable to unregister callback
  2136. *
  2137. * ERRNO:
  2138. *   S_usbKeyboardLib_NOT_REGISTERED
  2139. */
  2141. STATUS usbKeyboardDynamicAttachUnRegister
  2142.     (
  2143.     USB_KBD_ATTACH_CALLBACK callback, /* callback to be unregistered */
  2144.     pVOID arg     /* user-defined arg to callback */
  2145.     )
  2147.     {
  2148.     pATTACH_REQUEST pRequest;
  2149.     int status = S_usbKeyboardLib_NOT_REGISTERED;
  2151.     OSS_MUTEX_TAKE (kbdMutex, OSS_BLOCK);
  2153.     pRequest = usbListFirst (&reqList);
  2155.     while (pRequest != NULL)
  2156. {
  2157. if (callback == pRequest->callback && arg == pRequest->callbackArg)
  2158.     {
  2159.     /* We found a matching notification request. */
  2161.     destroyAttachRequest (pRequest);
  2162.     status = OK;
  2163.     break;
  2164.     }
  2166. pRequest = usbListNext (&pRequest->reqLink);
  2167. }
  2169.     OSS_MUTEX_RELEASE (kbdMutex);
  2171.     return ossStatus (status);
  2172.     }
  2175. /***************************************************************************
  2176. *
  2177. * usbKeyboardSioChanLock - Marks SIO_CHAN structure as in use
  2178. *
  2179. * A caller uses usbKeyboardSioChanLock() to notify usbKeyboardLib that
  2180. * it is using the indicated SIO_CHAN structure.  usbKeyboardLib maintains
  2181. * a count of callers using a particular SIO_CHAN structure so that it 
  2182. * knows when it is safe to dispose of a structure when the underlying
  2183. * USB keyboard is removed from the system.  So long as the "lock count"
  2184. * is greater than zero, usbKeyboardLib will not dispose of an SIO_CHAN
  2185. * structure.
  2186. *
  2187. * RETURNS: OK, or ERROR if unable to mark SIO_CHAN structure in use.
  2188. */
  2190. STATUS usbKeyboardSioChanLock
  2191.     (
  2192.     SIO_CHAN *pChan /* SIO_CHAN to be marked as in use */
  2193.     )
  2195.     {
  2196.     pUSB_KBD_SIO_CHAN pSioChan = (pUSB_KBD_SIO_CHAN) pChan;
  2197.     pSioChan->lockCount++;
  2199.     return OK;
  2200.     }
  2203. /***************************************************************************
  2204. *
  2205. * usbKeyboardSioChanUnlock - Marks SIO_CHAN structure as unused
  2206. *
  2207. * This function releases a lock placed on an SIO_CHAN structure.  When a
  2208. * caller no longer needs an SIO_CHAN structure for which it has previously
  2209. * called usbKeyboardSioChanLock(), then it should call this function to
  2210. * release the lock.
  2211. *
  2212. * NOTE: If the underlying USB keyboard device has already been removed
  2213. * from the system, then this function will automatically dispose of the
  2214. * SIO_CHAN structure if this call removes the last lock on the structure.
  2215. * Therefore, a caller must not reference the SIO_CHAN again structure after
  2216. * making this call.
  2217. *
  2218. * RETURNS: OK, or ERROR if unable to mark SIO_CHAN structure unused
  2219. *
  2220. * ERRNO:
  2221. *   S_usbKeyboardLib_NOT_LOCKED
  2222. */
  2224. STATUS usbKeyboardSioChanUnlock
  2225.     (
  2226.     SIO_CHAN *pChan /* SIO_CHAN to be marked as unused */
  2227.     )
  2229.     {
  2230.     pUSB_KBD_SIO_CHAN pSioChan = (pUSB_KBD_SIO_CHAN) pChan;
  2231.     int status = OK;
  2234.     OSS_MUTEX_TAKE (kbdMutex, OSS_BLOCK);
  2236.     if (pSioChan->lockCount == 0)
  2237. status = S_usbKeyboardLib_NOT_LOCKED;
  2238.     else
  2239. {
  2240. /* If this is the last lock and the underlying USB keyboard is
  2241.  * no longer connected, then dispose of the keyboard.
  2242.  */
  2244. if (--pSioChan->lockCount == 0 && !pSioChan->connected)
  2245.     destroySioChan (pSioChan);
  2246. }
  2248.     OSS_MUTEX_RELEASE (kbdMutex);
  2250.     return ossStatus (status);
  2251.     }