22 files changed, 283 insertions, 55 deletions

diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index be5dc80836c3..5a8a2c91c2b2 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -403,6 +403,13 @@ config USB_SERIAL_MCT_U232
           To compile this driver as a module, choose M here: the
           module will be called mct_u232.
 
+config USB_SERIAL_NAVMAN
+        tristate "USB Navman GPS device"
+        depends on USB_SERIAL
+        help
+          To compile this driver as a module, choose M here: the
+          module will be called navman.
+
 config USB_SERIAL_PL2303
         tristate "USB Prolific 2303 Single Port Serial Driver"
         depends on USB_SERIAL
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index f0b04420cea1..f7fe4172efed 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -32,6 +32,7 @@ obj-$(CONFIG_USB_SERIAL_KEYSPAN_PDA)		+= keyspan_pda.o
 obj-$(CONFIG_USB_SERIAL_KLSI)                   += kl5kusb105.o
 obj-$(CONFIG_USB_SERIAL_KOBIL_SCT)              += kobil_sct.o
 obj-$(CONFIG_USB_SERIAL_MCT_U232)               += mct_u232.o
+obj-$(CONFIG_USB_SERIAL_NAVMAN)                 += navman.o
 obj-$(CONFIG_USB_SERIAL_OMNINET)                += omninet.o
 obj-$(CONFIG_USB_SERIAL_OPTION)                 += option.o
 obj-$(CONFIG_USB_SERIAL_PL2303)                 += pl2303.o
diff --git a/drivers/usb/serial/cp2101.c b/drivers/usb/serial/cp2101.c
index dc7a069503e0..e0c2acdb3f06 100644
--- a/drivers/usb/serial/cp2101.c
+++ b/drivers/usb/serial/cp2101.c
@@ -32,7 +32,7 @@
 /*
  * Version Information
  */
-#define DRIVER_VERSION "v0.06"
+#define DRIVER_VERSION "v0.07"
 #define DRIVER_DESC "Silicon Labs CP2101/CP2102 RS232 serial adaptor driver"
 
 /*
@@ -58,6 +58,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
         { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
         { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
+        { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
         { USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
         { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
         { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
@@ -169,9 +170,7 @@ static int cp2101_get_config(struct usb_serial_port* port, u8 request,
         /* Number of integers required to contain the array */
         length = (((size - 1) | 3) + 1)/4;
 
-        buf = kmalloc (length * sizeof(u32), GFP_KERNEL);
-        memset(buf, 0, length * sizeof(u32));
-
+        buf = kcalloc(length, sizeof(u32), GFP_KERNEL);
         if (!buf) {
                 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
                 return -ENOMEM;
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index 68067fe117a4..7212fbe3b6f2 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -98,10 +98,16 @@ static struct usb_device_id id_table_cyphidcomrs232 [] = {
         { }                                             /* Terminating entry */
 };
 
+static struct usb_device_id id_table_nokiaca42v2 [] = {
+        { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) },
+        { }                                             /* Terminating entry */
+};
+
 static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) },
         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) },
         { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) },
+        { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) },
         { }                                             /* Terminating entry */
 };
 
