usrusbkbdinit.c

T2.0 USB driver.rar T2.0 USB driver.rar

/* usrUsbKbdInit.c - Initialization of the USB Keyboard driver */

/* Copyright 1999-2001 Wind River Systems, Inc. */

/*
Modification history
--------------------
01b,02feb01,wef Added ios functionality - allows for open, close, read,
                ioctl, etc access to the printer.
01a,23aug00,wef	Created
*/

/*
DESCRIPTION

This configlette initializes the USB keyboard driver.  This assumes the
USB host stack has already been initialized and has a host controller
driver attached.   

This configlette demonstrates how a user might integrate a USB class 
driver into the vxWorks file system.  usbKbdDevCreate () intalls a USB
keyboard and its associated driver functions into the driver table allowing
the keyboard to be accesed with standard fopen, close, read, write, etc. type
calls.  

There is an included test routine playWithKeyboard () that demonstrates 
using the ios functionality

*/


/* includes */

#include "drv/usb/usbKeyboardLib.h"
#include "usb/usbHid.h"
#include "vxWorks.h"
#include "iv.h"
#include "ioLib.h"
#include "iosLib.h"
#include "tyLib.h"
#include "intLib.h"
#include "errnoLib.h"
#include "sioLib.h"
#include "stdlib.h"
#include "stdio.h"
#include "logLib.h"
#include "selectLib.h"


/* defines */

#define TX_BUF_NUM	0x10000

#define USB_KBD_MUTEX_TAKE(tmout)		\
    semTake (usbKbdMutex, (int) (tmout))

#define USB_KBD_MUTEX_GIVE			\
    semGive (usbKbdMutex)

#define USB_KBD_LIST_SEM_TAKE(tmout)		\
    semTake (usbKbdListMutex, (int) (tmout))

#define USB_KBD_LIST_SEM_GIVE			\
    semGive (usbKbdListMutex)


#define KBD_NAME_LEN_MAX        100
#define USB_KBD_NAME		"/usbKb/"


#define CTRL_Z			    26	/* ASCI code for ^Z */


/* data types */

/* typedefs */
 
typedef struct usb_kbd_node
    {
    NODE		node;
    struct usb_kbd_dev	* pUsbKbdDev;
    } USB_KBD_NODE;

typedef struct usb_kbd_dev /* USB_KBD_DEV */
    {
    DEV_HDR             ioDev;
    SIO_CHAN    *       pSioChan;
    UINT16              numOpen;
    UINT32              bufSize;
    UCHAR	*       buff;
    SEL_WAKEUP_LIST     selList;
    USB_KBD_NODE	* pUsbKbdNode;
    } USB_KBD_DEV;
 

/* local variables */

LOCAL SEM_ID    usbKbdMutex;		/* mutex semaphore */
LOCAL SEM_ID    usbKbdListMutex;	/* mutex semaphore to protect list */
LOCAL UINT32	kbdCount = 0;
LOCAL LIST      usbKbdList;		/* all USB keyboards in the system */

LOCAL SIO_CHAN *pKbdSioChan;

LOCAL int usbKbdDrvNum = 0;		/* driver number */

LOCAL BOOL enterPressed;

/* forward declarations */

LOCAL void	kbdAttachCallback (void * arg, SIO_CHAN *pChan, 
				   UINT16 attachCode);

LOCAL void	usbKbdDrvAttachCallback (void * arg, SIO_CHAN *pChan, 
					 UINT16 attachCode);


LOCAL int	usbKbdRead (USB_KBD_DEV * pUsbKbdDev,UCHAR *buffer, 
			    UINT32 nBytes);

LOCAL int	usbKbdClose (USB_KBD_DEV * pUsbKbdDev);

LOCAL int	usbKbdWrite (USB_KBD_DEV * pUsbKbdDev, UCHAR * buffer,
			     UINT32 nBytes);

