Merge branch 'master' of /home/cbou/linux-2.6

Conflicts:

	drivers/power/Kconfig
	drivers/power/Makefile

1 files changed, 190 insertions, 210 deletions

diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 8ce5a56a48e3..2e663f1afd5e 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -33,7 +33,7 @@
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <asm/atomic.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
@@ -44,7 +44,7 @@
 static int initial_mode = 1;
 
 /* debug flag */
-static int debug = 0;
+static int debug;
 
 #define GARMIN_VENDOR_ID             0x091E
 
@@ -56,7 +56,7 @@ static int debug = 0;
 #define VERSION_MINOR   31
 
 #define _STR(s) #s
-#define _DRIVER_VERSION(a,b) "v" _STR(a) "." _STR(b)
+#define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b)
 #define DRIVER_VERSION _DRIVER_VERSION(VERSION_MAJOR, VERSION_MINOR)
 #define DRIVER_AUTHOR "hermann kneissel"
 #define DRIVER_DESC "garmin gps driver"
@@ -65,37 +65,37 @@ static int debug = 0;
 #define EINVPKT 1000    /* invalid packet structure */
 
 
-// size of the header of a packet using the usb protocol
+/* size of the header of a packet using the usb protocol */
 #define GARMIN_PKTHDR_LENGTH    12
 
-// max. possible size of a packet using the serial protocol 
-#define MAX_SERIAL_PKT_SIZ (3+255+3)
+/* max. possible size of a packet using the serial protocol */
+#define MAX_SERIAL_PKT_SIZ (3 + 255 + 3)
 
-// max. possible size of a packet with worst case stuffing
-#define MAX_SERIAL_PKT_SIZ_STUFFED MAX_SERIAL_PKT_SIZ+256
+/*  max. possible size of a packet with worst case stuffing */
+#define MAX_SERIAL_PKT_SIZ_STUFFED (MAX_SERIAL_PKT_SIZ + 256)
 
-// size of a buffer able to hold a complete (no stuffing) packet
-// (the document protocol does not contain packets with a larger
-//  size, but in theory a packet may be 64k+12 bytes - if in
-//  later protocol versions larger packet sizes occur, this value
-//  should be increased accordingly, so the input buffer is always 
-//  large enough the store a complete packet inclusive header)
-#define GPS_IN_BUFSIZ  (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ) 
+/* size of a buffer able to hold a complete (no stuffing) packet
+ * (the document protocol does not contain packets with a larger
+ *  size, but in theory a packet may be 64k+12 bytes - if in
+ *  later protocol versions larger packet sizes occur, this value
+ *  should be increased accordingly, so the input buffer is always
+ *  large enough the store a complete packet inclusive header) */
+#define GPS_IN_BUFSIZ  (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ)
 
-// size of a buffer able to hold a complete (incl. stuffing) packet
-#define GPS_OUT_BUFSIZ (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ_STUFFED) 
+/* size of a buffer able to hold a complete (incl. stuffing) packet */
+#define GPS_OUT_BUFSIZ (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ_STUFFED)
 
-// where to place the packet id of a serial packet, so we can
-// prepend the usb-packet header without the need to move the
-// packets data
+/* where to place the packet id of a serial packet, so we can
+ * prepend the usb-packet header without the need to move the
+ * packets data */
 #define GSP_INITIAL_OFFSET (GARMIN_PKTHDR_LENGTH-2)
 
-// max. size of incoming private packets (header+1 param)
+/* max. size of incoming private packets (header+1 param) */
 #define PRIVPKTSIZ (GARMIN_PKTHDR_LENGTH+4)
 
 #define GARMIN_LAYERID_TRANSPORT  0
 #define GARMIN_LAYERID_APPL      20
-// our own layer-id to use for some control mechanisms
+/* our own layer-id to use for some control mechanisms */
 #define GARMIN_LAYERID_PRIVATE  0x01106E4B
 
 #define GARMIN_PKTID_PVT_DATA   51
@@ -103,7 +103,7 @@ static int debug = 0;
 
 #define CMND_ABORT_TRANSFER 0
 
-// packet ids used in private layer
+/* packet ids used in private layer */
 #define PRIV_PKTID_SET_DEBUG    1
 #define PRIV_PKTID_SET_MODE     2
 #define PRIV_PKTID_INFO_REQ     3
@@ -121,7 +121,8 @@ static int debug = 0;
 struct garmin_packet {
         struct list_head  list;
         int               seq;
-        int               size; // the real size of the data array, always > 0
+        /* the real size of the data array, always > 0 */
+        int               size;
         __u8              data[1];
 };
 
