Patch to option HSO driver to the kernel

2,977 lines not on this page · raw message

@@ -1464,7 +1464,7 @@ static int hso_set_suspend(struct hso_de
 	return 0;
 }
 
-/* Toggles radioon or off ( used by ioctl ) */
+/* Toggles radio on or off ( used by ioctl ) */
 static int hso_set_radio(struct hso_device *hso_dev, int enabled)
 {
 	if (!hso_dev)

@@ -2291,7 +2291,7 @@ static int hso_serial_common_create(stru
 	spin_lock_init(&serial->serial_lock);
 	serial->num_rx_urbs = num_urbs;
 
-	/* RX , allocate urb and initialize */
+	/* RX, allocate urb and initialize */
 
 	/* prepare our RX buffer */
 	serial->rx_data_length = rx_size;

@@ -2311,7 +2311,7 @@ static int hso_serial_common_create(stru
 		}
 	}
 
-	/* TX , allocate urb and initialize */
+	/* TX, allocate urb and initialize */
 	serial->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
 	if (!serial->tx_urb) {
 		dev_err(dev, "Could not allocate urb?\n");

@@ -3131,14 +3131,8 @@ static void set_ethernet_addr(struct hso
 	unsigned char buffer[13];
 	unsigned char checkserial[7] = "Serial";
 
-	/* we can't fail, therefor we use a default macaddress (constructed
-	 * from the pointer of our struct) */
-	mac_addr[0] = 0x00;
-	mac_addr[1] = 0x03;
-	mac_addr[2] = (unsigned char)(((unsigned long)odev) & 0xFF);
-	mac_addr[3] = (unsigned char)((((unsigned long)odev) >> 8) & 0xFF);
-	mac_addr[4] = (unsigned char)((((unsigned long)odev) >> 16) & 0xFF);
-	mac_addr[5] = (unsigned char)((((unsigned long)odev) >> 24) & 0xFF);
+	/* we can't fail, therefor we use a random macaddress */
+	random_ether_addr(mac_addr);
 	dummy_mac[0] = 0xFA;
 	dummy_mac[1] = mac_addr[1];
 	dummy_mac[2] = mac_addr[2];

@@ -3174,7 +3168,7 @@ static void set_ethernet_addr(struct hso
 		}
 	} else {
 		dev_err(&odev->parent->usb->dev, "Attempting to get MAC "
-			"address failed: using default\n");
+			"address failed: using random\n");
 	}
 
 	/* Now copy it over to our network device structure */

@@ -60,6 +60,7 @@
 #include <linux/ip.h>
 #include <linux/proc_fs.h>
 #include <linux/uaccess.h>
+#include <linux/usb/cdc.h>
 #include <net/arp.h>
 #include <asm/byteorder.h>
 

@@ -94,25 +95,10 @@
 
 #define	HSO_NET_TX_TIMEOUT		(HZ*10)
 
-#define SEND_ENCAPSULATED_COMMAND	0x00
-#define GET_ENCAPSULATED_RESPONSE	0x01
-
 /* Serial port defines and structs. */
 #define HSO_THRESHOLD_THROTTLE		(7*1024)
 #define HSO_THRESHOLD_UNTHROTTLE	(2*1024)
 
-/* These definitions used in the Ethernet Packet Filtering requests */
-/* See CDC Spec Table 62 */
-#define MODE_FLAG_PROMISCUOUS		(1<<0)
-#define MODE_FLAG_ALL_MULTICAST		(1<<1)
-#define MODE_FLAG_DIRECTED		(1<<2)
-#define MODE_FLAG_BROADCAST		(1<<3)
-#define MODE_FLAG_MULTICAST		(1<<4)
-
-/* CDC Spec class requests - CDC Spec Table 46 */
-#define SET_ETHERNET_MULTICAST_FILTER	0x40
-#define SET_ETHERNET_PACKET_FILTER	0x43
-
 #define HSO_SERIAL_FLAG_THROTTLED	0
 #define HSO_SERIAL_FLAG_TX_SENT		1
 #define HSO_SERIAL_FLAG_RX_SENT		2

@@ -262,6 +248,7 @@ struct hso_device {
 
 	struct device *dev;
 	struct kref ref;
+	struct mutex mutex;
 
 	/* TODO: Not sure about the ones below */
 	struct proc_dir_entry *ourproc;

@@ -339,7 +326,7 @@ static struct usb_endpoint_descriptor *h
 						  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);
+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);

@@ -655,12 +642,12 @@ static int hso_net_open(struct net_devic
 
 	hso_start_net_device(odev->parent);
 
-	/* Tell the kernel we are ready to start receiving from it */
-	netif_start_queue(net);
-
 	/* We are up and running. */
 	set_bit(HSO_NET_RUNNING, &odev->flags);
 
+	/* Tell the kernel we are ready to start receiving from it */
+	netif_start_queue(net);
+
 	return 0;
 }
 