@@ -149,6 +155,7 @@ struct cypress_buf {
 /* function prototypes for the Cypress USB to serial device */
 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 int  cypress_open                (struct usb_serial_port *port, struct file *filp);
 static void cypress_close               (struct usb_serial_port *port, struct file *filp);
@@ -235,6 +242,34 @@ static struct usb_serial_driver cypress_hidcom_device = {
         .write_int_callback =           cypress_write_int_callback,
 };
 
+static struct usb_serial_driver cypress_ca42v2_device = {
+        .driver = {
+                .owner =                THIS_MODULE,
+                .name =                 "nokiaca42v2",
+        },
+        .description =                  "Nokia CA-42 V2 Adapter",
+        .id_table =                     id_table_nokiaca42v2,
+        .num_interrupt_in =             1,
+        .num_interrupt_out =            1,
+        .num_bulk_in =                  NUM_DONT_CARE,
+        .num_bulk_out =                 NUM_DONT_CARE,
+        .num_ports =                    1,
+        .attach =                       cypress_ca42v2_startup,
+        .shutdown =                     cypress_shutdown,
+        .open =                         cypress_open,
+        .close =                        cypress_close,
+        .write =                        cypress_write,
+        .write_room =                   cypress_write_room,
+        .ioctl =                        cypress_ioctl,
+        .set_termios =                  cypress_set_termios,
+        .tiocmget =                     cypress_tiocmget,
+        .tiocmset =                     cypress_tiocmset,
+        .chars_in_buffer =              cypress_chars_in_buffer,
+        .throttle =                     cypress_throttle,
+        .unthrottle =                   cypress_unthrottle,
+        .read_int_callback =            cypress_read_int_callback,
+        .write_int_callback =           cypress_write_int_callback,
+};
 
 /*****************************************************************************
  * Cypress serial helper functions
@@ -286,6 +321,12 @@ static int cypress_serial_control (struct usb_serial_port *port, unsigned baud_m
                                                     __FUNCTION__);
                                                 new_baudrate = priv->baud_rate;
                                         }
+                                } else if (priv->chiptype == CT_CA42V2) {
+                                        if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
+                                                err("%s - failed setting baud rate, unsupported speed",
+                                                    __FUNCTION__);
+                                                new_baudrate = priv->baud_rate;
+                                        }
                                 } else if (priv->chiptype == CT_GENERIC) {
                                         if ( (new_baudrate = mask_to_rate(baud_mask)) == -1) {
                                                 err("%s - failed setting baud rate, unsupported speed",
@@ -435,11 +476,10 @@ static int generic_startup (struct usb_serial *serial)
 
         dbg("%s - port %d", __FUNCTION__, serial->port[0]->number);
 
-        priv = kmalloc(sizeof (struct cypress_private), GFP_KERNEL);
+        priv = kzalloc(sizeof (struct cypress_private), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
-        memset(priv, 0x00, sizeof (struct cypress_private));
         spin_lock_init(&priv->lock);
         priv->buf = cypress_buf_alloc(CYPRESS_BUF_SIZE);
         if (priv->buf == NULL) {
@@ -500,6 +540,25 @@ static int cypress_hidcom_startup (struct usb_serial *serial)
 } /* cypress_hidcom_startup */
 
 
+static int cypress_ca42v2_startup (struct usb_serial *serial)
+{
+        struct cypress_private *priv;
+
+        dbg("%s", __FUNCTION__);
+
+        if (generic_startup(serial)) {
+                dbg("%s - Failed setting up port %d", __FUNCTION__,
+                                serial->port[0]->number);
+                return 1;
+        }
+
+        priv = usb_get_serial_port_data(serial->port[0]);
+        priv->chiptype = CT_CA42V2;
+
+        return 0;
+} /* cypress_ca42v2_startup */
+
+
 static void cypress_shutdown (struct usb_serial *serial)
 {
         struct cypress_private *priv;
@@ -944,6 +1003,10 @@ static void cypress_set_termios (struct usb_serial_port *port,
                         *(tty->termios) = tty_std_termios;
                         tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL |
                                 CLOCAL;
+                } else if (priv->chiptype == CT_CA42V2) {
+                        *(tty->termios) = tty_std_termios;
+                        tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL |
+                                CLOCAL;
                 }
                 priv->termios_initialized = 1;
         }
@@ -1542,6 +1605,9 @@ static int __init cypress_init(void)
         retval = usb_serial_register(&cypress_hidcom_device);
         if (retval)
                 goto failed_hidcom_register;
+        retval = usb_serial_register(&cypress_ca42v2_device);
+        if (retval)
+                goto failed_ca42v2_register;
         retval = usb_register(&cypress_driver);
         if (retval)
                 goto failed_usb_register;
@@ -1550,6 +1616,8 @@ static int __init cypress_init(void)
         return 0;
 failed_usb_register:
         usb_deregister(&cypress_driver);
+failed_ca42v2_register:
+        usb_serial_deregister(&cypress_ca42v2_device);
 failed_hidcom_register:
         usb_serial_deregister(&cypress_hidcom_device);
 failed_em_register:
@@ -1566,6 +1634,7 @@ static void __exit cypress_exit (void)
         usb_deregister (&cypress_driver);
         usb_serial_deregister (&cypress_earthmate_device);
         usb_serial_deregister (&cypress_hidcom_device);
+        usb_serial_deregister (&cypress_ca42v2_device);
 }
 
 