@@ -164,7 +165,7 @@ struct garmin_data {
 #define MODE_NATIVE          0
 #define MODE_GARMIN_SERIAL   1
 
-// Flags used in garmin_data.flags:
+/* Flags used in garmin_data.flags: */
 #define FLAGS_SESSION_REPLY_MASK  0x00C0
 #define FLAGS_SESSION_REPLY1_SEEN 0x0080
 #define FLAGS_SESSION_REPLY2_SEEN 0x0040
@@ -185,7 +186,7 @@ struct garmin_data {
 
 
 /* function prototypes */
-static void gsp_next_packet(struct garmin_data * garmin_data_p);
+static void gsp_next_packet(struct garmin_data *garmin_data_p);
 static int  garmin_write_bulk(struct usb_serial_port *port,
                              const unsigned char *buf, int count,
                              int dismiss_ack);
@@ -217,12 +218,13 @@ static unsigned char const PRIVATE_REQ[]
 
 
 static struct usb_device_id id_table [] = {
-        /* the same device id seems to be used by all usb enabled gps devices */
-        { USB_DEVICE(GARMIN_VENDOR_ID, 3 ) },
+        /* the same device id seems to be used by all
+           usb enabled GPS devices */
+        { USB_DEVICE(GARMIN_VENDOR_ID, 3) },
         { }                                     /* Terminating entry */
 };
 
-MODULE_DEVICE_TABLE (usb, id_table);
+MODULE_DEVICE_TABLE(usb, id_table);
 
 static struct usb_driver garmin_driver = {
         .name =         "garmin_gps",
@@ -233,9 +235,10 @@ static struct usb_driver garmin_driver = {
 };
 
 
-static inline int noResponseFromAppLayer(struct garmin_data * garmin_data_p)
+static inline int noResponseFromAppLayer(struct garmin_data *garmin_data_p)
 {
-        return atomic_read(&garmin_data_p->req_count) == atomic_read(&garmin_data_p->resp_count);
+        return atomic_read(&garmin_data_p->req_count) ==
+                                atomic_read(&garmin_data_p->resp_count);
 }
 
 
@@ -261,10 +264,10 @@ static inline int getDataLength(const __u8 *usbPacket)
  */
 static inline int isAbortTrfCmnd(const unsigned char *buf)
 {
-        if (0 == memcmp(buf, GARMIN_STOP_TRANSFER_REQ, 
-                        sizeof(GARMIN_STOP_TRANSFER_REQ)) ||
-            0 == memcmp(buf, GARMIN_STOP_TRANSFER_REQ_V2, 
-                        sizeof(GARMIN_STOP_TRANSFER_REQ_V2)))
+        if (0 == memcmp(buf, GARMIN_STOP_TRANSFER_REQ,
+                                        sizeof(GARMIN_STOP_TRANSFER_REQ)) ||
+            0 == memcmp(buf, GARMIN_STOP_TRANSFER_REQ_V2,
+                                        sizeof(GARMIN_STOP_TRANSFER_REQ_V2)))
                 return 1;
         else
                 return 0;
@@ -275,11 +278,11 @@ static inline int isAbortTrfCmnd(const unsigned char *buf)
 static void send_to_tty(struct usb_serial_port *port,
                         char *data, unsigned int actual_length)
 {
-        struct tty_struct *tty = port->tty;
+        struct tty_struct *tty = port->port.tty;
 
         if (tty && actual_length) {
 
-                usb_serial_debug_data(debug, &port->dev, 
+                usb_serial_debug_data(debug, &port->dev,
                                         __func__, actual_length, data);
 
                 tty_buffer_request_room(tty, actual_length);
@@ -296,7 +299,7 @@ static void send_to_tty(struct usb_serial_port *port,
 /*
  * queue a received (usb-)packet for later processing
  */
-static int pkt_add(struct garmin_data * garmin_data_p,
+static int pkt_add(struct garmin_data *garmin_data_p,
                    unsigned char *data, unsigned int data_length)
 {
         int state = 0;
@@ -307,7 +310,7 @@ static int pkt_add(struct garmin_data * garmin_data_p,
         /* process only packets containg data ... */
         if (data_length) {
                 pkt = kmalloc(sizeof(struct garmin_packet)+data_length,
-                              GFP_ATOMIC);
+                                                                GFP_ATOMIC);
                 if (pkt == NULL) {
                         dev_err(&garmin_data_p->port->dev, "out of memory\n");
                         return 0;
@@ -325,16 +328,15 @@ static int pkt_add(struct garmin_data * garmin_data_p,
 
                 /* in serial mode, if someone is waiting for data from
                    the device, iconvert and send the next packet to tty. */
-                if (result && (state == STATE_GSP_WAIT_DATA)) {
+                if (result && (state == STATE_GSP_WAIT_DATA))
                         gsp_next_packet(garmin_data_p);
-                }
         }
         return result;
 }
 
 
 /* get the next pending packet */
-static struct garmin_packet *pkt_pop(struct garmin_data * garmin_data_p)
+static struct garmin_packet *pkt_pop(struct garmin_data *garmin_data_p)
 {
         unsigned long flags;
         struct garmin_packet *result = NULL;
@@ -350,7 +352,7 @@ static struct garmin_packet *pkt_pop(struct garmin_data * garmin_data_p)
 
 
 /* free up all queued data */
-static void pkt_clear(struct garmin_data * garmin_data_p)
+static void pkt_clear(struct garmin_data *garmin_data_p)
 {
         unsigned long flags;
         struct garmin_packet *result = NULL;
@@ -372,7 +374,7 @@ static void pkt_clear(struct garmin_data * garmin_data_p)
  ******************************************************************************/
 
 /* send an ack packet back to the tty */
-static int gsp_send_ack(struct garmin_data * garmin_data_p, __u8 pkt_id)
+static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
 {
         __u8 pkt[10];
         __u8 cksum = 0;
@@ -391,9 +393,8 @@ static int gsp_send_ack(struct garmin_data * garmin_data_p, __u8 pkt_id)
         *ptr++ = pkt_id;
         cksum += pkt_id;
 
-        if (pkt_id == DLE) {
+        if (pkt_id == DLE)
                 *ptr++ = DLE;
-        }
 
         *ptr++ = 0;
         *ptr++ = 0xFF & (-cksum);
@@ -415,12 +416,12 @@ static int gsp_send_ack(struct garmin_data * garmin_data_p, __u8 pkt_id)
  * at GSP_INITIAL_OFFSET.
  *
  * count - number of bytes in the input buffer including space reserved for
- *         the usb header: GSP_INITIAL_OFFSET + number of bytes in packet 
+ *         the usb header: GSP_INITIAL_OFFSET + number of bytes in packet
  *         (including pkt-id, data-length a. cksum)
  */
-static int gsp_rec_packet(struct garmin_data * garmin_data_p, int count)
+static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
 {
-        const __u8* recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
+        const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
         __le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
 
         int cksum = 0;
@@ -440,8 +441,8 @@ static int gsp_rec_packet(struct garmin_data * garmin_data_p, int count)
         cksum += *recpkt++;
         cksum += *recpkt++;
 
-        // sanity check, remove after test ...
-        if ((__u8*)&(usbdata[3]) != recpkt) {
+        /* sanity check, remove after test ... */
+        if ((__u8 *)&(usbdata[3]) != recpkt) {
                 dbg("%s - ptr mismatch %p - %p",
                         __func__, &(usbdata[4]), recpkt);
                 return -EINVPKT;
@@ -462,7 +463,7 @@ static int gsp_rec_packet(struct garmin_data * garmin_data_p, int count)
         usbdata[1] = __cpu_to_le32(pktid);
         usbdata[2] = __cpu_to_le32(size);
 
-        garmin_write_bulk (garmin_data_p->port, garmin_data_p->inbuffer,
+        garmin_write_bulk(garmin_data_p->port, garmin_data_p->inbuffer,
                            GARMIN_PKTHDR_LENGTH+size, 0);
 
         /* if this was an abort-transfer command, flush all
@@ -495,7 +496,7 @@ static int gsp_rec_packet(struct garmin_data * garmin_data_p, int count)
  * if the input is an abort command, drop all queued data.
  */
 
-static int gsp_receive(struct garmin_data * garmin_data_p,
+static int gsp_receive(struct garmin_data *garmin_data_p,
                        const unsigned char *buf, int count)
 {
         unsigned long flags;
@@ -504,10 +505,11 @@ static int gsp_receive(struct garmin_data * garmin_data_p,
         int i = 0;
         __u8 *dest;
         int size;
-        // dleSeen: set if last byte read was a DLE
+        /* dleSeen: set if last byte read was a DLE */
         int dleSeen;
-        // skip: if set, skip incoming data until possible start of
-        //       new packet
+        /* skip: if set, skip incoming data until possible start of
+         *       new packet
+         */
         int skip;
         __u8 data;
 
@@ -521,14 +523,13 @@ static int gsp_receive(struct garmin_data * garmin_data_p,
         dbg("%s - dle=%d skip=%d size=%d count=%d",
                 __func__, dleSeen, skip, size, count);
 
-        if (size == 0) {
+        if (size == 0)
                 size = GSP_INITIAL_OFFSET;
-        }
 
         while (offs < count) {
 
                 data = *(buf+offs);
-                offs ++;
+                offs++;
 
                 if (data == DLE) {
                         if (skip) { /* start of a new pkt */
@@ -554,9 +555,8 @@ static int gsp_receive(struct garmin_data * garmin_data_p,
                                         ack_or_nak_seen = NAK;
                                         dbg("NAK packet complete.");
                                 } else {
-                                        dbg("packet complete "
-                                                        "- id=0x%X.",
-                                                        0xFF & data);
+                                        dbg("packet complete - id=0x%X.",
+                                                0xFF & data);
                                         gsp_rec_packet(garmin_data_p, size);
                                 }
 
@@ -589,7 +589,7 @@ static int gsp_receive(struct garmin_data * garmin_data_p,
 
         garmin_data_p->insize = size;
 
-        // copy flags back to structure
+        /* copy flags back to structure */
         if (skip)
                 garmin_data_p->flags |= FLAGS_GSP_SKIP;
         else
@@ -600,16 +600,13 @@ static int gsp_receive(struct garmin_data * garmin_data_p,
         else
                 garmin_data_p->flags &= ~FLAGS_GSP_DLESEEN;
 
-        if (ack_or_nak_seen) {
+        if (ack_or_nak_seen)
                 garmin_data_p->state = STATE_GSP_WAIT_DATA;
-        }
 
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
-        if (ack_or_nak_seen) {
+        if (ack_or_nak_seen)
                 gsp_next_packet(garmin_data_p);
-        }
-
         return count;
 }
 
@@ -623,7 +620,7 @@ static int gsp_receive(struct garmin_data * garmin_data_p,
  *
  * return <0 on error, 0 if packet is incomplete or > 0 if packet was sent
  */
-static int gsp_send(struct garmin_data * garmin_data_p,
+static int gsp_send(struct garmin_data *garmin_data_p,
                     const unsigned char *buf, int count)
 {
         const unsigned char *src;
@@ -631,11 +628,11 @@ static int gsp_send(struct garmin_data * garmin_data_p,
         int pktid = 0;
         int datalen = 0;
         int cksum = 0;
-        int i=0;
+        int i = 0;
         int k;
 
         dbg("%s - state %d - %d bytes.", __func__,
-                 garmin_data_p->state, count);
+                                        garmin_data_p->state, count);
 
         k = garmin_data_p->outsize;
         if ((k+count) > GPS_OUT_BUFSIZ) {
@@ -650,7 +647,7 @@ static int gsp_send(struct garmin_data * garmin_data_p,
 
         if (k >= GARMIN_PKTHDR_LENGTH) {
                 pktid  = getPacketId(garmin_data_p->outbuffer);
-                datalen= getDataLength(garmin_data_p->outbuffer);
+                datalen = getDataLength(garmin_data_p->outbuffer);
                 i = GARMIN_PKTHDR_LENGTH + datalen;
                 if (k < i)
                         return 0;
@@ -658,19 +655,18 @@ static int gsp_send(struct garmin_data * garmin_data_p,
                 return 0;
         }
 
-        dbg("%s - %d bytes in buffer, %d bytes in pkt.", __func__,
-                 k, i);
+        dbg("%s - %d bytes in buffer, %d bytes in pkt.", __func__, k, i);
 
         /* garmin_data_p->outbuffer now contains a complete packet */
 
         usb_serial_debug_data(debug, &garmin_data_p->port->dev,
-                                   __func__, k, garmin_data_p->outbuffer);
+                                __func__, k, garmin_data_p->outbuffer);
 
         garmin_data_p->outsize = 0;
 
         if (GARMIN_LAYERID_APPL != getLayerId(garmin_data_p->outbuffer)) {
-                dbg("not an application packet (%d)", 
-                        getLayerId(garmin_data_p->outbuffer));
+                dbg("not an application packet (%d)",
+                                getLayerId(garmin_data_p->outbuffer));
                 return -1;
         }
 
@@ -688,14 +684,14 @@ static int gsp_send(struct garmin_data * garmin_data_p,
 
         k = 0;
         src = garmin_data_p->outbuffer+GARMIN_PKTHDR_LENGTH;
-        for (i=0; i<datalen; i++) {
+        for (i = 0; i < datalen; i++) {
                 if (*src++ == DLE)
                         k++;
         }
 
         src = garmin_data_p->outbuffer+GARMIN_PKTHDR_LENGTH;
         if (k > (GARMIN_PKTHDR_LENGTH-2)) {
-                /* can't add stuffing DLEs in place, move data to end 
+                /* can't add stuffing DLEs in place, move data to end
                    of buffer ... */
                 dst = garmin_data_p->outbuffer+GPS_OUT_BUFSIZ-datalen;
                 memcpy(dst, src, datalen);
@@ -712,14 +708,14 @@ static int gsp_send(struct garmin_data * garmin_data_p,
         if (datalen == DLE)
                 *dst++ = DLE;
 
-        for (i=0; i<datalen; i++) {
+        for (i = 0; i < datalen; i++) {
                 __u8 c = *src++;
                 *dst++ = c;
                 cksum += c;
                 if (c == DLE)
                         *dst++ = DLE;
         }
-                
+
         cksum = 0xFF & -cksum;
         *dst++ = cksum;
         if (cksum == DLE)
@@ -744,7 +740,7 @@ static int gsp_send(struct garmin_data * garmin_data_p,
 /*
  * Process the next pending data packet - if there is one
  */
-static void gsp_next_packet(struct garmin_data * garmin_data_p)
+static void gsp_next_packet(struct garmin_data *garmin_data_p)
 {
         struct garmin_packet *pkt = NULL;
 
@@ -774,17 +770,17 @@ static void gsp_next_packet(struct garmin_data * garmin_data_p)
  * buf contains the data read, it may span more than one packet
  * or even incomplete packets
  */
-static int nat_receive(struct garmin_data * garmin_data_p,
+static int nat_receive(struct garmin_data *garmin_data_p,
                        const unsigned char *buf, int count)
 {
         unsigned long flags;
-        __u8 * dest;
+        __u8 *dest;
         int offs = 0;
         int result = count;
         int len;
 
         while (offs < count) {
-                // if buffer contains header, copy rest of data
+                /* if buffer contains header, copy rest of data */
                 if (garmin_data_p->insize >= GARMIN_PKTHDR_LENGTH)
                         len = GARMIN_PKTHDR_LENGTH
                               +getDataLength(garmin_data_p->inbuffer);
@@ -792,9 +788,9 @@ static int nat_receive(struct garmin_data * garmin_data_p,
                         len = GARMIN_PKTHDR_LENGTH;
 
                 if (len >= GPS_IN_BUFSIZ) {
-                        /* seem to be an invalid packet, ignore rest of input */
-                        dbg("%s - packet size too large: %d",
-                                __func__, len);
+                        /* seems to be an invalid packet, ignore rest
+                           of input */
+                        dbg("%s - packet size too large: %d", __func__, len);
                         garmin_data_p->insize = 0;
                         count = 0;
                         result = -EINVPKT;
@@ -804,7 +800,7 @@ static int nat_receive(struct garmin_data * garmin_data_p,
                                 len = (count-offs);
                         if (len > 0) {
                                 dest = garmin_data_p->inbuffer
-                                        +garmin_data_p->insize;
+                                                + garmin_data_p->insize;
                                 memcpy(dest, buf+offs, len);
                                 garmin_data_p->insize += len;
                                 offs += len;
@@ -816,17 +812,19 @@ static int nat_receive(struct garmin_data * garmin_data_p,
                         len = GARMIN_PKTHDR_LENGTH+
                            getDataLength(garmin_data_p->inbuffer);
                         if (garmin_data_p->insize >= len) {
-                                garmin_write_bulk (garmin_data_p->port,
-                                                   garmin_data_p->inbuffer,
-                                                   len, 0);
+                                garmin_write_bulk(garmin_data_p->port,
+                                                   garmin_data_p->inbuffer,
+                                                   len, 0);
                                 garmin_data_p->insize = 0;
 
                                 /* if this was an abort-transfer command,
                                    flush all queued data. */
                                 if (isAbortTrfCmnd(garmin_data_p->inbuffer)) {
-                                        spin_lock_irqsave(&garmin_data_p->lock, flags);
+                                        spin_lock_irqsave(&garmin_data_p->lock,
+                                                                        flags);
                                         garmin_data_p->flags |= FLAGS_DROP_DATA;
-                                        spin_unlock_irqrestore(&garmin_data_p->lock, flags);
+                                        spin_unlock_irqrestore(
+                                                &garmin_data_p->lock, flags);
                                         pkt_clear(garmin_data_p);
                                 }
                         }
@@ -842,7 +840,7 @@ static int nat_receive(struct garmin_data * garmin_data_p,
 
 static void priv_status_resp(struct usb_serial_port *port)
 {
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         __le32 *pkt = (__le32 *)garmin_data_p->privpkt;
 
         pkt[0] = __cpu_to_le32(GARMIN_LAYERID_PRIVATE);
@@ -852,7 +850,7 @@ static void priv_status_resp(struct usb_serial_port *port)
         pkt[4] = __cpu_to_le32(garmin_data_p->mode);
         pkt[5] = __cpu_to_le32(garmin_data_p->serial_num);
 
-        send_to_tty(port, (__u8*)pkt, 6*4);
+        send_to_tty(port, (__u8 *)pkt, 6 * 4);
 }
 
 
@@ -864,7 +862,7 @@ static int process_resetdev_request(struct usb_serial_port *port)
 {
         unsigned long flags;
         int status;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 
         spin_lock_irqsave(&garmin_data_p->lock, flags);
         garmin_data_p->flags &= ~(CLEAR_HALT_REQUIRED);
@@ -872,8 +870,8 @@ static int process_resetdev_request(struct usb_serial_port *port)
         garmin_data_p->serial_num = 0;
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
-        usb_kill_urb (port->interrupt_in_urb);
-        dbg("%s - usb_reset_device", __func__ );
+        usb_kill_urb(port->interrupt_in_urb);
+        dbg("%s - usb_reset_device", __func__);
         status = usb_reset_device(port->serial->dev);
         if (status)
                 dbg("%s - usb_reset_device failed: %d",
@@ -886,7 +884,7 @@ static int process_resetdev_request(struct usb_serial_port *port)
 /*
  * clear all cached data
  */
-static int garmin_clear(struct garmin_data * garmin_data_p)
+static int garmin_clear(struct garmin_data *garmin_data_p)
 {
         unsigned long flags;
         int status = 0;
@@ -896,8 +894,7 @@ static int garmin_clear(struct garmin_data * garmin_data_p)
         if (port != NULL && atomic_read(&garmin_data_p->resp_count)) {
                 /* send a terminate command */
                 status = garmin_write_bulk(port, GARMIN_STOP_TRANSFER_REQ,
-                                           sizeof(GARMIN_STOP_TRANSFER_REQ),
-                                           1);
+                                        sizeof(GARMIN_STOP_TRANSFER_REQ), 1);
         }
 
         /* flush all queued data */
@@ -920,28 +917,26 @@ static int garmin_init_session(struct usb_serial_port *port)
 {
         unsigned long flags;
         struct usb_serial *serial = port->serial;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         int status = 0;
 
         if (status == 0) {
-                usb_kill_urb (port->interrupt_in_urb);
+                usb_kill_urb(port->interrupt_in_urb);
 
                 dbg("%s - adding interrupt input", __func__);
                 port->interrupt_in_urb->dev = serial->dev;
                 status = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
                 if (status)
                         dev_err(&serial->dev->dev,
-                                "%s - failed submitting interrupt urb,"
-                                " error %d\n",
-                                __func__, status);
+                          "%s - failed submitting interrupt urb, error %d\n",
+                                                        __func__, status);
         }
 
         if (status == 0) {
                 dbg("%s - starting session ...", __func__);
                 garmin_data_p->state = STATE_ACTIVE;
                 status = garmin_write_bulk(port, GARMIN_START_SESSION_REQ,
-                                           sizeof(GARMIN_START_SESSION_REQ),
-                                           0);
+                                        sizeof(GARMIN_START_SESSION_REQ), 0);
 
                 if (status >= 0) {
 
@@ -951,14 +946,14 @@ static int garmin_init_session(struct usb_serial_port *port)
 
                         /* not needed, but the win32 driver does it too ... */
                         status = garmin_write_bulk(port,
-                                                   GARMIN_START_SESSION_REQ2,
-                                                   sizeof(GARMIN_START_SESSION_REQ2),
-                                                   0);
+                                        GARMIN_START_SESSION_REQ2,
+                                        sizeof(GARMIN_START_SESSION_REQ2), 0);
                         if (status >= 0) {
                                 status = 0;
                                 spin_lock_irqsave(&garmin_data_p->lock, flags);
                                 garmin_data_p->ignorePkts++;
-                                spin_unlock_irqrestore(&garmin_data_p->lock, flags);
+                                spin_unlock_irqrestore(&garmin_data_p->lock,
+                                                                        flags);
                         }
                 }
         }
@@ -970,11 +965,12 @@ static int garmin_init_session(struct usb_serial_port *port)
 
 
 
-static int garmin_open (struct usb_serial_port *port, struct file *filp)
+static int garmin_open(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         unsigned long flags;
         int status = 0;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 
         dbg("%s - port %d", __func__, port->number);
 
@@ -983,8 +979,8 @@ static int garmin_open (struct usb_serial_port *port, struct file *filp)
          * through, otherwise it is scheduled, and with high data rates (like
          * with OHCI) data can get lost.
          */
-        if (port->tty)
-                port->tty->low_latency = 1;
+        if (tty)
+                tty->low_latency = 1;
 
         spin_lock_irqsave(&garmin_data_p->lock, flags);
         garmin_data_p->mode  = initial_mode;
@@ -995,23 +991,22 @@ static int garmin_open (struct usb_serial_port *port, struct file *filp)
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
         /* shutdown any bulk reads that might be going on */
-        usb_kill_urb (port->write_urb);
-        usb_kill_urb (port->read_urb);
+        usb_kill_urb(port->write_urb);
+        usb_kill_urb(port->read_urb);
 
-        if (garmin_data_p->state == STATE_RESET) {
+        if (garmin_data_p->state == STATE_RESET)
                 status = garmin_init_session(port);
-        }
 
         garmin_data_p->state = STATE_ACTIVE;
-
         return status;
 }
 
 
-static void garmin_close (struct usb_serial_port *port, struct file * filp)
+static void garmin_close(struct tty_struct *tty,
+                        struct usb_serial_port *port, struct file *filp)
 {
         struct usb_serial *serial = port->serial;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 
         dbg("%s - port %d - mode=%d state=%d flags=0x%X", __func__,
                 port->number, garmin_data_p->mode,
@@ -1025,8 +1020,8 @@ static void garmin_close (struct usb_serial_port *port, struct file * filp)
                 garmin_clear(garmin_data_p);
 
         /* shutdown our urbs */
-        usb_kill_urb (port->read_urb);
-        usb_kill_urb (port->write_urb);
+        usb_kill_urb(port->read_urb);
+        usb_kill_urb(port->write_urb);
 
         if (!port->serial->disconnected) {
                 if (noResponseFromAppLayer(garmin_data_p) ||
@@ -1042,21 +1037,22 @@ static void garmin_close (struct usb_serial_port *port, struct file * filp)
         mutex_unlock(&port->serial->disc_mutex);
 }
 
-
-static void garmin_write_bulk_callback (struct urb *urb)
+static void garmin_write_bulk_callback(struct urb *urb)
 {
         unsigned long flags;
         struct usb_serial_port *port = urb->context;
         int status = urb->status;
 
         if (port) {
-                struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+                struct garmin_data *garmin_data_p =
+                                        usb_get_serial_port_data(port);
 
                 dbg("%s - port %d", __func__, port->number);
 
                 if (GARMIN_LAYERID_APPL == getLayerId(urb->transfer_buffer)
                     && (garmin_data_p->mode == MODE_GARMIN_SERIAL))  {
-                        gsp_send_ack(garmin_data_p, ((__u8 *)urb->transfer_buffer)[4]);
+                        gsp_send_ack(garmin_data_p,
+                                        ((__u8 *)urb->transfer_buffer)[4]);
                 }
 
                 if (status) {
@@ -1070,20 +1066,21 @@ static void garmin_write_bulk_callback (struct urb *urb)
                 usb_serial_port_softint(port);
         }
 
-        /* Ignore errors that resulted from garmin_write_bulk with dismiss_ack=1 */
+        /* Ignore errors that resulted from garmin_write_bulk with
+           dismiss_ack = 1 */
 
         /* free up the transfer buffer, as usb_free_urb() does not do this */
-        kfree (urb->transfer_buffer);
+        kfree(urb->transfer_buffer);
 }
 
 
-static int garmin_write_bulk (struct usb_serial_port *port,
+static int garmin_write_bulk(struct usb_serial_port *port,
                               const unsigned char *buf, int count,
                               int dismiss_ack)
 {
         unsigned long flags;
         struct usb_serial *serial = port->serial;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         struct urb *urb;
         unsigned char *buffer;
         int status;
@@ -1095,7 +1092,7 @@ static int garmin_write_bulk (struct usb_serial_port *port,
         garmin_data_p->flags &= ~FLAGS_DROP_DATA;
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
-        buffer = kmalloc (count, GFP_ATOMIC);
+        buffer = kmalloc(count, GFP_ATOMIC);
         if (!buffer) {
                 dev_err(&port->dev, "out of memory\n");
                 return -ENOMEM;
@@ -1104,17 +1101,17 @@ static int garmin_write_bulk (struct usb_serial_port *port,
         urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!urb) {
                 dev_err(&port->dev, "no more free urbs\n");
-                kfree (buffer);
+                kfree(buffer);
                 return -ENOMEM;
         }
 
-        memcpy (buffer, buf, count);
+        memcpy(buffer, buf, count);
 
         usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
 
-        usb_fill_bulk_urb (urb, serial->dev,
-                                usb_sndbulkpipe (serial->dev,
-                                port->bulk_out_endpointAddress),
+        usb_fill_bulk_urb(urb, serial->dev,
+                                usb_sndbulkpipe(serial->dev,
+                                        port->bulk_out_endpointAddress),
                                 buffer, count,
                                 garmin_write_bulk_callback,
                                 dismiss_ack ? NULL : port);
@@ -1132,33 +1129,29 @@ static int garmin_write_bulk (struct usb_serial_port *port,
         status = usb_submit_urb(urb, GFP_ATOMIC);
         if (status) {
                 dev_err(&port->dev,
-                        "%s - usb_submit_urb(write bulk) "
-                        "failed with status = %d\n",
+                   "%s - usb_submit_urb(write bulk) failed with status = %d\n",
                                 __func__, status);
                 count = status;
         }
 
         /* we are done with this urb, so let the host driver
          * really free it when it is finished with it */
-        usb_free_urb (urb);
+        usb_free_urb(urb);
 
         return count;
 }
 
-
-
-static int garmin_write (struct usb_serial_port *port,
-                         const unsigned char *buf, int count)
+static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
+                                         const unsigned char *buf, int count)
 {
         int pktid, pktsiz, len;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         __le32 *privpkt = (__le32 *)garmin_data_p->privpkt;
 
         usb_serial_debug_data(debug, &port->dev, __func__, count, buf);
 
         /* check for our private packets */
         if (count >= GARMIN_PKTHDR_LENGTH) {
-
                 len = PRIVPKTSIZ;
                 if (count < len)
                         len = count;
@@ -1169,15 +1162,16 @@ static int garmin_write (struct usb_serial_port *port,
                 pktid  = getPacketId(garmin_data_p->privpkt);
 
                 if (count == (GARMIN_PKTHDR_LENGTH+pktsiz)
-                    && GARMIN_LAYERID_PRIVATE == getLayerId(garmin_data_p->privpkt)) {
+                    && GARMIN_LAYERID_PRIVATE ==
+                                getLayerId(garmin_data_p->privpkt)) {
 
                         dbg("%s - processing private request %d",
                                 __func__, pktid);
 
-                        // drop all unfinished transfers
+                        /* drop all unfinished transfers */
                         garmin_clear(garmin_data_p);
 
-                        switch(pktid) {
+                        switch (pktid) {
 
                         case PRIV_PKTID_SET_DEBUG:
                                 if (pktsiz != 4)
@@ -1226,44 +1220,31 @@ static int garmin_write (struct usb_serial_port *port,
 }
 
 
-static int garmin_write_room (struct usb_serial_port *port)
+static int garmin_write_room(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
         /*
          * Report back the bytes currently available in the output buffer.
          */
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         return GPS_OUT_BUFSIZ-garmin_data_p->outsize;
 }
 
 
-static int garmin_chars_in_buffer (struct usb_serial_port *port)
-{
-        /*
-         * Report back the number of bytes currently in our input buffer.
-         * Will this lock up the driver - the buffer contains an incomplete
-         * package which will not be written to the device until it
-         * has been completed ?
-         */
-        //struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
-        //return garmin_data_p->insize;
-        return 0;
-}
-
-
-static void garmin_read_process(struct garmin_data * garmin_data_p,
+static void garmin_read_process(struct garmin_data *garmin_data_p,
                                  unsigned char *data, unsigned data_length)
 {
         if (garmin_data_p->flags & FLAGS_DROP_DATA) {
                 /* abort-transfer cmd is actice */
                 dbg("%s - pkt dropped", __func__);
         } else if (garmin_data_p->state != STATE_DISCONNECTED &&
-                   garmin_data_p->state != STATE_RESET ) {
+                garmin_data_p->state != STATE_RESET) {
 
                 /* remember any appl.layer packets, so we know
                    if a reset is required or not when closing
                    the device */
                 if (0 == memcmp(data, GARMIN_APP_LAYER_REPLY,
-                                sizeof(GARMIN_APP_LAYER_REPLY))) {
+                                sizeof(GARMIN_APP_LAYER_REPLY))) {
                         atomic_inc(&garmin_data_p->resp_count);
                 }
 
@@ -1273,9 +1254,8 @@ static void garmin_read_process(struct garmin_data * garmin_data_p,
                 if (garmin_data_p->flags & FLAGS_QUEUING) {
                         pkt_add(garmin_data_p, data, data_length);
                 } else if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
-                        if (getLayerId(data) == GARMIN_LAYERID_APPL) {
+                        if (getLayerId(data) == GARMIN_LAYERID_APPL)
                                 pkt_add(garmin_data_p, data, data_length);
-                        }
                 } else {
                         send_to_tty(garmin_data_p->port, data, data_length);
                 }
@@ -1283,12 +1263,12 @@ static void garmin_read_process(struct garmin_data * garmin_data_p,
 }
 
 
-static void garmin_read_bulk_callback (struct urb *urb)
+static void garmin_read_bulk_callback(struct urb *urb)
 {
         unsigned long flags;
         struct usb_serial_port *port = urb->context;
         struct usb_serial *serial =  port->serial;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         unsigned char *data = urb->transfer_buffer;
         int status = urb->status;
         int retval;
@@ -1306,7 +1286,7 @@ static void garmin_read_bulk_callback (struct urb *urb)
                 return;
         }
 
-        usb_serial_debug_data(debug, &port->dev, 
+        usb_serial_debug_data(debug, &port->dev,
                                 __func__, urb->actual_length, data);
 
         garmin_read_process(garmin_data_p, data, urb->actual_length);
@@ -1340,13 +1320,13 @@ static void garmin_read_bulk_callback (struct urb *urb)
 }
 
 
-static void garmin_read_int_callback (struct urb *urb)
+static void garmin_read_int_callback(struct urb *urb)
 {
         unsigned long flags;
         int retval;
         struct usb_serial_port *port = urb->context;
         struct usb_serial *serial = port->serial;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         unsigned char *data = urb->transfer_buffer;
         int status = urb->status;
 
@@ -1372,30 +1352,31 @@ static void garmin_read_int_callback (struct urb *urb)
 
         if (urb->actual_length == sizeof(GARMIN_BULK_IN_AVAIL_REPLY) &&
             0 == memcmp(data, GARMIN_BULK_IN_AVAIL_REPLY,
-                        sizeof(GARMIN_BULK_IN_AVAIL_REPLY))) {
+                                sizeof(GARMIN_BULK_IN_AVAIL_REPLY))) {
 
                 dbg("%s - bulk data available.", __func__);
 
                 if (0 == (garmin_data_p->flags & FLAGS_BULK_IN_ACTIVE)) {
 
                         /* bulk data available */
-                        usb_fill_bulk_urb (port->read_urb, serial->dev,
-                                        usb_rcvbulkpipe (serial->dev,
-                                        port->bulk_in_endpointAddress),
+                        usb_fill_bulk_urb(port->read_urb, serial->dev,
+                                        usb_rcvbulkpipe(serial->dev,
+                                                port->bulk_in_endpointAddress),
                                         port->read_urb->transfer_buffer,
                                         port->read_urb->transfer_buffer_length,
                                         garmin_read_bulk_callback, port);
                         retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                         if (retval) {
                                 dev_err(&port->dev,
-                                        "%s - failed submitting read urb, error %d\n",
-                                __func__, retval);
+                                 "%s - failed submitting read urb, error %d\n",
+                                                        __func__, retval);
                         } else {
                                 spin_lock_irqsave(&garmin_data_p->lock, flags);
                                 garmin_data_p->flags |= FLAGS_BULK_IN_ACTIVE;
                                 /* do not send this packet to the user */
                                 garmin_data_p->ignorePkts = 1;
-                                spin_unlock_irqrestore(&garmin_data_p->lock, flags);
+                                spin_unlock_irqrestore(&garmin_data_p->lock,
+                                                                        flags);
                         }
                 } else {
                         /* bulk-in transfer still active */
@@ -1406,15 +1387,15 @@ static void garmin_read_int_callback (struct urb *urb)
 
         } else if (urb->actual_length == (4+sizeof(GARMIN_START_SESSION_REPLY))
                          && 0 == memcmp(data, GARMIN_START_SESSION_REPLY,
-                                        sizeof(GARMIN_START_SESSION_REPLY))) {
+                                        sizeof(GARMIN_START_SESSION_REPLY))) {
 
                 spin_lock_irqsave(&garmin_data_p->lock, flags);
                 garmin_data_p->flags |= FLAGS_SESSION_REPLY1_SEEN;
                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
                 /* save the serial number */
-                garmin_data_p->serial_num 
-                        = __le32_to_cpup((__le32*)(data+GARMIN_PKTHDR_LENGTH));
+                garmin_data_p->serial_num = __le32_to_cpup(
+                                        (__le32 *)(data+GARMIN_PKTHDR_LENGTH));
 
                 dbg("%s - start-of-session reply seen - serial %u.",
                         __func__, garmin_data_p->serial_num);
@@ -1433,7 +1414,7 @@ static void garmin_read_int_callback (struct urb *urb)
         }
 
         port->interrupt_in_urb->dev = port->serial->dev;
-        retval = usb_submit_urb (urb, GFP_ATOMIC);
+        retval = usb_submit_urb(urb, GFP_ATOMIC);
         if (retval)
                 dev_err(&urb->dev->dev,
                         "%s - Error %d submitting interrupt urb\n",
@@ -1446,7 +1427,7 @@ static void garmin_read_int_callback (struct urb *urb)
  * and then sets a timer to call itself again until all queued data
  * is sent.
  */
-static int garmin_flush_queue(struct garmin_data * garmin_data_p)
+static int garmin_flush_queue(struct garmin_data *garmin_data_p)
 {
         unsigned long flags;
         struct garmin_packet *pkt;
@@ -1468,10 +1449,11 @@ static int garmin_flush_queue(struct garmin_data * garmin_data_p)
 }
 
 
-static void garmin_throttle (struct usb_serial_port *port)
+static void garmin_throttle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         unsigned long flags;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
 
         dbg("%s - port %d", __func__, port->number);
         /* set flag, data received will be put into a queue
@@ -1482,10 +1464,11 @@ static void garmin_throttle (struct usb_serial_port *port)
 }
 
 
-static void garmin_unthrottle (struct usb_serial_port *port)
+static void garmin_unthrottle(struct tty_struct *tty)
 {
+        struct usb_serial_port *port = tty->driver_data;
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         unsigned long flags;
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
         int status;
 
         dbg("%s - port %d", __func__, port->number);
@@ -1507,8 +1490,6 @@ static void garmin_unthrottle (struct usb_serial_port *port)
         }
 }
 
-
-
 /*
  * The timer is currently only used to send queued packets to
  * the tty in cases where the protocol provides no own handshaking
@@ -1526,11 +1507,11 @@ static void timeout_handler(unsigned long data)
 
 
 
-static int garmin_attach (struct usb_serial *serial)
+static int garmin_attach(struct usb_serial *serial)
 {
         int status = 0;
         struct usb_serial_port *port = serial->port[0];
-        struct garmin_data * garmin_data_p = NULL;
+        struct garmin_data *garmin_data_p = NULL;
 
         dbg("%s", __func__);
 
@@ -1542,7 +1523,7 @@ static int garmin_attach (struct usb_serial *serial)
         init_timer(&garmin_data_p->timer);
         spin_lock_init(&garmin_data_p->lock);
         INIT_LIST_HEAD(&garmin_data_p->pktlist);
-        //garmin_data_p->timer.expires = jiffies + session_timeout;
+        /* garmin_data_p->timer.expires = jiffies + session_timeout; */
         garmin_data_p->timer.data = (unsigned long)garmin_data_p;
         garmin_data_p->timer.function = timeout_handler;
         garmin_data_p->port = port;
@@ -1556,16 +1537,16 @@ static int garmin_attach (struct usb_serial *serial)
 }
 
 
-static void garmin_shutdown (struct usb_serial *serial)
+static void garmin_shutdown(struct usb_serial *serial)
 {
         struct usb_serial_port *port = serial->port[0];
-        struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
+        struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 
         dbg("%s", __func__);
 
-        usb_kill_urb (port->interrupt_in_urb);
+        usb_kill_urb(port->interrupt_in_urb);
         del_timer_sync(&garmin_data_p->timer);
-        kfree (garmin_data_p);
+        kfree(garmin_data_p);
         usb_set_serial_port_data(port, NULL);
 }
 
@@ -1588,7 +1569,6 @@ static struct usb_serial_driver garmin_device = {
         .shutdown            = garmin_shutdown,
         .write               = garmin_write,
         .write_room          = garmin_write_room,
-        .chars_in_buffer     = garmin_chars_in_buffer,
         .write_bulk_callback = garmin_write_bulk_callback,
         .read_bulk_callback  = garmin_read_bulk_callback,
         .read_int_callback   = garmin_read_int_callback,
@@ -1596,7 +1576,7 @@ static struct usb_serial_driver garmin_device = {
 
 
 
-static int __init garmin_init (void)
+static int __init garmin_init(void)
 {
         int retval;
 
@@ -1616,10 +1596,10 @@ failed_garmin_register:
 }
 
 
-static void __exit garmin_exit (void)
+static void __exit garmin_exit(void)
 {
-        usb_deregister (&garmin_driver);
-        usb_serial_deregister (&garmin_device);
+        usb_deregister(&garmin_driver);
+        usb_serial_deregister(&garmin_device);
 }
 
 
@@ -1628,8 +1608,8 @@ static void __exit garmin_exit (void)
 module_init(garmin_init);
 module_exit(garmin_exit);
 
-MODULE_AUTHOR( DRIVER_AUTHOR );
-MODULE_DESCRIPTION( DRIVER_DESC );
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
 module_param(debug, bool, S_IWUSR | S_IRUGO);