From: Greg Kroah-Hartman Date: Sat, 5 Dec 2009 23:30:43 +0000 (-0800) Subject: .27 patches X-Git-Tag: v2.6.31.7~6 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=fa5372e3d9bcbb74a002f26ce98f9b139f96e89c;p=thirdparty%2Fkernel%2Fstable-queue.git .27 patches --- diff --git a/queue-2.6.27/dca-redesign-locks-to-fix-deadlocks.patch b/queue-2.6.27/dca-redesign-locks-to-fix-deadlocks.patch new file mode 100644 index 00000000000..40882e1c60e --- /dev/null +++ b/queue-2.6.27/dca-redesign-locks-to-fix-deadlocks.patch @@ -0,0 +1,169 @@ +From eb4400e3a040b90a3ad805b01fcbc99a5f615c8f Mon Sep 17 00:00:00 2001 +From: Maciej Sosnowski +Date: Mon, 2 Feb 2009 23:26:57 -0800 +Subject: dca: redesign locks to fix deadlocks + +From: Maciej Sosnowski + +commit eb4400e3a040b90a3ad805b01fcbc99a5f615c8f upstream. + +Change spin_locks to irqsave to prevent dead-locks. +Protect adding and deleting to/from dca_providers list. +Drop the lock during dca_sysfs_add_req() and dca_sysfs_remove_req() calls +as they might sleep (use GFP_KERNEL allocation). + +Signed-off-by: Maciej Sosnowski +Acked-by: Jeff Kirsher +Signed-off-by: David S. Miller +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/dca/dca-core.c | 51 +++++++++++++++++++++++++++++++------------------ + 1 file changed, 33 insertions(+), 18 deletions(-) + +--- a/drivers/dca/dca-core.c ++++ b/drivers/dca/dca-core.c +@@ -28,7 +28,7 @@ + #include + #include + +-#define DCA_VERSION "1.4" ++#define DCA_VERSION "1.8" + + MODULE_VERSION(DCA_VERSION); + MODULE_LICENSE("GPL"); +@@ -60,16 +60,17 @@ int dca_add_requester(struct device *dev + { + struct dca_provider *dca; + int err, slot = -ENODEV; ++ unsigned long flags; + + if (!dev) + return -EFAULT; + +- spin_lock(&dca_lock); ++ spin_lock_irqsave(&dca_lock, flags); + + /* check if the requester has not been added already */ + dca = dca_find_provider_by_dev(dev); + if (dca) { +- spin_unlock(&dca_lock); ++ spin_unlock_irqrestore(&dca_lock, flags); + return -EEXIST; + } + +@@ -78,19 +79,21 @@ int dca_add_requester(struct device *dev + if (slot >= 0) + break; + } +- if (slot < 0) { +- spin_unlock(&dca_lock); ++ ++ spin_unlock_irqrestore(&dca_lock, flags); ++ ++ if (slot < 0) + return slot; +- } + + err = dca_sysfs_add_req(dca, dev, slot); + if (err) { +- dca->ops->remove_requester(dca, dev); +- spin_unlock(&dca_lock); ++ spin_lock_irqsave(&dca_lock, flags); ++ if (dca == dca_find_provider_by_dev(dev)) ++ dca->ops->remove_requester(dca, dev); ++ spin_unlock_irqrestore(&dca_lock, flags); + return err; + } + +- spin_unlock(&dca_lock); + return 0; + } + EXPORT_SYMBOL_GPL(dca_add_requester); +@@ -103,25 +106,25 @@ int dca_remove_requester(struct device * + { + struct dca_provider *dca; + int slot; ++ unsigned long flags; + + if (!dev) + return -EFAULT; + +- spin_lock(&dca_lock); ++ spin_lock_irqsave(&dca_lock, flags); + dca = dca_find_provider_by_dev(dev); + if (!dca) { +- spin_unlock(&dca_lock); ++ spin_unlock_irqrestore(&dca_lock, flags); + return -ENODEV; + } + slot = dca->ops->remove_requester(dca, dev); +- if (slot < 0) { +- spin_unlock(&dca_lock); ++ spin_unlock_irqrestore(&dca_lock, flags); ++ ++ if (slot < 0) + return slot; +- } + + dca_sysfs_remove_req(dca, slot); + +- spin_unlock(&dca_lock); + return 0; + } + EXPORT_SYMBOL_GPL(dca_remove_requester); +@@ -135,17 +138,18 @@ u8 dca_common_get_tag(struct device *dev + { + struct dca_provider *dca; + u8 tag; ++ unsigned long flags; + +- spin_lock(&dca_lock); ++ spin_lock_irqsave(&dca_lock, flags); + + dca = dca_find_provider_by_dev(dev); + if (!dca) { +- spin_unlock(&dca_lock); ++ spin_unlock_irqrestore(&dca_lock, flags); + return -ENODEV; + } + tag = dca->ops->get_tag(dca, dev, cpu); + +- spin_unlock(&dca_lock); ++ spin_unlock_irqrestore(&dca_lock, flags); + return tag; + } + +@@ -217,11 +221,16 @@ static BLOCKING_NOTIFIER_HEAD(dca_provid + int register_dca_provider(struct dca_provider *dca, struct device *dev) + { + int err; ++ unsigned long flags; + + err = dca_sysfs_add_provider(dca, dev); + if (err) + return err; ++ ++ spin_lock_irqsave(&dca_lock, flags); + list_add(&dca->node, &dca_providers); ++ spin_unlock_irqrestore(&dca_lock, flags); ++ + blocking_notifier_call_chain(&dca_provider_chain, + DCA_PROVIDER_ADD, NULL); + return 0; +@@ -234,9 +243,15 @@ EXPORT_SYMBOL_GPL(register_dca_provider) + */ + void unregister_dca_provider(struct dca_provider *dca) + { ++ unsigned long flags; ++ + blocking_notifier_call_chain(&dca_provider_chain, + DCA_PROVIDER_REMOVE, NULL); ++ ++ spin_lock_irqsave(&dca_lock, flags); + list_del(&dca->node); ++ spin_unlock_irqrestore(&dca_lock, flags); ++ + dca_sysfs_remove_provider(dca); + } + EXPORT_SYMBOL_GPL(unregister_dca_provider); diff --git a/queue-2.6.27/hwmon-it87-fix-vid-reading-on-it8718f.patch b/queue-2.6.27/hwmon-it87-fix-vid-reading-on-it8718f.patch new file mode 100644 index 00000000000..5e5b360acd3 --- /dev/null +++ b/queue-2.6.27/hwmon-it87-fix-vid-reading-on-it8718f.patch @@ -0,0 +1,35 @@ +From stable-bounces@linux.kernel.org Sat Nov 7 10:12:32 2009 +From: Jean Delvare +Date: Sat, 7 Nov 2009 19:11:41 +0100 +Subject: hwmon: (it87) Fix VID reading on IT8718F +To: stable@kernel.org +Cc: Willy Tarreau +Message-ID: <20091107191141.4fe66483@hyperion.delvare> + +From: Jean Delvare + +commit 371dc4a6d8c3c74a9a1c74b87c2affb3fcef6500 upstream + +Comparing apples to bananas doesn't seem right. + +The bug has been there since support for the IT8718F was added, so +VID never worked for this chip. + +Signed-off-by: Jean Delvare +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/hwmon/it87.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/hwmon/it87.c ++++ b/drivers/hwmon/it87.c +@@ -1017,7 +1017,7 @@ static int __init it87_find(unsigned sho + int reg; + + superio_select(GPIO); +- if (chip_type == it8718) ++ if (sio_data->type == it8718) + sio_data->vid_value = superio_inb(IT87_SIO_VID_REG); + + reg = superio_inb(IT87_SIO_PINX2_REG); diff --git a/queue-2.6.27/series b/queue-2.6.27/series index afeaa0b3701..2a95dd7e0ab 100644 --- a/queue-2.6.27/series +++ b/queue-2.6.27/series @@ -14,3 +14,7 @@ fuse-prevent-fuse_put_request-on-invalid-pointer.patch isdn-hfc_usb-fix-read-buffer-overflow.patch thinkpad-acpi-fix-sign-of-erestartsys-return.patch usb-ohci-quirk-amd-prefetch-for-usb-1.1-iso-transfer.patch +usb-suspend-resume-support-for-option-driver.patch +usb-usb-serial-replace-shutdown-with-disconnect-release.patch +dca-redesign-locks-to-fix-deadlocks.patch +hwmon-it87-fix-vid-reading-on-it8718f.patch diff --git a/queue-2.6.27/usb-suspend-resume-support-for-option-driver.patch b/queue-2.6.27/usb-suspend-resume-support-for-option-driver.patch new file mode 100644 index 00000000000..5e5130fe7f0 --- /dev/null +++ b/queue-2.6.27/usb-suspend-resume-support-for-option-driver.patch @@ -0,0 +1,172 @@ +From 4901b2c34ecb6fc45909228ad269c8126efe4401 Mon Sep 17 00:00:00 2001 +From: Oliver Neukum +Date: Tue, 27 Jan 2009 17:21:40 +0100 +Subject: USB: suspend/resume support for option driver + +From: Oliver Neukum + +commit 4901b2c34ecb6fc45909228ad269c8126efe4401 upstream. + +This patch implements suspend and resume methods for the +option driver. With my hardware I can even suspend the system +and keep up a connection for a short time. + +Signed-off-by: Oliver Neukum +Signed-Off-By: Matthias Urlichs +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/usb/serial/option.c | 86 ++++++++++++++++++++++++++++++++++++++++---- + 1 file changed, 80 insertions(+), 6 deletions(-) + +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -62,6 +62,8 @@ static int option_tiocmget(struct tty_s + static int option_tiocmset(struct tty_struct *tty, struct file *file, + unsigned int set, unsigned int clear); + static int option_send_setup(struct tty_struct *tty, struct usb_serial_port *port); ++static int option_suspend(struct usb_serial *serial, pm_message_t message); ++static int option_resume(struct usb_serial *serial); + + /* Vendor and product IDs */ + #define OPTION_VENDOR_ID 0x0AF0 +@@ -511,6 +513,8 @@ static struct usb_driver option_driver = + .name = "option", + .probe = usb_serial_probe, + .disconnect = usb_serial_disconnect, ++ .suspend = usb_serial_suspend, ++ .resume = usb_serial_resume, + .id_table = option_ids, + .no_dynamic_id = 1, + }; +@@ -539,6 +543,8 @@ static struct usb_serial_driver option_1 + .attach = option_startup, + .shutdown = option_shutdown, + .read_int_callback = option_instat_callback, ++ .suspend = option_suspend, ++ .resume = option_resume, + }; + + static int debug; +@@ -809,10 +815,10 @@ static void option_instat_callback(struc + req_pkt->bRequestType, req_pkt->bRequest); + } + } else +- dbg("%s: error %d", __func__, status); ++ err("%s: error %d", __func__, status); + + /* Resubmit urb so we continue receiving IRQ data */ +- if (status != -ESHUTDOWN) { ++ if (status != -ESHUTDOWN && status != -ENOENT) { + urb->dev = serial->dev; + err = usb_submit_urb(urb, GFP_ATOMIC); + if (err) +@@ -831,7 +837,6 @@ static int option_write_room(struct tty_ + + portdata = usb_get_serial_port_data(port); + +- + for (i = 0; i < N_OUT_URB; i++) { + this_urb = portdata->out_urbs[i]; + if (this_urb && !test_bit(i, &portdata->out_busy)) +@@ -1090,14 +1095,12 @@ bail_out_error: + return 1; + } + +-static void option_shutdown(struct usb_serial *serial) ++static void stop_read_write_urbs(struct usb_serial *serial) + { + int i, j; + struct usb_serial_port *port; + struct option_port_private *portdata; + +- dbg("%s", __func__); +- + /* Stop reading/writing urbs */ + for (i = 0; i < serial->num_ports; ++i) { + port = serial->port[i]; +@@ -1107,6 +1110,17 @@ static void option_shutdown(struct usb_s + for (j = 0; j < N_OUT_URB; j++) + usb_kill_urb(portdata->out_urbs[j]); + } ++} ++ ++static void option_shutdown(struct usb_serial *serial) ++{ ++ int i, j; ++ struct usb_serial_port *port; ++ struct option_port_private *portdata; ++ ++ dbg("%s", __func__); ++ ++ stop_read_write_urbs(serial); + + /* Now free them */ + for (i = 0; i < serial->num_ports; ++i) { +@@ -1137,6 +1151,66 @@ static void option_shutdown(struct usb_s + } + } + ++static int option_suspend(struct usb_serial *serial, pm_message_t message) ++{ ++ dbg("%s entered", __func__); ++ stop_read_write_urbs(serial); ++ ++ return 0; ++} ++ ++static int option_resume(struct usb_serial *serial) ++{ ++ int err, i, j; ++ struct usb_serial_port *port; ++ struct urb *urb; ++ struct option_port_private *portdata; ++ ++ dbg("%s entered", __func__); ++ /* get the interrupt URBs resubmitted unconditionally */ ++ for (i = 0; i < serial->num_ports; i++) { ++ port = serial->port[i]; ++ if (!port->interrupt_in_urb) { ++ dbg("%s: No interrupt URB for port %d\n", __func__, i); ++ continue; ++ } ++ port->interrupt_in_urb->dev = serial->dev; ++ err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO); ++ dbg("Submitted interrupt URB for port %d (result %d)", i, err); ++ if (err < 0) { ++ err("%s: Error %d for interrupt URB of port%d", ++ __func__, err, i); ++ return err; ++ } ++ } ++ ++ for (i = 0; i < serial->num_ports; i++) { ++ /* walk all ports */ ++ port = serial->port[i]; ++ portdata = usb_get_serial_port_data(port); ++ mutex_lock(&port->mutex); ++ ++ /* skip closed ports */ ++ if (!port->port.count) { ++ mutex_unlock(&port->mutex); ++ continue; ++ } ++ ++ for (j = 0; j < N_IN_URB; j++) { ++ urb = portdata->in_urbs[j]; ++ err = usb_submit_urb(urb, GFP_NOIO); ++ if (err < 0) { ++ mutex_unlock(&port->mutex); ++ err("%s: Error %d for bulk URB %d", ++ __func__, err, i); ++ return err; ++ } ++ } ++ mutex_unlock(&port->mutex); ++ } ++ return 0; ++} ++ + MODULE_AUTHOR(DRIVER_AUTHOR); + MODULE_DESCRIPTION(DRIVER_DESC); + MODULE_VERSION(DRIVER_VERSION); diff --git a/queue-2.6.27/usb-usb-serial-replace-shutdown-with-disconnect-release.patch b/queue-2.6.27/usb-usb-serial-replace-shutdown-with-disconnect-release.patch new file mode 100644 index 00000000000..d7cf1e5303e --- /dev/null +++ b/queue-2.6.27/usb-usb-serial-replace-shutdown-with-disconnect-release.patch @@ -0,0 +1,1506 @@ +From stern+4b124458@rowland.harvard.edu Tue Dec 1 07:01:10 2009 +From: Alan Stern +Date: Tue, 1 Dec 2009 10:01:08 -0500 (EST) +Subject: USB: usb-serial: replace shutdown with disconnect, release +To: Greg KH , +Cc: Rory Filer , USB list +Message-ID: + +This is commit f9c99bb8b3a1ec81af68d484a551307326c2e933 back-ported to +2.6.27.39. + +This patch (as1254-2) splits up the shutdown method of usb_serial_driver +into a disconnect and a release method. + +The problem is that the usb-serial core was calling shutdown during +disconnect handling, but drivers didn't expect it to be called until +after all the open file references had been closed. The result was an +oops when the close method tried to use memory that had been +deallocated by shutdown. + +Signed-off-by: Alan Stern +Tested-by: Rory Filer +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/usb/serial/aircable.c | 5 +-- + drivers/usb/serial/belkin_sa.c | 7 ++-- + drivers/usb/serial/cp2101.c | 6 ++-- + drivers/usb/serial/cyberjack.c | 20 ++++++++++---- + drivers/usb/serial/cypress_m8.c | 11 +++---- + drivers/usb/serial/digi_acceleport.c | 20 ++++++++++---- + drivers/usb/serial/empeg.c | 8 ----- + drivers/usb/serial/ftdi_sio.c | 14 --------- + drivers/usb/serial/garmin_gps.c | 16 +++++++++-- + drivers/usb/serial/generic.c | 9 ++++-- + drivers/usb/serial/io_edgeport.c | 29 ++++++++++++++------ + drivers/usb/serial/io_tables.h | 12 +++++--- + drivers/usb/serial/io_ti.c | 22 ++++++++++++--- + drivers/usb/serial/ipaq.c | 7 ---- + drivers/usb/serial/iuu_phoenix.c | 6 ++-- + drivers/usb/serial/keyspan.c | 13 ++++++++- + drivers/usb/serial/keyspan.h | 12 +++++--- + drivers/usb/serial/keyspan_pda.c | 4 +- + drivers/usb/serial/kl5kusb105.c | 39 +++++++++++++++------------ + drivers/usb/serial/kobil_sct.c | 12 ++------ + drivers/usb/serial/mct_u232.c | 13 +++------ + drivers/usb/serial/mos7720.c | 9 ++---- + drivers/usb/serial/mos7840.c | 48 ++++++++++++++++++++++++++++------ + drivers/usb/serial/omninet.c | 19 ++++++++++--- + drivers/usb/serial/option.c | 17 ++++++++---- + drivers/usb/serial/oti6858.c | 7 ++-- + drivers/usb/serial/pl2303.c | 5 +-- + drivers/usb/serial/sierra.c | 28 +++++++++++++++++-- + drivers/usb/serial/spcp8x5.c | 5 +-- + drivers/usb/serial/ti_usb_3410_5052.c | 10 ++----- + drivers/usb/serial/usb-serial.c | 29 +++++++++----------- + drivers/usb/serial/visor.c | 13 +++------ + drivers/usb/serial/whiteheat.c | 6 ++-- + include/linux/usb/serial.h | 12 +++++--- + 34 files changed, 298 insertions(+), 195 deletions(-) + +--- a/drivers/usb/serial/aircable.c ++++ b/drivers/usb/serial/aircable.c +@@ -362,7 +362,7 @@ static int aircable_attach(struct usb_se + return 0; + } + +-static void aircable_shutdown(struct usb_serial *serial) ++static void aircable_release(struct usb_serial *serial) + { + + struct usb_serial_port *port = serial->port[0]; +@@ -373,7 +373,6 @@ static void aircable_shutdown(struct usb + if (priv) { + serial_buf_free(priv->tx_buf); + serial_buf_free(priv->rx_buf); +- usb_set_serial_port_data(port, NULL); + kfree(priv); + } + } +@@ -598,7 +597,7 @@ static struct usb_serial_driver aircable + .num_ports = 1, + .attach = aircable_attach, + .probe = aircable_probe, +- .shutdown = aircable_shutdown, ++ .release = aircable_release, + .write = aircable_write, + .write_room = aircable_write_room, + .write_bulk_callback = aircable_write_bulk_callback, +--- a/drivers/usb/serial/belkin_sa.c ++++ b/drivers/usb/serial/belkin_sa.c +@@ -90,7 +90,7 @@ static int debug; + + /* function prototypes for a Belkin USB Serial Adapter F5U103 */ + static int belkin_sa_startup(struct usb_serial *serial); +-static void belkin_sa_shutdown(struct usb_serial *serial); ++static void belkin_sa_release(struct usb_serial *serial); + static int belkin_sa_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp); + static void belkin_sa_close(struct tty_struct *tty, +@@ -143,7 +143,7 @@ static struct usb_serial_driver belkin_d + .tiocmget = belkin_sa_tiocmget, + .tiocmset = belkin_sa_tiocmset, + .attach = belkin_sa_startup, +- .shutdown = belkin_sa_shutdown, ++ .release = belkin_sa_release, + }; + + +@@ -198,14 +198,13 @@ static int belkin_sa_startup(struct usb_ + } + + +-static void belkin_sa_shutdown(struct usb_serial *serial) ++static void belkin_sa_release(struct usb_serial *serial) + { + struct belkin_sa_private *priv; + int i; + + dbg("%s", __func__); + +- /* stop reads and writes on all ports */ + for (i = 0; i < serial->num_ports; ++i) { + /* My special items, the standard routines free my urbs */ + priv = usb_get_serial_port_data(serial->port[i]); +--- a/drivers/usb/serial/cp2101.c ++++ b/drivers/usb/serial/cp2101.c +@@ -50,7 +50,7 @@ static int cp2101_tiocmset(struct tty_st + unsigned int, unsigned int); + static void cp2101_break_ctl(struct tty_struct *, int); + static int cp2101_startup(struct usb_serial *); +-static void cp2101_shutdown(struct usb_serial *); ++static void cp2101_disconnect(struct usb_serial *); + + + static int debug; +@@ -125,7 +125,7 @@ static struct usb_serial_driver cp2101_d + .tiocmget = cp2101_tiocmget, + .tiocmset = cp2101_tiocmset, + .attach = cp2101_startup, +- .shutdown = cp2101_shutdown, ++ .disconnect = cp2101_disconnect, + }; + + /* Config request types */ +@@ -727,7 +727,7 @@ static int cp2101_startup(struct usb_ser + return 0; + } + +-static void cp2101_shutdown(struct usb_serial *serial) ++static void cp2101_disconnect(struct usb_serial *serial) + { + int i; + +--- a/drivers/usb/serial/cyberjack.c ++++ b/drivers/usb/serial/cyberjack.c +@@ -58,7 +58,8 @@ static int debug; + + /* Function prototypes */ + static int cyberjack_startup(struct usb_serial *serial); +-static void cyberjack_shutdown(struct usb_serial *serial); ++static void cyberjack_disconnect(struct usb_serial *serial); ++static void cyberjack_release(struct usb_serial *serial); + static int cyberjack_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp); + static void cyberjack_close(struct tty_struct *tty, +@@ -95,7 +96,8 @@ static struct usb_serial_driver cyberjac + .id_table = id_table, + .num_ports = 1, + .attach = cyberjack_startup, +- .shutdown = cyberjack_shutdown, ++ .disconnect = cyberjack_disconnect, ++ .release = cyberjack_release, + .open = cyberjack_open, + .close = cyberjack_close, + .write = cyberjack_write, +@@ -148,17 +150,25 @@ static int cyberjack_startup(struct usb_ + return 0; + } + +-static void cyberjack_shutdown(struct usb_serial *serial) ++static void cyberjack_disconnect(struct usb_serial *serial) + { + int i; + + dbg("%s", __func__); + +- for (i = 0; i < serial->num_ports; ++i) { ++ for (i = 0; i < serial->num_ports; ++i) + usb_kill_urb(serial->port[i]->interrupt_in_urb); ++} ++ ++static void cyberjack_release(struct usb_serial *serial) ++{ ++ int i; ++ ++ dbg("%s", __func__); ++ ++ for (i = 0; i < serial->num_ports; ++i) { + /* My special items, the standard routines free my urbs */ + kfree(usb_get_serial_port_data(serial->port[i])); +- usb_set_serial_port_data(serial->port[i], NULL); + } + } + +--- a/drivers/usb/serial/cypress_m8.c ++++ b/drivers/usb/serial/cypress_m8.c +@@ -171,7 +171,7 @@ struct cypress_buf { + static int cypress_earthmate_startup(struct usb_serial *serial); + static int cypress_hidcom_startup(struct usb_serial *serial); + static int cypress_ca42v2_startup(struct usb_serial *serial); +-static void cypress_shutdown(struct usb_serial *serial); ++static void cypress_release(struct usb_serial *serial); + static int cypress_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp); + static void cypress_close(struct tty_struct *tty, +@@ -215,7 +215,7 @@ static struct usb_serial_driver cypress_ + .id_table = id_table_earthmate, + .num_ports = 1, + .attach = cypress_earthmate_startup, +- .shutdown = cypress_shutdown, ++ .release = cypress_release, + .open = cypress_open, + .close = cypress_close, + .write = cypress_write, +@@ -241,7 +241,7 @@ static struct usb_serial_driver cypress_ + .id_table = id_table_cyphidcomrs232, + .num_ports = 1, + .attach = cypress_hidcom_startup, +- .shutdown = cypress_shutdown, ++ .release = cypress_release, + .open = cypress_open, + .close = cypress_close, + .write = cypress_write, +@@ -267,7 +267,7 @@ static struct usb_serial_driver cypress_ + .id_table = id_table_nokiaca42v2, + .num_ports = 1, + .attach = cypress_ca42v2_startup, +- .shutdown = cypress_shutdown, ++ .release = cypress_release, + .open = cypress_open, + .close = cypress_close, + .write = cypress_write, +@@ -612,7 +612,7 @@ static int cypress_ca42v2_startup(struct + } /* cypress_ca42v2_startup */ + + +-static void cypress_shutdown(struct usb_serial *serial) ++static void cypress_release(struct usb_serial *serial) + { + struct cypress_private *priv; + +@@ -625,7 +625,6 @@ static void cypress_shutdown(struct usb_ + if (priv) { + cypress_buf_free(priv->buf); + kfree(priv); +- usb_set_serial_port_data(serial->port[0], NULL); + } + } + +--- a/drivers/usb/serial/digi_acceleport.c ++++ b/drivers/usb/serial/digi_acceleport.c +@@ -460,7 +460,8 @@ static void digi_close(struct tty_struct + struct file *filp); + static int digi_startup_device(struct usb_serial *serial); + static int digi_startup(struct usb_serial *serial); +-static void digi_shutdown(struct usb_serial *serial); ++static void digi_disconnect(struct usb_serial *serial); ++static void digi_release(struct usb_serial *serial); + static void digi_read_bulk_callback(struct urb *urb); + static int digi_read_inb_callback(struct urb *urb); + static int digi_read_oob_callback(struct urb *urb); +@@ -522,7 +523,8 @@ static struct usb_serial_driver digi_acc + .tiocmget = digi_tiocmget, + .tiocmset = digi_tiocmset, + .attach = digi_startup, +- .shutdown = digi_shutdown, ++ .disconnect = digi_disconnect, ++ .release = digi_release, + }; + + static struct usb_serial_driver digi_acceleport_4_device = { +@@ -548,7 +550,8 @@ static struct usb_serial_driver digi_acc + .tiocmget = digi_tiocmget, + .tiocmset = digi_tiocmset, + .attach = digi_startup, +- .shutdown = digi_shutdown, ++ .disconnect = digi_disconnect, ++ .release = digi_release, + }; + + +@@ -1586,16 +1589,23 @@ static int digi_startup(struct usb_seria + } + + +-static void digi_shutdown(struct usb_serial *serial) ++static void digi_disconnect(struct usb_serial *serial) + { + int i; +- dbg("digi_shutdown: TOP, in_interrupt()=%ld", in_interrupt()); ++ dbg("digi_disconnect: TOP, in_interrupt()=%ld", in_interrupt()); + + /* stop reads and writes on all ports */ + for (i = 0; i < serial->type->num_ports + 1; i++) { + usb_kill_urb(serial->port[i]->read_urb); + usb_kill_urb(serial->port[i]->write_urb); + } ++} ++ ++ ++static void digi_release(struct usb_serial *serial) ++{ ++ int i; ++ dbg("digi_release: TOP, in_interrupt()=%ld", in_interrupt()); + + /* free the private data structures for all ports */ + /* number of regular ports + 1 for the out-of-band port */ +--- a/drivers/usb/serial/empeg.c ++++ b/drivers/usb/serial/empeg.c +@@ -92,7 +92,6 @@ static int empeg_chars_in_buffer(struct + static void empeg_throttle(struct tty_struct *tty); + static void empeg_unthrottle(struct tty_struct *tty); + static int empeg_startup(struct usb_serial *serial); +-static void empeg_shutdown(struct usb_serial *serial); + static void empeg_set_termios(struct tty_struct *tty, + struct usb_serial_port *port, struct ktermios *old_termios); + static void empeg_write_bulk_callback(struct urb *urb); +@@ -126,7 +125,6 @@ static struct usb_serial_driver empeg_de + .throttle = empeg_throttle, + .unthrottle = empeg_unthrottle, + .attach = empeg_startup, +- .shutdown = empeg_shutdown, + .set_termios = empeg_set_termios, + .write = empeg_write, + .write_room = empeg_write_room, +@@ -429,12 +427,6 @@ static int empeg_startup(struct usb_ser + } + + +-static void empeg_shutdown(struct usb_serial *serial) +-{ +- dbg("%s", __func__); +-} +- +- + static void empeg_set_termios(struct tty_struct *tty, + struct usb_serial_port *port, struct ktermios *old_termios) + { +--- a/drivers/usb/serial/ftdi_sio.c ++++ b/drivers/usb/serial/ftdi_sio.c +@@ -708,7 +708,6 @@ static const char *ftdi_chip_name[] = { + /* function prototypes for a FTDI serial converter */ + static int ftdi_sio_probe(struct usb_serial *serial, + const struct usb_device_id *id); +-static void ftdi_shutdown(struct usb_serial *serial); + static int ftdi_sio_port_probe(struct usb_serial_port *port); + static int ftdi_sio_port_remove(struct usb_serial_port *port); + static int ftdi_open(struct tty_struct *tty, +@@ -764,7 +763,6 @@ static struct usb_serial_driver ftdi_sio + .ioctl = ftdi_ioctl, + .set_termios = ftdi_set_termios, + .break_ctl = ftdi_break_ctl, +- .shutdown = ftdi_shutdown, + }; + + +@@ -1442,18 +1440,6 @@ static int ftdi_mtxorb_hack_setup(struct + return 0; + } + +-/* ftdi_shutdown is called from usbserial:usb_serial_disconnect +- * it is called when the usb device is disconnected +- * +- * usbserial:usb_serial_disconnect +- * calls __serial_close for each open of the port +- * shutdown is called then (ie ftdi_shutdown) +- */ +-static void ftdi_shutdown(struct usb_serial *serial) +-{ +- dbg("%s", __func__); +-} +- + static int ftdi_sio_port_remove(struct usb_serial_port *port) + { + struct ftdi_private *priv = usb_get_serial_port_data(port); +--- a/drivers/usb/serial/garmin_gps.c ++++ b/drivers/usb/serial/garmin_gps.c +@@ -1527,7 +1527,7 @@ static int garmin_attach(struct usb_seri + } + + +-static void garmin_shutdown(struct usb_serial *serial) ++static void garmin_disconnect(struct usb_serial *serial) + { + struct usb_serial_port *port = serial->port[0]; + struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); +@@ -1536,8 +1536,17 @@ static void garmin_shutdown(struct usb_s + + usb_kill_urb(port->interrupt_in_urb); + del_timer_sync(&garmin_data_p->timer); ++} ++ ++ ++static void garmin_release(struct usb_serial *serial) ++{ ++ struct usb_serial_port *port = serial->port[0]; ++ struct garmin_data *garmin_data_p = usb_get_serial_port_data(port); ++ ++ dbg("%s", __func__); ++ + kfree(garmin_data_p); +- usb_set_serial_port_data(port, NULL); + } + + +@@ -1556,7 +1565,8 @@ static struct usb_serial_driver garmin_d + .throttle = garmin_throttle, + .unthrottle = garmin_unthrottle, + .attach = garmin_attach, +- .shutdown = garmin_shutdown, ++ .disconnect = garmin_disconnect, ++ .release = garmin_release, + .write = garmin_write, + .write_room = garmin_write_room, + .write_bulk_callback = garmin_write_bulk_callback, +--- a/drivers/usb/serial/generic.c ++++ b/drivers/usb/serial/generic.c +@@ -63,7 +63,8 @@ struct usb_serial_driver usb_serial_gene + .id_table = generic_device_ids, + .usb_driver = &generic_driver, + .num_ports = 1, +- .shutdown = usb_serial_generic_shutdown, ++ .disconnect = usb_serial_generic_disconnect, ++ .release = usb_serial_generic_release, + .throttle = usb_serial_generic_throttle, + .unthrottle = usb_serial_generic_unthrottle, + .resume = usb_serial_generic_resume, +@@ -419,7 +420,7 @@ void usb_serial_generic_unthrottle(struc + } + } + +-void usb_serial_generic_shutdown(struct usb_serial *serial) ++void usb_serial_generic_disconnect(struct usb_serial *serial) + { + int i; + +@@ -430,3 +431,7 @@ void usb_serial_generic_shutdown(struct + generic_cleanup(serial->port[i]); + } + ++void usb_serial_generic_release(struct usb_serial *serial) ++{ ++ dbg("%s", __func__); ++} +--- a/drivers/usb/serial/io_edgeport.c ++++ b/drivers/usb/serial/io_edgeport.c +@@ -225,7 +225,8 @@ static int edge_tiocmget(struct tty_str + static int edge_tiocmset(struct tty_struct *tty, struct file *file, + unsigned int set, unsigned int clear); + static int edge_startup(struct usb_serial *serial); +-static void edge_shutdown(struct usb_serial *serial); ++static void edge_disconnect(struct usb_serial *serial); ++static void edge_release(struct usb_serial *serial); + + #include "io_tables.h" /* all of the devices that this driver supports */ + +@@ -3178,21 +3179,16 @@ static int edge_startup(struct usb_seria + + + /**************************************************************************** +- * edge_shutdown ++ * edge_disconnect + * This function is called whenever the device is removed from the usb bus. + ****************************************************************************/ +-static void edge_shutdown(struct usb_serial *serial) ++static void edge_disconnect(struct usb_serial *serial) + { + struct edgeport_serial *edge_serial = usb_get_serial_data(serial); +- int i; + + dbg("%s", __func__); + + /* stop reads and writes on all ports */ +- for (i = 0; i < serial->num_ports; ++i) { +- kfree(usb_get_serial_port_data(serial->port[i])); +- usb_set_serial_port_data(serial->port[i], NULL); +- } + /* free up our endpoint stuff */ + if (edge_serial->is_epic) { + usb_kill_urb(edge_serial->interrupt_read_urb); +@@ -3203,9 +3199,24 @@ static void edge_shutdown(struct usb_ser + usb_free_urb(edge_serial->read_urb); + kfree(edge_serial->bulk_in_buffer); + } ++} ++ ++ ++/**************************************************************************** ++ * edge_release ++ * This function is called when the device structure is deallocated. ++ ****************************************************************************/ ++static void edge_release(struct usb_serial *serial) ++{ ++ struct edgeport_serial *edge_serial = usb_get_serial_data(serial); ++ int i; ++ ++ dbg("%s", __func__); ++ ++ for (i = 0; i < serial->num_ports; ++i) ++ kfree(usb_get_serial_port_data(serial->port[i])); + + kfree(edge_serial); +- usb_set_serial_data(serial, NULL); + } + + +--- a/drivers/usb/serial/io_tables.h ++++ b/drivers/usb/serial/io_tables.h +@@ -117,7 +117,8 @@ static struct usb_serial_driver edgeport + .throttle = edge_throttle, + .unthrottle = edge_unthrottle, + .attach = edge_startup, +- .shutdown = edge_shutdown, ++ .disconnect = edge_disconnect, ++ .release = edge_release, + .ioctl = edge_ioctl, + .set_termios = edge_set_termios, + .tiocmget = edge_tiocmget, +@@ -145,7 +146,8 @@ static struct usb_serial_driver edgeport + .throttle = edge_throttle, + .unthrottle = edge_unthrottle, + .attach = edge_startup, +- .shutdown = edge_shutdown, ++ .disconnect = edge_disconnect, ++ .release = edge_release, + .ioctl = edge_ioctl, + .set_termios = edge_set_termios, + .tiocmget = edge_tiocmget, +@@ -173,7 +175,8 @@ static struct usb_serial_driver edgeport + .throttle = edge_throttle, + .unthrottle = edge_unthrottle, + .attach = edge_startup, +- .shutdown = edge_shutdown, ++ .disconnect = edge_disconnect, ++ .release = edge_release, + .ioctl = edge_ioctl, + .set_termios = edge_set_termios, + .tiocmget = edge_tiocmget, +@@ -200,7 +203,8 @@ static struct usb_serial_driver epic_dev + .throttle = edge_throttle, + .unthrottle = edge_unthrottle, + .attach = edge_startup, +- .shutdown = edge_shutdown, ++ .disconnect = edge_disconnect, ++ .release = edge_release, + .ioctl = edge_ioctl, + .set_termios = edge_set_termios, + .tiocmget = edge_tiocmget, +--- a/drivers/usb/serial/io_ti.c ++++ b/drivers/usb/serial/io_ti.c +@@ -2652,7 +2652,7 @@ cleanup: + return -ENOMEM; + } + +-static void edge_shutdown(struct usb_serial *serial) ++static void edge_disconnect(struct usb_serial *serial) + { + int i; + struct edgeport_port *edge_port; +@@ -2662,12 +2662,22 @@ static void edge_shutdown(struct usb_ser + for (i = 0; i < serial->num_ports; ++i) { + edge_port = usb_get_serial_port_data(serial->port[i]); + edge_remove_sysfs_attrs(edge_port->port); ++ } ++} ++ ++static void edge_release(struct usb_serial *serial) ++{ ++ int i; ++ struct edgeport_port *edge_port; ++ ++ dbg("%s", __func__); ++ ++ for (i = 0; i < serial->num_ports; ++i) { ++ edge_port = usb_get_serial_port_data(serial->port[i]); + edge_buf_free(edge_port->ep_out_buf); + kfree(edge_port); +- usb_set_serial_port_data(serial->port[i], NULL); + } + kfree(usb_get_serial_data(serial)); +- usb_set_serial_data(serial, NULL); + } + + +@@ -2904,7 +2914,8 @@ static struct usb_serial_driver edgeport + .throttle = edge_throttle, + .unthrottle = edge_unthrottle, + .attach = edge_startup, +- .shutdown = edge_shutdown, ++ .disconnect = edge_disconnect, ++ .release = edge_release, + .port_probe = edge_create_sysfs_attrs, + .ioctl = edge_ioctl, + .set_termios = edge_set_termios, +@@ -2933,7 +2944,8 @@ static struct usb_serial_driver edgeport + .throttle = edge_throttle, + .unthrottle = edge_unthrottle, + .attach = edge_startup, +- .shutdown = edge_shutdown, ++ .disconnect = edge_disconnect, ++ .release = edge_release, + .port_probe = edge_create_sysfs_attrs, + .ioctl = edge_ioctl, + .set_termios = edge_set_termios, +--- a/drivers/usb/serial/ipaq.c ++++ b/drivers/usb/serial/ipaq.c +@@ -79,7 +79,6 @@ static int ipaq_open(struct tty_struct + static void ipaq_close(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp); + static int ipaq_startup(struct usb_serial *serial); +-static void ipaq_shutdown(struct usb_serial *serial); + static int ipaq_write(struct tty_struct *tty, struct usb_serial_port *port, + const unsigned char *buf, int count); + static int ipaq_write_bulk(struct usb_serial_port *port, +@@ -581,7 +580,6 @@ static struct usb_serial_driver ipaq_dev + .open = ipaq_open, + .close = ipaq_close, + .attach = ipaq_startup, +- .shutdown = ipaq_shutdown, + .write = ipaq_write, + .write_room = ipaq_write_room, + .chars_in_buffer = ipaq_chars_in_buffer, +@@ -957,11 +955,6 @@ static int ipaq_startup(struct usb_seria + return usb_reset_configuration(serial->dev); + } + +-static void ipaq_shutdown(struct usb_serial *serial) +-{ +- dbg("%s", __func__); +-} +- + static int __init ipaq_init(void) + { + int retval; +--- a/drivers/usb/serial/iuu_phoenix.c ++++ b/drivers/usb/serial/iuu_phoenix.c +@@ -122,8 +122,8 @@ static int iuu_startup(struct usb_serial + return 0; + } + +-/* Shutdown function */ +-static void iuu_shutdown(struct usb_serial *serial) ++/* Release function */ ++static void iuu_release(struct usb_serial *serial) + { + struct usb_serial_port *port = serial->port[0]; + struct iuu_private *priv = usb_get_serial_port_data(port); +@@ -1171,7 +1171,7 @@ static struct usb_serial_driver iuu_devi + .tiocmget = iuu_tiocmget, + .tiocmset = iuu_tiocmset, + .attach = iuu_startup, +- .shutdown = iuu_shutdown, ++ .release = iuu_release, + }; + + static int __init iuu_init(void) +--- a/drivers/usb/serial/keyspan.c ++++ b/drivers/usb/serial/keyspan.c +@@ -2678,7 +2678,7 @@ static int keyspan_startup(struct usb_se + return 0; + } + +-static void keyspan_shutdown(struct usb_serial *serial) ++static void keyspan_disconnect(struct usb_serial *serial) + { + int i, j; + struct usb_serial_port *port; +@@ -2718,6 +2718,17 @@ static void keyspan_shutdown(struct usb_ + usb_free_urb(p_priv->out_urbs[j]); + } + } ++} ++ ++static void keyspan_release(struct usb_serial *serial) ++{ ++ int i; ++ struct usb_serial_port *port; ++ struct keyspan_serial_private *s_priv; ++ ++ dbg("%s", __func__); ++ ++ s_priv = usb_get_serial_data(serial); + + /* dbg("Freeing serial->private."); */ + kfree(s_priv); +--- a/drivers/usb/serial/keyspan.h ++++ b/drivers/usb/serial/keyspan.h +@@ -42,7 +42,8 @@ static void keyspan_close (struct tty_s + struct usb_serial_port *port, + struct file *filp); + static int keyspan_startup (struct usb_serial *serial); +-static void keyspan_shutdown (struct usb_serial *serial); ++static void keyspan_disconnect (struct usb_serial *serial); ++static void keyspan_release (struct usb_serial *serial); + static int keyspan_write_room (struct tty_struct *tty); + + static int keyspan_write (struct tty_struct *tty, +@@ -569,7 +570,8 @@ static struct usb_serial_driver keyspan_ + .tiocmget = keyspan_tiocmget, + .tiocmset = keyspan_tiocmset, + .attach = keyspan_startup, +- .shutdown = keyspan_shutdown, ++ .disconnect = keyspan_disconnect, ++ .release = keyspan_release, + }; + + static struct usb_serial_driver keyspan_2port_device = { +@@ -589,7 +591,8 @@ static struct usb_serial_driver keyspan_ + .tiocmget = keyspan_tiocmget, + .tiocmset = keyspan_tiocmset, + .attach = keyspan_startup, +- .shutdown = keyspan_shutdown, ++ .disconnect = keyspan_disconnect, ++ .release = keyspan_release, + }; + + static struct usb_serial_driver keyspan_4port_device = { +@@ -609,7 +612,8 @@ static struct usb_serial_driver keyspan_ + .tiocmget = keyspan_tiocmget, + .tiocmset = keyspan_tiocmset, + .attach = keyspan_startup, +- .shutdown = keyspan_shutdown, ++ .disconnect = keyspan_disconnect, ++ .release = keyspan_release, + }; + + #endif +--- a/drivers/usb/serial/keyspan_pda.c ++++ b/drivers/usb/serial/keyspan_pda.c +@@ -789,7 +789,7 @@ static int keyspan_pda_startup(struct us + return 0; + } + +-static void keyspan_pda_shutdown(struct usb_serial *serial) ++static void keyspan_pda_release(struct usb_serial *serial) + { + dbg("%s", __func__); + +@@ -847,7 +847,7 @@ static struct usb_serial_driver keyspan_ + .tiocmget = keyspan_pda_tiocmget, + .tiocmset = keyspan_pda_tiocmset, + .attach = keyspan_pda_startup, +- .shutdown = keyspan_pda_shutdown, ++ .release = keyspan_pda_release, + }; + + +--- a/drivers/usb/serial/kl5kusb105.c ++++ b/drivers/usb/serial/kl5kusb105.c +@@ -73,7 +73,8 @@ static int debug; + * Function prototypes + */ + static int klsi_105_startup(struct usb_serial *serial); +-static void klsi_105_shutdown(struct usb_serial *serial); ++static void klsi_105_disconnect(struct usb_serial *serial); ++static void klsi_105_release(struct usb_serial *serial); + static int klsi_105_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp); + static void klsi_105_close(struct tty_struct *tty, +@@ -132,7 +133,8 @@ static struct usb_serial_driver kl5kusb1 + .tiocmget = klsi_105_tiocmget, + .tiocmset = klsi_105_tiocmset, + .attach = klsi_105_startup, +- .shutdown = klsi_105_shutdown, ++ .disconnect = klsi_105_disconnect, ++ .release = klsi_105_release, + .throttle = klsi_105_throttle, + .unthrottle = klsi_105_unthrottle, + }; +@@ -314,7 +316,7 @@ err_cleanup: + } /* klsi_105_startup */ + + +-static void klsi_105_shutdown(struct usb_serial *serial) ++static void klsi_105_disconnect(struct usb_serial *serial) + { + int i; + +@@ -324,33 +326,36 @@ static void klsi_105_shutdown(struct usb + for (i = 0; i < serial->num_ports; ++i) { + struct klsi_105_private *priv = + usb_get_serial_port_data(serial->port[i]); +- unsigned long flags; + + if (priv) { + /* kill our write urb pool */ + int j; + struct urb **write_urbs = priv->write_urb_pool; +- spin_lock_irqsave(&priv->lock, flags); + + for (j = 0; j < NUM_URBS; j++) { + if (write_urbs[j]) { +- /* FIXME - uncomment the following +- * usb_kill_urb call when the host +- * controllers get fixed to set +- * urb->dev = NULL after the urb is +- * finished. Otherwise this call +- * oopses. */ +- /* usb_kill_urb(write_urbs[j]); */ +- kfree(write_urbs[j]->transfer_buffer); ++ usb_kill_urb(write_urbs[j]); + usb_free_urb(write_urbs[j]); + } + } +- spin_unlock_irqrestore(&priv->lock, flags); +- kfree(priv); +- usb_set_serial_port_data(serial->port[i], NULL); + } + } +-} /* klsi_105_shutdown */ ++} /* klsi_105_disconnect */ ++ ++ ++static void klsi_105_release(struct usb_serial *serial) ++{ ++ int i; ++ ++ dbg("%s", __func__); ++ ++ for (i = 0; i < serial->num_ports; ++i) { ++ struct klsi_105_private *priv = ++ usb_get_serial_port_data(serial->port[i]); ++ ++ kfree(priv); ++ } ++} /* klsi_105_release */ + + static int klsi_105_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp) +--- a/drivers/usb/serial/kobil_sct.c ++++ b/drivers/usb/serial/kobil_sct.c +@@ -69,7 +69,7 @@ static int debug; + + /* Function prototypes */ + static int kobil_startup(struct usb_serial *serial); +-static void kobil_shutdown(struct usb_serial *serial); ++static void kobil_release(struct usb_serial *serial); + static int kobil_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp); + static void kobil_close(struct tty_struct *tty, struct usb_serial_port *port, +@@ -118,7 +118,7 @@ static struct usb_serial_driver kobil_de + .id_table = id_table, + .num_ports = 1, + .attach = kobil_startup, +- .shutdown = kobil_shutdown, ++ .release = kobil_release, + .ioctl = kobil_ioctl, + .set_termios = kobil_set_termios, + .tiocmget = kobil_tiocmget, +@@ -202,17 +202,13 @@ static int kobil_startup(struct usb_seri + } + + +-static void kobil_shutdown(struct usb_serial *serial) ++static void kobil_release(struct usb_serial *serial) + { + int i; + dbg("%s - port %d", __func__, serial->port[0]->number); + +- for (i = 0; i < serial->num_ports; ++i) { +- while (serial->port[i]->port.count > 0) +- kobil_close(NULL, serial->port[i], NULL); ++ for (i = 0; i < serial->num_ports; ++i) + kfree(usb_get_serial_port_data(serial->port[i])); +- usb_set_serial_port_data(serial->port[i], NULL); +- } + } + + +--- a/drivers/usb/serial/mct_u232.c ++++ b/drivers/usb/serial/mct_u232.c +@@ -92,7 +92,7 @@ static int debug; + * Function prototypes + */ + static int mct_u232_startup(struct usb_serial *serial); +-static void mct_u232_shutdown(struct usb_serial *serial); ++static void mct_u232_release(struct usb_serial *serial); + static int mct_u232_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp); + static void mct_u232_close(struct tty_struct *tty, +@@ -148,7 +148,7 @@ static struct usb_serial_driver mct_u232 + .tiocmget = mct_u232_tiocmget, + .tiocmset = mct_u232_tiocmset, + .attach = mct_u232_startup, +- .shutdown = mct_u232_shutdown, ++ .release = mct_u232_release, + }; + + +@@ -401,7 +401,7 @@ static int mct_u232_startup(struct usb_s + } /* mct_u232_startup */ + + +-static void mct_u232_shutdown(struct usb_serial *serial) ++static void mct_u232_release(struct usb_serial *serial) + { + struct mct_u232_private *priv; + int i; +@@ -411,12 +411,9 @@ static void mct_u232_shutdown(struct usb + for (i = 0; i < serial->num_ports; ++i) { + /* My special items, the standard routines free my urbs */ + priv = usb_get_serial_port_data(serial->port[i]); +- if (priv) { +- usb_set_serial_port_data(serial->port[i], NULL); +- kfree(priv); +- } ++ kfree(priv); + } +-} /* mct_u232_shutdown */ ++} /* mct_u232_release */ + + static int mct_u232_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp) +--- a/drivers/usb/serial/mos7720.c ++++ b/drivers/usb/serial/mos7720.c +@@ -1547,19 +1547,16 @@ static int mos7720_startup(struct usb_se + return 0; + } + +-static void mos7720_shutdown(struct usb_serial *serial) ++static void mos7720_release(struct usb_serial *serial) + { + int i; + + /* free private structure allocated for serial port */ +- for (i = 0; i < serial->num_ports; ++i) { ++ for (i = 0; i < serial->num_ports; ++i) + kfree(usb_get_serial_port_data(serial->port[i])); +- usb_set_serial_port_data(serial->port[i], NULL); +- } + + /* free private structure allocated for serial device */ + kfree(usb_get_serial_data(serial)); +- usb_set_serial_data(serial, NULL); + } + + static struct usb_driver usb_driver = { +@@ -1584,7 +1581,7 @@ static struct usb_serial_driver moschip7 + .throttle = mos7720_throttle, + .unthrottle = mos7720_unthrottle, + .attach = mos7720_startup, +- .shutdown = mos7720_shutdown, ++ .release = mos7720_release, + .ioctl = mos7720_ioctl, + .set_termios = mos7720_set_termios, + .write = mos7720_write, +--- a/drivers/usb/serial/mos7840.c ++++ b/drivers/usb/serial/mos7840.c +@@ -2643,16 +2643,16 @@ error: + } + + /**************************************************************************** +- * mos7840_shutdown ++ * mos7840_disconnect + * This function is called whenever the device is removed from the usb bus. + ****************************************************************************/ + +-static void mos7840_shutdown(struct usb_serial *serial) ++static void mos7840_disconnect(struct usb_serial *serial) + { + int i; + unsigned long flags; + struct moschip_port *mos7840_port; +- dbg("%s \n", " shutdown :entering.........."); ++ dbg("%s\n", " disconnect :entering.........."); + + if (!serial) { + dbg("%s", "Invalid Handler \n"); +@@ -2670,10 +2670,41 @@ static void mos7840_shutdown(struct usb_ + mos7840_port->zombie = 1; + spin_unlock_irqrestore(&mos7840_port->pool_lock, flags); + usb_kill_urb(mos7840_port->control_urb); +- kfree(mos7840_port->ctrl_buf); +- kfree(mos7840_port->dr); +- kfree(mos7840_port); +- mos7840_set_port_private(serial->port[i], NULL); ++ } ++ ++ dbg("%s\n", "Thank u ::"); ++ ++} ++ ++/**************************************************************************** ++ * mos7840_release ++ * This function is called when the usb_serial structure is freed. ++ ****************************************************************************/ ++ ++static void mos7840_release(struct usb_serial *serial) ++{ ++ int i; ++ struct moschip_port *mos7840_port; ++ dbg("%s\n", " release :entering.........."); ++ ++ if (!serial) { ++ dbg("%s", "Invalid Handler"); ++ return; ++ } ++ ++ /* check for the ports to be closed,close the ports and disconnect */ ++ ++ /* free private structure allocated for serial port * ++ * stop reads and writes on all ports */ ++ ++ for (i = 0; i < serial->num_ports; ++i) { ++ mos7840_port = mos7840_get_port_private(serial->port[i]); ++ dbg("mos7840_port %d = %p", i, mos7840_port); ++ if (mos7840_port) { ++ kfree(mos7840_port->ctrl_buf); ++ kfree(mos7840_port->dr); ++ kfree(mos7840_port); ++ } + } + + dbg("%s\n", "Thank u :: "); +@@ -2714,7 +2745,8 @@ static struct usb_serial_driver moschip7 + .tiocmget = mos7840_tiocmget, + .tiocmset = mos7840_tiocmset, + .attach = mos7840_startup, +- .shutdown = mos7840_shutdown, ++ .disconnect = mos7840_disconnect, ++ .release = mos7840_release, + .read_bulk_callback = mos7840_bulk_in_callback, + .read_int_callback = mos7840_interrupt_callback, + }; +--- a/drivers/usb/serial/omninet.c ++++ b/drivers/usb/serial/omninet.c +@@ -73,7 +73,8 @@ static void omninet_write_bulk_callback( + static int omninet_write(struct tty_struct *tty, struct usb_serial_port *port, + const unsigned char *buf, int count); + static int omninet_write_room(struct tty_struct *tty); +-static void omninet_shutdown(struct usb_serial *serial); ++static void omninet_disconnect(struct usb_serial *serial); ++static void omninet_release(struct usb_serial *serial); + static int omninet_attach(struct usb_serial *serial); + + static struct usb_device_id id_table[] = { +@@ -109,7 +110,8 @@ static struct usb_serial_driver zyxel_om + .write_room = omninet_write_room, + .read_bulk_callback = omninet_read_bulk_callback, + .write_bulk_callback = omninet_write_bulk_callback, +- .shutdown = omninet_shutdown, ++ .disconnect = omninet_disconnect, ++ .release = omninet_release, + }; + + +@@ -342,13 +344,22 @@ static void omninet_write_bulk_callback( + } + + +-static void omninet_shutdown(struct usb_serial *serial) ++static void omninet_disconnect(struct usb_serial *serial) + { + struct usb_serial_port *wport = serial->port[1]; +- struct usb_serial_port *port = serial->port[0]; ++ + dbg("%s", __func__); + + usb_kill_urb(wport->write_urb); ++} ++ ++ ++static void omninet_release(struct usb_serial *serial) ++{ ++ struct usb_serial_port *port = serial->port[0]; ++ ++ dbg("%s", __func__); ++ + kfree(usb_get_serial_port_data(port)); + } + +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -48,7 +48,8 @@ static int option_open(struct tty_struc + static void option_close(struct tty_struct *tty, struct usb_serial_port *port, + struct file *filp); + static int option_startup(struct usb_serial *serial); +-static void option_shutdown(struct usb_serial *serial); ++static void option_disconnect(struct usb_serial *serial); ++static void option_release(struct usb_serial *serial); + static int option_write_room(struct tty_struct *tty); + + static void option_instat_callback(struct urb *urb); +@@ -541,7 +542,8 @@ static struct usb_serial_driver option_1 + .tiocmget = option_tiocmget, + .tiocmset = option_tiocmset, + .attach = option_startup, +- .shutdown = option_shutdown, ++ .disconnect = option_disconnect, ++ .release = option_release, + .read_int_callback = option_instat_callback, + .suspend = option_suspend, + .resume = option_resume, +@@ -1112,7 +1114,14 @@ static void stop_read_write_urbs(struct + } + } + +-static void option_shutdown(struct usb_serial *serial) ++static void option_disconnect(struct usb_serial *serial) ++{ ++ dbg("%s", __func__); ++ ++ stop_read_write_urbs(serial); ++} ++ ++static void option_release(struct usb_serial *serial) + { + int i, j; + struct usb_serial_port *port; +@@ -1120,8 +1129,6 @@ static void option_shutdown(struct usb_s + + dbg("%s", __func__); + +- stop_read_write_urbs(serial); +- + /* Now free them */ + for (i = 0; i < serial->num_ports; ++i) { + port = serial->port[i]; +--- a/drivers/usb/serial/oti6858.c ++++ b/drivers/usb/serial/oti6858.c +@@ -160,7 +160,7 @@ static int oti6858_tiocmget(struct tty_s + static int oti6858_tiocmset(struct tty_struct *tty, struct file *file, + unsigned int set, unsigned int clear); + static int oti6858_startup(struct usb_serial *serial); +-static void oti6858_shutdown(struct usb_serial *serial); ++static void oti6858_release(struct usb_serial *serial); + + /* functions operating on buffers */ + static struct oti6858_buf *oti6858_buf_alloc(unsigned int size); +@@ -195,7 +195,7 @@ static struct usb_serial_driver oti6858_ + .write_room = oti6858_write_room, + .chars_in_buffer = oti6858_chars_in_buffer, + .attach = oti6858_startup, +- .shutdown = oti6858_shutdown, ++ .release = oti6858_release, + }; + + struct oti6858_private { +@@ -833,7 +833,7 @@ static int oti6858_ioctl(struct tty_stru + } + + +-static void oti6858_shutdown(struct usb_serial *serial) ++static void oti6858_release(struct usb_serial *serial) + { + struct oti6858_private *priv; + int i; +@@ -845,7 +845,6 @@ static void oti6858_shutdown(struct usb_ + if (priv) { + oti6858_buf_free(priv->buf); + kfree(priv); +- usb_set_serial_port_data(serial->port[i], NULL); + } + } + } +--- a/drivers/usb/serial/pl2303.c ++++ b/drivers/usb/serial/pl2303.c +@@ -905,7 +905,7 @@ static void pl2303_break_ctl(struct tty_ + dbg("%s - error sending break = %d", __func__, result); + } + +-static void pl2303_shutdown(struct usb_serial *serial) ++static void pl2303_release(struct usb_serial *serial) + { + int i; + struct pl2303_private *priv; +@@ -917,7 +917,6 @@ static void pl2303_shutdown(struct usb_s + if (priv) { + pl2303_buf_free(priv->buf); + kfree(priv); +- usb_set_serial_port_data(serial->port[i], NULL); + } + } + } +@@ -1145,7 +1144,7 @@ static struct usb_serial_driver pl2303_d + .write_room = pl2303_write_room, + .chars_in_buffer = pl2303_chars_in_buffer, + .attach = pl2303_startup, +- .shutdown = pl2303_shutdown, ++ .release = pl2303_release, + }; + + static int __init pl2303_init(void) +--- a/drivers/usb/serial/sierra.c ++++ b/drivers/usb/serial/sierra.c +@@ -677,7 +677,7 @@ static int sierra_startup(struct usb_ser + return 0; + } + +-static void sierra_shutdown(struct usb_serial *serial) ++static void sierra_disconnect(struct usb_serial *serial) + { + int i, j; + struct usb_serial_port *port; +@@ -696,10 +696,29 @@ static void sierra_shutdown(struct usb_s + for (j = 0; j < N_IN_URB; j++) { + usb_kill_urb(portdata->in_urbs[j]); + usb_free_urb(portdata->in_urbs[j]); +- kfree(portdata->in_buffer[j]); + } ++ } ++} ++ ++static void sierra_release(struct usb_serial *serial) ++{ ++ int i, j; ++ struct usb_serial_port *port; ++ struct sierra_port_private *portdata; ++ ++ dev_dbg(&serial->dev->dev, "%s\n", __func__); ++ ++ for (i = 0; i < serial->num_ports; ++i) { ++ port = serial->port[i]; ++ if (!port) ++ continue; ++ portdata = usb_get_serial_port_data(port); ++ if (!portdata) ++ continue; ++ ++ for (j = 0; j < N_IN_URB; j++) ++ kfree(portdata->in_buffer[j]); + kfree(portdata); +- usb_set_serial_port_data(port, NULL); + } + } + +@@ -721,7 +740,8 @@ static struct usb_serial_driver sierra_d + .tiocmget = sierra_tiocmget, + .tiocmset = sierra_tiocmset, + .attach = sierra_startup, +- .shutdown = sierra_shutdown, ++ .disconnect = sierra_disconnect, ++ .release = sierra_release, + .read_int_callback = sierra_instat_callback, + }; + +--- a/drivers/usb/serial/spcp8x5.c ++++ b/drivers/usb/serial/spcp8x5.c +@@ -356,7 +356,7 @@ cleanup: + } + + /* call when the device plug out. free all the memory alloced by probe */ +-static void spcp8x5_shutdown(struct usb_serial *serial) ++static void spcp8x5_release(struct usb_serial *serial) + { + int i; + struct spcp8x5_private *priv; +@@ -366,7 +366,6 @@ static void spcp8x5_shutdown(struct usb_ + if (priv) { + free_ringbuf(priv->buf); + kfree(priv); +- usb_set_serial_port_data(serial->port[i] , NULL); + } + } + } +@@ -1041,7 +1040,7 @@ static struct usb_serial_driver spcp8x5_ + .write_bulk_callback = spcp8x5_write_bulk_callback, + .chars_in_buffer = spcp8x5_chars_in_buffer, + .attach = spcp8x5_startup, +- .shutdown = spcp8x5_shutdown, ++ .release = spcp8x5_release, + }; + + static int __init spcp8x5_init(void) +--- a/drivers/usb/serial/ti_usb_3410_5052.c ++++ b/drivers/usb/serial/ti_usb_3410_5052.c +@@ -148,7 +148,7 @@ struct ti_device { + /* Function Declarations */ + + static int ti_startup(struct usb_serial *serial); +-static void ti_shutdown(struct usb_serial *serial); ++static void ti_release(struct usb_serial *serial); + static int ti_open(struct tty_struct *tty, struct usb_serial_port *port, + struct file *file); + static void ti_close(struct tty_struct *tty, struct usb_serial_port *port, +@@ -271,7 +271,7 @@ static struct usb_serial_driver ti_1port + .id_table = ti_id_table_3410, + .num_ports = 1, + .attach = ti_startup, +- .shutdown = ti_shutdown, ++ .release = ti_release, + .open = ti_open, + .close = ti_close, + .write = ti_write, +@@ -299,7 +299,7 @@ static struct usb_serial_driver ti_2port + .id_table = ti_id_table_5052, + .num_ports = 2, + .attach = ti_startup, +- .shutdown = ti_shutdown, ++ .release = ti_release, + .open = ti_open, + .close = ti_close, + .write = ti_write, +@@ -506,7 +506,7 @@ free_tdev: + } + + +-static void ti_shutdown(struct usb_serial *serial) ++static void ti_release(struct usb_serial *serial) + { + int i; + struct ti_device *tdev = usb_get_serial_data(serial); +@@ -519,12 +519,10 @@ static void ti_shutdown(struct usb_seria + if (tport) { + ti_buf_free(tport->tp_write_buf); + kfree(tport); +- usb_set_serial_port_data(serial->port[i], NULL); + } + } + + kfree(tdev); +- usb_set_serial_data(serial, NULL); + } + + +--- a/drivers/usb/serial/usb-serial.c ++++ b/drivers/usb/serial/usb-serial.c +@@ -140,6 +140,14 @@ static void destroy_serial(struct kref * + if (serial->minor != SERIAL_TTY_NO_MINOR) + return_serial(serial); + ++ serial->type->release(serial); ++ ++ for (i = 0; i < serial->num_ports; ++i) { ++ port = serial->port[i]; ++ if (port) ++ put_device(&port->dev); ++ } ++ + /* If this is a "fake" port, we have to clean it up here, as it will + * not get cleaned up in port_release() as it was never registered with + * the driver core */ +@@ -147,9 +155,8 @@ static void destroy_serial(struct kref * + for (i = serial->num_ports; + i < serial->num_port_pointers; ++i) { + port = serial->port[i]; +- if (!port) +- continue; +- port_free(port); ++ if (port) ++ port_free(port); + } + } + +@@ -1061,10 +1068,6 @@ void usb_serial_disconnect(struct usb_in + serial->disconnected = 1; + mutex_unlock(&serial->disc_mutex); + +- /* Unfortunately, many of the sub-drivers expect the port structures +- * to exist when their shutdown method is called, so we have to go +- * through this awkward two-step unregistration procedure. +- */ + for (i = 0; i < serial->num_ports; ++i) { + port = serial->port[i]; + if (port) { +@@ -1075,14 +1078,7 @@ void usb_serial_disconnect(struct usb_in + device_del(&port->dev); + } + } +- serial->type->shutdown(serial); +- for (i = 0; i < serial->num_ports; ++i) { +- port = serial->port[i]; +- if (port) { +- put_device(&port->dev); +- serial->port[i] = NULL; +- } +- } ++ serial->type->disconnect(serial); + + /* let the last holder of this object + * cause it to be cleaned up */ +@@ -1246,7 +1242,8 @@ static void fixup_generic(struct usb_ser + set_to_generic_if_null(device, chars_in_buffer); + set_to_generic_if_null(device, read_bulk_callback); + set_to_generic_if_null(device, write_bulk_callback); +- set_to_generic_if_null(device, shutdown); ++ set_to_generic_if_null(device, disconnect); ++ set_to_generic_if_null(device, release); + set_to_generic_if_null(device, resume); + } + +--- a/drivers/usb/serial/visor.c ++++ b/drivers/usb/serial/visor.c +@@ -48,7 +48,7 @@ static void visor_unthrottle(struct tty_ + static int visor_probe(struct usb_serial *serial, + const struct usb_device_id *id); + static int visor_calc_num_ports(struct usb_serial *serial); +-static void visor_shutdown(struct usb_serial *serial); ++static void visor_release(struct usb_serial *serial); + static void visor_write_bulk_callback(struct urb *urb); + static void visor_read_bulk_callback(struct urb *urb); + static void visor_read_int_callback(struct urb *urb); +@@ -203,7 +203,7 @@ static struct usb_serial_driver handspri + .attach = treo_attach, + .probe = visor_probe, + .calc_num_ports = visor_calc_num_ports, +- .shutdown = visor_shutdown, ++ .release = visor_release, + .write = visor_write, + .write_room = visor_write_room, + .write_bulk_callback = visor_write_bulk_callback, +@@ -228,7 +228,7 @@ static struct usb_serial_driver clie_5_d + .attach = clie_5_attach, + .probe = visor_probe, + .calc_num_ports = visor_calc_num_ports, +- .shutdown = visor_shutdown, ++ .release = visor_release, + .write = visor_write, + .write_room = visor_write_room, + .write_bulk_callback = visor_write_bulk_callback, +@@ -916,7 +916,7 @@ static int clie_5_attach(struct usb_seri + return generic_startup(serial); + } + +-static void visor_shutdown(struct usb_serial *serial) ++static void visor_release(struct usb_serial *serial) + { + struct visor_private *priv; + int i; +@@ -925,10 +925,7 @@ static void visor_shutdown(struct usb_se + + for (i = 0; i < serial->num_ports; i++) { + priv = usb_get_serial_port_data(serial->port[i]); +- if (priv) { +- usb_set_serial_port_data(serial->port[i], NULL); +- kfree(priv); +- } ++ kfree(priv); + } + } + +--- a/drivers/usb/serial/whiteheat.c ++++ b/drivers/usb/serial/whiteheat.c +@@ -144,7 +144,7 @@ static int whiteheat_firmware_attach(st + + /* function prototypes for the Connect Tech WhiteHEAT serial converter */ + static int whiteheat_attach(struct usb_serial *serial); +-static void whiteheat_shutdown(struct usb_serial *serial); ++static void whiteheat_release(struct usb_serial *serial); + static int whiteheat_open(struct tty_struct *tty, + struct usb_serial_port *port, struct file *filp); + static void whiteheat_close(struct tty_struct *tty, +@@ -190,7 +190,7 @@ static struct usb_serial_driver whitehea + .id_table = id_table_std, + .num_ports = 4, + .attach = whiteheat_attach, +- .shutdown = whiteheat_shutdown, ++ .release = whiteheat_release, + .open = whiteheat_open, + .close = whiteheat_close, + .write = whiteheat_write, +@@ -600,7 +600,7 @@ no_command_buffer: + } + + +-static void whiteheat_shutdown(struct usb_serial *serial) ++static void whiteheat_release(struct usb_serial *serial) + { + struct usb_serial_port *command_port; + struct usb_serial_port *port; +--- a/include/linux/usb/serial.h ++++ b/include/linux/usb/serial.h +@@ -177,8 +177,10 @@ static inline void usb_set_serial_data(s + * This will be called when the struct usb_serial structure is fully set + * set up. Do any local initialization of the device, or any private + * memory structure allocation at this point in time. +- * @shutdown: pointer to the driver's shutdown function. This will be +- * called when the device is removed from the system. ++ * @disconnect: pointer to the driver's disconnect function. This will be ++ * called when the device is unplugged or unbound from the driver. ++ * @release: pointer to the driver's release function. This will be called ++ * when the usb_serial data structure is about to be destroyed. + * @usb_driver: pointer to the struct usb_driver that controls this + * device. This is necessary to allow dynamic ids to be added to + * the driver from sysfs. +@@ -208,7 +210,8 @@ struct usb_serial_driver { + int (*attach)(struct usb_serial *serial); + int (*calc_num_ports) (struct usb_serial *serial); + +- void (*shutdown)(struct usb_serial *serial); ++ void (*disconnect)(struct usb_serial *serial); ++ void (*release)(struct usb_serial *serial); + + int (*port_probe)(struct usb_serial_port *port); + int (*port_remove)(struct usb_serial_port *port); +@@ -288,7 +291,8 @@ extern void usb_serial_generic_read_bulk + extern void usb_serial_generic_write_bulk_callback(struct urb *urb); + extern void usb_serial_generic_throttle(struct tty_struct *tty); + extern void usb_serial_generic_unthrottle(struct tty_struct *tty); +-extern void usb_serial_generic_shutdown(struct usb_serial *serial); ++extern void usb_serial_generic_disconnect(struct usb_serial *serial); ++extern void usb_serial_generic_release(struct usb_serial *serial); + extern int usb_serial_generic_register(int debug); + extern void usb_serial_generic_deregister(void); +