diff --git a/drivers/usb/serial/cypress_m8.h b/drivers/usb/serial/cypress_m8.h
index 1fa119efe41a..e1c7c27e18b7 100644
--- a/drivers/usb/serial/cypress_m8.h
+++ b/drivers/usb/serial/cypress_m8.h
@@ -18,6 +18,10 @@
 /* Cypress HID->COM RS232 Adapter */
 #define VENDOR_ID_CYPRESS                0x04b4
 #define PRODUCT_ID_CYPHIDCOM             0x5500
+
+/* Nokia CA-42 USB to serial cable */
+#define VENDOR_ID_DAZZLE                0x07d0
+#define PRODUCT_ID_CA42                 0x4101
 /* End of device listing */
 
 /* Used for setting / requesting serial line settings */
@@ -34,6 +38,7 @@
 
 #define CT_EARTHMATE    0x01
 #define CT_CYPHIDCOM    0x02
+#define CT_CA42V2       0x03
 #define CT_GENERIC      0x0F
 /* End of chiptype definitions */
 
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index c145e1ed8429..f3af81b4dd29 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -492,6 +492,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
+        { USB_DEVICE(ICOM_ID1_VID, ICOM_ID1_PID) },
         { },                                    /* Optional parameter entry */
         { }                                     /* Terminating entry */
 };
@@ -1141,12 +1142,11 @@ static int ftdi_sio_attach (struct usb_serial *serial)
         
         dbg("%s",__FUNCTION__);
 
-        priv = kmalloc(sizeof(struct ftdi_private), GFP_KERNEL);
+        priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
         if (!priv){
                 err("%s- kmalloc(%Zd) failed.", __FUNCTION__, sizeof(struct ftdi_private));
                 return -ENOMEM;
         }
-        memset(priv, 0, sizeof(*priv));
 
         spin_lock_init(&priv->rx_lock);
         init_waitqueue_head(&priv->delta_msr_wait);
diff --git a/drivers/usb/serial/ftdi_sio.h b/drivers/usb/serial/ftdi_sio.h
index bdef3b8c731f..8da773c2744d 100644
--- a/drivers/usb/serial/ftdi_sio.h
+++ b/drivers/usb/serial/ftdi_sio.h
@@ -146,6 +146,13 @@
 #define KOBIL_CONV_KAAN_PID     0x2021  /* KOBIL_Konverter for KAAN */
 
 /*
+ * Icom ID-1 digital transceiver
+ */
+
+#define ICOM_ID1_VID            0x0C26
+#define ICOM_ID1_PID            0x0004
+
+/*
  * DSS-20 Sync Station for Sony Ericsson P800
  */
  
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index d6f55e9dccae..5ec9bf5bac8d 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -1422,12 +1422,11 @@ static int garmin_attach (struct usb_serial *serial)
 
         dbg("%s", __FUNCTION__);
 
-        garmin_data_p = kmalloc (sizeof(struct garmin_data), GFP_KERNEL);
+        garmin_data_p = kzalloc(sizeof(struct garmin_data), GFP_KERNEL);
         if (garmin_data_p == NULL) {
                 dev_err(&port->dev, "%s - Out of memory\n", __FUNCTION__);
                 return -ENOMEM;
         }
-        memset (garmin_data_p, 0, sizeof(struct garmin_data));
         init_timer(&garmin_data_p->timer);
         spin_lock_init(&garmin_data_p->lock);
         INIT_LIST_HEAD(&garmin_data_p->pktlist);
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 3f29e6b0fd19..b606c5968102 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -2725,12 +2725,11 @@ static int edge_startup (struct usb_serial *serial)
         dev = serial->dev;
 
         /* create our private serial structure */
-        edge_serial = kmalloc (sizeof(struct edgeport_serial), GFP_KERNEL);
+        edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
         if (edge_serial == NULL) {
                 dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
                 return -ENOMEM;
         }
-        memset (edge_serial, 0, sizeof(struct edgeport_serial));
         spin_lock_init(&edge_serial->es_lock);
         edge_serial->serial = serial;
         usb_set_serial_data(serial, edge_serial);
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index afc0f34b3a46..8e1e2253748b 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -2727,12 +2727,11 @@ static int edge_startup (struct usb_serial *serial)
         dev = serial->dev;
 
         /* create our private serial structure */
-        edge_serial = kmalloc (sizeof(struct edgeport_serial), GFP_KERNEL);
+        edge_serial = kzalloc(sizeof(struct edgeport_serial), GFP_KERNEL);
         if (edge_serial == NULL) {
                 dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
                 return -ENOMEM;
         }