LOCAL int	usbKbdOpen (USB_KBD_DEV * pUsbKbdDev, char * name,
			    int flags, int mode);

LOCAL STATUS	usbKbdTxCallback (void *, char *);

LOCAL int 	usbKbdIoctl (USB_KBD_DEV * pUsbKbdDev, int request, void * arg);

LOCAL STATUS 	usbKbdDevFind (SIO_CHAN *pChan, USB_KBD_DEV * pUsbKbdDev);

LOCAL STATUS	usbKbdDevDelete (USB_KBD_DEV * pUsbKbdDev);


/*******************************************************************************
*
* usbKbdDevCreate - create a VxWorks device for an USB keyboard
*
* This routine creates a device on a specified serial channel.  Each channel
* to be used should have exactly one device associated with it by calling
* this routine.
*
* For instance, to create the device "/ /0", the proper call would be:
* .CS
*     usbKbdDevCreate ("/usbKb/0", pSioChan);
* .CE
* Where pSioChan is the address of the underlying SIO_CHAN serial channel
* descriptor (defined in sioLib.h).
* This routine is typically called by the USB keyboard driver, when it detects 
* an insertion of a USB keyboard.
*
* RETURNS: OK, or ERROR if the driver is not installed, or the
* device already exists, or failed to allocate memory.
*/

STATUS usbKbdDevCreate
    (
    char	* name,         /* name to use for this device      */
    SIO_CHAN	* pSioChan	/* pointer to core driver structure */
    )
    {
    USB_KBD_NODE	* pUsbKbdNode = NULL;   /* pointer to device node */
    USB_KBD_DEV		* pUsbKbdDev = NULL;     /* pointer to USB device */


    /* Create the mutex semaphores */
 
    usbKbdMutex = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE |
			      SEM_INVERSION_SAFE);
 
    usbKbdListMutex = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE |
				  SEM_INVERSION_SAFE);
 
    /* initialize the linked list */
 
    lstInit (&usbKbdList);

    /* Install the appropriate functions into the driver table */

    usbKbdDrvNum = iosDrvInstall ((FUNCPTR) NULL, 
				  (FUNCPTR) usbKbdDevDelete, 
				  (FUNCPTR) usbKbdOpen, 
				  (FUNCPTR) usbKbdClose, 
				  (FUNCPTR) usbKbdRead, 
				  (FUNCPTR) usbKbdWrite, 
				  (FUNCPTR) usbKbdIoctl);

    /*  check to see if there was room to install the driver */

    if (usbKbdDrvNum <= 0)
        {
        errnoSet (S_ioLib_NO_DRIVER);
	printf ("There is no more room in the driver table\n");
	return (ERROR);
        }


    if (pSioChan == (SIO_CHAN *) ERROR)
	{
	printf ("pSioChan is ERROR\n");
	return (ERROR);
	}

    /* allocate memory for the device */

    if ((pUsbKbdDev = (USB_KBD_DEV *) calloc (1, sizeof (USB_KBD_DEV))) == NULL)
	{
	printf ("calloc returned NULL - out of memory\n");
	return (ERROR);
	}

    pUsbKbdDev->pSioChan = pSioChan;

    /* allocate memory for this node, and populate it */

    pUsbKbdNode = (USB_KBD_NODE *) calloc (1, sizeof (USB_KBD_NODE));

    /* record useful information */

    pUsbKbdNode->pUsbKbdDev = pUsbKbdDev;
    pUsbKbdDev->pUsbKbdNode = pUsbKbdNode;

    /* add the node to the list */

    USB_KBD_LIST_SEM_TAKE (WAIT_FOREVER);

    lstAdd (&usbKbdList, (NODE *) pUsbKbdNode);

    USB_KBD_LIST_SEM_GIVE;
 
    /* allow for select support */

    selWakeupListInit (&pUsbKbdDev->selList);

    /* start the device in the only supported mode */

    sioIoctl (pUsbKbdDev->pSioChan, SIO_MODE_SET, (void *) SIO_MODE_INT);

    /* add the device to the I/O system */

    return (iosDevAdd (&pUsbKbdDev->ioDev, name, usbKbdDrvNum));
    }