@@ -669,10 +656,10 @@ static int hso_net_close(struct net_devi
 {
 	struct hso_net *odev = netdev_priv(net);
 
-	/* no longer running */
-	clear_bit(HSO_NET_RUNNING, &odev->flags);
 	/* we don't need the queue anymore */
 	netif_stop_queue(net);
+	/* no longer running */
+	clear_bit(HSO_NET_RUNNING, &odev->flags);
 
 	hso_stop_net_device(odev->parent);
 

@@ -834,34 +821,34 @@ static void hso_net_set_multicast(struct
 	if (net->flags & IFF_PROMISC) {
 		/* Unconditionally log net taps. */
 		D1("%s: Promiscuous mode enabled", net->name);
-		odev->mode_flags = MODE_FLAG_ALL_MULTICAST |
-				   MODE_FLAG_DIRECTED |
-				   MODE_FLAG_BROADCAST |
-				   MODE_FLAG_MULTICAST |
-				   MODE_FLAG_PROMISCUOUS;
+		odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
+				   USB_CDC_PACKET_TYPE_DIRECTED |
+				   USB_CDC_PACKET_TYPE_BROADCAST |
+				   USB_CDC_PACKET_TYPE_MULTICAST |
+				   USB_CDC_PACKET_TYPE_PROMISCUOUS;
 	} else if (net->mc_count > odev->wNumberMCFilters) {
 		/* Too many to filter perfectly -- accept all multicasts. */
 		D1("%s: too many MC filters for hardware, using allmulti",
 		   net->name);
-		odev->mode_flags = MODE_FLAG_ALL_MULTICAST |
-				   MODE_FLAG_DIRECTED |
-				   MODE_FLAG_BROADCAST |
-				   MODE_FLAG_MULTICAST;
+		odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
+				   USB_CDC_PACKET_TYPE_DIRECTED |
+				   USB_CDC_PACKET_TYPE_BROADCAST |
+				   USB_CDC_PACKET_TYPE_MULTICAST;
 	} else if (net->flags & IFF_ALLMULTI) {
 		/* Filter in software */
 		D1("%s: using allmulti", net->name);
-		odev->mode_flags = MODE_FLAG_ALL_MULTICAST |
-				   MODE_FLAG_DIRECTED |
-				   MODE_FLAG_BROADCAST |
-				   MODE_FLAG_MULTICAST;
+		odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
+				   USB_CDC_PACKET_TYPE_DIRECTED |
+				   USB_CDC_PACKET_TYPE_BROADCAST |
+				   USB_CDC_PACKET_TYPE_MULTICAST;
 	} else {
 		/* do multicast filtering in hardware */
 		struct dev_mc_list *mclist;
 		D1("%s: set multicast filters", net->name);
-		odev->mode_flags = MODE_FLAG_ALL_MULTICAST |
-				   MODE_FLAG_DIRECTED |
-				   MODE_FLAG_BROADCAST |
-				   MODE_FLAG_MULTICAST;
+		odev->mode_flags = USB_CDC_PACKET_TYPE_ALL_MULTICAST |
+				   USB_CDC_PACKET_TYPE_DIRECTED |
+				   USB_CDC_PACKET_TYPE_BROADCAST |
+				   USB_CDC_PACKET_TYPE_MULTICAST;
 		buf = kmalloc(6 * net->mc_count, GFP_ATOMIC);
 		if (!buf) {
 			dev_err(&net->dev, "No memory to allocate?");

@@ -885,7 +872,6 @@ static void read_bulk_callback(struct ur
 	struct hso_net *odev = urb->context;
 	struct net_device *net = NULL;
 	int result = 0;
-	unsigned long flags = 0;
 	int status = urb->status;
 
 	/* is al ok?  (Filip: Who's Al ?) */

@@ -923,11 +909,11 @@ static void read_bulk_callback(struct ur
 	if (urb->actual_length) {
 		/* Handle the IP stream, add header and push it onto network
 		 * stack if the packet is complete. */
-		spin_lock_irqsave(&odev->net_lock, flags);
+		spin_lock(&odev->net_lock);
 		packetizeRx(odev, urb->transfer_buffer, urb->actual_length,
 			    (urb->transfer_buffer_length >
 			     urb->actual_length) ? 1 : 0);
-		spin_unlock_irqrestore(&odev->net_lock, flags);
+		spin_unlock(&odev->net_lock);
 	}
 
 	/* We are done with this URB, resubmit it. Prep the USB to wait for

@@ -1198,8 +1184,7 @@ static void _hso_serial_set_termios(stru
 static int hso_serial_open(struct tty_struct *tty, struct file *filp)
 {
 	struct hso_serial *serial = get_serial_by_index(tty->index);
-	int result = 0;
-	unsigned long flags;
+	int result;
 
 	/* sanity check */
 	if (serial == NULL || serial->magic != HSO_SERIAL_MAGIC) {

@@ -1208,12 +1193,12 @@ static int hso_serial_open(struct tty_st
 		return -ENODEV;
 	}
 
-	usb_autopm_get_interface(serial->parent->interface);
+	mutex_lock(&serial->parent->mutex);
+	result = usb_autopm_get_interface(serial->parent->interface);
+	if (result < 0)
+		goto err_out;
 
 	D1("Opening %d", serial->minor);
-	/* lock it down */
-	spin_lock_irqsave(&serial->serial_lock, flags);
-
 	kref_get(&serial->parent->ref);
 
 	/* setup */

@@ -1227,7 +1212,7 @@ static int hso_serial_open(struct tty_st
 		serial->flags = 0;
 		/* Force default termio settings */
 		_hso_serial_set_termios(tty, NULL);
-		result = hso_start_serial_device(serial->parent);
+		result = hso_start_serial_device(serial->parent, GFP_KERNEL);
 		if (result) {
 			hso_stop_serial_device(serial->parent);
 			serial->open_count--;

@@ -1237,13 +1222,13 @@ static int hso_serial_open(struct tty_st
 		D1("Port was already open");
 	}
 
-	spin_unlock_irqrestore(&serial->serial_lock, flags);
-
 	usb_autopm_put_interface(serial->parent->interface);
 
 	/* done */
 	if (result)
 		hso_serial_tiocmset(tty, NULL, TIOCM_RTS | TIOCM_DTR, 0);
+err_out:
+	mutex_unlock(&serial->parent->mutex);
 	return result;
 }
 

@@ -1251,7 +1236,6 @@ static int hso_serial_open(struct tty_st
 static void hso_serial_close(struct tty_struct *tty, struct file *filp)
 {
 	struct hso_serial *serial = tty->driver_data;
-	unsigned long flags;
 	u8 usb_gone;
 
 	D1("Closing serial port");

@@ -1262,6 +1246,7 @@ static void hso_serial_close(struct tty_
 		return;
 	}
 
+	mutex_lock(&serial->parent->mutex);
 	usb_gone = test_bit(HSO_SERIAL_USB_GONE, &serial->flags);
 
 	if (!usb_gone)

@@ -1269,7 +1254,6 @@ static void hso_serial_close(struct tty_
 
 	/* reset the rts and dtr */
 	/* do the actual close */
-	spin_lock_irqsave(&serial->serial_lock, flags);
 	serial->open_count--;
 	if (serial->open_count <= 0) {
 		kref_put(&serial->parent->ref, hso_serial_ref_free);

@@ -1281,11 +1265,9 @@ static void hso_serial_close(struct tty_
 		if (!usb_gone)
 			hso_stop_serial_device(serial->parent);
 	}
-	if (serial->open_count < 0)
-		serial->open_count = 0;
-	spin_unlock_irqrestore(&serial->serial_lock, flags);
 	if (!usb_gone)
 		usb_autopm_put_interface(serial->parent->interface);
+	mutex_unlock(&serial->parent->mutex);
 }
 
 /* close the requested serial port */

@@ -1639,24 +1621,24 @@ static int mux_device_request(struct hso
 	ctrl_req->wIndex = hso_port_to_mux(port);
 	ctrl_req->wLength = size;
 
-	if (type == GET_ENCAPSULATED_RESPONSE) {
+	if (type == USB_CDC_GET_ENCAPSULATED_RESPONSE) {
 		/* Reading command */
 		ctrl_req->bRequestType = USB_DIR_IN |
 					 USB_TYPE_OPTION_VENDOR |
 					 USB_RECIP_INTERFACE;
-		ctrl_req->bRequest = GET_ENCAPSULATED_RESPONSE;
+		ctrl_req->bRequest = USB_CDC_GET_ENCAPSULATED_RESPONSE;
 		pipe = usb_rcvctrlpipe(serial->parent->usb, 0);
 	} else {
 		/* Writing command */
 		ctrl_req->bRequestType = USB_DIR_OUT |
 					 USB_TYPE_OPTION_VENDOR |
 					 USB_RECIP_INTERFACE;
-		ctrl_req->bRequest = SEND_ENCAPSULATED_COMMAND;
+		ctrl_req->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;
 		pipe = usb_sndctrlpipe(serial->parent->usb, 0);
 	}
 	/* syslog */
 	D2("%s command (%02x) len: %d, port: %d",
-	   type == GET_ENCAPSULATED_RESPONSE ? "Read" : "Write",
+	   type == USB_CDC_GET_ENCAPSULATED_RESPONSE ? "Read" : "Write",
 	   ctrl_req->bRequestType, ctrl_req->wLength, port);
 
 	/* Load ctrl urb */

@@ -1696,7 +1678,7 @@ static int hso_mux_serial_read(struct hs
 		return 0;
 	}
 	return mux_device_request(serial,
-				  GET_ENCAPSULATED_RESPONSE,
+				  USB_CDC_GET_ENCAPSULATED_RESPONSE,
 				  serial->parent->port_spec & HSO_PORT_MASK,
 				  serial->rx_urb[0],
 				  &serial->ctrl_req_rx,

@@ -1759,7 +1741,7 @@ static int hso_mux_serial_write_data(str
 		return -EINVAL;
 
 	return mux_device_request(serial,
-				  SEND_ENCAPSULATED_COMMAND,
+				  USB_CDC_SEND_ENCAPSULATED_COMMAND,
 				  serial->parent->port_spec & HSO_PORT_MASK,
 				  serial->tx_urb,
 				  &serial->ctrl_req_tx,

@@ -2145,20 +2127,17 @@ static int hso_stop_net_device(struct hs
 		return -ENODEV;
 
 	for (i = 0; i < MUX_BULK_RX_BUF_COUNT; i++) {
-		if (hso_net->mux_bulk_rx_urb_pool[i]
-		    && (hso_net->mux_bulk_rx_urb_pool[i]->status ==
-			-EINPROGRESS))
-			usb_unlink_urb(hso_net->mux_bulk_rx_urb_pool[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
-	    && (hso_net->mux_bulk_tx_urb->status == -EINPROGRESS))
-		usb_unlink_urb(hso_net->mux_bulk_tx_urb);
+	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)
+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);

@@ -2180,7 +2159,7 @@ static int hso_start_serial_device(struc
 					  serial->rx_data_length,
 					  hso_std_serial_read_bulk_callback,
 					  serial);
-			result = usb_submit_urb(serial->rx_urb[i], GFP_KERNEL);
+			result = usb_submit_urb(serial->rx_urb[i], flags);
 			if (result) {
 				dev_warn(&serial->parent->usb->dev,
 					 "Failed to submit urb - res %d\n",

@@ -2361,6 +2340,7 @@ static struct hso_device *hso_create_dev
 	hso_dev->usb = interface_to_usbdev(intf);
 	hso_dev->interface = intf;
 	kref_init(&hso_dev->ref);
+	mutex_init(&hso_dev->mutex);
 
 	INIT_WORK(&hso_dev->async_get_intf, async_get_intf);
 	INIT_WORK(&hso_dev->async_put_intf, async_put_intf);

@@ -2959,7 +2939,7 @@ static int hso_resume(struct usb_interfa
 		if (serial_table[i] && (serial_table[i]->interface == iface)) {
 			if (dev2ser(serial_table[i])->open_count) {
 				result =
-				    hso_start_serial_device(serial_table[i]);
+				    hso_start_serial_device(serial_table[i], GFP_NOIO);
 				hso_kick_transmit(dev2ser(serial_table[i]));
 				if (result)
 					goto out;

@@ -2999,15 +2979,18 @@ static void hso_serial_ref_free(struct k
 
 static void hso_free_interface(struct usb_interface *interface)
 {
+	struct hso_serial *hso_dev;
 	int i;
 
 	for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
 		if (serial_table[i]
 		    && (serial_table[i]->interface == interface)) {
-			if (dev2ser(serial_table[i])->tty)
-				tty_hangup(dev2ser(serial_table[i])->tty);
-			set_bit(HSO_SERIAL_USB_GONE,
-				&dev2ser(serial_table[i])->flags);
+			hso_dev = dev2ser(serial_table[i]);
+			if (hso_dev->tty)
+				tty_hangup(hso_dev->tty);
+			mutex_lock(&hso_dev->parent->mutex);
+			set_bit(HSO_SERIAL_USB_GONE, &hso_dev->flags);
+			mutex_unlock(&hso_dev->parent->mutex);
 			kref_put(&serial_table[i]->ref, hso_serial_ref_free);
 		}
 	}

@@ -3069,7 +3052,7 @@ static int hso_get_mux_ports(struct usb_
 static int hso_mux_submit_intr_urb(struct hso_shared_int *shared_int,
 				   struct usb_device *usb, gfp_t gfp)
 {
-	int result = 0;
+	int result;
 
 	usb_fill_int_urb(shared_int->shared_intr_urb, usb,
 			 usb_rcvintpipe(usb,

@@ -220,6 +220,7 @@ struct hso_serial {
 	unsigned long flags;
 	u8 rts_state;
 	u8 dtr_state;
+	int tx_urb_used:1;
 
 	/* from usb_serial_port */
 	struct tty_struct *tty;

@@ -1521,12 +1522,13 @@ static void hso_kick_transmit(struct hso
 {
 	u8 *temp = NULL;
 	unsigned long flags;
+	int res;
 
 	spin_lock_irqsave(&serial->serial_lock, flags);
 	if (!serial->tx_buffer_count)
 		goto out;
 
-	if (serial->tx_urb->status == -EINPROGRESS)
+	if (serial->tx_urb_used)
 		goto out;
 
 	/* Wakeup USB interface if necessary */

@@ -1540,10 +1542,13 @@ static void hso_kick_transmit(struct hso
 	serial->tx_data_count = serial->tx_buffer_count;
 	serial->tx_buffer_count = 0;
 
-out:
 	/* If temp is set, it means we switched buffers */
-	if (temp && serial->write_data)
-		serial->write_data(serial);
+	if (temp && serial->write_data) {
+		res = serial->write_data(serial);
+		if (res >= 0)
+			serial->tx_urb_used = 1;
+	}
+out:
 	spin_unlock_irqrestore(&serial->serial_lock, flags);
 }
 

@@ -1783,6 +1788,9 @@ static void ctrl_callback(struct urb *ur
 	if (!serial)
 		return;
 
+	spin_lock(&serial->serial_lock);
+	serial->tx_urb_used = 0;
+	spin_unlock(&serial->serial_lock);
 	if (status) {
 		log_usb_status(status, __func__);
 		return;

@@ -1914,6 +1922,9 @@ static void hso_std_serial_write_bulk_ca
 		return;
 	}
 
+	spin_lock(&serial->serial_lock);
+	serial->tx_urb_used = 0;
+	spin_unlock(&serial->serial_lock);
 	if (status) {
 		log_usb_status(status, __func__);
 		return;

2,977 lines not on this page · raw message

@@ -1663,7 +1663,7 @@ static void intr_callback(struct urb *ur
 		}
 	}
 	/* Resubmit interrupt urb */
-	hso_mux_submit_intr_urb(shared_int, urb->dev, GFP_KERNEL);
+	hso_mux_submit_intr_urb(shared_int, urb->dev, GFP_ATOMIC);
 }
 
 /* called for writing to muxed serial port */

@@ -1694,7 +1694,7 @@ static int hso_std_serial_write_data(str
 			  serial->tx_data, serial->tx_data_count,
 			  hso_std_serial_write_bulk_callback, serial);
 
-	result = usb_submit_urb(serial->tx_urb, GFP_KERNEL);
+	result = usb_submit_urb(serial->tx_urb, GFP_ATOMIC);
 	if (result) {
 		dev_warn(&serial->parent->usb->dev,
 			 "Failed to submit urb - res %d\n", result);

@@ -2040,7 +2040,7 @@ static int hso_start_net_device(struct h
 
 		/* Put it out there so the device can send us stuff */
 		result = usb_submit_urb(hso_net->mux_bulk_rx_urb_pool[i],
-					GFP_KERNEL);
+					GFP_NOIO);
 		if (result)
 			dev_warn(&hso_dev->usb->dev,
 				"%s failed mux_bulk_rx_urb[%d] %d\n", __func__,

@@ -2104,7 +2104,7 @@ static int hso_start_serial_device(struc
 		if (!serial->shared_int->use_count) {
 			result =
 			    hso_mux_submit_intr_urb(serial->shared_int,
-						    hso_dev->usb, GFP_KERNEL);
+						    hso_dev->usb, GFP_ATOMIC);
 		}
 		serial->shared_int->use_count++;
 		spin_unlock_bh(&serial->shared_int->shared_int_lock);

@@ -400,7 +400,6 @@ static int debug;
 static int procfs = 1;
 static int tty_major;
 static int disable_net;
-static int enable_autopm;
 
 /* driver info */
 static const char driver_name[] = "hso";

@@ -555,9 +554,6 @@ static int hso_proc_options(char *buf, c
 	len +=
 	    snprintf(buf + len, count - len, "tty_major: 0x%02x\n", tty_major);
 	len +=
-	    snprintf(buf + len, count - len, "enable_autopm: 0x%02x\n",
-		     enable_autopm);
-	len +=
 	    snprintf(buf + len, count - len, "disable_net: 0x%02x\n",
 		     disable_net);
 	return len;

@@ -2718,11 +2714,6 @@ static int hso_probe(struct usb_interfac
 	/* save our data pointer in this device */
 	usb_set_intfdata(interface, hso_dev);
 
-	if (enable_autopm == 0) {
-		usb_autopm_get_interface(hso_dev->interface);
-		hso_dev->suspend_disabled = 1;
-	}
-
 	/* done */
 	return 0;
 

@@ -3213,8 +3204,3 @@ module_param(tty_major, int, S_IRUGO | S
 /* set the major tty number (eg: insmod hso.ko tty_major=245) */
 MODULE_PARM_DESC(disable_net, "Disable the network interface");
 module_param(disable_net, int, S_IRUGO | S_IWUSR);
-
-/* enable autosuspend (default disabled) (eg: insmod hso.ko enable_autopm=1) */
-MODULE_PARM_DESC(enable_autopm,
-		 "Enable the auto power managment (autosuspend)");
-module_param(enable_autopm, int, S_IRUGO | S_IWUSR);

@@ -345,7 +345,6 @@ static int hso_get_activity(struct hso_d
 /* convert a character representing a hex value to a number */
 static unsigned char hex2dec(unsigned char digit)
 {
-
 	if ((digit >= '0') && (digit <= '9'))
 		return (digit - '0');
 	/* Map all characters to 0-15 */

@@ -353,7 +352,7 @@ static unsigned char hex2dec(unsigned ch
 		return (digit - 'a' + 10) % 16;
 	if ((digit >= 'A') && (digit <= 'Z'))
 		return (digit - 'A' + 10) % 16;
-	return 16;
+	return 0;
 }
 
 #define SIOCSETRADIO   (SIOCDEVPRIVATE+4)

@@ -3032,7 +3031,6 @@ static void set_ethernet_addr(struct hso
 	int i = 0;
 	int len = 0;
 	unsigned char buffer[13];
-	unsigned char checkserial[7] = "Serial";
 
 	/* we can't fail, therefor we use a random macaddress */
 	random_ether_addr(mac_addr);

@@ -3048,26 +3046,11 @@ static void set_ethernet_addr(struct hso
 	len = usb_string(odev->parent->usb,
 			 odev->parent->usb->descriptor.iSerialNumber,
 			 buffer, 13);
-	if (len != 12) {
-		/* some devices don't have the serial filled in, checking ... */
-		for (i = 0; i < 6; i++) {
-			if (buffer[i] != checkserial[i]) {
-				/* Fill in the mac_addr */
-				for (i = 2; i < 6; i++) {
-					if ((16 == buffer[2 * i]) ||
-					    (16 == buffer[2 * i + 1])) {
-						dev_err(&odev->parent->usb->dev,
-							"Bad value in MAC "
-							"address i:%d\n", i);
-					} else {
-						mac_addr[i] =
-						    (hex2dec(buffer[2 * i]) <<
-						     4) + hex2dec(buffer[2 * i +
-									 1]);
-					}
-				}
-				break;
-			}
+	if (len != 12 && strcmp("Serial", buffer)) {
+		/* Fill in the mac_addr */
+		for (i = 1; i < 6; i++) {
+			mac_addr[i] = (hex2dec(buffer[2 * i]) << 4) +
+				       hex2dec(buffer[2 * i + 1]);
 		}
 	} else {
 		dev_err(&odev->parent->usb->dev, "Attempting to get MAC "

@@ -3236,7 +3219,7 @@ module_param(debug, int, S_IRUGO | S_IWU
 MODULE_PARM_DESC(tty_major, "Set the major tty number");
 module_param(tty_major, int, S_IRUGO | S_IWUSR);
 
-/* set the major tty number (eg: insmod hso.ko tty_major=245) */
+/* disable network interface (eg: insmod hso.ko disable_net=1) */
 MODULE_PARM_DESC(disable_net, "Disable the network interface");
 module_param(disable_net, int, S_IRUGO | S_IWUSR);
 

@@ -315,7 +315,6 @@ static int hso_get_activity(struct hso_d
 /* convert a character representing a hex value to a number */
 static unsigned char hex2dec(unsigned char digit)
 {
-
 	if ((digit >= '0') && (digit <= '9'))
 		return (digit - '0');
 	/* Map all characters to 0-15 */

@@ -323,7 +322,7 @@ static unsigned char hex2dec(unsigned ch
 		return (digit - 'a' + 10) % 16;
 	if ((digit >= 'A') && (digit <= 'Z'))
 		return (digit - 'A' + 10) % 16;
-	return 16;
+	return 0;
 }
 
 #define SIOCSETRADIO   (SIOCDEVPRIVATE+4)

@@ -2308,7 +2307,6 @@ static void set_ethernet_addr(struct hso
 	int i = 0;
 	int len = 0;
 	unsigned char buffer[13];
-	unsigned char checkserial[7] = "Serial";
 
 	/* we can't fail, therefor we use a random macaddress */
 	random_ether_addr(mac_addr);

@@ -2324,27 +2322,14 @@ static void set_ethernet_addr(struct hso
 	len = usb_string(odev->parent->usb,
 			 odev->parent->usb->descriptor.iSerialNumber,
 			 buffer, 13);
-	if (len != 12) {
-		/* some devices don't have the serial filled in, checking ... */
+	if (len != 12 && strcmp("Serial", buffer)) {
+		/* Fill in the mac_addr */
 		for (i = 0; i < 6; i++) {
-			if (buffer[i] != checkserial[i]) {
-				/* Fill in the mac_addr */
-				for (i = 2; i < 6; i++) {
-					if ((16 == buffer[2 * i]) ||
-					    (16 == buffer[2 * i + 1])) {
-						dev_err(&odev->parent->usb->dev,
-							"Bad value in MAC "
-							"address i:%d\n", i);
-					} else {
-						mac_addr[i] =
-						    (hex2dec(buffer[2 * i]) <<
-						     4) + hex2dec(buffer[2 * i +
-									 1]);
-					}
-				}
-				break;
-			}
+			mac_addr[i] = (hex2dec(buffer[2 * i]) << 4) +
+				       hex2dec(buffer[2 * i + 1]);
 		}
+		mac_addr[0] &= 0xfe;	/* clear multicast bit */
+		mac_addr[0] |= 0x02;	/* set local assignment bit (IEEE802) */
 	} else {
 		dev_err(&odev->parent->usb->dev, "Attempting to get MAC "
 			"address failed: using random\n");

@@ -3200,7 +3185,7 @@ module_param(debug, int, S_IRUGO | S_IWU
 MODULE_PARM_DESC(tty_major, "Set the major tty number");
 module_param(tty_major, int, S_IRUGO | S_IWUSR);
 
-/* set the major tty number (eg: insmod hso.ko tty_major=245) */
+/* disable network interface (eg: insmod hso.ko disable_net=1) */
 MODULE_PARM_DESC(disable_net, "Disable the network interface");
 module_param(disable_net, int, S_IRUGO | S_IWUSR);
 

@@ -853,61 +853,24 @@ static int hso_net_start_xmit(struct sk_
 	return result;
 }
 
-static int hso_net_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
+static void hso_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
 {
 	struct hso_net *odev = netdev_priv(net);
-	u32 usercmd = 0;
 	char tmp[40];
 
-	switch (cmd) {
-	case SIOCETHTOOL:
-		/* net specific */
-		if (copy_from_user(&usercmd, rq->ifr_data, sizeof(usercmd)))
-			return -EFAULT;
-
-		switch (usercmd) {
-		case ETHTOOL_GDRVINFO:
-			{
-			/* get driver info */
-			struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
-			strncpy(info.driver, driver_name, ETHTOOL_BUSINFO_LEN);
-			strncpy(info.version, DRIVER_VERSION,
-				ETHTOOL_BUSINFO_LEN);
-			sprintf(tmp, "usb%d:%d",
-				odev->parent->usb->bus->busnum,
-				odev->parent->usb->devnum);
-			strncpy(info.bus_info, tmp, ETHTOOL_BUSINFO_LEN);
-			sprintf(tmp, "%s %x.%x", driver_name,
-				((odev->bcdCDC & 0xff00) >> 8),
-				(odev->bcdCDC & 0x00ff));
-			strncpy(info.fw_version, tmp, ETHTOOL_BUSINFO_LEN);
-			if (copy_to_user(rq->ifr_data, &info, sizeof(info)))
-				return -EFAULT;
-
-			return 0;
-			}
-		case ETHTOOL_GLINK:
-			{
-			/* get link status */
-			struct ethtool_value edata = { ETHTOOL_GLINK };
-
-			edata.data = netif_carrier_ok(net);
-			if (copy_to_user(rq->ifr_data, &edata, sizeof(edata)))
-				return -EFAULT;
-
-			return 0;
-			}
-		default:
-			dev_warn(&net->dev, "Got unsupported ioctl: %x\n",
-				 usercmd);
-			/* the ethtool user space tool relies on this */
-			return -EOPNOTSUPP;
-		}
-	default:
-		return -ENOTTY;	/* per ioctl man page */
-	}
+	strncpy(info->driver, driver_name, ETHTOOL_BUSINFO_LEN);
+	strncpy(info->version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
+	usb_make_path(odev->parent->usb, info->bus_info, sizeof info->bus_info);
+	sprintf(tmp, "%s %x.%x", driver_name, ((odev->bcdCDC & 0xff00) >> 8),
+		(odev->bcdCDC & 0x00ff));
+	strncpy(info->fw_version, tmp, ETHTOOL_BUSINFO_LEN);
 }
 
+static struct ethtool_ops ops = {
+	.get_drvinfo = hso_get_drvinfo,
+	.get_link = ethtool_op_get_link
+};
+
 static struct net_device_stats *hso_net_get_stats(struct net_device *net)
 {
 	return &((struct hso_net *)netdev_priv(net))->stats;

@@ -2281,7 +2244,6 @@ static void hso_net_init(struct net_devi
 	net->open = hso_net_open;
 	net->stop = hso_net_close;
 	net->hard_start_xmit = hso_net_start_xmit;
-	net->do_ioctl = hso_net_ioctl;
 	net->get_stats = hso_net_get_stats;
 	net->tx_timeout = hso_net_tx_timeout;
 	net->watchdog_timeo = HSO_NET_TX_TIMEOUT;

@@ -2289,6 +2251,7 @@ static void hso_net_init(struct net_devi
 	net->flags |= IFF_NOARP;
 	net->mtu = DEFAULT_MTU - 14;
 	net->tx_queue_len = 10;
+	SET_ETHTOOL_OPS(net, &ops);
 	hso_net->skb_rx_buf = NULL;
 	hso_net->rx_parse_state = WAIT_IP;
 	hso_net->wMaxSegmentSize = DEFAULT_MTU;

@@ -156,7 +156,7 @@ struct hso_shared_int {
 	struct usb_device *usb;
 	int use_count;
 	int ref_count;
-	spinlock_t shared_int_lock;
+	struct mutex shared_int_lock;
 };
 
 struct hso_net {

@@ -2040,14 +2040,14 @@ static int hso_start_serial_device(struc
 			}
 		}
 	} else {
-		spin_lock_bh(&serial->shared_int->shared_int_lock);
+		mutex_lock(&serial->shared_int->shared_int_lock);
 		if (!serial->shared_int->use_count) {
 			result =
 			    hso_mux_submit_intr_urb(serial->shared_int,
-						    hso_dev->usb, GFP_ATOMIC);
+						    hso_dev->usb, flags);
 		}
 		serial->shared_int->use_count++;
-		spin_unlock_bh(&serial->shared_int->shared_int_lock);
+		mutex_unlock(&serial->shared_int->shared_int_lock);
 	}
 
 	return result;

@@ -2070,7 +2070,7 @@ static int hso_stop_serial_device(struct
 		usb_kill_urb(serial->rx_urb[i]);
 
 	if (serial->shared_int) {
-		spin_lock_bh(&serial->shared_int->shared_int_lock);
+		mutex_lock(&serial->shared_int->shared_int_lock);
 		if (serial->shared_int->use_count &&
 		    (--serial->shared_int->use_count == 0)) {
 			struct urb *urb;

@@ -2079,7 +2079,7 @@ static int hso_stop_serial_device(struct
 			if (urb)
 				usb_kill_urb(urb);
 		}
-		spin_unlock_bh(&serial->shared_int->shared_int_lock);
+		mutex_unlock(&serial->shared_int->shared_int_lock);
 	}
 
 	return 0;

@@ -2352,10 +2352,10 @@ static void hso_free_serial_device(struc
 	hso_serial_common_free(serial);
 
 	if (serial->shared_int) {
-		spin_lock_bh(&serial->shared_int->shared_int_lock);
+		mutex_lock(&serial->shared_int->shared_int_lock);
 		if (--serial->shared_int->ref_count == 0)
 			hso_free_shared_int(serial->shared_int);
-		spin_unlock_bh(&serial->shared_int->shared_int_lock);
+		mutex_unlock(&serial->shared_int->shared_int_lock);
 	}
 	kfree(serial);
 	hso_free_device(hso_dev);

@@ -2468,9 +2468,9 @@ struct hso_device *hso_create_mux_serial
 	serial->write_data = hso_mux_serial_write_data;
 
 	serial->shared_int = mux;
-	spin_lock_bh(&serial->shared_int->shared_int_lock);
+	mutex_lock(&serial->shared_int->shared_int_lock);
 	serial->shared_int->ref_count++;
-	spin_unlock_bh(&serial->shared_int->shared_int_lock);
+	mutex_unlock(&serial->shared_int->shared_int_lock);
 
 	/* and record this serial */
 	set_serial_by_index(serial->minor, serial);

@@ -2535,7 +2535,7 @@ struct hso_shared_int *hso_create_shared
 		goto exit;
 	}
 
-	spin_lock_init(&mux->shared_int_lock);
+	mutex_init(&mux->shared_int_lock);
 
 	return mux;
 

@@ -242,6 +242,7 @@ struct hso_device {
 	u8 is_active;
 	u8 suspend_disabled;
 	u8 usb_gone;
+	u8 sleeping;
 	struct work_struct async_get_intf;
 	struct work_struct async_put_intf;
 

@@ -252,6 +253,7 @@ struct hso_device {
 	struct device *dev;
 	struct kref ref;
 	struct mutex mutex;
+	spinlock_t lock;
 
 	/* TODO: Not sure about the ones below */
 	struct proc_dir_entry *ourproc;

@@ -2184,6 +2186,7 @@ static struct hso_device *hso_create_dev
 	hso_dev->interface = intf;
 	kref_init(&hso_dev->ref);
 	mutex_init(&hso_dev->mutex);
+	spin_lock_init(&hso_dev->lock);
 
 	INIT_WORK(&hso_dev->async_get_intf, async_get_intf);
 	INIT_WORK(&hso_dev->async_put_intf, async_put_intf);

@@ -2757,12 +2760,16 @@ static void async_put_intf(struct work_s
 
 static int hso_get_activity(struct hso_device *hso_dev)
 {
-	if (hso_dev->usb->state == USB_STATE_SUSPENDED) {
+	unsigned long flags;
+
+	spin_lock_irqsave(&hso_dev->lock, flags);
+	if (hso_dev->sleeping) {
 		if (!hso_dev->is_active) {
 			hso_dev->is_active = 1;
 			schedule_work(&hso_dev->async_get_intf);
 		}
 	}
+	spin_unlock_irqrestore(&hso_dev->lock, flags);
 
 	if (hso_dev->usb->state != USB_STATE_CONFIGURED)
 		return -EAGAIN;

@@ -2774,22 +2781,32 @@ static int hso_get_activity(struct hso_d
 
 static int hso_put_activity(struct hso_device *hso_dev)
 {
-	if (hso_dev->usb->state != USB_STATE_SUSPENDED) {
+	unsigned long flags;
+
+	spin_lock_irqsave(&hso_dev->lock, flags);
+	if (hso_dev->sleeping) {
 		if (hso_dev->is_active) {
 			hso_dev->is_active = 0;
 			schedule_work(&hso_dev->async_put_intf);
+			spin_unlock_irqrestore(&hso_dev->lock, flags);
 			return -EAGAIN;
 		}
 	}
 	hso_dev->is_active = 0;
+	spin_unlock_irqrestore(&hso_dev->lock, flags);
 	return 0;
 }
 
 /* called by kernel when we need to suspend device */
 static int hso_suspend(struct usb_interface *iface, pm_message_t message)
 {
+	struct hso_device *hso_dev = usb_get_intfdata(iface);
 	int i, result = 0;
 
+	spin_lock_irq(&hso_dev->lock);
+	hso_dev->sleeping = 1;
+	spin_unlock_irq(&hso_dev->lock);
+
 	/* Stop all serial ports */
 	for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
 		if (serial_table[i] && (serial_table[i]->interface == iface)) {

@@ -2816,9 +2833,14 @@ out:
 /* called by kernel when we need to resume device */
 static int hso_resume(struct usb_interface *iface)
 {
+	struct hso_device *hso_dev = usb_get_intfdata(iface);
 	int i, result = 0;
 	struct hso_net *hso_net;
 
+	spin_lock_irq(&hso_dev->lock);
+	hso_dev->sleeping = 0;
+	spin_unlock_irq(&hso_dev->lock);
+
 	/* Start all serial ports */
 	for (i = 0; i < HSO_SERIAL_TTY_MINORS; i++) {
 		if (serial_table[i] && (serial_table[i]->interface == iface)) {

@@ -2052,7 +2052,7 @@
 	}
 
 	if (serial->tx_urb)
-		usb_kill_urb(serial->rx_urb[i]);
+		usb_kill_urb(serial->tx_urb);
 
 	if (serial->shared_int) {
 		mutex_lock(&serial->shared_int->shared_int_lock);

@@ -853,61 +853,22 @@ static int hso_net_start_xmit(struct sk_
 	return result;
 }
 
-static int hso_net_ioctl(struct net_device *net, struct ifreq *rq, int cmd)
+static void hso_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *info)
 {
 	struct hso_net *odev = netdev_priv(net);
-	u32 usercmd = 0;
-	char tmp[40];
 
-	switch (cmd) {
-	case SIOCETHTOOL:
-		/* net specific */
-		if (copy_from_user(&usercmd, rq->ifr_data, sizeof(usercmd)))
-			return -EFAULT;
-
-		switch (usercmd) {
-		case ETHTOOL_GDRVINFO:
-			{
-			/* get driver info */
-			struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
-			strncpy(info.driver, driver_name, ETHTOOL_BUSINFO_LEN);
-			strncpy(info.version, DRIVER_VERSION,
-				ETHTOOL_BUSINFO_LEN);
-			sprintf(tmp, "usb%d:%d",
-				odev->parent->usb->bus->busnum,
-				odev->parent->usb->devnum);
-			strncpy(info.bus_info, tmp, ETHTOOL_BUSINFO_LEN);
-			sprintf(tmp, "%s %x.%x", driver_name,
-				((odev->bcdCDC & 0xff00) >> 8),
-				(odev->bcdCDC & 0x00ff));
-			strncpy(info.fw_version, tmp, ETHTOOL_BUSINFO_LEN);
-			if (copy_to_user(rq->ifr_data, &info, sizeof(info)))
-				return -EFAULT;
-
-			return 0;
-			}
-		case ETHTOOL_GLINK:
-			{
-			/* get link status */
-			struct ethtool_value edata = { ETHTOOL_GLINK };
-
-			edata.data = netif_carrier_ok(net);
-			if (copy_to_user(rq->ifr_data, &edata, sizeof(edata)))
-				return -EFAULT;
-
-			return 0;
-			}
-		default:
-			dev_warn(&net->dev, "Got unsupported ioctl: %x\n",
-				 usercmd);
-			/* the ethtool user space tool relies on this */
-			return -EOPNOTSUPP;
-		}
-	default:
-		return -ENOTTY;	/* per ioctl man page */
-	}
+	strncpy(info->driver, driver_name, ETHTOOL_BUSINFO_LEN);
+	strncpy(info->version, DRIVER_VERSION, ETHTOOL_BUSINFO_LEN);
+	usb_make_path(odev->parent->usb, info->bus_info, sizeof info->bus_info);
+	snprintf(info->fw_version, ETHTOOL_BUSINFO_LEN, "%s %x.%x", driver_name,
+		 ((odev->bcdCDC & 0xff00) >> 8), (odev->bcdCDC & 0x00ff));
 }
 
+static struct ethtool_ops ops = {
+	.get_drvinfo = hso_get_drvinfo,
+	.get_link = ethtool_op_get_link
+};
+
 static struct net_device_stats *hso_net_get_stats(struct net_device *net)
 {
 	return &((struct hso_net *)netdev_priv(net))->stats;

@@ -2281,7 +2242,6 @@ static void hso_net_init(struct net_devi
 	net->open = hso_net_open;
 	net->stop = hso_net_close;
 	net->hard_start_xmit = hso_net_start_xmit;
-	net->do_ioctl = hso_net_ioctl;
 	net->get_stats = hso_net_get_stats;
 	net->tx_timeout = hso_net_tx_timeout;
 	net->watchdog_timeo = HSO_NET_TX_TIMEOUT;

@@ -2289,6 +2249,7 @@ static void hso_net_init(struct net_devi
 	net->flags |= IFF_NOARP;
 	net->mtu = DEFAULT_MTU - 14;
 	net->tx_queue_len = 10;
+	SET_ETHTOOL_OPS(net, &ops);
 	hso_net->skb_rx_buf = NULL;
 	hso_net->rx_parse_state = WAIT_IP;
 	hso_net->wMaxSegmentSize = DEFAULT_MTU;

@@ -2201,21 +2201,13 @@ static int hso_stop_serial_device(struct
 		return -ENODEV;
 
 	for (i = 0; i < serial->num_rx_urbs; i++) {
-		if (serial->rx_urb[i]
-		    && (serial->rx_urb[i]->status == -EINPROGRESS)) {
-			if (in_interrupt())
-				usb_unlink_urb(serial->rx_urb[i]);
-			else
+		if (serial->rx_urb[i])
 				usb_kill_urb(serial->rx_urb[i]);
-		}
 	}
 
-	if (serial->tx_urb && (serial->tx_urb->status == -EINPROGRESS)) {
-		if (in_interrupt())
-			usb_unlink_urb(serial->tx_urb);
-		else
-			usb_kill_urb(serial->rx_urb[i]);
-	}
+	if (serial->tx_urb)
+		usb_kill_urb(serial->rx_urb[i]);
+
 	if (serial->shared_int) {
 		spin_lock_bh(&serial->shared_int->shared_int_lock);
 		if (serial->shared_int->use_count &&

@@ -2223,12 +2215,8 @@ static int hso_stop_serial_device(struct
 			struct urb *urb;
 
 			urb = serial->shared_int->shared_intr_urb;
-			if ((urb) && (urb->status == -EINPROGRESS)) {
-				if (in_interrupt())
-					usb_unlink_urb(urb);
-				else
-					usb_kill_urb(urb);
-			}
+			if (urb)
+				usb_kill_urb(urb);
 		}
 		spin_unlock_bh(&serial->shared_int->shared_int_lock);
 	}