usbtty.lst

OMAP1510的USB驱动程序

              
              /* usbtty_puts() helper function for finding the next '\n' in a string */
              static int next_nl_pos (const char *s)
              {
C51 COMPILER V8.09   USBTTY                                                                05/05/2008 19:48:27 PAGE 8   

                      int i;
              
                      for (i = 0; s[i] != '\0'; i++) {
                              if (s[i] == '\n')
                                      return i;
                      }
                      return i;
              }
              
              /*
               * Output a string to the usb client port.
               */
              static void __usbtty_puts (const char *str, int len)
              {
                      int maxlen = usbtty_output.totalsize;
                      int space, n;
              
                      /* break str into chunks < buffer size, if needed */
                      while (len > 0) {
                              space = maxlen - usbtty_output.size;
              
                              /* Empty buffer here, if needed, to ensure space... */
                              if (space <= 0) {
                                      write_buffer (&usbtty_output);
                                      space = maxlen - usbtty_output.size;
                                      if (space <= 0) {
                                              space = len;    /* allow old data to be overwritten. */
                                      }
                              }
              
                              n = MIN (space, MIN (len, maxlen));
                              buf_push (&usbtty_output, str, n);
              
                              str += n;
                              len -= n;
                      }
              }
              
              void usbtty_puts (const char *str)
              {
                      int n;
                      int len = strlen (str);
              
                      /* add '\r' for each '\n' */
                      while (len > 0) {
                              n = next_nl_pos (str);
              
                              if (str[n] == '\n') {
                                      __usbtty_puts (str, n + 1);
                                      __usbtty_puts ("\r", 1);
                                      str += (n + 1);
                                      len -= (n + 1);
                              } else {
                                      /* No \n found.  All done. */
                                      __usbtty_puts (str, n);
                                      break;
                              }
                      }
              
                      /* Poll at end to handle new data... */
                      usbtty_poll ();
              }
