/////////////////////////////////////////////////////////////////////////// //// usb.c //// //// //// //// Standard USB request and token handler code. //// //// //// //// This file is part of CCS's PIC USB driver code, which includes: //// //// usb_desc_*.h - an example set of config and device descriptor //// //// usb.c - USB token and request handler code //// //// usb.h - definitions, prototypes and global variables //// //// //// //// The following examples are provided by CCS: //// //// ex_usb_mouse.c - A HID Mouse. //// //// ex_usb_hid.c - A custom application using HID protocol. //// //// ex_usb_kbmouse.c - A HID Mouse/Keyboard combo using multiple //// //// interfaces. //// //// ex_usb_kbmouse.c - A HID Mouse/Keyboard combo using multiple //// //// HID Reports. //// //// ex_usb_scope.c - A digital oscilloscope using a custom //// //// protocol requiring custom Windows drivers. //// //// //// //// Many settings important to the USB API are defined in usb.h. //// //// See the documentation in usb.h about these settings. //// //// //// //// The majority of this code is called and used by the interrupt //// //// generated by the hardware level, and therefore it is not meant //// //// to be called by the user. The following functions are of use to //// //// the user (for more docs on the functions, read the comments at //// //// each function): //// //// //// //// ********************** FUNCTIONS *********************** //// //// //// //// usb_enumerated() - returns TRUE if device has been enumerated //// //// (configured) by host, FALSE if it has not. //// //// Do not try to use the USB peripheral until you //// //// are enumerated. //// //// //// //// usb_wait_for_enumeration() - Sits in an infinte loop until device //// //// is enumerated. //// //// //// //// usb_kbhit() - Returns true if OUT endpoint contains data from //// //// host. //// //// //// //// usb_puts() - Sends a multiple packet message to the host //// //// //// //// usb_gets() - Gets multiple packets from the host //// //// //// //// The rest of the functions in this file are part of the USB //// //// interrupt service routine and are not meant to be called by the //// //// user. //// //// //// //// ************************* NOTE ************************** //// //// This code will not create a multiple configuration device. //// //// If you wish to create a multiple configuration device then you //// //// will have to modify these drivers. //// //// //// //// ************************* NOTE ************************** //// //// This code does not support Get_Idle or Set_Idle HID-specific //// //// requests. These requests are optional. If you want to support //// //// these requests you must provide the code yourself. See //// //// usb_isr_tkn_setup_ClassInterface() if you wish to add this //// //// support. //// /////////////////////////////////////////////////////////////////////////// //// //// //// If you wish to provide your own USB peripheral hardware layer, it //// //// must include the following functions: //// //// //// //// void usb_stall_ep(int8 endpoint); //// //// void usb_unstall_ep(int8 endpoint); //// //// int1 usb_endpoint_stalled(int8 endpoint); //// //// void usb_set_address(int8 address); //// //// void usb_set_configured(int config); //// //// int8 usb_get_packet(int8 endpoint, int8 * ptr, int8 max); //// //// int1 usb_put_packet(int endpoint, int * ptr, int len, USB_DTS_BIT toggle); //// //// void usb_request_send_response(int8 len); //// //// int1 usb_kbhit(int8 endpoint); //// //// //// //// CCS provides a USB peripheral hardware layer for PIC16C7x5 //// //// (pic_usb.h), 18Fxx5x (pic18_usb.h) and National's USBN960x //// //// (usbn960x.c). See these files for more documentation. //// //// //// /////////////////////////////////////////////////////////////////////////// //// //// //// Version History: //// //// //// //// July 13th, 2005: //// //// usb_puts() packet_size and this_packet_len changed to 16bits. //// //// usb_gets() len, packet_size and this_packet_len to 16bits. //// //// //// //// June 20th, 2005: //// //// Initial 18fxx5x release. //// //// usb_kbhit() removed, usb_kbhit() now implemented in hardware //// //// layer. //// //// //// //// May 13th, 2005: //// //// Beta release, only works with 18Fxx5x hardware layer. //// //// Now supports multiple interfaces (many defines in descriptors //// //// will have to be changed, see examples) //// //// TODO: alot of indexing and length handling for descriptors is //// //// only 8bit, so make sure all descriptor tables are less than //// //// 256 bytes long. //// //// //// //// Apr 21st, 2005: //// //// Initial Alpha Release with PIC18Fxx5x support. (ONLY TESTED //// //// WITH 18F4550) //// //// usb_puts() doesn't need max packet size as a paremeter, uses //// //// usb_ep_tx_size[] defined in usb.h //// //// usb_puts() timeout parameter now in ms, not seconds. //// //// USB Stack no longer buffers incoming data. If there is data to //// //// get usb_kbhit(en) will return TRUE and the data will sit in //// //// the endpoint buffer until you usb_get_packet(), which will //// //// then free the endpoint buffer for more data. This affects //// //// routines such as usb_gets() and usb_kbhit(). //// //// usb_gets() no longer reads buffered data (see above note), //// //// now it reads multiple packets in the same way usb_puts() //// //// writes multiple packets //// //// usb_kbhit() is hardware specific, so has been moved to hardware //// //// layer. //// //// //// //// Nov 11th, 2004: //// //// No longer includes wrong descriptor header. //// //// //// //// June 24th, 2004: //// //// Optimization and cleanup. //// //// The following definitions changed: //// //// USB_EPx_TX_ENABLE and USB_EPx_RX_ENABLE have changed. See usb.h //// //// USB_CONFIG_DESCRIPTORS[] removed //// //// USB_CONFIG_DESC_LEN changed to USB_DESC_CONFIG_LEN //// //// USB_INTERFACE_DESC_LEN changed to USB_DESC_INTERFACE_LEN //// //// USB_CLASS_DESC_LEN changed to USB_DESC_CLASS_LEN //// //// USB_ENDPOINT_DESC_LEN changed to USB_DESC_ENDPOINT_LEN //// //// USB_CONFIG_DESC_KEY changed to USB_DESC_CONFIG_TYPE //// //// USB_INTERFACE_DESC_KEY changed to USB_DESC_INTERFACE_TYPE //// //// USB_CLASS_DESC_KEY changed to USB_DESC_CLASS_TYPE //// //// USB_ENDPOINT_DESC_KEY changed to USB_DESC_ENDPOINT_TYPE //// //// USB_STRING_X[] arrays removed, see USB_STRING_DESC[] and //// //// USB_STRING_DESC_OFFSET[] //// //// dev_req, curr_config, status_device and getdesc_type global //// //// variables moved into struct USB_stack_status //// //// //// //// December 5th, 2003: Fixed a potential bug where descriptors are //// //// evenly dividable by 8 (MAX_EP0_PACKET_SIZE) //// //// //// //// October 15th, 2003: Support for boot protocol added. //// //// Set USB_HID_BOOT_PROTOCOL to TRUE to support this. //// //// The array hid_protocol[] saves which protocol mode each //// //// interface is in. It is your applications job to send //// //// data that either fit the boot protocol or HID protocol. //// //// //// //// May 6th, 2003: Fixed a potential stack overflow using PCM //// //// //// //// October 28th, 2002: Problem with usb_puts and timeout fixed. //// //// //// //// October 28th, 2002: Typo fixed in get_next_string_character(), //// //// although it didn't cause any serious problems //// //// //// //// October 25th, 2002: Another change to usb_puts() was made to fix //// //// problems with multiple packet messages //// //// October 29th, 2002: Fixed a problem with multiple packet string //// //// descriptors that require a 0 len packet to //// //// end message. //// //// //// //// October 23rd, 2002: usb_puts() will bomb out of error quicker //// //// //// //// August 2nd, 2002: Initial Public Release //// //// //// /////////////////////////////////////////////////////////////////////////// //// (C) Copyright 1996,2005 Custom Computer Services //// //// This source code may only be used by licensed users of the CCS //// //// C compiler. This source code may only be distributed to other //// //// licensed users of the CCS C compiler. No other use, //// //// reproduction or distribution is permitted without written //// //// permission. Derivative programs created using this software //// //// in object code form are not restricted in any way. //// /////////////////////////////////////////////////////////////////////////// #IFNDEF __USB_DRIVER__ #DEFINE __USB_DRIVER__ #include #IFNDEF __USB_HARDWARE__ #ERROR You must include USB hardware driver. #ENDIF #IFNDEF __USB_DESCRIPTORS__ #ERROR You must include USB descriptors. #ENDIF int8 USB_address_pending; //save previous state because packets can take several isrs int8 usb_getdesc_ptr; int8 usb_getdesc_len=0; //for reading string and config descriptors #IF USB_HID_BOOT_PROTOCOL int8 hid_protocol[USB_NUM_HID_INTERFACES]; #ENDIF int8 USB_Interface[USB_MAX_NUM_INTERFACES]; //config state for all of our interfaces, NUM_INTERFACES defined with descriptors /// BEGIN User Functions /**************************************************************************** /* usb_kbhit(endpoint) /* /* Input: endpoint - endpoint to check /* /* Output: TRUE if there is new data in RX buffer, FALSE if there is not. /* /* Summary: Similar to kbhit(), sees if there is new data in the RX USB buffers. /* /*****************************************************************************/ #define usb_kbhit(x) bit_test(__usb_kbhit_status,x) /************************************************************** /* usb_enumerated() /* /* Input: Global variable USB_Curr_Config /* Returns: Returns a 1 if device is configured / enumerated, /* Returns a 0 if device is un-configured / not enumerated. /* /* Summary: Use this to see if device is configured / enumerated. /***************************************************************/ #define usb_enumerated() (USB_stack_status.curr_config) /************************************************************** /* usb_wait_for_enumeration() /* /* Input: Global variable USB_Curr_Config /* /* Summary: Waits in-definately until device is configured / enumerated. /***************************************************************/ void usb_wait_for_enumeration(void) { while (USB_stack_status.curr_config == 0) {restart_wdt();} } /**************************************************************************** /* usb_puts(endpoint, *ptr, len, timeout) /* /* Inputs: endpoint - endpoint to send data out /* ptr - points to array of data to send /* len - amount of data to send /* timeout - time in milli-seconds, for each packet, to wait before timeout. /* set to 0 for no timeout. /* /* Summary: Used for sending multiple packets of data as one message. If sending /* only one packet it is more effecient to use only usb_put_packet() /* /*****************************************************************************/ int1 usb_puts(int8 endpoint, int8 * ptr, int16 len, int8 timeout) { int16 i=0; int1 res; int16 this_packet_len; int16 packet_size; int32 timeout_1us; packet_size=usb_ep_tx_size[endpoint]; //send data packets until timeout or no more packets to send while (i < len) { timeout_1us=(int32)timeout*1000; if ((len - i) > packet_size) {this_packet_len=packet_size;} else {this_packet_len=len-i;} do { res=usb_put_packet(endpoint,ptr + i,this_packet_len,USB_DTS_TOGGLE); //send 64 byte packets if (!res) { delay_us(1); timeout_1us--; } } while (!res && timeout_1us); i+=packet_size; } //send 0len packet if needed if (i==len) { timeout_1us=(int32)timeout*1000; do { res=usb_put_packet(endpoint,0,0,USB_DTS_TOGGLE); //indicate end of message if (!res) { delay_us(1); timeout_1us--; } } while (!res && timeout_1us); } return(res); } /**************************************************************************** /* usb_gets(endpoint, ptr, max, timeout) /* /* Input: endpoint - endpoint to get data from /* ptr - place / array to store data to /* max - max amount of data to get from USB and store into ptr /* timeout - time in milliseconds, for each packet, to wait before timeout. /* set to 0 for no timeout. /* /* Output: Amount of data returned. It may be less than max. /* /* Summary: Gets data from the host. Will get multiple-packet messages /* and finish when either it receives a 0-len packet or a packet /* of less size than maximum. /* /* NOTE: NOT THOUROUGHLY TESTED. I AM NOT EVEN SURE IF THIS IS A GOOD IDEA /* /*****************************************************************************/ int8 usb_gets(int8 endpoint, int8 * ptr, int16 max, int16 timeout) { int16 ret=0; int16 to; int16 len; int16 packet_size; int16 this_packet_max; packet_size=usb_ep_rx_size[endpoint]; do { if (packet_size < max) {this_packet_max=packet_size;} else {this_packet_max=max;} to=0; do { if (usb_kbhit(endpoint)) { len=usb_get_packet(endpoint,ptr,this_packet_max); ptr+=len; max-=len; ret+=len; break; } else { to++; delay_ms(1); } } while (to!=timeout); } while ((len == packet_size) && (to!=timeout) && max); return(ret); } /// END User Functions /// BEGIN USB Token, standard and HID request handler (part of ISR) /************************************************************** /* usb_token_reset() /* /* Output: modifies global variables USB_Interface[], in[], usb_getdesc_ptr, /* usb_getdesc_len, USB_status_device, USB_dev_req /* /* Summary: Resets the token handler to initial (unconfigured) state. /***************************************************************/ void usb_token_reset() { int i; for (i=0;i usb_ep0_rx_buffer[6]) usb_getdesc_len = usb_ep0_rx_buffer[6]; } USB_stack_status.dev_req=GET_DESCRIPTOR; usb_copy_desc_seg_to_ep(); } /************************************************************** /* usb_finish_set_address() /* /* Input: USB_address_pending holds the address we were asked to set to. /* /* Summary: Sets the address. /* /* This code should only be run on the PIC USB peripheral, and not the /* National peripheral. /* /* Part of usb_isr_tok_setup_dne() /***************************************************************/ void usb_finish_set_address() { debug_usb(debug_putc," FSA "); USB_stack_status.curr_config=0; // make sure current configuration is 0 #ifdef __PIC__ USB_stack_status.dev_req=NONE; // no request pending usb_set_address(USB_address_pending); #endif } //////////////////////////////////////////////////////////////////////////// /// /// The following function retrieve data from constant arrays. This may /// look un-optimized, but remember that you can't create a pointer to /// a constant array. /// /////////////////////////////////////////////////////////////////////////// void usb_copy_desc_seg_to_ep(void) { int i=0; char c; while ((usb_getdesc_len)&&(i