-        memset (edge_serial, 0, sizeof(struct edgeport_serial));
         sema_init(&edge_serial->es_sem, 1);
         edge_serial->serial = serial;
         usb_set_serial_data(serial, edge_serial);
@@ -2745,12 +2744,11 @@ static int edge_startup (struct usb_serial *serial)
 
         /* set up our port private structures */
         for (i = 0; i < serial->num_ports; ++i) {
-                edge_port = kmalloc (sizeof(struct edgeport_port), GFP_KERNEL);
+                edge_port = kzalloc(sizeof(struct edgeport_port), GFP_KERNEL);
                 if (edge_port == NULL) {
                         dev_err(&serial->dev->dev, "%s - Out of memory\n", __FUNCTION__);
                         goto cleanup;
                 }
-                memset (edge_port, 0, sizeof(struct edgeport_port));
                 spin_lock_init(&edge_port->ep_lock);
                 edge_port->ep_out_buf = edge_buf_alloc(EDGE_OUT_BUF_SIZE);
                 if (edge_port->ep_out_buf == NULL) {
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index a59010421444..426182ddc42a 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -184,10 +184,9 @@ static struct irda_class_desc *irda_usb_find_class_desc(struct usb_device *dev,
         struct irda_class_desc *desc;
         int ret;
                 
-        desc = kmalloc(sizeof (struct irda_class_desc), GFP_KERNEL);
+        desc = kzalloc(sizeof (struct irda_class_desc), GFP_KERNEL);
         if (desc == NULL) 
                 return NULL;
-        memset(desc, 0, sizeof(struct irda_class_desc));
         
         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev,0),
                         IU_REQ_GET_CLASS_DESC,
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 3b958e60f5e8..052b735c4fbd 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -2250,12 +2250,11 @@ static int keyspan_startup (struct usb_serial *serial)
         }
 
         /* Setup private data for serial driver */
-        s_priv = kmalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
+        s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
         if (!s_priv) {
                 dbg("%s - kmalloc for keyspan_serial_private failed.", __FUNCTION__);
                 return -ENOMEM;
         }
-        memset(s_priv, 0, sizeof(struct keyspan_serial_private));
 
         s_priv->device_details = d_details;
         usb_set_serial_data(serial, s_priv);
@@ -2263,12 +2262,11 @@ static int keyspan_startup (struct usb_serial *serial)
         /* Now setup per port private data */
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                p_priv = kmalloc(sizeof(struct keyspan_port_private), GFP_KERNEL);
+                p_priv = kzalloc(sizeof(struct keyspan_port_private), GFP_KERNEL);
                 if (!p_priv) {
                         dbg("%s - kmalloc for keyspan_port_private (%d) failed!.", __FUNCTION__, i);
                         return (1);
                 }
-                memset(p_priv, 0, sizeof(struct keyspan_port_private));
                 p_priv->device_details = d_details;
                 usb_set_serial_port_data(port, p_priv);
         }
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index b8b213185d0f..87dfcd89ffab 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -255,11 +255,9 @@ static int kobil_open (struct usb_serial_port *port, struct file *filp)
         }
         
         // allocate memory for transfer buffer
-        transfer_buffer = (unsigned char *) kmalloc(transfer_buffer_length, GFP_KERNEL);  
+        transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
         if (! transfer_buffer) {
                 return -ENOMEM;
-        } else {
-                memset(transfer_buffer, 0, transfer_buffer_length);
         }
         
         // allocate write_urb