C51 COMPILER V8.09   USBTTY                                                                05/05/2008 19:48:27 PAGE 9   

              
              /*
               * Initialize the usb client port.
               *
               */
              int drv_usbtty_init (void)
              {
                      int rc;
                      char * sn;
                      int snlen;
              
                      if (!(sn = getenv("serial#"))) {
                              sn = "000000000000";
                      }
                      snlen = strlen(sn);
                      if (snlen > sizeof(serial_number) - 1) {
                              printf ("Warning: serial number %s is too long (%d > %d)\n",
                                      sn, snlen, sizeof(serial_number) - 1);
                              snlen = sizeof(serial_number) - 1;
                      }
                      memcpy (serial_number, sn, snlen);
                      serial_number[snlen] = '\0';
              
                      /* prepare buffers... */
                      buf_init (&usbtty_input, USBTTY_BUFFER_SIZE);
                      buf_init (&usbtty_output, USBTTY_BUFFER_SIZE);
              
                      /* Now, set up USB controller and infrastructure */
                      udc_init ();            /* Basic USB initialization */
              
                      usbtty_init_strings ();
                      usbtty_init_instances ();
              
                      udc_startup_events (device_instance);   /* Enable our device, initialize udc pointers */
                      udc_connect ();         /* Enable pullup for host detection */
              
                      usbtty_init_endpoints ();
              
                      /* Device initialization */
                      memset (&usbttydev, 0, sizeof (usbttydev));
              
                      strcpy (usbttydev.name, "usbtty");
                      usbttydev.ext = 0;      /* No extensions */
                      usbttydev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT;
                      usbttydev.tstc = usbtty_tstc;   /* 'tstc' function */
                      usbttydev.getc = usbtty_getc;   /* 'getc' function */
                      usbttydev.putc = usbtty_putc;   /* 'putc' function */
                      usbttydev.puts = usbtty_puts;   /* 'puts' function */
              
                      rc = device_register (&usbttydev);
              
                      return (rc == 0) ? 1 : rc;
              }
              
              static void usbtty_init_strings (void)
              {
                      struct usb_string_descriptor *string;
              
                      string = (struct usb_string_descriptor *) wstrManufacturer;
                      string->bLength = sizeof (wstrManufacturer);
                      string->bDescriptorType = USB_DT_STRING;
                      str2wide (CONFIG_USBD_MANUFACTURER, string->wData);
C51 COMPILER V8.09   USBTTY                                                                05/05/2008 19:48:27 PAGE 10  

              
                      string = (struct usb_string_descriptor *) wstrProduct;
                      string->bLength = sizeof (wstrProduct);
                      string->bDescriptorType = USB_DT_STRING;
                      str2wide (CONFIG_USBD_PRODUCT_NAME, string->wData);
              
                      string = (struct usb_string_descriptor *) wstrSerial;
                      string->bLength = 2 + 2*strlen(serial_number);
                      string->bDescriptorType = USB_DT_STRING;
                      str2wide (serial_number, string->wData);
              
                      string = (struct usb_string_descriptor *) wstrConfiguration;
                      string->bLength = sizeof (wstrConfiguration);
                      string->bDescriptorType = USB_DT_STRING;
                      str2wide (CONFIG_USBD_CONFIGURATION_STR, string->wData);
              
                      string = (struct usb_string_descriptor *) wstrInterface;
                      string->bLength = sizeof (wstrInterface);
                      string->bDescriptorType = USB_DT_STRING;
                      str2wide (CONFIG_USBD_INTERFACE_STR, string->wData);
              
                      /* Now, initialize the string table for ep0 handling */
                      usb_strings = usbtty_string_table;
              }
              
              static void usbtty_init_instances (void)
              {
                      int i;
              
                      /* initialize device instance */
                      memset (device_instance, 0, sizeof (struct usb_device_instance));
                      device_instance->device_state = STATE_INIT;
                      device_instance->device_descriptor = &device_descriptor;
                      device_instance->event = usbtty_event_handler;
                      device_instance->bus = bus_instance;
                      device_instance->configurations = NUM_CONFIGS;
                      device_instance->configuration_instance_array = config_instance;
              
                      /* initialize bus instance */
                      memset (bus_instance, 0, sizeof (struct usb_bus_instance));
                      bus_instance->device = device_instance;
                      bus_instance->endpoint_array = endpoint_instance;
                      bus_instance->max_endpoints = 1;
                      bus_instance->maxpacketsize = 64;
                      bus_instance->serial_number_str = serial_number;
              
                      /* configuration instance */
                      memset (config_instance, 0,
                              sizeof (struct usb_configuration_instance));
                      config_instance->interfaces = NUM_INTERFACES;
                      config_instance->configuration_descriptor = config_descriptors;
                      config_instance->interface_instance_array = interface_instance;
              
                      /* interface instance */
                      memset (interface_instance, 0,
                              sizeof (struct usb_interface_instance));
                      interface_instance->alternates = 1;
                      interface_instance->alternates_instance_array = alternate_instance;
              
                      /* alternates instance */
                      memset (alternate_instance, 0,
                              sizeof (struct usb_alternate_instance));
C51 COMPILER V8.09   USBTTY                                                                05/05/2008 19:48:27 PAGE 11  

                      alternate_instance->interface_descriptor = interface_descriptors;
                      alternate_instance->endpoints = NUM_ENDPOINTS;
                      alternate_instance->endpoints_descriptor_array = ep_descriptor_ptrs;
              
                      /* endpoint instances */
                      memset (&endpoint_instance[0], 0,
                              sizeof (struct usb_endpoint_instance));
                      endpoint_instance[0].endpoint_address = 0;
                      endpoint_instance[0].rcv_packetSize = EP0_MAX_PACKET_SIZE;
                      endpoint_instance[0].rcv_attributes = USB_ENDPOINT_XFER_CONTROL;
                      endpoint_instance[0].tx_packetSize = EP0_MAX_PACKET_SIZE;
                      endpoint_instance[0].tx_attributes = USB_ENDPOINT_XFER_CONTROL;
                      udc_setup_ep (device_instance, 0, &endpoint_instance[0]);
              
                      for (i = 1; i <= NUM_ENDPOINTS; i++) {
                              memset (&endpoint_instance[i], 0,
                                      sizeof (struct usb_endpoint_instance));
              
                              endpoint_instance[i].endpoint_address =
                                      ep_descriptors[i - 1].bEndpointAddress;
              
                              endpoint_instance[i].rcv_packetSize =
                                      ep_descriptors[i - 1].wMaxPacketSize;
                              endpoint_instance[i].rcv_attributes =