/*******************************************************************************
*
* usbKbdDevDelete - delete a VxWorks device for an USB keyboard
*
* This routine deletes a device on a specified serial channel.  
*
* This routine is typically called by the USB keyboard driver, when it detects 
* a removal of a USB keyboard.
*
* RETURNS: OK, or ERROR if the driver is not installed.
*/

LOCAL STATUS usbKbdDevDelete
    (
    USB_KBD_DEV	* pUsbKbdDev		/* keyboard device to read from */
    )
    {
    int		status = OK;		/* holder for the return value */

    if (usbKbdDrvNum <= 0)
        {
        errnoSet (S_ioLib_NO_DRIVER);
        return (ERROR);
        }

    /* remove the device from the I/O system */

    iosDevDelete (&pUsbKbdDev->ioDev);

    /* remove from list */

    USB_KBD_LIST_SEM_TAKE (WAIT_FOREVER);
    lstDelete (&usbKbdList, (NODE *) pUsbKbdDev->pUsbKbdNode);
    USB_KBD_LIST_SEM_GIVE;

    /* free memory for the device */

    free (pUsbKbdDev->pUsbKbdNode);
    free (pUsbKbdDev);

    return (status);
    }


/*************************************************************************
*
* usbKbdDevFind - find the USB_KBD_DEV device for an SIO channel
*
* RETURNS: OK, or ERROR
*/
 
LOCAL STATUS usbKbdDevFind
    (
    SIO_CHAN *		pChan,          /* pointer to affected SIO_CHAN */
    USB_KBD_DEV *	pUsbKbdDev	/* pointer to an USB_KBD_DEV */
    )
    {
    USB_KBD_NODE *      pUsbKbdNode = NULL;     /* pointer to USB device node */
    USB_KBD_DEV *	pTempDev;		/* pointer to an USB_KBD_DEV */

    if (pChan == NULL)
        return (ERROR);
 
    /* protect it from other module's routines */
 
    USB_KBD_LIST_SEM_TAKE (WAIT_FOREVER);
 
    /* loop through all the devices */
 
    for (pUsbKbdNode = (USB_KBD_NODE *) lstFirst (&usbKbdList);
         pUsbKbdNode != NULL;
         pUsbKbdNode = (USB_KBD_NODE *) lstNext ((NODE *) pUsbKbdNode))
        {
        pTempDev = pUsbKbdNode->pUsbKbdDev;

	/* return as soon as you find it */
	if (pTempDev->pSioChan == pChan)
	    {
	    * (UINT32 *) pUsbKbdDev = (UINT32) pTempDev;
	    USB_KBD_LIST_SEM_GIVE;
	    return (OK);
	    }
        }

    USB_KBD_LIST_SEM_GIVE;

    return (ERROR);
    }

/*************************************************************************
*
* kbdAttachCallback - receives attach callbacks from keyboard SIO driver
*
* RETURNS: N/A
*/
LOCAL void kbdAttachCallback
    (
    void * arg,			/* caller-defined argument */
    SIO_CHAN *pChan,		/* pointer to affected SIO_CHAN */
    UINT16 attachCode		/* defined as USB_KBD_xxxx */
    )
    {
    UINT32	usbKbdDev;		/* keyboard device */
    char	kbdName [KBD_NAME_LEN_MAX];	/* keyboard name */

    /*  A keyboard has been attached. */

    if (attachCode == USB_KBD_ATTACH)
	{

	/*  Lock this particular channel for this particular keyboard */
	
	if (usbKeyboardSioChanLock (pChan) != OK)
	    {
	    printf("usbKeyboardSioChanLock () returned ERROR\n");
	    }
	else
	    {