@@ -383,11 +381,10 @@ static void kobil_read_int_callback( struct urb *purb, struct pt_regs *regs)
                 
                 // BEGIN DEBUG
                 /*
-                  dbg_data = (unsigned char *) kmalloc((3 *  purb->actual_length + 10) * sizeof(char), GFP_KERNEL);
+                  dbg_data = kzalloc((3 *  purb->actual_length + 10) * sizeof(char), GFP_KERNEL);
                   if (! dbg_data) {
                   return;
                   }
-                  memset(dbg_data, 0, (3 *  purb->actual_length + 10));
                   for (i = 0; i < purb->actual_length; i++) { 
                   sprintf(dbg_data +3*i, "%02X ", data[i]); 
                   }
@@ -518,11 +515,10 @@ static int kobil_tiocmget(struct usb_serial_port *port, struct file *file)
         }
 
         // allocate memory for transfer buffer
-        transfer_buffer = (unsigned char *) kmalloc(transfer_buffer_length, GFP_KERNEL);  
+        transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
         if (!transfer_buffer) {
                 return -ENOMEM;
         }
-        memset(transfer_buffer, 0, transfer_buffer_length);
 
         result = usb_control_msg( port->serial->dev, 
                                   usb_rcvctrlpipe(port->serial->dev, 0 ), 
@@ -564,11 +560,10 @@ static int  kobil_tiocmset(struct usb_serial_port *port, struct file *file,
         }
 
         // allocate memory for transfer buffer
-        transfer_buffer = (unsigned char *) kmalloc(transfer_buffer_length, GFP_KERNEL);
+        transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
         if (! transfer_buffer) {
                 return -ENOMEM;
         }
-        memset(transfer_buffer, 0, transfer_buffer_length);
 
         if (set & TIOCM_RTS)
                 rts = 1;
@@ -655,11 +650,10 @@ static int  kobil_ioctl(struct usb_serial_port *port, struct file *file,
                                                    (struct termios __user *)arg))
                         return -EFAULT;
                 
-                settings = (unsigned char *) kmalloc(50, GFP_KERNEL);  
+                settings = kzalloc(50, GFP_KERNEL);
                 if (! settings) {
                         return -ENOBUFS;
                 }
-                memset(settings, 0, 50);
 
                 switch (priv->internal_termios.c_cflag & CBAUD) {
                 case B1200:
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index b6d6cab9c859..35bd29b6c408 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -348,10 +348,9 @@ static int mct_u232_startup (struct usb_serial *serial)
         struct mct_u232_private *priv;
         struct usb_serial_port *port, *rport;
 
-        priv = kmalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
+        priv = kzalloc(sizeof(struct mct_u232_private), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
-        memset(priv, 0, sizeof(struct mct_u232_private));
         spin_lock_init(&priv->lock);
         usb_set_serial_port_data(serial->port[0], priv);
 
diff --git a/drivers/usb/serial/navman.c b/drivers/usb/serial/navman.c
new file mode 100644
index 000000000000..7f544081032e
--- /dev/null
+++ b/drivers/usb/serial/navman.c
@@ -0,0 +1,157 @@
+/*
+ * Navman Serial USB driver
+ *
+ * Copyright (C) 2006 Greg Kroah-Hartman <gregkh@suse.de>
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License
+ *      version 2 as published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/tty.h>
+#include <linux/tty_flip.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include "usb-serial.h"
+
+static int debug;
+
+static struct usb_device_id id_table [] = {
+        { USB_DEVICE(0x0a99, 0x0001) }, /* Talon Technology device */
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+static struct usb_driver navman_driver = {
+        .name =         "navman",
+        .probe =        usb_serial_probe,
+        .disconnect =   usb_serial_disconnect,
+        .id_table =     id_table,
+        .no_dynamic_id =        1,
+};
+
+static void navman_read_int_callback(struct urb *urb, struct pt_regs *regs)
+{
+        struct usb_serial_port *port = urb->context;
+        unsigned char *data = urb->transfer_buffer;
+        struct tty_struct *tty;
+        int result;
+
+        switch (urb->status) {
+        case 0:
+                /* success */
+                break;
+        case -ECONNRESET:
+        case -ENOENT:
+        case -ESHUTDOWN:
+                /* this urb is terminated, clean up */
+                dbg("%s - urb shutting down with status: %d",
+                    __FUNCTION__, urb->status);
+                return;
+        default:
+                dbg("%s - nonzero urb status received: %d",
+                    __FUNCTION__, urb->status);
+                goto exit;
+        }
+
+        usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
+                              urb->actual_length, data);
+
+        tty = port->tty;
+        if (tty && urb->actual_length) {
+                tty_buffer_request_room(tty, urb->actual_length);
+                tty_insert_flip_string(tty, data, urb->actual_length);
+                tty_flip_buffer_push(tty);
+        }
+
+exit:
+        result = usb_submit_urb(urb, GFP_ATOMIC);
+        if (result)
+                dev_err(&urb->dev->dev,
+                        "%s - Error %d submitting interrupt urb\n",
+                        __FUNCTION__, result);
+}
+
+static int navman_open(struct usb_serial_port *port, struct file *filp)
+{
+        int result = 0;
+
+        dbg("%s - port %d", __FUNCTION__, port->number);
+
+        if (port->interrupt_in_urb) {
+                dbg("%s - adding interrupt input for treo", __FUNCTION__);
+                result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
+                if (result)
+                        dev_err(&port->dev,
+                                "%s - failed submitting interrupt urb, error %d\n",
+                                __FUNCTION__, result);
+        }
+        return result;
+}
+
+static void navman_close(struct usb_serial_port *port, struct file *filp)
+{
+        dbg("%s - port %d", __FUNCTION__, port->number);
+
+        if (port->interrupt_in_urb)
+                usb_kill_urb(port->interrupt_in_urb);
+}
+
+static int navman_write(struct usb_serial_port *port,
+                        const unsigned char *buf, int count)
+{
+        dbg("%s - port %d", __FUNCTION__, port->number);
+
+        /*
+         * This device can't write any data, only read from the device
+         * so we just silently eat all data sent to us and say it was
+         * successfully sent.
+         * Evil, I know, but do you have a better idea?
+         */
+
+        return count;
+}
+
+static struct usb_serial_driver navman_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "navman",
+        },
+        .id_table =             id_table,
+        .num_interrupt_in =     NUM_DONT_CARE,
+        .num_bulk_in =          NUM_DONT_CARE,
+        .num_bulk_out =         NUM_DONT_CARE,
+        .num_ports =            1,
+        .open =                 navman_open,
+        .close =                navman_close,
+        .write =                navman_write,
+        .read_int_callback =    navman_read_int_callback,
+};
+
+static int __init navman_init(void)
+{
+        int retval;
+
+        retval = usb_serial_register(&navman_device);
+        if (retval)
+                return retval;
+        retval = usb_register(&navman_driver);
+        if (retval)
+                usb_serial_deregister(&navman_device);
+        return retval;
+}
+
+static void __exit navman_exit(void)
+{
+        usb_deregister(&navman_driver);
+        usb_serial_deregister(&navman_device);
+}
+
+module_init(navman_init);
+module_exit(navman_exit);
+MODULE_LICENSE("GPL");
+
+module_param(debug, bool, S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 762d8ff9a1e4..4d40704dea2c 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -204,7 +204,7 @@ static void omninet_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
         int i;
         int result;
 
-//      dbg("omninet_read_bulk_callback");
+        dbg("%s - port %d", __FUNCTION__, port->number);
 
         if (urb->status) {
                 dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, urb->status);
@@ -250,7 +250,7 @@ static int omninet_write (struct usb_serial_port *port, const unsigned char *buf
 
         int                     result;
 
-//      dbg("omninet_write port %d", port->number);
+        dbg("%s - port %d", __FUNCTION__, port->number);
 
         if (count == 0) {
                 dbg("%s - write request of 0 bytes", __FUNCTION__);
@@ -302,7 +302,7 @@ static int omninet_write_room (struct usb_serial_port *port)
         if (wport->write_urb_busy)
                 room = wport->bulk_out_size - OMNINET_HEADERLEN;
 
-//      dbg("omninet_write_room returns %d", room);
+        dbg("%s - returns %d", __FUNCTION__, room);
 
         return (room);
 }
@@ -312,7 +312,7 @@ static void omninet_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
 /*      struct omninet_header   *header = (struct omninet_header  *) urb->transfer_buffer; */
         struct usb_serial_port  *port   = (struct usb_serial_port *) urb->context;
 
-//      dbg("omninet_write_bulk_callback, port %0x\n", port);
+        dbg("%s - port %0x\n", __FUNCTION__, port->number);
 
         port->write_urb_busy = 0;
         if (urb->status) {
@@ -321,8 +321,6 @@ static void omninet_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
         }
 
         schedule_work(&port->work);
-
-//      dbg("omninet_write_bulk_callback, tty %0x\n", tty);
 }
 
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 52bdf6fe46f2..a8455c9e79dd 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -631,13 +631,12 @@ static int option_startup(struct usb_serial *serial)
         /* Now setup per port private data */
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
-                portdata = kmalloc(sizeof(*portdata), GFP_KERNEL);
+                portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
                 if (!portdata) {
                         dbg("%s: kmalloc for option_port_private (%d) failed!.",
                                         __FUNCTION__, i);
                         return (1);
                 }
-                memset(portdata, 0, sizeof(struct option_port_private));
 
                 usb_set_serial_port_data(port, portdata);
 
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 37c81c08faad..b3014fda645c 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -77,6 +77,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
         { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
         { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
+        { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
         { }                                     /* Terminating entry */
 };
 
@@ -218,10 +219,9 @@ static int pl2303_startup (struct usb_serial *serial)
         dbg("device type: %d", type);
 
         for (i = 0; i < serial->num_ports; ++i) {
-                priv = kmalloc (sizeof (struct pl2303_private), GFP_KERNEL);
+                priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
                 if (!priv)
                         goto cleanup;
-                memset (priv, 0x00, sizeof (struct pl2303_private));
                 spin_lock_init(&priv->lock);
                 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
                 if (priv->buf == NULL) {
@@ -383,12 +383,11 @@ static void pl2303_set_termios (struct usb_serial_port *port, struct termios *ol
                 }
         }
 
-        buf = kmalloc (7, GFP_KERNEL);
+        buf = kzalloc (7, GFP_KERNEL);
         if (!buf) {
                 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
                 return;
         }
-        memset (buf, 0x00, 0x07);
         
         i = usb_control_msg (serial->dev, usb_rcvctrlpipe (serial->dev, 0),
                              GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
@@ -828,6 +827,7 @@ static void pl2303_update_line_status(struct usb_serial_port *port,
         spin_lock_irqsave(&priv->lock, flags);
         priv->line_status = data[status_idx];
         spin_unlock_irqrestore(&priv->lock, flags);
+        wake_up_interruptible (&priv->delta_msr_wait);
 
 exit:
         return;
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index 9bc4755162ad..77901d143979 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -75,3 +75,7 @@
 /* Leadtek GPS 9531 (ID 0413:2101) */
 #define LEADTEK_VENDOR_ID       0x0413
 #define LEADTEK_9531_PRODUCT_ID 0x2101
+
+/* USB GSM cable from Speed Dragon Multimedia, Ltd */
+#define SPEEDDRAGON_VENDOR_ID   0x0e55
+#define SPEEDDRAGON_PRODUCT_ID  0x110b
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index c18db3257073..c3a2071b802d 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -416,12 +416,11 @@ static int ti_startup(struct usb_serial *serial)
             dev->actconfig->desc.bConfigurationValue);
 
         /* create device structure */
-        tdev = kmalloc(sizeof(struct ti_device), GFP_KERNEL);
+        tdev = kzalloc(sizeof(struct ti_device), GFP_KERNEL);
         if (tdev == NULL) {
                 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
                 return -ENOMEM;
         }
-        memset(tdev, 0, sizeof(struct ti_device));
         sema_init(&tdev->td_open_close_sem, 1);
         tdev->td_serial = serial;
         usb_set_serial_data(serial, tdev);
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index b5c96e74a903..097f4e8488fe 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -564,12 +564,11 @@ static struct usb_serial * create_serial (struct usb_device *dev,
 {
         struct usb_serial *serial;
 
-        serial = kmalloc (sizeof (*serial), GFP_KERNEL);
+        serial = kzalloc(sizeof(*serial), GFP_KERNEL);
         if (!serial) {
                 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
                 return NULL;
         }
-        memset (serial, 0, sizeof(*serial));
         serial->dev = usb_get_dev(dev);
         serial->type = driver;
         serial->interface = interface;
@@ -778,10 +777,9 @@ int usb_serial_probe(struct usb_interface *interface,
         serial->num_port_pointers = max_endpoints;
         dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
         for (i = 0; i < max_endpoints; ++i) {
-                port = kmalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
+                port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
                 if (!port)
                         goto probe_error;
-                memset(port, 0x00, sizeof(struct usb_serial_port));
                 port->number = i + serial->minor;
                 port->serial = serial;
                 spin_lock_init(&port->lock);
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index 11a48d874752..f5c3841d4843 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -763,10 +763,9 @@ static int generic_startup(struct usb_serial *serial)
         int i;
 
         for (i = 0; i < serial->num_ports; ++i) {
-                priv = kmalloc (sizeof(*priv), GFP_KERNEL);
+                priv = kzalloc (sizeof(*priv), GFP_KERNEL);
                 if (!priv)
                         return -ENOMEM;
-                memset (priv, 0x00, sizeof(*priv));
                 spin_lock_init(&priv->lock);
                 usb_set_serial_port_data(serial->port[i], priv);
         }