dereferencing NULL pointer

|static inline struct hso_serial *get_serial_by_tty(struct tty_struct *tty)
|{
| if (tty)
|  return tty->driver_data;
| return ((void *)0);
|}
|enum pkt_parse_state {
| WAIT_IP,
| WAIT_DATA,
| WAIT_SYNC
|};
|
|
|
|
|
|struct hso_shared_int {
| struct usb_endpoint_descriptor *intr_endp;
| void *shared_intr_buf;
| struct urb *shared_intr_urb;
| struct usb_device *usb;
| int use_count;
| int ref_count;
| struct mutex shared_int_lock;
|};
|
|struct hso_net {
| struct hso_device *parent;
| struct net_device *net;
| struct rfkill *rfkill;
|
| struct usb_endpoint_descriptor *in_endp;
| struct usb_endpoint_descriptor *out_endp;
|
| struct urb *mux_bulk_rx_urb_pool[4];
| struct urb *mux_bulk_tx_urb;
| void *mux_bulk_rx_buf_pool[4];
| void *mux_bulk_tx_buf;
|
| struct sk_buff *skb_rx_buf;
| struct sk_buff *skb_tx_buf;
|
| enum pkt_parse_state rx_parse_state;
| spinlock_t net_lock;
|
| unsigned short rx_buf_size;
| unsigned short rx_buf_missing;
| struct iphdr rx_ip_hdr;
|
| unsigned long flags;
|};
|
|enum rx_ctrl_state{
| RX_IDLE,
| RX_SENT,
| RX_PENDING
|};
|struct hso_serial_state_notification {
| u8 bmRequestType;
| u8 bNotification;
| u16 wValue;
| u16 wIndex;
| u16 wLength;
| u16 UART_state_bitmap;
|} ;
|
|struct hso_tiocmget {
| struct mutex mutex;
| wait_queue_head_t waitq;
| int intr_completed;
| struct usb_endpoint_descriptor *endp;
| struct urb *urb;
| struct hso_serial_state_notification serial_state_notification;
| u16 prev_UART_state_bitmap;
| struct uart_icount icount;
|};
|
|
|struct hso_serial {
| struct hso_device *parent;
| int magic;
| u8 minor;
|
| struct hso_shared_int *shared_int;
|
|
|
| struct urb *rx_urb[2];
| u8 num_rx_urbs;
| u8 *rx_data[2];
| u16 rx_data_length;
|
| struct urb *tx_urb;
| u8 *tx_data;
| u8 *tx_buffer;
| u16 tx_data_length;
| u16 tx_data_count;
| u16 tx_buffer_count;
| struct usb_ctrlrequest ctrl_req_tx;
| struct usb_ctrlrequest ctrl_req_rx;
|
| struct usb_endpoint_descriptor *in_endp;
| struct usb_endpoint_descriptor *out_endp;
|
| enum rx_ctrl_state rx_state;
| u8 rts_state;
| u8 dtr_state;
| unsigned tx_urb_used:1;
|
|
| struct tty_struct *tty;
| int open_count;
| spinlock_t serial_lock;
|
| int (*write_data) (struct hso_serial *serial);
| struct hso_tiocmget *tiocmget;
|
|
|
|
| int curr_rx_urb_idx;
| u16 curr_rx_urb_offset;
| u8 rx_urb_filled[2];
| struct tasklet_struct unthrottle_tasklet;
| struct work_struct retry_unthrottle_workqueue;
|};
|
|struct hso_device {
| union {
|  struct hso_serial *dev_serial;
|  struct hso_net *dev_net;
| } port_data;
|
| u32 port_spec;
|
| u8 is_active;
| u8 usb_gone;
| struct work_struct async_get_intf;
| struct work_struct async_put_intf;
| struct work_struct reset_device;
|
| struct usb_device *usb;
| struct usb_interface *interface;
|
| struct device *dev;
| struct kref ref;
| struct mutex mutex;
|};
|static int hso_serial_tiocmset(struct tty_struct *tty, struct file *file,
|          unsigned int set, unsigned int clear);
|static void ctrl_callback(struct urb *urb);
|static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial);
|static void hso_kick_transmit(struct hso_serial *serial);
|
|static int hso_mux_submit_intr_urb(struct hso_shared_int *mux_int,
|       struct usb_device *usb, gfp_t gfp);
|static void handle_usb_error(int status, const char *function,
|        struct hso_device *hso_dev);
|static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
|        int type, int dir);
|static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports);
|static void hso_free_interface(struct usb_interface *intf);
|static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags);
|static int hso_stop_serial_device(struct hso_device *hso_dev);
|static int hso_start_net_device(struct hso_device *hso_dev);
|static void hso_free_shared_int(struct hso_shared_int *shared_int);
|static int hso_stop_net_device(struct hso_device *hso_dev);
|static void hso_serial_ref_free(struct kref *ref);
|static void hso_std_serial_read_bulk_callback(struct urb *urb);
|static int hso_mux_serial_read(struct hso_serial *serial);
|static void async_get_intf(struct work_struct *data);
|static void async_put_intf(struct work_struct *data);
|static int hso_put_activity(struct hso_device *hso_dev);
|static int hso_get_activity(struct hso_device *hso_dev);
|static void tiocmget_intr_callback(struct urb *urb);
|static void reset_device(struct work_struct *data);
|
|
|
|
|
|
|static inline struct hso_net *dev2net(struct hso_device *hso_dev)
|{
| return hso_dev->port_data.dev_net;
|}
|
|static inline struct hso_serial *dev2ser(struct hso_device *hso_dev)
|{
| return hso_dev->port_data.dev_serial;
|}
|static int debug;
|static int tty_major;
|static int disable_net;
|
|
|static const char driver_name[] = "hso";
|static const char tty_filename[] = "ttyHS";
|static const char *version = "drivers/net/usb/.tmp_hso.o.armored.c" ": " "Option Wireless";
|
|static struct usb_driver hso_driver;
|
|static struct tty_driver *tty_drv;
|static struct hso_device *serial_table[256];
|static struct hso_device *network_table[10];
|static spinlock_t serial_table_lock;
|
|static const s32 default_port_spec[] = {
| 0x0100 | 0x12,
| 0x0200 | 0x10,
| 0x0200 | 0x11,
| 0
|};
|
|static const s32 icon321_port_spec[] = {
| 0x0100 | 0x12,
| 0x0200 | 0x9,
| 0x0200 | 0x11,
| 0x0200 | 0x10,
| 0
|};
|static const struct usb_device_id hso_ids[] = {
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6711), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6731), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6751), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6771), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6791), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6811), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6911), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6951), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x6971), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7011), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7031), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7051), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7071), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7111), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7211), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7251), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7271), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7311), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xc031), .driver_info = (kernel_ulong_t)default_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd013), .driver_info = (kernel_ulong_t)icon321_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd031), .driver_info = (kernel_ulong_t)icon321_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd033), .driver_info = (kernel_ulong_t)icon321_port_spec},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7301)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7361)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7381)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7401)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7501)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7601)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7701)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7706)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7801)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7901)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7A01)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x7A05)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8200)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8201)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8300)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8302)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8304)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8400)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8600)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8800)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x8900)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0x9000)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd035)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd055)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd155)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd255)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd057)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd157)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd257)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd357)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xd058)},
| {.match_flags = (0x0001 | 0x0002), .idVendor = (0x0af0), .idProduct = (0xc100)},
| {}
|};
|extern const struct usb_device_id __mod_usb_device_table ;
|
|
|static ssize_t hso_sysfs_show_porttype(struct device *dev,
|           struct device_attribute *attr,
|           char *buf)
|{
| struct hso_device *hso_dev = dev_get_drvdata(dev);
| char *port_name;
|
| if (!hso_dev)
|  return 0;
|
| switch (hso_dev->port_spec & 0xFF) {
| case 0x1:
|  port_name = "Control";
|  break;
| case 0x2:
|  port_name = "Application";
|  break;
| case 0x5:
|  port_name = "Application2";
|  break;
| case 0x3:
|  port_name = "GPS";
|  break;
| case 0x6:
|  port_name = "GPS Control";
|  break;
| case 0x4:
|  port_name = "PCSC";
|  break;
| case 0x10:
|  port_name = "Diagnostic";
|  break;
| case 0x9:
|  port_name = "Diagnostic2";
|  break;
| case 0x11:
|  port_name = "Modem";
|  break;
| case 0x12:
|  port_name = "Network";
|  break;
| default:
|  port_name = "Unknown";
|  break;
| }
|
| return sprintf(buf, "%s\n", port_name);
|}
|static struct device_attribute dev_attr_hsotype = { .attr = {.name = "hsotype", .mode = (00400|00040|00004) }, .show = hso_sysfs_show_porttype, .store = ((void *)0), };
|
|static int hso_urb_to_index(struct hso_serial *serial, struct urb *urb)
|{
| int idx;
|
| for (idx = 0; idx < serial->num_rx_urbs; idx++)
|  if (serial->rx_urb[idx] == urb)
|   return idx;
| dev_err(serial->parent->dev, "hso_urb_to_index failed\n");
| return -1;
|}
|
|
|static u32 hso_mux_to_port(int mux)
|{
| u32 result;
|
| switch (mux) {
| case 0x1:
|  result = 0x1;
|  break;
| case 0x2:
|  result = 0x2;
|  break;
| case 0x4:
|  result = 0x4;
|  break;
| case 0x8:
|  result = 0x3;
|  break;
| case 0x10:
|  result = 0x5;
|  break;
| default:
|  result = 0x0;
| }
| return result;
|}
|
|
|static u32 hso_port_to_mux(int port)
|{
| u32 result;
|
| switch (port & 0xFF) {
| case 0x1:
|  result = 0x0;
|  break;
| case 0x2:
|  result = 0x1;
|  break;
| case 0x4:
|  result = 0x2;
|  break;
| case 0x3:
|  result = 0x3;
|  break;
| case 0x5:
|  result = 0x4;
|  break;
| default:
|  result = 0x0;
| }
| return result;
|}
|
|static struct hso_serial *get_serial_by_shared_int_and_type(
|     struct hso_shared_int *shared_int,
|     int mux)
|{
| int i, port;
|
| port = hso_mux_to_port(mux);
|
| for (i = 0; i < 256; i++) {
|  if (serial_table[i] &&
|      (dev2ser(serial_table[i])->shared_int == shared_int) &&
|      ((serial_table[i]->port_spec & 0xFF) == port)) {
|   return dev2ser(serial_table[i]);
|  }
| }
|
| return ((void *)0);
|}
|
|static struct hso_serial *get_serial_by_index(unsigned index)
|{
| struct hso_serial *serial = ((void *)0);
| unsigned long flags;
|
| __st_spin_lock_irqsave_st__(&serial_table_lock, flags);
| if (serial_table[index])
|  serial = dev2ser(serial_table[index]);
| __st_spin_unlock_irqrestore_st__(&serial_table_lock, flags);
|
| return serial;
|}
|
|static int get_free_serial_index(void)
|{
| int index;
| unsigned long flags;
|
| __st_spin_lock_irqsave_st__(&serial_table_lock, flags);
| for (index = 0; index < 256; index++) {
|  if (serial_table[index] == ((void *)0)) {
|   __st_spin_unlock_irqrestore_st__(&serial_table_lock, flags);
|   return index;
|  }
| }
| __st_spin_unlock_irqrestore_st__(&serial_table_lock, flags);
|
| printk("<3>" "%s: no free serial devices in table\n", __func__);
| return -1;
|}
|
|static void set_serial_by_index(unsigned index, struct hso_serial *serial)
|{
| unsigned long flags;
|
| __st_spin_lock_irqsave_st__(&serial_table_lock, flags);
| if (serial)
|  serial_table[index] = serial->parent;
| else
|  serial_table[index] = ((void *)0);
| __st_spin_unlock_irqrestore_st__(&serial_table_lock, flags);
|}
|
|static void handle_usb_error(int status, const char *function,
|        struct hso_device *hso_dev)
|{
| char *explanation;
|
| switch (status) {
| case -19:
|  explanation = "no device";
|  break;
| case -2:
|  explanation = "endpoint not enabled";
|  break;
| case -32:
|  explanation = "endpoint stalled";
|  break;
| case -28:
|  explanation = "not enough bandwidth";
|  break;
| case -108:
|  explanation = "device disabled";
|  break;
| case -113:
|  explanation = "device suspended";
|  break;
| case -22:
| case -11:
| case -27:
| case -90:
|  explanation = "internal error";
|  break;
| case -84:
| case -71:
| case -62:
| case -110:
|  explanation = "protocol error";
|  if (hso_dev)
|   schedule_work(&hso_dev->reset_device);
|  break;
| default:
|  explanation = "unknown status";
|  break;
| }
|
|
| do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "%s: received USB status - %s (%d)" "\n", 717, __func__, function, explanation, status); } while (0); } while (0);
|}
|
|
|
|
|static int hso_net_open(struct net_device *net)
|{
| struct hso_net *odev = netdev_priv(net);
| unsigned long flags = 0;
|
| if (!odev) {
|  dev_err(&net->dev, "No net device !\n");
|  return -19;
| }
|
| odev->skb_tx_buf = ((void *)0);
|
|
| __st_spin_lock_irqsave_st__(&odev->net_lock, flags);
| odev->rx_parse_state = WAIT_IP;
| odev->rx_buf_size = 0;
| odev->rx_buf_missing = sizeof(struct iphdr);
| __st_spin_unlock_irqrestore_st__(&odev->net_lock, flags);
|
|
| set_bit(0, &odev->flags);
| hso_start_net_device(odev->parent);
|
|
| netif_start_queue(net);
|
| return 0;
|}
|
|
|static int hso_net_close(struct net_device *net)
|{
| struct hso_net *odev = netdev_priv(net);
|
|
| netif_stop_queue(net);
|
| clear_bit(0, &odev->flags);
|
| hso_stop_net_device(odev->parent);
|
|
| return 0;
|}
|
|
|static void write_bulk_callback(struct urb *urb)
|{
| struct hso_net *odev = urb->context;
| int status = urb->status;
|
|
| if (!odev || !(__builtin_constant_p((0)) ? constant_test_bit((0), (&odev->flags)) : variable_test_bit((0), (&odev->flags)))) {
|  dev_err(&urb->dev->dev, "%s: device not running\n", __func__);
|  return;
| }
|
|
| if (!netif_device_present(odev->net)) {
|  dev_err(&urb->dev->dev, "%s: net device not present\n",
|   __func__);
|  return;
| }
|
|
|
| if (status)
|  handle_usb_error(status, __func__, odev->parent);
|
| hso_put_activity(odev->parent);
|
|
| netif_wake_queue(odev->net);
|}
|
|
|static netdev_tx_t hso_net_start_xmit(struct sk_buff *skb,
|         struct net_device *net)
|{
| struct hso_net *odev = netdev_priv(net);
| int result;
|
|
| netif_stop_queue(net);
| if (hso_get_activity(odev->parent) == -11) {
|  odev->skb_tx_buf = skb;
|  return NETDEV_TX_OK;
| }
|
|
| ;
|
| __st_memcpy_st__(odev->mux_bulk_tx_buf, skb->data, skb->len);
| do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "len: %d/%d" "\n", 816, __func__, skb->len, 2048); } while (0); } while (0);
|
|
| usb_fill_bulk_urb(odev->mux_bulk_tx_urb,
|     odev->parent->usb,
|     ((3 << 30) | __create_pipe(odev->parent->usb, odev->out_endp-> bEndpointAddress & 0x7F))
|
|                               ,
|     odev->mux_bulk_tx_buf, skb->len, write_bulk_callback,
|     odev);
|
|
| odev->mux_bulk_tx_urb->transfer_flags |= 0x0040;
|
|
| result = usb_submit_urb(odev->mux_bulk_tx_urb, ((( gfp_t)0x20u)));
| if (result) {
|  dev_warn(&odev->parent->interface->dev,
|   "failed mux_bulk_tx_urb %d\n", result);
|  net->stats.tx_errors++;
|  netif_start_queue(net);
| } else {
|  net->stats.tx_packets++;
|  net->stats.tx_bytes += skb->len;
| }
| consume_skb(skb);
|
| return NETDEV_TX_OK;
|}
|
|static const struct ethtool_ops ops = {
| .get_link = ethtool_op_get_link
|};
|
|
|static void hso_net_tx_timeout(struct net_device *net)
|{
| struct hso_net *odev = netdev_priv(net);
|
| if (!odev)
|  return;
|
|
| dev_warn(&net->dev, "Tx timed out.\n");
|
|
| if (odev->mux_bulk_tx_urb &&
|     (odev->mux_bulk_tx_urb->status == -115))
|  usb_unlink_urb(odev->mux_bulk_tx_urb);
|
|
| net->stats.tx_errors++;
|}
|
|
|static void packetizeRx(struct hso_net *odev, unsigned char *ip_pkt,
|   unsigned int count, unsigned char is_eop)
|{
| unsigned short temp_bytes;
| unsigned short buffer_offset = 0;
| unsigned short frame_len;
| unsigned char *tmp_rx_buf;
|
|
| do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "Rx %d bytes" "\n", 880, __func__, count); } while (0); } while (0);
| ;
|
| while (count) {
|  switch (odev->rx_parse_state) {
|  case WAIT_IP:
|
|
|   temp_bytes =
|       (count <
|        odev->rx_buf_missing) ? count : odev->
|       rx_buf_missing;
|
|   __st_memcpy_st__(((unsigned char *)(&odev->rx_ip_hdr)) +
|          odev->rx_buf_size, ip_pkt + buffer_offset,
|          temp_bytes);
|
|   odev->rx_buf_size += temp_bytes;
|   buffer_offset += temp_bytes;
|   odev->rx_buf_missing -= temp_bytes;
|   count -= temp_bytes;
|
|   if (!odev->rx_buf_missing) {
|
|
|    frame_len = (__builtin_constant_p((__u16)(( __u16)(__be16)(odev->rx_ip_hdr.tot_len))) ? ((__u16)( (((__u16)(( __u16)(__be16)(odev->rx_ip_hdr.tot_len)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(odev->rx_ip_hdr.tot_len)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(odev->rx_ip_hdr.tot_len)));
|
|    if ((frame_len > 1500) ||
|        (frame_len < sizeof(struct iphdr))) {
|     dev_err(&odev->net->dev,
|      "Invalid frame (%d) length\n",
|      frame_len);
|     odev->rx_parse_state = WAIT_SYNC;
|     continue;
|    }
|
|    odev->skb_rx_buf = netdev_alloc_skb(odev->net,
|            frame_len);
|    if (!odev->skb_rx_buf) {
|
|     do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "could not allocate memory" "\n", 920, __func__); } while (0); } while (0);
|     odev->rx_parse_state = WAIT_SYNC;
|     return;
|    }
|
|
|
|    tmp_rx_buf =
|        skb_put(odev->skb_rx_buf,
|         sizeof(struct iphdr));
|    __st_memcpy_st__(tmp_rx_buf, (char *)&(odev->rx_ip_hdr),
|           sizeof(struct iphdr));
|
|
|    odev->rx_buf_size = sizeof(struct iphdr);
|
|
|    odev->rx_buf_missing =
|        frame_len - sizeof(struct iphdr);
|    odev->rx_parse_state = WAIT_DATA;
|   }
|   break;
|
|  case WAIT_DATA:
|   temp_bytes = (count < odev->rx_buf_missing)
|     ? count : odev->rx_buf_missing;
|
|
|
|
|   tmp_rx_buf = skb_put(odev->skb_rx_buf, temp_bytes);
|   __st_memcpy_st__(tmp_rx_buf, ip_pkt + buffer_offset, temp_bytes);
|
|   odev->rx_buf_missing -= temp_bytes;
|   count -= temp_bytes;
|   buffer_offset += temp_bytes;
|   odev->rx_buf_size += temp_bytes;
|   if (!odev->rx_buf_missing) {
|
|
|    odev->skb_rx_buf->protocol = (( __be16)(__builtin_constant_p((__u16)((0x0800))) ? ((__u16)( (((__u16)((0x0800)) & (__u16)0x00ffU) << 8) | (((__u16)((0x0800)) & (__u16)0xff00U) >> 8))) : __fswab16((0x0800))));
|
|    odev->skb_rx_buf->ip_summed =
|     1;
|
|    skb_reset_mac_header(odev->skb_rx_buf);
|
|
|    netif_rx(odev->skb_rx_buf);
|
|    odev->skb_rx_buf = ((void *)0);
|
|
|    odev->net->stats.rx_packets++;
|
|    odev->net->stats.rx_bytes += odev->rx_buf_size;
|
|    odev->rx_buf_size = 0;
|    odev->rx_buf_missing = sizeof(struct iphdr);
|    odev->rx_parse_state = WAIT_IP;
|   }
|   break;
|
|  case WAIT_SYNC:
|   do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " " W_S" "\n", 984, __func__); } while (0); } while (0);
|   count = 0;
|   break;
|  default:
|   do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " " " "\n", 988, __func__); } while (0); } while (0);
|   count--;
|   break;
|  }
| }
|
|
| if (is_eop) {
|  if (odev->rx_parse_state == WAIT_SYNC) {
|   odev->rx_parse_state = WAIT_IP;
|   odev->rx_buf_size = 0;
|   odev->rx_buf_missing = sizeof(struct iphdr);
|  }
| }
|}
|
|
|static void read_bulk_callback(struct urb *urb)
|{
| struct hso_net *odev = urb->context;
| struct net_device *net;
| int result;
| int status = urb->status;
|
|
| if (status) {
|  handle_usb_error(status, __func__, odev->parent);
|  return;
| }
|
|
| if (!odev || !(__builtin_constant_p((0)) ? constant_test_bit((0), (&odev->flags)) : variable_test_bit((0), (&odev->flags)))) {
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "BULK IN callback but driver is not active!" "\n", 1020, __func__); } while (0); } while (0);
|  return;
| }
| usb_mark_last_busy(urb->dev);
|
| net = odev->net;
|
| if (!netif_device_present(net)) {
|
|  return;
| }
|
| if (odev->parent->port_spec & 0x01000000) {
|  u32 rest;
|  u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
|  rest = urb->actual_length %
|   (( __u16)(__le16)(odev->in_endp->wMaxPacketSize));
|  if (((rest == 5) || (rest == 6)) &&
|      !memcmp(((u8 *) urb->transfer_buffer) +
|       urb->actual_length - 4, crc_check, 4)) {
|   urb->actual_length -= 4;
|  }
| }
|
|
| if (urb->actual_length) {
|
|
|  __st_spin_lock_st__(&odev->net_lock);
|  packetizeRx(odev, urb->transfer_buffer, urb->actual_length,
|       (urb->transfer_buffer_length >
|        urb->actual_length) ? 1 : 0);
|  __st_spin_unlock_st__(&odev->net_lock);
| }
|
|
|
| usb_fill_bulk_urb(urb,
|     odev->parent->usb,
|     ((3 << 30) | __create_pipe(odev->parent->usb, odev->in_endp-> bEndpointAddress & 0x7F) | 0x80)
|
|                               ,
|     urb->transfer_buffer, 2048,
|     read_bulk_callback, odev);
|
|
|
| result = usb_submit_urb(urb, ((( gfp_t)0x20u)));
| if (result)
|  dev_warn(&odev->parent->interface->dev,
|    "%s failed submit mux_bulk_rx_urb %d\n", __func__,
|    result);
|}
|
|
|
|static void hso_init_termios(struct ktermios *termios)
|{
|
|
|
| termios->c_iflag &=
|  ~(0000001
|  | 0000002
|  | 0000010
|  | 0000040
|  | 0000100
|  | 0000200
|  | 0000400
|  | 0002000);
|
|
| termios->c_oflag &= ~0000001;
|
| termios->c_lflag &=
|  ~(0000010
|  | 0000100
|  | 0000002
|
|  | 0000001
|
|  | 0100000);
|
| termios->c_cflag &=
|  ~(0000060
|  | 0000400
|  | 0010017
|  | 0010000);
|
| termios->c_cflag |= 0000060;
|
|
| tty_termios_encode_baud_rate(termios, 115200, 115200);
|}
|
|static void _hso_serial_set_termios(struct tty_struct *tty,
|        struct ktermios *old)
|{
| struct hso_serial *serial = get_serial_by_tty(tty);
| struct ktermios *termios;
|
| if (!serial) {
|  printk("<3>" "%s: no tty structures", __func__);
|  return;
| }
|
| do { if (0x08 & debug) do { printk("<6>" "[%d:%s]: " "port %d" "\n", 1126, __func__, serial->minor); } while (0); } while (0);
|
|
|
|
| termios = tty->termios;
| termios->c_iflag &= ~0002000;
|
| termios->c_cflag &=
|  ~(0000060
|  | 0000400
|  | 0010017
|  | 0010000);
|
| termios->c_cflag |= 0000060;
|
|
| tty_encode_baud_rate(tty, 115200, 115200);
|}
|
|static void hso_resubmit_rx_bulk_urb(struct hso_serial *serial, struct urb *urb)
|{
| int result;
|
|
| usb_fill_bulk_urb(urb, serial->parent->usb,
|     ((3 << 30) | __create_pipe(serial->parent->usb, serial->in_endp-> bEndpointAddress & 0x7F) | 0x80)
|
|                               ,
|     urb->transfer_buffer, serial->rx_data_length,
|     hso_std_serial_read_bulk_callback, serial);
|
|
| result = usb_submit_urb(urb, ((( gfp_t)0x20u)));
| if (result) {
|  dev_err(&urb->dev->dev, "%s failed submit serial rx_urb %d\n",
|   __func__, result);
| }
|}
|
|
|
|
|static void put_rxbuf_data_and_resubmit_bulk_urb(struct hso_serial *serial)
|{
| int count;
| struct urb *curr_urb;
|
| while (serial->rx_urb_filled[serial->curr_rx_urb_idx]) {
|  curr_urb = serial->rx_urb[serial->curr_rx_urb_idx];
|  count = put_rxbuf_data(curr_urb, serial);
|  if (count == -1)
|   return;
|  if (count == 0) {
|   serial->curr_rx_urb_idx++;
|   if (serial->curr_rx_urb_idx >= serial->num_rx_urbs)
|    serial->curr_rx_urb_idx = 0;
|   hso_resubmit_rx_bulk_urb(serial, curr_urb);
|  }
| }
|}
|
|static void put_rxbuf_data_and_resubmit_ctrl_urb(struct hso_serial *serial)
|{
| int count = 0;
| struct urb *urb;
|
| urb = serial->rx_urb[0];
| if (serial->open_count > 0) {
|  count = put_rxbuf_data(urb, serial);
|  if (count == -1)
|   return;
| }
|
|
| if (count == 0 && ((urb->actual_length != 0) ||
|      (serial->rx_state == RX_PENDING))) {
|  serial->rx_state = RX_SENT;
|  hso_mux_serial_read(serial);
| } else
|  serial->rx_state = RX_IDLE;
|}
|
|
|
|static void hso_std_serial_read_bulk_callback(struct urb *urb)
|{
| struct hso_serial *serial = urb->context;
| int status = urb->status;
|
|
| if (!serial) {
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "serial == NULL" "\n", 1218, __func__); } while (0); } while (0);
|  return;
| } else if (status) {
|  handle_usb_error(status, __func__, serial->parent);
|  return;
| }
|
| do { if (0x08 & debug) do { printk("<6>" "[%d:%s]: " "\n--- Got serial_read_bulk callback %02x ---" "\n", 1225, __func__, status); } while (0); } while (0);
| do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "Actual length = %d\n" "\n", 1226, __func__, urb->actual_length); } while (0); } while (0);
| ;
|
|
| if (serial->open_count == 0)
|  return;
|
| if (status == 0) {
|  if (serial->parent->port_spec & 0x01000000) {
|   u32 rest;
|   u8 crc_check[4] = { 0xDE, 0xAD, 0xBE, 0xEF };
|   rest =
|       urb->actual_length %
|       (( __u16)(__le16)(serial->in_endp->wMaxPacketSize));
|   if (((rest == 5) || (rest == 6)) &&
|       !memcmp(((u8 *) urb->transfer_buffer) +
|        urb->actual_length - 4, crc_check, 4)) {
|    urb->actual_length -= 4;
|   }
|  }
|
|  __st_spin_lock_st__(&serial->serial_lock);
|  serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 1;
|  put_rxbuf_data_and_resubmit_bulk_urb(serial);
|  __st_spin_unlock_st__(&serial->serial_lock);
| } else if (status == -2 || status == -104) {
|
|  do { if (0x02 & debug) do { printk("<6>" "[%d:%s]: " "Port %d, successfully unlinked urb" "\n", 1253, __func__, serial->minor); } while (0); } while (0);
|  __st_spin_lock_st__(&serial->serial_lock);
|  serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
|  hso_resubmit_rx_bulk_urb(serial, urb);
|  __st_spin_unlock_st__(&serial->serial_lock);
| } else {
|  do { if (0x02 & debug) do { printk("<6>" "[%d:%s]: " "Port %d, status = %d for read urb" "\n", 1259, __func__, serial->minor, status); } while (0); } while (0);
|  return;
| }
|}
|
|
|
|
|
|static void hso_unthrottle_tasklet(struct hso_serial *serial)
|{
| unsigned long flags;
|
| __st_spin_lock_irqsave_st__(&serial->serial_lock, flags);
| if ((serial->parent->port_spec & 0x0100))
|  put_rxbuf_data_and_resubmit_ctrl_urb(serial);
| else
|  put_rxbuf_data_and_resubmit_bulk_urb(serial);
| __st_spin_unlock_irqrestore_st__(&serial->serial_lock, flags);
|}
|
|static void hso_unthrottle(struct tty_struct *tty)
|{
| struct hso_serial *serial = get_serial_by_tty(tty);
|
| tasklet_hi_schedule(&serial->unthrottle_tasklet);
|}
|
|static void hso_unthrottle_workfunc(struct work_struct *work)
|{
| struct hso_serial *serial =
|     ({ const typeof( ((struct hso_serial *)0)->retry_unthrottle_workqueue ) *__mptr = (work); (struct hso_serial *)( (char *)__mptr - 1 );})
|                               ;
| hso_unthrottle_tasklet(serial);
|}
|
|
|static int hso_serial_open(struct tty_struct *tty, struct file *filp)
|{
| struct hso_serial *serial = get_serial_by_index(tty->index);
| int result;
|
|
| if (serial == ((void *)0) || serial->magic != 0x48534f31) {
|  ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("drivers/net/usb/.tmp_hso.o.armored.c", 1303); __builtin_expect(!!(__ret_warn_on), 0); });
|  tty->driver_data = ((void *)0);
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "Failed to open port" "\n", 1305, __func__); } while (0); } while (0);
|  return -19;
| }
|
| __st_mutex_lock_st__(&serial->parent->mutex);
| result = usb_autopm_get_interface(serial->parent->interface);
| if (result < 0)
|  goto err_out;
|
| do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "Opening %d" "\n", 1314, __func__, serial->minor); } while (0); } while (0);
| kref_get(&serial->parent->ref);
|
|
| __st_spin_lock_irq_st__(&serial->serial_lock);
| tty->driver_data = serial;
| tty_kref_put(serial->tty);
| serial->tty = tty_kref_get(tty);
| __st_spin_unlock_irq_st__(&serial->serial_lock);
|
|
| serial->open_count++;
| if (serial->open_count == 1) {
|  serial->rx_state = RX_IDLE;
|
|  _hso_serial_set_termios(tty, ((void *)0));
|  tasklet_init(&serial->unthrottle_tasklet,
|        (void (*)(unsigned long))hso_unthrottle_tasklet,
|        (unsigned long)serial);
|  do { do { static struct lock_class_key __key; __init_work(((&serial->retry_unthrottle_workqueue)), 0); ((&serial->retry_unthrottle_workqueue))->data = (atomic_long_t) { (WORK_STRUCT_NO_CPU) }; lockdep_init_map(&((&serial->retry_unthrottle_workqueue))->lockdep_map, "(&serial->retry_unthrottle_workqueue)", &__key, 0); INIT_LIST_HEAD(&((&serial->retry_unthrottle_workqueue))->entry); do { (((&serial->retry_unthrottle_workqueue)))->func = (((hso_unthrottle_workfunc))); } while (0); } while (0); } while (0)
|                             ;
|  result = hso_start_serial_device(serial->parent, __st_GFP_KERNEL_st__);
|  if (result) {
|   hso_stop_serial_device(serial->parent);
|   serial->open_count--;
|   kref_put(&serial->parent->ref, hso_serial_ref_free);
|  }
| } else {
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "Port was already open" "\n", 1342, __func__); } while (0); } while (0);
| }
|
| usb_autopm_put_interface(serial->parent->interface);
|
|
| if (result)
|  hso_serial_tiocmset(tty, ((void *)0), 0x004 | 0x002, 0);
|err_out:
| __st_mutex_unlock_st__(&serial->parent->mutex);
| return result;
|}
|
|
|static void hso_serial_close(struct tty_struct *tty, struct file *filp)
|{
| struct hso_serial *serial = tty->driver_data;
| u8 usb_gone;
|
| do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "Closing serial port" "\n", 1361, __func__); } while (0); } while (0);
|
|
| if (serial == ((void *)0))
|  return;
|
| __st_mutex_lock_st__(&serial->parent->mutex);
| usb_gone = serial->parent->usb_gone;
|
| if (!usb_gone)
|  usb_autopm_get_interface(serial->parent->interface);
|
|
|
| serial->open_count--;
|
| if (serial->open_count <= 0) {
|  serial->open_count = 0;
|  __st_spin_lock_irq_st__(&serial->serial_lock);
|  if (serial->tty == tty) {
|   serial->tty->driver_data = ((void *)0);
|   serial->tty = ((void *)0);
|   tty_kref_put(tty);
|  }
|  __st_spin_unlock_irq_st__(&serial->serial_lock);
|  if (!usb_gone)
|   hso_stop_serial_device(serial->parent);
|  tasklet_kill(&serial->unthrottle_tasklet);
|  cancel_work_sync(&serial->retry_unthrottle_workqueue);
| }
|
| if (!usb_gone)
|  usb_autopm_put_interface(serial->parent->interface);
|
| __st_mutex_unlock_st__(&serial->parent->mutex);
|
| kref_put(&serial->parent->ref, hso_serial_ref_free);
|}
|
|
|static int hso_serial_write(struct tty_struct *tty, const unsigned char *buf,
|       int count)
|{
| struct hso_serial *serial = get_serial_by_tty(tty);
| int space, tx_bytes;
| unsigned long flags;
|
|
| if (serial == ((void *)0)) {
|  printk("<3>" "%s: serial is NULL\n", __func__);
|  return -19;
| }
|
| __st_spin_lock_irqsave_st__(&serial->serial_lock, flags);
|
| space = serial->tx_data_length - serial->tx_buffer_count;
| tx_bytes = (count < space) ? count : space;
|
| if (!tx_bytes)
|  goto out;
|
| __st_memcpy_st__(serial->tx_buffer + serial->tx_buffer_count, buf, tx_bytes);
| serial->tx_buffer_count += tx_bytes;
|
|out:
| __st_spin_unlock_irqrestore_st__(&serial->serial_lock, flags);
|
| hso_kick_transmit(serial);
|
| return tx_bytes;
|}
|
|
|static int hso_serial_write_room(struct tty_struct *tty)
|{
| struct hso_serial *serial = get_serial_by_tty(tty);
| int room;
| unsigned long flags;
|
| __st_spin_lock_irqsave_st__(&serial->serial_lock, flags);
| room = serial->tx_data_length - serial->tx_buffer_count;
| __st_spin_unlock_irqrestore_st__(&serial->serial_lock, flags);
|
|
| return room;
|}
|
|
|static void hso_serial_set_termios(struct tty_struct *tty, struct ktermios *old)
|{
| struct hso_serial *serial = get_serial_by_tty(tty);
| unsigned long flags;
|
| if (old)
|  do { if (0x10 & debug) do { printk("<6>" "[%d:%s]: " "Termios called with: cflags new[%d] - old[%d]" "\n",
| 1456
|  , __func__, tty->termios->c_cflag, old->c_cflag); } while (0); } while (0)
|                                         ;
|
|
| __st_spin_lock_irqsave_st__(&serial->serial_lock, flags);
| if (serial->open_count)
|  _hso_serial_set_termios(tty, old);
| else
|  tty->termios = old;
| __st_spin_unlock_irqrestore_st__(&serial->serial_lock, flags);
|
|
|}
|
|
|static int hso_serial_chars_in_buffer(struct tty_struct *tty)
|{
| struct hso_serial *serial = get_serial_by_tty(tty);
| int chars;
| unsigned long flags;
|
|
| if (serial == ((void *)0))
|  return 0;
|
| __st_spin_lock_irqsave_st__(&serial->serial_lock, flags);
| chars = serial->tx_buffer_count;
| __st_spin_unlock_irqrestore_st__(&serial->serial_lock, flags);
|
| return chars;
|}
|static int tiocmget_submit_urb(struct hso_serial *serial,
|          struct hso_tiocmget *tiocmget,
|          struct usb_device *usb)
|{
| int result;
|
| if (serial->parent->usb_gone)
|  return -19;
| usb_fill_int_urb(tiocmget->urb, usb,
|    ((1 << 30) | __create_pipe(usb, tiocmget->endp-> bEndpointAddress & 0x7F) | 0x80)
|
|                             ,
|    &tiocmget->serial_state_notification,
|    sizeof(struct hso_serial_state_notification),
|    tiocmget_intr_callback, serial,
|    tiocmget->endp->bInterval);
| result = usb_submit_urb(tiocmget->urb, ((( gfp_t)0x20u)));
| if (result) {
|  dev_warn(&usb->dev, "%s usb_submit_urb failed %d\n", __func__,
|    result);
| }
| return result;
|
|}
|
|static void tiocmget_intr_callback(struct urb *urb)
|{
| struct hso_serial *serial = urb->context;
| struct hso_tiocmget *tiocmget;
| int status = urb->status;
| u16 UART_state_bitmap, prev_UART_state_bitmap;
| struct uart_icount *icount;
| struct hso_serial_state_notification *serial_state_notification;
| struct usb_device *usb;
|
|
| if (!serial)
|  return;
| if (status) {
|  handle_usb_error(status, __func__, serial->parent);
|  return;
| }
| tiocmget = serial->tiocmget;
| if (!tiocmget)
|  return;
| usb = serial->parent->usb;
| serial_state_notification = &tiocmget->serial_state_notification;
| if (serial_state_notification->bmRequestType != (0xa1) ||
|     serial_state_notification->bNotification != (0x20) ||
|     (( __u16)(__le16)(serial_state_notification->wValue)) != (0x0) ||
|     (( __u16)(__le16)(serial_state_notification->wIndex)) != (0x2) ||
|     (( __u16)(__le16)(serial_state_notification->wLength)) != (0x2)) {
|  dev_warn(&usb->dev,
|    "hso received invalid serial state notification\n");
| 
|                                                    ;
| } else {
|
|  UART_state_bitmap = (( __u16)(__le16)(serial_state_notification-> UART_state_bitmap))
|                        ;
|  prev_UART_state_bitmap = tiocmget->prev_UART_state_bitmap;
|  icount = &tiocmget->icount;
|  __st_spin_lock_st__(&serial->serial_lock);
|  if ((UART_state_bitmap & (0x1<<6)) !=
|     (prev_UART_state_bitmap & (0x1<<6)))
|   icount->parity++;
|  if ((UART_state_bitmap & (0x1<<5)) !=
|     (prev_UART_state_bitmap & (0x1<<5)))
|   icount->parity++;
|  if ((UART_state_bitmap & (0x1<<4)) !=
|     (prev_UART_state_bitmap & (0x1<<4)))
|   icount->frame++;
|  if ((UART_state_bitmap & (0x1<<3)) &&
|     !(prev_UART_state_bitmap & (0x1<<3)))
|   icount->rng++;
|  if ((UART_state_bitmap & (0x1<<2)) !=
|     (prev_UART_state_bitmap & (0x1<<2)))
|   icount->brk++;
|  if ((UART_state_bitmap & (0x1<<1)) !=
|     (prev_UART_state_bitmap & (0x1<<1)))
|   icount->dsr++;
|  if ((UART_state_bitmap & (0x1<<0)) !=
|     (prev_UART_state_bitmap & (0x1<<0)))
|   icount->dcd++;
|  tiocmget->prev_UART_state_bitmap = UART_state_bitmap;
|  __st_spin_unlock_st__(&serial->serial_lock);
|  tiocmget->intr_completed = 1;
|  __wake_up(&tiocmget->waitq, 1, 1, ((void *)0));
| }
| __st_memset_st__(serial_state_notification, 0,
|        sizeof(struct hso_serial_state_notification));
| tiocmget_submit_urb(serial,
|       tiocmget,
|       serial->parent->usb);
|}
|static int
|hso_wait_modem_status(struct hso_serial *serial, unsigned long arg)
|{
| wait_queue_t wait = { .private = get_current(), .func = default_wake_function, .task_list = { ((void *)0), ((void *)0) } };
| struct uart_icount cprev, cnow;
| struct hso_tiocmget *tiocmget;
| int ret;
|
| tiocmget = serial->tiocmget;
| if (!tiocmget)
|  return -2;
|
|
|
| __st_spin_lock_irq_st__(&serial->serial_lock);
| __st_memcpy_st__(&cprev, &tiocmget->icount, sizeof(struct uart_icount));
| __st_spin_unlock_irq_st__(&serial->serial_lock);
| add_wait_queue(&tiocmget->waitq, &wait);
| for (;;) {
|  __st_spin_lock_irq_st__(&serial->serial_lock);
|  __st_memcpy_st__(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
|  __st_spin_unlock_irq_st__(&serial->serial_lock);
|  do { (void)({ __typeof(*((&get_current()->state))) __x = (((1))); switch (sizeof(*&get_current()->state)) { case 1: { volatile u8 *__ptr = (volatile u8 *)((&get_current()->state)); asm volatile("xchgb %0,%1" : "=q" (__x), "+m" (*__ptr) : "0" (__x) : "memory"); break; } case 2: { volatile u16 *__ptr = (volatile u16 *)((&get_current()->state)); asm volatile("xchgw %0,%1" : "=r" (__x), "+m" (*__ptr) : "0" (__x) : "memory"); break; } case 4: { volatile u32 *__ptr = (volatile u32 *)((&get_current()->state)); asm volatile("xchgl %0,%1" : "=r" (__x), "+m" (*__ptr) : "0" (__x) : "memory"); break; } case 8: { volatile u64 *__ptr = (volatile u64 *)((&get_current()->state)); asm volatile("xchgq %0,%1" : "=r" (__x), "+m" (*__ptr) : "0" (__x) : "memory"); break; } default: __xchg_wrong_size(); } __x; }); } while (0);
|  if (((arg & 0x080) && (cnow.rng != cprev.rng)) ||
|      ((arg & 0x100) && (cnow.dsr != cprev.dsr)) ||
|      ((arg & 0x040) && (cnow.dcd != cprev.dcd))) {
|   ret = 0;
|   break;
|  }
|  schedule();
|
|  if (signal_pending(get_current())) {
|   ret = -512;
|   break;
|  }
|  cprev = cnow;
| }
| get_current()->state = 0;
| remove_wait_queue(&tiocmget->waitq, &wait);
|
| return ret;
|}
|
|
|
|
|
|
|
|static int hso_get_count(struct tty_struct *tty,
|    struct serial_icounter_struct *icount)
|{
| struct uart_icount cnow;
| struct hso_serial *serial = get_serial_by_tty(tty);
| struct hso_tiocmget *tiocmget = serial->tiocmget;
|
| __st_memset_st__(&icount, 0, sizeof(struct serial_icounter_struct));
|
| if (!tiocmget)
|   return -2;
| __st_spin_lock_irq_st__(&serial->serial_lock);
| __st_memcpy_st__(&cnow, &tiocmget->icount, sizeof(struct uart_icount));
| __st_spin_unlock_irq_st__(&serial->serial_lock);
|
| icount->cts = cnow.cts;
| icount->dsr = cnow.dsr;
| icount->rng = cnow.rng;
| icount->dcd = cnow.dcd;
| icount->rx = cnow.rx;
| icount->tx = cnow.tx;
| icount->frame = cnow.frame;
| icount->overrun = cnow.overrun;
| icount->parity = cnow.parity;
| icount->brk = cnow.brk;
| icount->buf_overrun = cnow.buf_overrun;
|
| return 0;
|}
|
|
|static int hso_serial_tiocmget(struct tty_struct *tty, struct file *file)
|{
| int retval;
| struct hso_serial *serial = get_serial_by_tty(tty);
| struct hso_tiocmget *tiocmget;
| u16 UART_state_bitmap;
|
|
| if (!serial) {
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "no tty structures" "\n", 1679, __func__); } while (0); } while (0);
|  return -22;
| }
| __st_spin_lock_irq_st__(&serial->serial_lock);
| retval = ((serial->rts_state) ? 0x004 : 0) |
|     ((serial->dtr_state) ? 0x002 : 0);
| tiocmget = serial->tiocmget;
| if (tiocmget) {
|
|  UART_state_bitmap = (( __u16)(__le16)(tiocmget->prev_UART_state_bitmap))
|                                    ;
|  if (UART_state_bitmap & (0x1<<3))
|   retval |= 0x080;
|  if (UART_state_bitmap & (0x1<<0))
|   retval |= 0x040;
|  if (UART_state_bitmap & (0x1<<1))
|   retval |= 0x100;
| }
| __st_spin_unlock_irq_st__(&serial->serial_lock);
| return retval;
|}
|
|static int hso_serial_tiocmset(struct tty_struct *tty, struct file *file,
|          unsigned int set, unsigned int clear)
|{
| int val = 0;
| unsigned long flags;
| int if_num;
| struct hso_serial *serial = get_serial_by_tty(tty);
|
|
| if (!serial) {
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "no tty structures" "\n", 1711, __func__); } while (0); } while (0);
|  return -22;
| }
|
| if ((serial->parent->port_spec & 0xFF) != 0x11)
|  return -22;
|
| if_num = serial->parent->interface->altsetting->desc.bInterfaceNumber;
|
| __st_spin_lock_irqsave_st__(&serial->serial_lock, flags);
| if (set & 0x004)
|  serial->rts_state = 1;
| if (set & 0x002)
|  serial->dtr_state = 1;
|
| if (clear & 0x004)
|  serial->rts_state = 0;
| if (clear & 0x002)
|  serial->dtr_state = 0;
|
| if (serial->dtr_state)
|  val |= 0x01;
| if (serial->rts_state)
|  val |= 0x02;
|
| __st_spin_unlock_irqrestore_st__(&serial->serial_lock, flags);
|
| return usb_control_msg(serial->parent->usb,
|          ((2 << 30) | __create_pipe(serial->parent->usb, 0) | 0x80), 0x22,
|          0x21, val, if_num, ((void *)0), 0,
|          5000);
|}
|
|static int hso_serial_ioctl(struct tty_struct *tty, struct file *file,
|       unsigned int cmd, unsigned long arg)
|{
| struct hso_serial *serial = get_serial_by_tty(tty);
| int ret = 0;
| do { if (0x08 & debug) do { printk("<6>" "[%d:%s]: " "IOCTL cmd: %d, arg: %ld" "\n", 1749, __func__, cmd, arg); } while (0); } while (0);
|
| if (!serial)
|  return -19;
| switch (cmd) {
| case 0x545C:
|  ret = hso_wait_modem_status(serial, arg);
|  break;
| default:
|  ret = -515;
|  break;
| }
| return ret;
|}
|
|
|
|static void hso_kick_transmit(struct hso_serial *serial)
|{
| u8 *temp;
| unsigned long flags;
| int res;
|
| __st_spin_lock_irqsave_st__(&serial->serial_lock, flags);
| if (!serial->tx_buffer_count)
|  goto out;
|
| if (serial->tx_urb_used)
|  goto out;
|
|
| if (hso_get_activity(serial->parent) == -11)
|  goto out;
|
|
| temp = serial->tx_buffer;
| serial->tx_buffer = serial->tx_data;
| serial->tx_data = temp;
| serial->tx_data_count = serial->tx_buffer_count;
| serial->tx_buffer_count = 0;
|
|
| if (temp && serial->write_data) {
|  res = serial->write_data(serial);
|  if (res >= 0)
|   serial->tx_urb_used = 1;
| }
|out:
| __st_spin_unlock_irqrestore_st__(&serial->serial_lock, flags);
|}
|
|
|static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
|         struct urb *ctrl_urb,
|         struct usb_ctrlrequest *ctrl_req,
|         u8 *ctrl_urb_data, u32 size)
|{
| int result;
| int pipe;
|
|
| if (!serial || !ctrl_urb || !ctrl_req) {
|  printk("<3>" "%s: Wrong arguments\n", __func__);
|  return -22;
| }
|
|
| ctrl_req->wValue = 0;
| ctrl_req->wIndex = (( __le16)(__u16)(hso_port_to_mux(port)));
| ctrl_req->wLength = (( __le16)(__u16)(size));
|
| if (type == 0x01) {
|
|  ctrl_req->bRequestType = 0x80 |
|      0x20 |
|      0x01;
|  ctrl_req->bRequest = 0x01;
|  pipe = ((2 << 30) | __create_pipe(serial->parent->usb, 0) | 0x80);
| } else {
|
|  ctrl_req->bRequestType = 0 |
|      0x20 |
|      0x01;
|  ctrl_req->bRequest = 0x00;
|  pipe = ((2 << 30) | __create_pipe(serial->parent->usb, 0));
| }
|
| do { if (0x02 & debug) do { printk("<6>" "[%d:%s]: " "%s command (%02x) len: %d, port: %d" "\n",
|
| 1838
| , __func__, type == 0x01 ? "Read" : "Write", ctrl_req->bRequestType, ctrl_req->wLength, port); } while (0); } while (0)
|
|                                                    ;
|
|
| ctrl_urb->transfer_flags = 0;
| usb_fill_control_urb(ctrl_urb,
|        serial->parent->usb,
|        pipe,
|        (u8 *) ctrl_req,
|        ctrl_urb_data, size, ctrl_callback, serial);
|
| result = usb_submit_urb(ctrl_urb, ((( gfp_t)0x20u)));
| if (result) {
|  dev_err(&ctrl_urb->dev->dev,
|   "%s failed submit ctrl_urb %d type %d\n", __func__,
|   result, type);
|  return result;
| }
|
|
| return size;
|}
|
|
|static int hso_mux_serial_read(struct hso_serial *serial)
|{
| if (!serial)
|  return -22;
|
|
| __st_memset_st__(serial->rx_data[0], 0, 1024);
|
|
| if (serial->num_rx_urbs != 1) {
|  dev_err(&serial->parent->interface->dev,
|   "ERROR: mux'd reads with multiple buffers "
|   "not possible\n");
|  return 0;
| }
| return mux_device_request(serial,
|      0x01,
|      serial->parent->port_spec & 0xFF,
|      serial->rx_urb[0],
|      &serial->ctrl_req_rx,
|      serial->rx_data[0], serial->rx_data_length);
|}
|
|
|static void intr_callback(struct urb *urb)
|{
| struct hso_shared_int *shared_int = urb->context;
| struct hso_serial *serial;
| unsigned char *port_req;
| int status = urb->status;
| int i;
|
| usb_mark_last_busy(urb->dev);
|
|
| if (!shared_int)
|  return;
|
|
| if (status) {
|  handle_usb_error(status, __func__, ((void *)0));
|  return;
| }
| do { if (0x08 & debug) do { printk("<6>" "[%d:%s]: " "\n--- Got intr callback 0x%02X ---" "\n", 1904, __func__, status); } while (0); } while (0);
|
|
| port_req = urb->transfer_buffer;
| do { if (0x08 & debug) do { printk("<6>" "[%d:%s]: " " port_req = 0x%.2X\n" "\n", 1908, __func__, *port_req); } while (0); } while (0);
|
| for (i = 0; i < 8; i++) {
|
|  if (*port_req & (1 << i)) {
|   serial = get_serial_by_shared_int_and_type(shared_int,
|           (1 << i));
|   if (serial != ((void *)0)) {
|    do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "Pending read interrupt on port %d\n" "\n", 1916, __func__, i); } while (0); } while (0);
|    __st_spin_lock_st__(&serial->serial_lock);
|    if (serial->rx_state == RX_IDLE &&
|     serial->open_count > 0) {
|
|
|     if (!serial->rx_urb_filled[0]) {
|      serial->rx_state = RX_SENT;
|      hso_mux_serial_read(serial);
|     } else
|      serial->rx_state = RX_PENDING;
|    } else {
|     do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "Already a read pending on " "port %d or port not open\n" "\n",
| 1929
|     , __func__, i); } while (0); } while (0)
|                                        ;
|    }
|    __st_spin_unlock_st__(&serial->serial_lock);
|   }
|  }
| }
|
| hso_mux_submit_intr_urb(shared_int, urb->dev, ((( gfp_t)0x20u)));
|}
|
|
|static int hso_mux_serial_write_data(struct hso_serial *serial)
|{
| if (((void *)0) == serial)
|  return -22;
|
| return mux_device_request(serial,
|      0x00,
|      serial->parent->port_spec & 0xFF,
|      serial->tx_urb,
|      &serial->ctrl_req_tx,
|      serial->tx_data, serial->tx_data_count);
|}
|
|
|static void hso_std_serial_write_bulk_callback(struct urb *urb)
|{
| struct hso_serial *serial = urb->context;
| int status = urb->status;
| struct tty_struct *tty;
|
|
| if (!serial) {
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "serial == NULL" "\n", 1962, __func__); } while (0); } while (0);
|  return;
| }
|
| __st_spin_lock_st__(&serial->serial_lock);
| serial->tx_urb_used = 0;
| tty = tty_kref_get(serial->tty);
| __st_spin_unlock_st__(&serial->serial_lock);
| if (status) {
|  handle_usb_error(status, __func__, serial->parent);
|  tty_kref_put(tty);
|  return;
| }
| hso_put_activity(serial->parent);
| if (tty) {
|  tty_wakeup(tty);
|  tty_kref_put(tty);
| }
| hso_kick_transmit(serial);
|
| do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " " " "\n", 1982, __func__); } while (0); } while (0);
|}
|
|
|static int hso_std_serial_write_data(struct hso_serial *serial)
|{
| int count = serial->tx_data_count;
| int result;
|
| usb_fill_bulk_urb(serial->tx_urb,
|     serial->parent->usb,
|     ((3 << 30) | __create_pipe(serial->parent->usb, serial->out_endp-> bEndpointAddress & 0x7F))
|
|                               ,
|     serial->tx_data, serial->tx_data_count,
|     hso_std_serial_write_bulk_callback, serial);
|
| result = usb_submit_urb(serial->tx_urb, ((( gfp_t)0x20u)));
| if (result) {
|  dev_warn(&serial->parent->usb->dev,
|    "Failed to submit urb - res %d\n", result);
|  return result;
| }
|
| return count;
|}
|
|
|static void ctrl_callback(struct urb *urb)
|{
| struct hso_serial *serial = urb->context;
| struct usb_ctrlrequest *req;
| int status = urb->status;
| struct tty_struct *tty;
|
|
| if (!serial)
|  return;
|
| __st_spin_lock_st__(&serial->serial_lock);
| serial->tx_urb_used = 0;
| tty = tty_kref_get(serial->tty);
| __st_spin_unlock_st__(&serial->serial_lock);
| if (status) {
|  handle_usb_error(status, __func__, serial->parent);
|  tty_kref_put(tty);
|  return;
| }
|
|
| req = (struct usb_ctrlrequest *)(urb->setup_packet);
| do { if (0x08 & debug) do { printk("<6>" "[%d:%s]: " "\n--- Got muxed ctrl callback 0x%02X ---" "\n", 2033, __func__, status); } while (0); } while (0);
| do { if (0x08 & debug) do { printk("<6>" "[%d:%s]: " "Actual length of urb = %d\n" "\n", 2034, __func__, urb->actual_length); } while (0); } while (0);
| ;
|
| if (req->bRequestType ==
|     (0x80 | 0x20 | 0x01)) {
|
|  serial->rx_urb_filled[0] = 1;
|  __st_spin_lock_st__(&serial->serial_lock);
|  put_rxbuf_data_and_resubmit_ctrl_urb(serial);
|  __st_spin_unlock_st__(&serial->serial_lock);
| } else {
|  hso_put_activity(serial->parent);
|  if (tty)
|   tty_wakeup(tty);
|
|  hso_kick_transmit(serial);
| }
| tty_kref_put(tty);
|}
|
|
|static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
|{
| struct tty_struct *tty;
| int write_length_remaining = 0;
| int curr_write_len;
|
|
| if (urb == ((void *)0) || serial == ((void *)0)) {
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "serial = NULL" "\n", 2063, __func__); } while (0); } while (0);
|  return -2;
| }
|
|
| tty = tty_kref_get(serial->tty);
|
|
| if (tty) {
|  write_length_remaining = urb->actual_length -
|   serial->curr_rx_urb_offset;
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "data to push to tty" "\n", 2074, __func__); } while (0); } while (0);
|  while (write_length_remaining) {
|   if ((__builtin_constant_p((0)) ? constant_test_bit((0), (&tty->flags)) : variable_test_bit((0), (&tty->flags)))) {
|    tty_kref_put(tty);
|    return -1;
|   }
|   curr_write_len = tty_insert_flip_string
|    (tty, urb->transfer_buffer +
|     serial->curr_rx_urb_offset,
|     write_length_remaining);
|   serial->curr_rx_urb_offset += curr_write_len;
|   write_length_remaining -= curr_write_len;
|   tty_flip_buffer_push(tty);
|  }
| }
| if (write_length_remaining == 0) {
|  serial->curr_rx_urb_offset = 0;
|  serial->rx_urb_filled[hso_urb_to_index(serial, urb)] = 0;
| }
| tty_kref_put(tty);
| return write_length_remaining;
|}
|
|
|
|
|static void hso_log_port(struct hso_device *hso_dev)
|{
| char *port_type;
| char port_dev[20];
|
| switch (hso_dev->port_spec & 0xFF) {
| case 0x1:
|  port_type = "Control";
|  break;
| case 0x2:
|  port_type = "Application";
|  break;
| case 0x3:
|  port_type = "GPS";
|  break;
| case 0x6:
|  port_type = "GPS control";
|  break;
| case 0x5:
|  port_type = "Application2";
|  break;
| case 0x4:
|  port_type = "PCSC";
|  break;
| case 0x10:
|  port_type = "Diagnostic";
|  break;
| case 0x9:
|  port_type = "Diagnostic2";
|  break;
| case 0x11:
|  port_type = "Modem";
|  break;
| case 0x12:
|  port_type = "Network";
|  break;
| default:
|  port_type = "Unknown";
|  break;
| }
| if ((hso_dev->port_spec & 0xFF) == 0x12) {
|  sprintf(port_dev, "%s", dev2net(hso_dev)->net->name);
| } else
|  sprintf(port_dev, "/dev/%s%d", tty_filename,
|   dev2ser(hso_dev)->minor);
|
| ({ if (0) dev_printk("<7>", &hso_dev->interface->dev, "HSO: Found %s port %s\n", port_type, port_dev); 0; })
|                      ;
|}
|
|static int hso_start_net_device(struct hso_device *hso_dev)
|{
| int i, result = 0;
| struct hso_net *hso_net = dev2net(hso_dev);
|
| if (!hso_net)
|  return -19;
|
|
| for (i = 0; i < 4; i++) {
|
|
|  usb_fill_bulk_urb(hso_net->mux_bulk_rx_urb_pool[i],
|      hso_dev->usb,
|      ((3 << 30) | __create_pipe(hso_dev->usb, hso_net->in_endp-> bEndpointAddress & 0x7F) | 0x80)
|
|                                ,
|      hso_net->mux_bulk_rx_buf_pool[i],
|      2048, read_bulk_callback,
|      hso_net);
|
|
|  result = usb_submit_urb(hso_net->mux_bulk_rx_urb_pool[i],
|     ((( gfp_t)0x10u)));
|  if (result)
|   dev_warn(&hso_dev->usb->dev,
|    "%s failed mux_bulk_rx_urb[%d] %d\n", __func__,
|    i, result);
| }
|
| return result;
|}
|
|static int hso_stop_net_device(struct hso_device *hso_dev)
|{
| int i;
| struct hso_net *hso_net = dev2net(hso_dev);
|
| if (!hso_net)
|  return -19;
|
| for (i = 0; i < 4; i++) {
|  if (hso_net->mux_bulk_rx_urb_pool[i])
|   usb_kill_urb(hso_net->mux_bulk_rx_urb_pool[i]);
|
| }
| if (hso_net->mux_bulk_tx_urb)
|  usb_kill_urb(hso_net->mux_bulk_tx_urb);
|
| return 0;
|}
|
|static int hso_start_serial_device(struct hso_device *hso_dev, gfp_t flags)
|{
| int i, result = 0;
| struct hso_serial *serial = dev2ser(hso_dev);
|
| if (!serial)
|  return -19;
|
|
|
| if (!(serial->parent->port_spec & 0x0100)) {
|  for (i = 0; i < serial->num_rx_urbs; i++) {
|   usb_fill_bulk_urb(serial->rx_urb[i],
|       serial->parent->usb,
|       ((3 << 30) | __create_pipe(serial->parent->usb, serial->in_endp-> bEndpointAddress & 0x7F) | 0x80)
|
|
|              ,
|       serial->rx_data[i],
|       serial->rx_data_length,
|       hso_std_serial_read_bulk_callback,
|       serial);
|   result = usb_submit_urb(serial->rx_urb[i], flags);
|   if (result) {
|    dev_warn(&serial->parent->usb->dev,
|      "Failed to submit urb - res %d\n",
|      result);
|    break;
|   }
|  }
| } else {
|  __st_mutex_lock_st__(&serial->shared_int->shared_int_lock);
|  if (!serial->shared_int->use_count) {
|   result =
|       hso_mux_submit_intr_urb(serial->shared_int,
|          hso_dev->usb, flags);
|  }
|  serial->shared_int->use_count++;
|  __st_mutex_unlock_st__(&serial->shared_int->shared_int_lock);
| }
| if (serial->tiocmget)
|  tiocmget_submit_urb(serial,
|        serial->tiocmget,
|        serial->parent->usb);
| return result;
|}
|
|static int hso_stop_serial_device(struct hso_device *hso_dev)
|{
| int i;
| struct hso_serial *serial = dev2ser(hso_dev);
| struct hso_tiocmget *tiocmget;
|
| if (!serial)
|  return -19;
|
| for (i = 0; i < serial->num_rx_urbs; i++) {
|  if (serial->rx_urb[i]) {
|    usb_kill_urb(serial->rx_urb[i]);
|    serial->rx_urb_filled[i] = 0;
|  }
| }
| serial->curr_rx_urb_idx = 0;
| serial->curr_rx_urb_offset = 0;
|
| if (serial->tx_urb)
|  usb_kill_urb(serial->tx_urb);
|
| if (serial->shared_int) {
|  __st_mutex_lock_st__(&serial->shared_int->shared_int_lock);
|  if (serial->shared_int->use_count &&
|      (--serial->shared_int->use_count == 0)) {
|   struct urb *urb;
|
|   urb = serial->shared_int->shared_intr_urb;
|   if (urb)
|    usb_kill_urb(urb);
|  }
|  __st_mutex_unlock_st__(&serial->shared_int->shared_int_lock);
| }
| tiocmget = serial->tiocmget;
| if (tiocmget) {
|  __wake_up(&tiocmget->waitq, 1, 1, ((void *)0));
|  usb_kill_urb(tiocmget->urb);
| }
|
| return 0;
|}
|
|static void hso_serial_common_free(struct hso_serial *serial)
|{
| int i;
|
| if (serial->parent->dev)
|  device_remove_file(serial->parent->dev, &dev_attr_hsotype);
|
| tty_unregister_device(tty_drv, serial->minor);
|
| for (i = 0; i < serial->num_rx_urbs; i++) {
|
|  usb_free_urb(serial->rx_urb[i]);
|
|  kfree(serial->rx_data[i]);
| }
|
|
| usb_free_urb(serial->tx_urb);
| kfree(serial->tx_data);
|}
|
|static int hso_serial_common_create(struct hso_serial *serial, int num_urbs,
|        int rx_size, int tx_size)
|{
| struct device *dev;
| int minor;
| int i;
|
| minor = get_free_serial_index();
| if (minor < 0)
|  goto exit;
|
|
| serial->parent->dev = tty_register_device(tty_drv, minor,
|     &serial->parent->interface->dev);
| dev = serial->parent->dev;
| dev_set_drvdata(dev, serial->parent);
| i = device_create_file(dev, &dev_attr_hsotype);
|
|
| serial->minor = minor;
| serial->magic = 0x48534f31;
| do { spinlock_check(&serial->serial_lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&serial->serial_lock)->rlock), "&(&serial->serial_lock)->rlock", &__key); } while (0); } while (0);
| serial->num_rx_urbs = num_urbs;
|
|
|
|
| serial->rx_data_length = rx_size;
| for (i = 0; i < serial->num_rx_urbs; i++) {
|  serial->rx_urb[i] = usb_alloc_urb(0, __st_GFP_KERNEL_st__);
|  if (!serial->rx_urb[i]) {
|   dev_err(dev, "Could not allocate urb?\n");
|   goto exit;
|  }
|  serial->rx_urb[i]->transfer_buffer = ((void *)0);
|  serial->rx_urb[i]->transfer_buffer_length = 0;
|  serial->rx_data[i] = kzalloc(serial->rx_data_length,
|          __st_GFP_KERNEL_st__);
|  if (!serial->rx_data[i]) {
|   dev_err(dev, "%s - Out of memory\n", __func__);
|   goto exit;
|  }
| }
|
|
| serial->tx_urb = usb_alloc_urb(0, __st_GFP_KERNEL_st__);
| if (!serial->tx_urb) {
|  dev_err(dev, "Could not allocate urb?\n");
|  goto exit;
| }
| serial->tx_urb->transfer_buffer = ((void *)0);
| serial->tx_urb->transfer_buffer_length = 0;
|
| serial->tx_data_count = 0;
| serial->tx_buffer_count = 0;
| serial->tx_data_length = tx_size;
| serial->tx_data = kzalloc(serial->tx_data_length, __st_GFP_KERNEL_st__);
| if (!serial->tx_data) {
|  dev_err(dev, "%s - Out of memory\n", __func__);
|  goto exit;
| }
| serial->tx_buffer = kzalloc(serial->tx_data_length, __st_GFP_KERNEL_st__);
| if (!serial->tx_buffer) {
|  dev_err(dev, "%s - Out of memory\n", __func__);
|  goto exit;
| }
|
| return 0;
|exit:
| hso_serial_common_free(serial);
| return -1;
|}
|
|
|static struct hso_device *hso_create_device(struct usb_interface *intf,
|         int port_spec)
|{
| struct hso_device *hso_dev;
|
| hso_dev = kzalloc(sizeof(*hso_dev), ((( gfp_t)0x20u)));
| if (!hso_dev)
|  return ((void *)0);
|
| hso_dev->port_spec = port_spec;
| hso_dev->usb = interface_to_usbdev(intf);
| hso_dev->interface = intf;
| kref_init(&hso_dev->ref);
| do { static struct lock_class_key __key; __mutex_init((&hso_dev->mutex), "&hso_dev->mutex", &__key); } while (0);
|
| do { do { static struct lock_class_key __key; __init_work(((&hso_dev->async_get_intf)), 0); ((&hso_dev->async_get_intf))->data = (atomic_long_t) { (WORK_STRUCT_NO_CPU) }; lockdep_init_map(&((&hso_dev->async_get_intf))->lockdep_map, "(&hso_dev->async_get_intf)", &__key, 0); INIT_LIST_HEAD(&((&hso_dev->async_get_intf))->entry); do { (((&hso_dev->async_get_intf)))->func = (((async_get_intf))); } while (0); } while (0); } while (0);
| do { do { static struct lock_class_key __key; __init_work(((&hso_dev->async_put_intf)), 0); ((&hso_dev->async_put_intf))->data = (atomic_long_t) { (WORK_STRUCT_NO_CPU) }; lockdep_init_map(&((&hso_dev->async_put_intf))->lockdep_map, "(&hso_dev->async_put_intf)", &__key, 0); INIT_LIST_HEAD(&((&hso_dev->async_put_intf))->entry); do { (((&hso_dev->async_put_intf)))->func = (((async_put_intf))); } while (0); } while (0); } while (0);
| do { do { static struct lock_class_key __key; __init_work(((&hso_dev->reset_device)), 0); ((&hso_dev->reset_device))->data = (atomic_long_t) { (WORK_STRUCT_NO_CPU) }; lockdep_init_map(&((&hso_dev->reset_device))->lockdep_map, "(&hso_dev->reset_device)", &__key, 0); INIT_LIST_HEAD(&((&hso_dev->reset_device))->entry); do { (((&hso_dev->reset_device)))->func = (((reset_device))); } while (0); } while (0); } while (0);
|
| return hso_dev;
|}
|
|
|static int remove_net_device(struct hso_device *hso_dev)
|{
| int i;
|
| for (i = 0; i < 10; i++) {
|  if (network_table[i] == hso_dev) {
|   network_table[i] = ((void *)0);
|   break;
|  }
| }
| if (i == 10)
|  return -1;
| return 0;
|}
|
|
|static void hso_free_net_device(struct hso_device *hso_dev)
|{
| int i;
| struct hso_net *hso_net = dev2net(hso_dev);
|
| if (!hso_net)
|  return;
|
| remove_net_device(hso_net->parent);
|
| if (hso_net->net) {
|  unregister_netdev(hso_net->net);
|  free_netdev(hso_net->net);
| }
|
|
| for (i = 0; i < 4; i++) {
|  usb_free_urb(hso_net->mux_bulk_rx_urb_pool[i]);
|  kfree(hso_net->mux_bulk_rx_buf_pool[i]);
|  hso_net->mux_bulk_rx_buf_pool[i] = ((void *)0);
| }
| usb_free_urb(hso_net->mux_bulk_tx_urb);
| kfree(hso_net->mux_bulk_tx_buf);
| hso_net->mux_bulk_tx_buf = ((void *)0);
|
| kfree(hso_dev);
|}
|
|static const struct net_device_ops hso_netdev_ops = {
| .ndo_open = hso_net_open,
| .ndo_stop = hso_net_close,
| .ndo_start_xmit = hso_net_start_xmit,
| .ndo_tx_timeout = hso_net_tx_timeout,
|};
|
|
|static void hso_net_init(struct net_device *net)
|{
| struct hso_net *hso_net = netdev_priv(net);
|
| do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "sizeof hso_net is %d" "\n", 2465, __func__, (int)sizeof(*hso_net)); } while (0); } while (0);
|
|
| net->netdev_ops = &hso_netdev_ops;
| net->watchdog_timeo = (250*10);
| net->flags = 0x10 | 0x80 | 0x1000;
| net->type = 0xFFFE;
| net->mtu = 1500 - 14;
| net->tx_queue_len = 10;
| ( (net)->ethtool_ops = (&ops) );
|
|
| do { spinlock_check(&hso_net->net_lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&hso_net->net_lock)->rlock), "&(&hso_net->net_lock)->rlock", &__key); } while (0); } while (0);
|}
|
|
|static int add_net_device(struct hso_device *hso_dev)
|{
| int i;
|
| for (i = 0; i < 10; i++) {
|  if (network_table[i] == ((void *)0)) {
|   network_table[i] = hso_dev;
|   break;
|  }
| }
| if (i == 10)
|  return -1;
| return 0;
|}
|
|static int hso_rfkill_set_block(void *data, bool blocked)
|{
| struct hso_device *hso_dev = data;
| int enabled = !blocked;
| int rv;
|
| __st_mutex_lock_st__(&hso_dev->mutex);
| if (hso_dev->usb_gone)
|  rv = 0;
| else
|  rv = usb_control_msg(hso_dev->usb, ((2 << 30) | __create_pipe(hso_dev->usb, 0) | 0x80),
|           enabled ? 0x82 : 0x81, 0x40, 0, 0, ((void *)0), 0,
|           5000);
| __st_mutex_unlock_st__(&hso_dev->mutex);
| return rv;
|}
|
|static const struct rfkill_ops hso_rfkill_ops = {
| .set_block = hso_rfkill_set_block,
|};
|
|
|static void hso_create_rfkill(struct hso_device *hso_dev,
|        struct usb_interface *interface)
|{
| struct hso_net *hso_net = dev2net(hso_dev);
| struct device *dev = &hso_net->net->dev;
| char *rfkn;
|
| rfkn = kzalloc(20, __st_GFP_KERNEL_st__);
| if (!rfkn)
|  dev_err(dev, "%s - Out of memory\n", __func__);
|
| snprintf(rfkn, 20, "hso-%d",
|   interface->altsetting->desc.bInterfaceNumber);
|
| hso_net->rfkill = rfkill_alloc(rfkn,
|           &interface_to_usbdev(interface)->dev,
|           RFKILL_TYPE_WWAN,
|           &hso_rfkill_ops, hso_dev);
| if (!hso_net->rfkill) {
|  dev_err(dev, "%s - Out of memory\n", __func__);
|  kfree(rfkn);
|  return;
| }
| if (rfkill_register(hso_net->rfkill) < 0) {
|  rfkill_destroy(hso_net->rfkill);
|  kfree(rfkn);
|  hso_net->rfkill = ((void *)0);
|  dev_err(dev, "%s - Failed to register rfkill\n", __func__);
|  return;
| }
|}
|
|static struct device_type hso_type = {
| .name = "wwan",
|};
|
|
|static struct hso_device *hso_create_net_device(struct usb_interface *interface,
|      int port_spec)
|{
| int result, i;
| struct net_device *net;
| struct hso_net *hso_net;
| struct hso_device *hso_dev;
|
| hso_dev = hso_create_device(interface, port_spec);
| if (!hso_dev)
|  return ((void *)0);
|
|
|
| net = alloc_netdev_mq(sizeof(struct hso_net), "hso%d", hso_net_init, 1);
| if (!net) {
|  dev_err(&interface->dev, "Unable to create ethernet device\n");
|  goto exit;
| }
|
| hso_net = netdev_priv(net);
|
| hso_dev->port_data.dev_net = hso_net;
| hso_net->net = net;
| hso_net->parent = hso_dev;
|
| hso_net->in_endp = hso_get_ep(interface, 2,
|          0x80);
| if (!hso_net->in_endp) {
|  dev_err(&interface->dev, "Can't find BULK IN endpoint\n");
|  goto exit;
| }
| hso_net->out_endp = hso_get_ep(interface, 2,
|           0);
| if (!hso_net->out_endp) {
|  dev_err(&interface->dev, "Can't find BULK OUT endpoint\n");
|  goto exit;
| }
| ((net)->dev.parent = (&interface->dev));
| ((net)->dev.type = (&hso_type));
|
|
| result = register_netdev(net);
| if (result) {
|  dev_err(&interface->dev, "Failed to register device\n");
|  goto exit;
| }
|
|
| for (i = 0; i < 4; i++) {
|  hso_net->mux_bulk_rx_urb_pool[i] = usb_alloc_urb(0, __st_GFP_KERNEL_st__);
|  if (!hso_net->mux_bulk_rx_urb_pool[i]) {
|   dev_err(&interface->dev, "Could not allocate rx urb\n");
|   goto exit;
|  }
|  hso_net->mux_bulk_rx_buf_pool[i] = kzalloc(2048,
|          __st_GFP_KERNEL_st__);
|  if (!hso_net->mux_bulk_rx_buf_pool[i]) {
|   dev_err(&interface->dev, "Could not allocate rx buf\n");
|   goto exit;
|  }
| }
| hso_net->mux_bulk_tx_urb = usb_alloc_urb(0, __st_GFP_KERNEL_st__);
| if (!hso_net->mux_bulk_tx_urb) {
|  dev_err(&interface->dev, "Could not allocate tx urb\n");
|  goto exit;
| }
| hso_net->mux_bulk_tx_buf = kzalloc(2048, __st_GFP_KERNEL_st__);
| if (!hso_net->mux_bulk_tx_buf) {
|  dev_err(&interface->dev, "Could not allocate tx buf\n");
|  goto exit;
| }
|
| add_net_device(hso_dev);
|
| hso_log_port(hso_dev);
|
| hso_create_rfkill(hso_dev, interface);
|
| return hso_dev;
|exit:
| hso_free_net_device(hso_dev);
| return ((void *)0);
|}
|
|static void hso_free_tiomget(struct hso_serial *serial)
|{
| struct hso_tiocmget *tiocmget = serial->tiocmget;
     |dereferencing NULL pointer here.[serial] prev
| if (tiocmget) {
|  if (tiocmget->urb) {
|   usb_free_urb(tiocmget->urb);
|   tiocmget->urb = ((void *)0);
|  }
|  serial->tiocmget = ((void *)0);
|  kfree(tiocmget);
|
| }
|}
|
|
|static void hso_free_serial_device(struct hso_device *hso_dev)
|{
| struct hso_serial *serial = dev2ser(hso_dev);
|
| if (!serial)
|  return;
| set_serial_by_index(serial->minor, ((void *)0));
|
| hso_serial_common_free(serial);
|
| if (serial->shared_int) {
|  __st_mutex_lock_st__(&serial->shared_int->shared_int_lock);
|  if (--serial->shared_int->ref_count == 0)
|   hso_free_shared_int(serial->shared_int);
|  else
|   __st_mutex_unlock_st__(&serial->shared_int->shared_int_lock);
| }
| hso_free_tiomget(serial);
| kfree(serial);
| kfree(hso_dev);
|}
|
|
|static struct hso_device *hso_create_bulk_serial_device(
|   struct usb_interface *interface, int port)
|{
| struct hso_device *hso_dev;
| struct hso_serial *serial;
| int num_urbs;
| struct hso_tiocmget *tiocmget;
|
| hso_dev = hso_create_device(interface, port);
| if (!hso_dev)
|  return ((void *)0);
|
| serial = kzalloc(sizeof(*serial), __st_GFP_KERNEL_st__);
     |pointer is NULL. prev next
| if (!serial)
     |not affected ==> pointer is still NULL. prev next
|  goto exit;
     |not affected ==> pointer is still NULL. prev next
|
| serial->parent = hso_dev;
| hso_dev->port_data.dev_serial = serial;
|
| if ((port & 0xFF) == 0x11) {
|  num_urbs = 2;
|  serial->tiocmget = kzalloc(sizeof(struct hso_tiocmget),
|        __st_GFP_KERNEL_st__);
|
|
|
|  if (serial->tiocmget) {
|   tiocmget = serial->tiocmget;
|   tiocmget->urb = usb_alloc_urb(0, __st_GFP_KERNEL_st__);
|   if (tiocmget->urb) {
|    do { static struct lock_class_key __key; __mutex_init((&tiocmget->mutex), "&tiocmget->mutex", &__key); } while (0);
|    do { static struct lock_class_key __key; __init_waitqueue_head((&tiocmget->waitq), &__key); } while (0);
|    tiocmget->endp = hso_get_ep(
|     interface,
|     3,
|     0x80);
|   } else
|    hso_free_tiomget(serial);
|  }
| }
| else
|  num_urbs = 1;
|
| if (hso_serial_common_create(serial, num_urbs, 4096,
|         8192))
|  goto exit;
|
| serial->in_endp = hso_get_ep(interface, 2,
|         0x80);
| if (!serial->in_endp) {
|  dev_err(&interface->dev, "Failed to find BULK IN ep\n");
|  goto exit2;
| }
|
| if (!
|     (serial->out_endp =
|      hso_get_ep(interface, 2, 0))) {
|  dev_err(&interface->dev, "Failed to find BULK IN ep\n");
|  goto exit2;
| }
|
| serial->write_data = hso_std_serial_write_data;
|
|
| set_serial_by_index(serial->minor, serial);
|
|
| hso_log_port(hso_dev);
|
|
| return hso_dev;
|
|exit2:
| hso_serial_common_free(serial);
     |<context>When called from here. next
|exit:
| hso_free_tiomget(serial);
     |not affected ==> pointer is still NULL. prev next
| kfree(serial);
| kfree(hso_dev);
| return ((void *)0);
|}
|
|
|static
|struct hso_device *hso_create_mux_serial_device(struct usb_interface *interface,
|      int port,
|      struct hso_shared_int *mux)
|{
| struct hso_device *hso_dev;
| struct hso_serial *serial;
| int port_spec;
|
| port_spec = 0x0100;
| port_spec &= ~0xFF;
|
| port_spec |= hso_mux_to_port(port);
| if ((port_spec & 0xFF) == 0x0)
|  return ((void *)0);
|
| hso_dev = hso_create_device(interface, port_spec);
| if (!hso_dev)
|  return ((void *)0);
|
| serial = kzalloc(sizeof(*serial), __st_GFP_KERNEL_st__);
| if (!serial)
|  goto exit;
|
| hso_dev->port_data.dev_serial = serial;
| serial->parent = hso_dev;
|
| if (hso_serial_common_create
|     (serial, 1, 1024, 64))
|  goto exit;
|
| serial->tx_data_length--;
| serial->write_data = hso_mux_serial_write_data;
|
| serial->shared_int = mux;
| __st_mutex_lock_st__(&serial->shared_int->shared_int_lock);
| serial->shared_int->ref_count++;
| __st_mutex_unlock_st__(&serial->shared_int->shared_int_lock);
|
|
| set_serial_by_index(serial->minor, serial);
|
|
| hso_log_port(hso_dev);
|
|
| return hso_dev;
|
|exit:
| if (serial) {
|  tty_unregister_device(tty_drv, serial->minor);
|  kfree(serial);
| }
| if (hso_dev)
|  kfree(hso_dev);
| return ((void *)0);
|
|}
|
|static void hso_free_shared_int(struct hso_shared_int *mux)
|{
| usb_free_urb(mux->shared_intr_urb);
| kfree(mux->shared_intr_buf);
| __st_mutex_unlock_st__(&mux->shared_int_lock);
| kfree(mux);
|}
|
|static
|struct hso_shared_int *hso_create_shared_int(struct usb_interface *interface)
|{
| struct hso_shared_int *mux = kzalloc(sizeof(*mux), __st_GFP_KERNEL_st__);
|
| if (!mux)
|  return ((void *)0);
|
| mux->intr_endp = hso_get_ep(interface, 3,
|        0x80);
| if (!mux->intr_endp) {
|  dev_err(&interface->dev, "Can't find INT IN endpoint\n");
|  goto exit;
| }
|
| mux->shared_intr_urb = usb_alloc_urb(0, __st_GFP_KERNEL_st__);
| if (!mux->shared_intr_urb) {
|  dev_err(&interface->dev, "Could not allocate intr urb?\n");
|  goto exit;
| }
| mux->shared_intr_buf =
|  kzalloc((( __u16)(__le16)(mux->intr_endp->wMaxPacketSize)),
|   __st_GFP_KERNEL_st__);
| if (!mux->shared_intr_buf) {
|  dev_err(&interface->dev, "Could not allocate intr buf?\n");
|  goto exit;
| }
|
| do { static struct lock_class_key __key; __mutex_init((&mux->shared_int_lock), "&mux->shared_int_lock", &__key); } while (0);
|
| return mux;
|
|exit:
| kfree(mux->shared_intr_buf);
| usb_free_urb(mux->shared_intr_urb);
| kfree(mux);
| return ((void *)0);
|}
|
|
|static int hso_get_config_data(struct usb_interface *interface)
|{
| struct usb_device *usbdev = interface_to_usbdev(interface);
| u8 config_data[17];
| u32 if_num = interface->altsetting->desc.bInterfaceNumber;
| s32 result;
|
| if (usb_control_msg(usbdev, ((2 << 30) | __create_pipe(usbdev, 0) | 0x80),
|       0x86, 0xC0, 0, 0, config_data, 17,
|       5000) != 0x11) {
|  return -5;
| }
|
| switch (config_data[if_num]) {
| case 0x0:
|  result = 0;
|  break;
| case 0x1:
|  result = 0x10;
|  break;
| case 0x2:
|  result = 0x3;
|  break;
| case 0x3:
|  result = 0x6;
|  break;
| case 0x4:
|  result = 0x2;
|  break;
| case 0x5:
|  result = 0x5;
|  break;
| case 0x6:
|  result = 0x1;
|  break;
| case 0x7:
|  result = 0x12;
|  break;
| case 0x8:
|  result = 0x11;
|  break;
| case 0x9:
|  result = 0x7;
|  break;
| case 0xa:
|  result = 0x4;
|  break;
| case 0xb:
|  result = 0x8;
|  break;
| default:
|  result = 0;
| }
|
| if (result)
|  result |= 0x0200;
|
| if (config_data[16] & 0x1)
|  result |= 0x01000000;
|
| return result;
|}
|
|
|static int hso_probe(struct usb_interface *interface,
|       const struct usb_device_id *id)
|{
| int mux, i, if_num, port_spec;
| unsigned char port_mask;
| struct hso_device *hso_dev = ((void *)0);
| struct hso_shared_int *shared_int;
| struct hso_device *tmp_dev = ((void *)0);
|
| if_num = interface->altsetting->desc.bInterfaceNumber;
|
|
|
| if (id->driver_info)
|  port_spec = ((u32 *)(id->driver_info))[if_num];
| else
|  port_spec = hso_get_config_data(interface);
|
| if (interface->cur_altsetting->desc.bInterfaceClass != 0xFF) {
|  dev_err(&interface->dev, "Not our interface\n");
|  return -19;
| }
|
|
| if (interface->num_altsetting > 1)
|  usb_set_interface(interface_to_usbdev(interface), if_num, 1);
| interface->needs_remote_wakeup = 1;
|
|
| switch (port_spec & 0xFF00) {
| case 0x0100:
|  if ((port_spec & 0xFF) == 0x12) {
|
|   if (!disable_net) {
|    hso_dev = hso_create_net_device(interface,
|        port_spec);
|    if (!hso_dev)
|     goto exit;
|    tmp_dev = hso_dev;
|   }
|  }
|
|  if (hso_get_mux_ports(interface, &port_mask))
|
|   goto exit;
|
|  shared_int = hso_create_shared_int(interface);
|  if (!shared_int)
|   goto exit;
|
|  for (i = 1, mux = 0; i < 0x100; i = i << 1, mux++) {
|   if (port_mask & i) {
|    hso_dev = hso_create_mux_serial_device(
|      interface, i, shared_int);
|    if (!hso_dev)
|     goto exit;
|   }
|  }
|
|  if (tmp_dev)
|   hso_dev = tmp_dev;
|  break;
|
| case 0x0200:
|
|  if (((port_spec & 0xFF) == 0x12) &&
|      !disable_net)
|   hso_dev = hso_create_net_device(interface, port_spec);
|  else
|   hso_dev =
|       hso_create_bulk_serial_device(interface, port_spec);
|  if (!hso_dev)
|   goto exit;
|  break;
| default:
|  goto exit;
| }
|
|
| usb_set_intfdata(interface, hso_dev);
|
|
| return 0;
|exit:
| hso_free_interface(interface);
| return -19;
|}
|
|
|static void hso_disconnect(struct usb_interface *interface)
|{
| hso_free_interface(interface);
|
|
| usb_set_intfdata(interface, ((void *)0));
|}
|
|static void async_get_intf(struct work_struct *data)
|{
| struct hso_device *hso_dev =
|     ({ const typeof( ((struct hso_device *)0)->async_get_intf ) *__mptr = (data); (struct hso_device *)( (char *)__mptr - 1 );});
| usb_autopm_get_interface(hso_dev->interface);
|}
|
|static void async_put_intf(struct work_struct *data)
|{
| struct hso_device *hso_dev =
|     ({ const typeof( ((struct hso_device *)0)->async_put_intf ) *__mptr = (data); (struct hso_device *)( (char *)__mptr - 1 );});
| usb_autopm_put_interface(hso_dev->interface);
|}
|
|static int hso_get_activity(struct hso_device *hso_dev)
|{
| if (hso_dev->usb->state == USB_STATE_SUSPENDED) {
|  if (!hso_dev->is_active) {
|   hso_dev->is_active = 1;
|   schedule_work(&hso_dev->async_get_intf);
|  }
| }
|
| if (hso_dev->usb->state != USB_STATE_CONFIGURED)
|  return -11;
|
| usb_mark_last_busy(hso_dev->usb);
|
| return 0;
|}
|
|static int hso_put_activity(struct hso_device *hso_dev)
|{
| if (hso_dev->usb->state != USB_STATE_SUSPENDED) {
|  if (hso_dev->is_active) {
|   hso_dev->is_active = 0;
|   schedule_work(&hso_dev->async_put_intf);
|   return -11;
|  }
| }
| hso_dev->is_active = 0;
| return 0;
|}
|
|
|static int hso_suspend(struct usb_interface *iface, pm_message_t message)
|{
| int i, result;
|
|
| for (i = 0; i < 256; i++) {
|  if (serial_table[i] && (serial_table[i]->interface == iface)) {
|   result = hso_stop_serial_device(serial_table[i]);
|   if (result)
|    goto out;
|  }
| }
|
|
| for (i = 0; i < 10; i++) {
|  if (network_table[i] &&
|      (network_table[i]->interface == iface)) {
|   result = hso_stop_net_device(network_table[i]);
|   if (result)
|    goto out;
|  }
| }
|
|out:
| return 0;
|}
|
|
|static int hso_resume(struct usb_interface *iface)
|{
| int i, result = 0;
| struct hso_net *hso_net;
|
|
| for (i = 0; i < 256; i++) {
|  if (serial_table[i] && (serial_table[i]->interface == iface)) {
|   if (dev2ser(serial_table[i])->open_count) {
|    result =
|        hso_start_serial_device(serial_table[i], ((( gfp_t)0x10u)));
|    hso_kick_transmit(dev2ser(serial_table[i]));
|    if (result)
|     goto out;
|   }
|  }
| }
|
|
| for (i = 0; i < 10; i++) {
|  if (network_table[i] &&
|      (network_table[i]->interface == iface)) {
|   hso_net = dev2net(network_table[i]);
|   if (hso_net->flags & 0x1) {
|
|
|    if (hso_net->skb_tx_buf) {
|     ({ if (0) dev_printk("<7>", &iface->dev, "Transmitting" " lingering data\n"); 0; })
|
|                          ;
|     hso_net_start_xmit(hso_net->skb_tx_buf,
|          hso_net->net);
|     hso_net->skb_tx_buf = ((void *)0);
|    }
|    result = hso_start_net_device(network_table[i]);
|    if (result)
|     goto out;
|   }
|  }
| }
|
|out:
| return result;
|}
|
|static void reset_device(struct work_struct *data)
|{
| struct hso_device *hso_dev =
|     ({ const typeof( ((struct hso_device *)0)->reset_device ) *__mptr = (data); (struct hso_device *)( (char *)__mptr - 1 );});
| struct usb_device *usb = hso_dev->usb;
| int result;
|
| if (hso_dev->usb_gone) {
|  do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "No reset during disconnect\n" "\n", 3154, __func__); } while (0); } while (0);
| } else {
|  result = usb_lock_device_for_reset(usb, hso_dev->interface);
|  if (result < 0)
|   do { if (0x01 & debug) do { printk("<6>" "[%d:%s]: " "unable to lock device for reset: %d\n" "\n", 3158, __func__, result); } while (0); } while (0);
|  else {
|   usb_reset_device(usb);
|   device_unlock(&(usb)->dev);
|  }
| }
|}
|
|static void hso_serial_ref_free(struct kref *ref)
|{
| struct hso_device *hso_dev = ({ const typeof( ((struct hso_device *)0)->ref ) *__mptr = (ref); (struct hso_device *)( (char *)__mptr - 1 );});
|
| hso_free_serial_device(hso_dev);
|}
|
|static void hso_free_interface(struct usb_interface *interface)
|{
| struct hso_serial *hso_dev;
| struct tty_struct *tty;
| int i;
|
| for (i = 0; i < 256; i++) {
|  if (serial_table[i] &&
|      (serial_table[i]->interface == interface)) {
|   hso_dev = dev2ser(serial_table[i]);
|   __st_spin_lock_irq_st__(&hso_dev->serial_lock);
|   tty = tty_kref_get(hso_dev->tty);
|   __st_spin_unlock_irq_st__(&hso_dev->serial_lock);
|   if (tty)
|    tty_hangup(tty);
|   __st_mutex_lock_st__(&hso_dev->parent->mutex);
|   tty_kref_put(tty);
|   hso_dev->parent->usb_gone = 1;
|   __st_mutex_unlock_st__(&hso_dev->parent->mutex);
|   kref_put(&serial_table[i]->ref, hso_serial_ref_free);
|  }
| }
|
| for (i = 0; i < 10; i++) {
|  if (network_table[i] &&
|      (network_table[i]->interface == interface)) {
|   struct rfkill *rfk = dev2net(network_table[i])->rfkill;
|
|
|   netif_stop_queue(dev2net(network_table[i])->net);
|   hso_stop_net_device(network_table[i]);
|   cancel_work_sync(&network_table[i]->async_put_intf);
|   cancel_work_sync(&network_table[i]->async_get_intf);
|   if (rfk) {
|    rfkill_unregister(rfk);
|    rfkill_destroy(rfk);
|   }
|   hso_free_net_device(network_table[i]);
|  }
| }
|}
|
|
|
|
|static struct usb_endpoint_descriptor *hso_get_ep(struct usb_interface *intf,
|        int type, int dir)
|{
| int i;
| struct usb_host_interface *iface = intf->cur_altsetting;
| struct usb_endpoint_descriptor *endp;
|
| for (i = 0; i < iface->desc.bNumEndpoints; i++) {
|  endp = &iface->endpoint[i].desc;
|  if (((endp->bEndpointAddress & 0x80) == dir) &&
|      (usb_endpoint_type(endp) == type))
|   return endp;
| }
|
| return ((void *)0);
|}
|
|
|static int hso_get_mux_ports(struct usb_interface *intf, unsigned char *ports)
|{
| int i;
| struct usb_host_interface *iface = intf->cur_altsetting;
|
| if (iface->extralen == 3) {
|  *ports = iface->extra[2];
|  return 0;
| }
|
| for (i = 0; i < iface->desc.bNumEndpoints; i++) {
|  if (iface->endpoint[i].extralen == 3) {
|   *ports = iface->endpoint[i].extra[2];
|   return 0;
|  }
| }
|
| return -1;
|}
|
|
|static int hso_mux_submit_intr_urb(struct hso_shared_int *shared_int,
|       struct usb_device *usb, gfp_t gfp)
|{
| int result;
|
| usb_fill_int_urb(shared_int->shared_intr_urb, usb,
|    ((1 << 30) | __create_pipe(usb, shared_int->intr_endp->bEndpointAddress & 0x7F) | 0x80)
|                                                   ,
|    shared_int->shared_intr_buf,
|    1,
|    intr_callback, shared_int,
|    shared_int->intr_endp->bInterval);
|
| result = usb_submit_urb(shared_int->shared_intr_urb, gfp);
| if (result)
|  dev_warn(&usb->dev, "%s failed mux_intr_urb %d\n", __func__,
|   result);
|
| return result;
|}
|
|
|static const struct tty_operations hso_serial_ops = {
| .open = hso_serial_open,
| .close = hso_serial_close,
| .write = hso_serial_write,
| .write_room = hso_serial_write_room,
| .ioctl = hso_serial_ioctl,
| .set_termios = hso_serial_set_termios,
| .chars_in_buffer = hso_serial_chars_in_buffer,
| .tiocmget = hso_serial_tiocmget,
| .tiocmset = hso_serial_tiocmset,
| .get_icount = hso_get_count,
| .unthrottle = hso_unthrottle
|};
|
|static struct usb_driver hso_driver = {
| .name = driver_name,
| .probe = hso_probe,
| .disconnect = hso_disconnect,
| .id_table = hso_ids,
| .suspend = hso_suspend,
| .resume = hso_resume,
| .reset_resume = hso_resume,
| .supports_autosuspend = 1,
|};
|
|static int hso_init(void)
|{
| int i;
| int result;
|
|
| printk("<6>" "hso: %s\n", version);
|
|
| do { spinlock_check(&serial_table_lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&serial_table_lock)->rlock), "&(&serial_table_lock)->rlock", &__key); } while (0); } while (0);
| for (i = 0; i < 256; i++)
|  serial_table[i] = ((void *)0);
|
|
| tty_drv = alloc_tty_driver(256);
| if (!tty_drv)
|  return -12;
|
|
| tty_drv->magic = 0x5402;
| tty_drv->owner = (&__this_module);
| tty_drv->driver_name = driver_name;
| tty_drv->name = tty_filename;
|
|
| if (tty_major)
|  tty_drv->major = tty_major;
|
| tty_drv->minor_start = 0;
| tty_drv->num = 256;
| tty_drv->type = 0x0003;
| tty_drv->subtype = 1;
| tty_drv->flags = 0x0004 | 0x0008;
| tty_drv->init_termios = tty_std_termios;
| hso_init_termios(&tty_drv->init_termios);
| tty_set_operations(tty_drv, &hso_serial_ops);
|
|
| result = tty_register_driver(tty_drv);
| if (result) {
|  printk("<3>" "%s - tty_register_driver failed(%d)\n",
|   __func__, result);
|  return result;
| }
|
|
| result = usb_register(&hso_driver);
| if (result) {
|  printk("<3>" "Could not register hso driver? error: %d\n",
|   result);
|
|  tty_unregister_driver(tty_drv);
|  return result;
| }
|
|
| return 0;
|}
|
|static void hso_exit(void)
|{
| printk("<6>" "hso: unloaded\n");
|
| tty_unregister_driver(tty_drv);
|
| usb_deregister(&hso_driver);
|}
|
|
|static inline initcall_t __inittest(void) { return hso_init; } int init_module(void) ;;
|static inline exitcall_t __exittest(void) { return hso_exit; } void cleanup_module(void) ;;
|
|static const char __mod_author3376[] = "author" "=" "Option Wireless";
|static const char __mod_description3377[] = "description" "=" "USB High Speed Option driver";
|static const char __mod_license3378[] = "license" "=" "GPL";
|
|
|static const char __mod_debug3381[] = "parm" "=" "debug" ":" "Level of debug [0x01 | 0x02 | 0x04 | 0x08 | 0x10]";
|static inline int *__check_debug(void) { return(&(debug)); }; static int __param_perm_check_debug = (sizeof(struct { int:-!!(((00400|00040|00004) | 00200) < 0 || ((00400|00040|00004) | 00200) > 0777 || (((00400|00040|00004) | 00200) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_debug[] = "debug"; static struct kernel_param const __param_debug = { __param_str_debug, ¶m_ops_int, (00400|00040|00004) | 00200, 0 ? 2 : 0, { &debug } }; static const char __mod_debugtype3382[] = "parmtype" "=" "debug" ":" "int";
|
|
|static const char __mod_tty_major3385[] = "parm" "=" "tty_major" ":" "Set the major tty number";
|static inline int *__check_tty_major(void) { return(&(tty_major)); }; static int __param_perm_check_tty_major = (sizeof(struct { int:-!!(((00400|00040|00004) | 00200) < 0 || ((00400|00040|00004) | 00200) > 0777 || (((00400|00040|00004) | 00200) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_tty_major[] = "tty_major"; static struct kernel_param const __param_tty_major = { __param_str_tty_major, ¶m_ops_int, (00400|00040|00004) | 00200, 0 ? 2 : 0, { &tty_major } }; static const char __mod_tty_majortype3386[] = "parmtype" "=" "tty_major" ":" "int";
|
|
|static const char __mod_disable_net3389[] = "parm" "=" "disable_net" ":" "Disable the network interface";
|static inline int *__check_disable_net(void) { return(&(disable_net)); }; static int __param_perm_check_disable_net = (sizeof(struct { int:-!!(((00400|00040|00004) | 00200) < 0 || ((00400|00040|00004) | 00200) > 0777 || (((00400|00040|00004) | 00200) & 2)); })) + (sizeof(struct { int:-!!(sizeof("") > (64 - sizeof(unsigned long))); })); static const char __param_str_disable_net[] = "disable_net"; static struct kernel_param const __param_disable_net = { __param_str_disable_net, ¶m_ops_int, (00400|00040|00004) | 00200, 0 ? 2 : 0, { &disable_net } }; static const char __mod_disable_nettype3390[] = "parmtype" "=" "disable_net" ":" "int";