drivers/usb/serial/garmin_gps.c

   1 /*
   2  * Garmin GPS driver
   3  *
   4  * Copyright (C) 2006-2011 Hermann Kneissel herkne@gmx.de
   5  *
   6  * The latest version of the driver can be found at
   7  * http://sourceforge.net/projects/garmin-gps/
   8  *
   9  * This driver has been derived from v2.1 of the visor driver.
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111 USA
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/errno.h>
  28 #include <linux/init.h>
  29 #include <linux/slab.h>
  30 #include <linux/timer.h>
  31 #include <linux/tty.h>
  32 #include <linux/tty_driver.h>
  33 #include <linux/tty_flip.h>
  34 #include <linux/module.h>
  35 #include <linux/spinlock.h>
  36 #include <linux/uaccess.h>
  37 #include <linux/atomic.h>
  38 #include <linux/usb.h>
  39 #include <linux/usb/serial.h>
  40
  41 /* the mode to be set when the port ist opened */
  42 static int initial_mode = 1;
  43
  44 /* debug flag */
  45 static bool debug;
  46
  47 #define GARMIN_VENDOR_ID             0x091E
  48
  49 /*
  50  * Version Information
  51  */
  52
  53 #define VERSION_MAJOR   0
  54 #define VERSION_MINOR   36
  55
  56 #define _STR(s) #s
  57 #define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b)
  58 #define DRIVER_VERSION _DRIVER_VERSION(VERSION_MAJOR, VERSION_MINOR)
  59 #define DRIVER_AUTHOR "hermann kneissel"
  60 #define DRIVER_DESC "garmin gps driver"
  61
  62 /* error codes returned by the driver */
  63 #define EINVPKT 1000    /* invalid packet structure */
  64
  65
  66 /* size of the header of a packet using the usb protocol */
  67 #define GARMIN_PKTHDR_LENGTH    12
  68
  69 /* max. possible size of a packet using the serial protocol */
  70 #define MAX_SERIAL_PKT_SIZ (3 + 255 + 3)
  71
  72 /*  max. possible size of a packet with worst case stuffing */
  73 #define MAX_SERIAL_PKT_SIZ_STUFFED (MAX_SERIAL_PKT_SIZ + 256)
  74
  75 /* size of a buffer able to hold a complete (no stuffing) packet
  76  * (the document protocol does not contain packets with a larger
  77  *  size, but in theory a packet may be 64k+12 bytes - if in
  78  *  later protocol versions larger packet sizes occur, this value
  79  *  should be increased accordingly, so the input buffer is always
  80  *  large enough the store a complete packet inclusive header) */
  81 #define GPS_IN_BUFSIZ  (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ)
  82
  83 /* size of a buffer able to hold a complete (incl. stuffing) packet */
  84 #define GPS_OUT_BUFSIZ (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ_STUFFED)
  85
  86 /* where to place the packet id of a serial packet, so we can
  87  * prepend the usb-packet header without the need to move the
  88  * packets data */
  89 #define GSP_INITIAL_OFFSET (GARMIN_PKTHDR_LENGTH-2)
  90
  91 /* max. size of incoming private packets (header+1 param) */
  92 #define PRIVPKTSIZ (GARMIN_PKTHDR_LENGTH+4)
  93
  94 #define GARMIN_LAYERID_TRANSPORT  0
  95 #define GARMIN_LAYERID_APPL      20
  96 /* our own layer-id to use for some control mechanisms */
  97 #define GARMIN_LAYERID_PRIVATE  0x01106E4B
  98
  99 #define GARMIN_PKTID_PVT_DATA   51
 100 #define GARMIN_PKTID_L001_COMMAND_DATA 10
 101
 102 #define CMND_ABORT_TRANSFER 0
 103
 104 /* packet ids used in private layer */
 105 #define PRIV_PKTID_SET_DEBUG    1
 106 #define PRIV_PKTID_SET_MODE     2
 107 #define PRIV_PKTID_INFO_REQ     3
 108 #define PRIV_PKTID_INFO_RESP    4
 109 #define PRIV_PKTID_RESET_REQ    5
 110 #define PRIV_PKTID_SET_DEF_MODE 6
 111
 112
 113 #define ETX     0x03
 114 #define DLE     0x10
 115 #define ACK     0x06
 116 #define NAK     0x15
 117
 118 /* structure used to queue incoming packets */
 119 struct garmin_packet {
 120         struct list_head  list;
 121         int               seq;
 122         /* the real size of the data array, always > 0 */
 123         int               size;
 124         __u8              data[1];
 125 };
 126
 127 /* structure used to keep the current state of the driver */
 128 struct garmin_data {
 129         __u8   state;
 130         __u16  flags;
 131         __u8   mode;
 132         __u8   count;
 133         __u8   pkt_id;
 134         __u32  serial_num;
 135         struct timer_list timer;
 136         struct usb_serial_port *port;
 137         int    seq_counter;
 138         int    insize;
 139         int    outsize;
 140         __u8   inbuffer [GPS_IN_BUFSIZ];  /* tty -> usb */
 141         __u8   outbuffer[GPS_OUT_BUFSIZ]; /* usb -> tty */
 142         __u8   privpkt[4*6];
 143         spinlock_t lock;
 144         struct list_head pktlist;
 145 };
 146
 147
 148 #define STATE_NEW            0
 149 #define STATE_INITIAL_DELAY  1
 150 #define STATE_TIMEOUT        2
 151 #define STATE_SESSION_REQ1   3
 152 #define STATE_SESSION_REQ2   4
 153 #define STATE_ACTIVE         5
 154
 155 #define STATE_RESET          8
 156 #define STATE_DISCONNECTED   9
 157 #define STATE_WAIT_TTY_ACK  10
 158 #define STATE_GSP_WAIT_DATA 11
 159
 160 #define MODE_NATIVE          0
 161 #define MODE_GARMIN_SERIAL   1
 162
 163 /* Flags used in garmin_data.flags: */
 164 #define FLAGS_SESSION_REPLY_MASK  0x00C0
 165 #define FLAGS_SESSION_REPLY1_SEEN 0x0080
 166 #define FLAGS_SESSION_REPLY2_SEEN 0x0040
 167 #define FLAGS_BULK_IN_ACTIVE      0x0020
 168 #define FLAGS_BULK_IN_RESTART     0x0010
 169 #define FLAGS_THROTTLED           0x0008
 170 #define APP_REQ_SEEN              0x0004
 171 #define APP_RESP_SEEN             0x0002
 172 #define CLEAR_HALT_REQUIRED       0x0001
 173
 174 #define FLAGS_QUEUING             0x0100
 175 #define FLAGS_DROP_DATA           0x0800
 176
 177 #define FLAGS_GSP_SKIP            0x1000
 178 #define FLAGS_GSP_DLESEEN         0x2000
 179
 180
 181
 182
 183
 184
 185 /* function prototypes */
 186 static int gsp_next_packet(struct garmin_data *garmin_data_p);
 187 static int garmin_write_bulk(struct usb_serial_port *port,
 188                              const unsigned char *buf, int count,
 189                              int dismiss_ack);
 190
 191 /* some special packets to be send or received */
 192 static unsigned char const GARMIN_START_SESSION_REQ[]
 193         = { 0, 0, 0, 0,  5, 0, 0, 0, 0, 0, 0, 0 };
 194 static unsigned char const GARMIN_START_SESSION_REPLY[]
 195         = { 0, 0, 0, 0,  6, 0, 0, 0, 4, 0, 0, 0 };
 196 static unsigned char const GARMIN_BULK_IN_AVAIL_REPLY[]
 197         = { 0, 0, 0, 0,  2, 0, 0, 0, 0, 0, 0, 0 };
 198 static unsigned char const GARMIN_APP_LAYER_REPLY[]
 199         = { 0x14, 0, 0, 0 };
 200 static unsigned char const GARMIN_START_PVT_REQ[]
 201         = { 20, 0, 0, 0,  10, 0, 0, 0, 2, 0, 0, 0, 49, 0 };
 202 static unsigned char const GARMIN_STOP_PVT_REQ[]
 203         = { 20, 0, 0, 0,  10, 0, 0, 0, 2, 0, 0, 0, 50, 0 };
 204 static unsigned char const GARMIN_STOP_TRANSFER_REQ[]
 205         = { 20, 0, 0, 0,  10, 0, 0, 0, 2, 0, 0, 0, 0, 0 };
 206 static unsigned char const GARMIN_STOP_TRANSFER_REQ_V2[]
 207         = { 20, 0, 0, 0,  10, 0, 0, 0, 1, 0, 0, 0, 0 };
 208 static unsigned char const PRIVATE_REQ[]
 209         =    { 0x4B, 0x6E, 0x10, 0x01,  0xFF, 0, 0, 0, 0xFF, 0, 0, 0 };
 210
 211
 212
 213 static const struct usb_device_id id_table[] = {
 214         /* the same device id seems to be used by all
 215            usb enabled GPS devices */
 216         { USB_DEVICE(GARMIN_VENDOR_ID, 3) },
 217         { }                                     /* Terminating entry */
 218 };
 219
 220 MODULE_DEVICE_TABLE(usb, id_table);
 221
 222 static struct usb_driver garmin_driver = {
 223         .name =         "garmin_gps",
 224         .probe =        usb_serial_probe,
 225         .disconnect =   usb_serial_disconnect,
 226         .id_table =     id_table,
 227 };
 228
 229
 230 static inline int getLayerId(const __u8 *usbPacket)
 231 {
 232         return __le32_to_cpup((__le32 *)(usbPacket));
 233 }
 234
 235 static inline int getPacketId(const __u8 *usbPacket)
 236 {
 237         return __le32_to_cpup((__le32 *)(usbPacket+4));
 238 }
 239
 240 static inline int getDataLength(const __u8 *usbPacket)
 241 {
 242         return __le32_to_cpup((__le32 *)(usbPacket+8));
 243 }
 244
 245
 246 /*
 247  * check if the usb-packet in buf contains an abort-transfer command.
 248  * (if yes, all queued data will be dropped)
 249  */
 250 static inline int isAbortTrfCmnd(const unsigned char *buf)
 251 {
 252         if (0 == memcmp(buf, GARMIN_STOP_TRANSFER_REQ,
 253                                         sizeof(GARMIN_STOP_TRANSFER_REQ)) ||
 254             0 == memcmp(buf, GARMIN_STOP_TRANSFER_REQ_V2,
 255                                         sizeof(GARMIN_STOP_TRANSFER_REQ_V2)))
 256                 return 1;
 257         else
 258                 return 0;
 259 }
 260
 261
 262
 263 static void send_to_tty(struct usb_serial_port *port,
 264                         char *data, unsigned int actual_length)
 265 {
 266         struct tty_struct *tty = tty_port_tty_get(&port->port);
 267
 268         if (tty && actual_length) {
 269
 270                 usb_serial_debug_data(debug, &port->dev,
 271                                         __func__, actual_length, data);
 272
 273                 tty_insert_flip_string(tty, data, actual_length);
 274                 tty_flip_buffer_push(tty);
 275         }
 276         tty_kref_put(tty);
 277 }
 278
 279
 280 /******************************************************************************
 281  * packet queue handling
 282  ******************************************************************************/
 283
 284 /*
 285  * queue a received (usb-)packet for later processing
 286  */
 287 static int pkt_add(struct garmin_data *garmin_data_p,
 288                    unsigned char *data, unsigned int data_length)
 289 {
 290         int state = 0;
 291         int result = 0;
 292         unsigned long flags;
 293         struct garmin_packet *pkt;
 294
 295         /* process only packets containg data ... */
 296         if (data_length) {
 297                 pkt = kmalloc(sizeof(struct garmin_packet)+data_length,
 298                                                                 GFP_ATOMIC);
 299                 if (pkt == NULL) {
 300                         dev_err(&garmin_data_p->port->dev, "out of memory\n");
 301                         return 0;
 302                 }
 303                 pkt->size = data_length;
 304                 memcpy(pkt->data, data, data_length);
 305
 306                 spin_lock_irqsave(&garmin_data_p->lock, flags);
 307                 garmin_data_p->flags |= FLAGS_QUEUING;
 308                 result = list_empty(&garmin_data_p->pktlist);
 309                 pkt->seq = garmin_data_p->seq_counter++;
 310                 list_add_tail(&pkt->list, &garmin_data_p->pktlist);
 311                 state = garmin_data_p->state;
 312                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 313
 314                 dbg("%s - added: pkt: %d - %d bytes",
 315                         __func__, pkt->seq, data_length);
 316
 317                 /* in serial mode, if someone is waiting for data from
 318                    the device, convert and send the next packet to tty. */
 319                 if (result && (state == STATE_GSP_WAIT_DATA))
 320                         gsp_next_packet(garmin_data_p);
 321         }
 322         return result;
 323 }
 324
 325
 326 /* get the next pending packet */
 327 static struct garmin_packet *pkt_pop(struct garmin_data *garmin_data_p)
 328 {
 329         unsigned long flags;
 330         struct garmin_packet *result = NULL;
 331
 332         spin_lock_irqsave(&garmin_data_p->lock, flags);
 333         if (!list_empty(&garmin_data_p->pktlist)) {
 334                 result = (struct garmin_packet *)garmin_data_p->pktlist.next;
 335                 list_del(&result->list);
 336         }
 337         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 338         return result;
 339 }
 340
 341
 342 /* free up all queued data */
 343 static void pkt_clear(struct garmin_data *garmin_data_p)
 344 {
 345         unsigned long flags;
 346         struct garmin_packet *result = NULL;
 347
 348         dbg("%s", __func__);
 349
 350         spin_lock_irqsave(&garmin_data_p->lock, flags);
 351         while (!list_empty(&garmin_data_p->pktlist)) {
 352                 result = (struct garmin_packet *)garmin_data_p->pktlist.next;
 353                 list_del(&result->list);
 354                 kfree(result);
 355         }
 356         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 357 }
 358
 359
 360 /******************************************************************************
 361  * garmin serial protocol handling handling
 362  ******************************************************************************/
 363
 364 /* send an ack packet back to the tty */
 365 static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
 366 {
 367         __u8 pkt[10];
 368         __u8 cksum = 0;
 369         __u8 *ptr = pkt;
 370         unsigned  l = 0;
 371
 372         dbg("%s - pkt-id: 0x%X.", __func__, 0xFF & pkt_id);
 373
 374         *ptr++ = DLE;
 375         *ptr++ = ACK;
 376         cksum += ACK;
 377
 378         *ptr++ = 2;
 379         cksum += 2;
 380
 381         *ptr++ = pkt_id;
 382         cksum += pkt_id;
 383
 384         if (pkt_id == DLE)
 385                 *ptr++ = DLE;
 386
 387         *ptr++ = 0;
 388         *ptr++ = 0xFF & (-cksum);
 389         *ptr++ = DLE;
 390         *ptr++ = ETX;
 391
 392         l = ptr-pkt;
 393
 394         send_to_tty(garmin_data_p->port, pkt, l);
 395         return 0;
 396 }
 397
 398
 399
 400 /*
 401  * called for a complete packet received from tty layer
 402  *
 403  * the complete packet (pktid ... cksum) is in garmin_data_p->inbuf starting
 404  * at GSP_INITIAL_OFFSET.
 405  *
 406  * count - number of bytes in the input buffer including space reserved for
 407  *         the usb header: GSP_INITIAL_OFFSET + number of bytes in packet
 408  *         (including pkt-id, data-length a. cksum)
 409  */
 410 static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
 411 {
 412         unsigned long flags;
 413         const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
 414         __le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
 415
 416         int cksum = 0;
 417         int n = 0;
 418         int pktid = recpkt[0];
 419         int size = recpkt[1];
 420
 421         usb_serial_debug_data(debug, &garmin_data_p->port->dev,
 422                                __func__, count-GSP_INITIAL_OFFSET, recpkt);
 423
 424         if (size != (count-GSP_INITIAL_OFFSET-3)) {
 425                 dbg("%s - invalid size, expected %d bytes, got %d",
 426                         __func__, size, (count-GSP_INITIAL_OFFSET-3));
 427                 return -EINVPKT;
 428         }
 429
 430         cksum += *recpkt++;
 431         cksum += *recpkt++;
 432
 433         /* sanity check, remove after test ... */
 434         if ((__u8 *)&(usbdata[3]) != recpkt) {
 435                 dbg("%s - ptr mismatch %p - %p",
 436                         __func__, &(usbdata[4]), recpkt);
 437                 return -EINVPKT;
 438         }
 439
 440         while (n < size) {
 441                 cksum += *recpkt++;
 442                 n++;
 443         }
 444
 445         if ((0xff & (cksum + *recpkt)) != 0) {
 446                 dbg("%s - invalid checksum, expected %02x, got %02x",
 447                         __func__, 0xff & -cksum, 0xff & *recpkt);
 448                 return -EINVPKT;
 449         }
 450
 451         usbdata[0] = __cpu_to_le32(GARMIN_LAYERID_APPL);
 452         usbdata[1] = __cpu_to_le32(pktid);
 453         usbdata[2] = __cpu_to_le32(size);
 454
 455         garmin_write_bulk(garmin_data_p->port, garmin_data_p->inbuffer,
 456                            GARMIN_PKTHDR_LENGTH+size, 0);
 457
 458         /* if this was an abort-transfer command, flush all
 459            queued data. */
 460         if (isAbortTrfCmnd(garmin_data_p->inbuffer)) {
 461                 spin_lock_irqsave(&garmin_data_p->lock, flags);
 462                 garmin_data_p->flags |= FLAGS_DROP_DATA;
 463                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 464                 pkt_clear(garmin_data_p);
 465         }
 466
 467         return count;
 468 }
 469
 470
 471
 472 /*
 473  * Called for data received from tty
 474  *
 475  * buf contains the data read, it may span more than one packet or even
 476  * incomplete packets
 477  *
 478  * input record should be a serial-record, but it may not be complete.
 479  * Copy it into our local buffer, until an etx is seen (or an error
 480  * occurs).
 481  * Once the record is complete, convert into a usb packet and send it
 482  * to the bulk pipe, send an ack back to the tty.
 483  *
 484  * If the input is an ack, just send the last queued packet to the
 485  * tty layer.
 486  *
 487  * if the input is an abort command, drop all queued data.
 488  */
 489
 490 static int gsp_receive(struct garmin_data *garmin_data_p,
 491                        const unsigned char *buf, int count)
 492 {
 493         unsigned long flags;
 494         int offs = 0;
 495         int ack_or_nak_seen = 0;
 496         __u8 *dest;
 497         int size;
 498         /* dleSeen: set if last byte read was a DLE */
 499         int dleSeen;
 500         /* skip: if set, skip incoming data until possible start of
 501          *       new packet
 502          */
 503         int skip;
 504         __u8 data;
 505
 506         spin_lock_irqsave(&garmin_data_p->lock, flags);
 507         dest = garmin_data_p->inbuffer;
 508         size = garmin_data_p->insize;
 509         dleSeen = garmin_data_p->flags & FLAGS_GSP_DLESEEN;
 510         skip = garmin_data_p->flags & FLAGS_GSP_SKIP;
 511         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 512
 513         /* dbg("%s - dle=%d skip=%d size=%d count=%d",
 514                 __func__, dleSeen, skip, size, count); */
 515
 516         if (size == 0)
 517                 size = GSP_INITIAL_OFFSET;
 518
 519         while (offs < count) {
 520
 521                 data = *(buf+offs);
 522                 offs++;
 523
 524                 if (data == DLE) {
 525                         if (skip) { /* start of a new pkt */
 526                                 skip = 0;
 527                                 size = GSP_INITIAL_OFFSET;
 528                                 dleSeen = 1;
 529                         } else if (dleSeen) {
 530                                 dest[size++] = data;
 531                                 dleSeen = 0;
 532                         } else {
 533                                 dleSeen = 1;
 534                         }
 535                 } else if (data == ETX) {
 536                         if (dleSeen) {
 537                                 /* packet complete */
 538
 539                                 data = dest[GSP_INITIAL_OFFSET];
 540
 541                                 if (data == ACK) {
 542                                         ack_or_nak_seen = ACK;
 543                                         dbg("ACK packet complete.");
 544                                 } else if (data == NAK) {
 545                                         ack_or_nak_seen = NAK;
 546                                         dbg("NAK packet complete.");
 547                                 } else {
 548                                         dbg("packet complete - id=0x%X.",
 549                                                 0xFF & data);
 550                                         gsp_rec_packet(garmin_data_p, size);
 551                                 }
 552
 553                                 skip = 1;
 554                                 size = GSP_INITIAL_OFFSET;
 555                                 dleSeen = 0;
 556                         } else {
 557                                 dest[size++] = data;
 558                         }
 559                 } else if (!skip) {
 560
 561                         if (dleSeen) {
 562                                 size = GSP_INITIAL_OFFSET;
 563                                 dleSeen = 0;
 564                         }
 565
 566                         dest[size++] = data;
 567                 }
 568
 569                 if (size >= GPS_IN_BUFSIZ) {
 570                         dbg("%s - packet too large.", __func__);
 571                         skip = 1;
 572                         size = GSP_INITIAL_OFFSET;
 573                         dleSeen = 0;
 574                 }
 575         }
 576
 577         spin_lock_irqsave(&garmin_data_p->lock, flags);
 578
 579         garmin_data_p->insize = size;
 580
 581         /* copy flags back to structure */
 582         if (skip)
 583                 garmin_data_p->flags |= FLAGS_GSP_SKIP;
 584         else
 585                 garmin_data_p->flags &= ~FLAGS_GSP_SKIP;
 586
 587         if (dleSeen)
 588                 garmin_data_p->flags |= FLAGS_GSP_DLESEEN;
 589         else
 590                 garmin_data_p->flags &= ~FLAGS_GSP_DLESEEN;
 591
 592         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 593
 594         if (ack_or_nak_seen) {
 595                 if (gsp_next_packet(garmin_data_p) > 0)
 596                         garmin_data_p->state = STATE_ACTIVE;
 597                 else
 598                         garmin_data_p->state = STATE_GSP_WAIT_DATA;
 599         }
 600         return count;
 601 }
 602
 603
 604
 605 /*
 606  * Sends a usb packet to the tty
 607  *
 608  * Assumes, that all packages and at an usb-packet boundary.
 609  *
 610  * return <0 on error, 0 if packet is incomplete or > 0 if packet was sent
 611  */
 612 static int gsp_send(struct garmin_data *garmin_data_p,
 613                     const unsigned char *buf, int count)
 614 {
 615         const unsigned char *src;
 616         unsigned char *dst;
 617         int pktid = 0;
 618         int datalen = 0;
 619         int cksum = 0;
 620         int i = 0;
 621         int k;
 622
 623         dbg("%s - state %d - %d bytes.", __func__,
 624                                         garmin_data_p->state, count);
 625
 626         k = garmin_data_p->outsize;
 627         if ((k+count) > GPS_OUT_BUFSIZ) {
 628                 dbg("packet too large");
 629                 garmin_data_p->outsize = 0;
 630                 return -4;
 631         }
 632
 633         memcpy(garmin_data_p->outbuffer+k, buf, count);
 634         k += count;
 635         garmin_data_p->outsize = k;
 636
 637         if (k >= GARMIN_PKTHDR_LENGTH) {
 638                 pktid  = getPacketId(garmin_data_p->outbuffer);
 639                 datalen = getDataLength(garmin_data_p->outbuffer);
 640                 i = GARMIN_PKTHDR_LENGTH + datalen;
 641                 if (k < i)
 642                         return 0;
 643         } else {
 644                 return 0;
 645         }
 646
 647         dbg("%s - %d bytes in buffer, %d bytes in pkt.", __func__, k, i);
 648
 649         /* garmin_data_p->outbuffer now contains a complete packet */
 650
 651         usb_serial_debug_data(debug, &garmin_data_p->port->dev,
 652                                 __func__, k, garmin_data_p->outbuffer);
 653
 654         garmin_data_p->outsize = 0;
 655
 656         if (GARMIN_LAYERID_APPL != getLayerId(garmin_data_p->outbuffer)) {
 657                 dbg("not an application packet (%d)",
 658                                 getLayerId(garmin_data_p->outbuffer));
 659                 return -1;
 660         }
 661
 662         if (pktid > 255) {
 663                 dbg("packet-id %d too large", pktid);
 664                 return -2;
 665         }
 666
 667         if (datalen > 255) {
 668                 dbg("packet-size %d too large", datalen);
 669                 return -3;
 670         }
 671
 672         /* the serial protocol should be able to handle this packet */
 673
 674         k = 0;
 675         src = garmin_data_p->outbuffer+GARMIN_PKTHDR_LENGTH;
 676         for (i = 0; i < datalen; i++) {
 677                 if (*src++ == DLE)
 678                         k++;
 679         }
 680
 681         src = garmin_data_p->outbuffer+GARMIN_PKTHDR_LENGTH;
 682         if (k > (GARMIN_PKTHDR_LENGTH-2)) {
 683                 /* can't add stuffing DLEs in place, move data to end
 684                    of buffer ... */
 685                 dst = garmin_data_p->outbuffer+GPS_OUT_BUFSIZ-datalen;
 686                 memcpy(dst, src, datalen);
 687                 src = dst;
 688         }
 689
 690         dst = garmin_data_p->outbuffer;
 691
 692         *dst++ = DLE;
 693         *dst++ = pktid;
 694         cksum += pktid;
 695         *dst++ = datalen;
 696         cksum += datalen;
 697         if (datalen == DLE)
 698                 *dst++ = DLE;
 699
 700         for (i = 0; i < datalen; i++) {
 701                 __u8 c = *src++;
 702                 *dst++ = c;
 703                 cksum += c;
 704                 if (c == DLE)
 705                         *dst++ = DLE;
 706         }
 707
 708         cksum = 0xFF & -cksum;
 709         *dst++ = cksum;
 710         if (cksum == DLE)
 711                 *dst++ = DLE;
 712         *dst++ = DLE;
 713         *dst++ = ETX;
 714
 715         i = dst-garmin_data_p->outbuffer;
 716
 717         send_to_tty(garmin_data_p->port, garmin_data_p->outbuffer, i);
 718
 719         garmin_data_p->pkt_id = pktid;
 720         garmin_data_p->state  = STATE_WAIT_TTY_ACK;
 721
 722         return i;
 723 }
 724
 725
 726 /*
 727  * Process the next pending data packet - if there is one
 728  */
 729 static int gsp_next_packet(struct garmin_data *garmin_data_p)
 730 {
 731         int result = 0;
 732         struct garmin_packet *pkt = NULL;
 733
 734         while ((pkt = pkt_pop(garmin_data_p)) != NULL) {
 735                 dbg("%s - next pkt: %d", __func__, pkt->seq);
 736                 result = gsp_send(garmin_data_p, pkt->data, pkt->size);
 737                 if (result > 0) {
 738                         kfree(pkt);
 739                         return result;
 740                 }
 741                 kfree(pkt);
 742         }
 743         return result;
 744 }
 745
 746
 747
 748 /******************************************************************************
 749  * garmin native mode
 750  ******************************************************************************/
 751
 752
 753 /*
 754  * Called for data received from tty
 755  *
 756  * The input data is expected to be in garmin usb-packet format.
 757  *
 758  * buf contains the data read, it may span more than one packet
 759  * or even incomplete packets
 760  */
 761 static int nat_receive(struct garmin_data *garmin_data_p,
 762                        const unsigned char *buf, int count)
 763 {
 764         unsigned long flags;
 765         __u8 *dest;
 766         int offs = 0;
 767         int result = count;
 768         int len;
 769
 770         while (offs < count) {
 771                 /* if buffer contains header, copy rest of data */
 772                 if (garmin_data_p->insize >= GARMIN_PKTHDR_LENGTH)
 773                         len = GARMIN_PKTHDR_LENGTH
 774                               +getDataLength(garmin_data_p->inbuffer);
 775                 else
 776                         len = GARMIN_PKTHDR_LENGTH;
 777
 778                 if (len >= GPS_IN_BUFSIZ) {
 779                         /* seems to be an invalid packet, ignore rest
 780                            of input */
 781                         dbg("%s - packet size too large: %d", __func__, len);
 782                         garmin_data_p->insize = 0;
 783                         count = 0;
 784                         result = -EINVPKT;
 785                 } else {
 786                         len -= garmin_data_p->insize;
 787                         if (len > (count-offs))
 788                                 len = (count-offs);
 789                         if (len > 0) {
 790                                 dest = garmin_data_p->inbuffer
 791                                                 + garmin_data_p->insize;
 792                                 memcpy(dest, buf+offs, len);
 793                                 garmin_data_p->insize += len;
 794                                 offs += len;
 795                         }
 796                 }
 797
 798                 /* do we have a complete packet ? */
 799                 if (garmin_data_p->insize >= GARMIN_PKTHDR_LENGTH) {
 800                         len = GARMIN_PKTHDR_LENGTH+
 801                            getDataLength(garmin_data_p->inbuffer);
 802                         if (garmin_data_p->insize >= len) {
 803                                 garmin_write_bulk(garmin_data_p->port,
 804                                                    garmin_data_p->inbuffer,
 805                                                    len, 0);
 806                                 garmin_data_p->insize = 0;
 807
 808                                 /* if this was an abort-transfer command,
 809                                    flush all queued data. */
 810                                 if (isAbortTrfCmnd(garmin_data_p->inbuffer)) {
 811                                         spin_lock_irqsave(&garmin_data_p->lock,
 812                                                                         flags);
 813                                         garmin_data_p->flags |= FLAGS_DROP_DATA;
 814                                         spin_unlock_irqrestore(
 815                                                 &garmin_data_p->lock, flags);
 816                                         pkt_clear(garmin_data_p);
 817                                 }
 818                         }
 819                 }
 820         }
 821         return result;
 822 }
 823
 824
 825 /******************************************************************************
 826  * private packets
 827  ******************************************************************************/
 828
 829 static void priv_status_resp(struct usb_serial_port *port)
 830 {
 831         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 832         __le32 *pkt = (__le32 *)garmin_data_p->privpkt;
 833
 834         pkt[0] = __cpu_to_le32(GARMIN_LAYERID_PRIVATE);
 835         pkt[1] = __cpu_to_le32(PRIV_PKTID_INFO_RESP);
 836         pkt[2] = __cpu_to_le32(12);
 837         pkt[3] = __cpu_to_le32(VERSION_MAJOR << 16 | VERSION_MINOR);
 838         pkt[4] = __cpu_to_le32(garmin_data_p->mode);
 839         pkt[5] = __cpu_to_le32(garmin_data_p->serial_num);
 840
 841         send_to_tty(port, (__u8 *)pkt, 6 * 4);
 842 }
 843
 844
 845 /******************************************************************************
 846  * Garmin specific driver functions
 847  ******************************************************************************/
 848
 849 static int process_resetdev_request(struct usb_serial_port *port)
 850 {
 851         unsigned long flags;
 852         int status;
 853         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 854
 855         spin_lock_irqsave(&garmin_data_p->lock, flags);
 856         garmin_data_p->flags &= ~(CLEAR_HALT_REQUIRED);
 857         garmin_data_p->state = STATE_RESET;
 858         garmin_data_p->serial_num = 0;
 859         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 860
 861         usb_kill_urb(port->interrupt_in_urb);
 862         dbg("%s - usb_reset_device", __func__);
 863         status = usb_reset_device(port->serial->dev);
 864         if (status)
 865                 dbg("%s - usb_reset_device failed: %d",
 866                         __func__, status);
 867         return status;
 868 }
 869
 870
 871
 872 /*
 873  * clear all cached data
 874  */
 875 static int garmin_clear(struct garmin_data *garmin_data_p)
 876 {
 877         unsigned long flags;
 878         int status = 0;
 879
 880         /* flush all queued data */
 881         pkt_clear(garmin_data_p);
 882
 883         spin_lock_irqsave(&garmin_data_p->lock, flags);
 884         garmin_data_p->insize = 0;
 885         garmin_data_p->outsize = 0;
 886         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 887
 888         return status;
 889 }
 890
 891
 892 static int garmin_init_session(struct usb_serial_port *port)
 893 {
 894         struct usb_serial *serial = port->serial;
 895         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 896         int status = 0;
 897         int i = 0;
 898
 899         if (status == 0) {
 900                 usb_kill_urb(port->interrupt_in_urb);
 901
 902                 dbg("%s - adding interrupt input", __func__);
 903                 status = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 904                 if (status)
 905                         dev_err(&serial->dev->dev,
 906                           "%s - failed submitting interrupt urb, error %d\n",
 907                                                         __func__, status);
 908         }
 909
 910         /*
 911          * using the initialization method from gpsbabel. See comments in
 912          * gpsbabel/jeeps/gpslibusb.c gusb_reset_toggles()
 913          */
 914         if (status == 0) {
 915                 dbg("%s - starting session ...", __func__);
 916                 garmin_data_p->state = STATE_ACTIVE;
 917
 918                 for (i = 0; i < 3; i++) {
 919                         status = garmin_write_bulk(port,
 920                                         GARMIN_START_SESSION_REQ,
 921                                         sizeof(GARMIN_START_SESSION_REQ), 0);
 922
 923                         if (status < 0)
 924                                 break;
 925                 }
 926
 927                 if (status > 0)
 928                         status = 0;
 929         }
 930
 931         return status;
 932 }
 933
 934
 935
 936 static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
 937 {
 938         unsigned long flags;
 939         int status = 0;
 940         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 941
 942         dbg("%s - port %d", __func__, port->number);
 943
 944         spin_lock_irqsave(&garmin_data_p->lock, flags);
 945         garmin_data_p->mode  = initial_mode;
 946         garmin_data_p->count = 0;
 947         garmin_data_p->flags &= FLAGS_SESSION_REPLY1_SEEN;
 948         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 949
 950         /* shutdown any bulk reads that might be going on */
 951         usb_kill_urb(port->write_urb);
 952         usb_kill_urb(port->read_urb);
 953
 954         if (garmin_data_p->state == STATE_RESET)
 955                 status = garmin_init_session(port);
 956
 957         garmin_data_p->state = STATE_ACTIVE;
 958         return status;
 959 }
 960
 961
 962 static void garmin_close(struct usb_serial_port *port)
 963 {
 964         struct usb_serial *serial = port->serial;
 965         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 966
 967         dbg("%s - port %d - mode=%d state=%d flags=0x%X", __func__,
 968                 port->number, garmin_data_p->mode,
 969                 garmin_data_p->state, garmin_data_p->flags);
 970
 971         if (!serial)
 972                 return;
 973
 974         mutex_lock(&port->serial->disc_mutex);
 975
 976         if (!port->serial->disconnected)
 977                 garmin_clear(garmin_data_p);
 978
 979         /* shutdown our urbs */
 980         usb_kill_urb(port->read_urb);
 981         usb_kill_urb(port->write_urb);
 982
 983         /* keep reset state so we know that we must start a new session */
 984         if (garmin_data_p->state != STATE_RESET)
 985                 garmin_data_p->state = STATE_DISCONNECTED;
 986
 987         mutex_unlock(&port->serial->disc_mutex);
 988 }
 989
 990
 991 static void garmin_write_bulk_callback(struct urb *urb)
 992 {
 993         struct usb_serial_port *port = urb->context;
 994
 995         if (port) {
 996                 struct garmin_data *garmin_data_p =
 997                                         usb_get_serial_port_data(port);
 998
 999                 dbg("%s - port %d", __func__, port->number);
1000
1001                 if (GARMIN_LAYERID_APPL == getLayerId(urb->transfer_buffer)) {
1002
1003                         if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
1004                                 gsp_send_ack(garmin_data_p,
1005                                         ((__u8 *)urb->transfer_buffer)[4]);
1006                         }
1007                 }
1008                 usb_serial_port_softint(port);
1009         }
1010
1011         /* Ignore errors that resulted from garmin_write_bulk with
1012            dismiss_ack = 1 */
1013
1014         /* free up the transfer buffer, as usb_free_urb() does not do this */
1015         kfree(urb->transfer_buffer);
1016 }
1017
1018
1019 static int garmin_write_bulk(struct usb_serial_port *port,
1020                               const unsigned char *buf, int count,
1021                               int dismiss_ack)
1022 {
1023         unsigned long flags;
1024         struct usb_serial *serial = port->serial;
1025         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1026         struct urb *urb;
1027         unsigned char *buffer;
1028         int status;
1029
1030         dbg("%s - port %d, state %d", __func__, port->number,
1031                 garmin_data_p->state);
1032
1033         spin_lock_irqsave(&garmin_data_p->lock, flags);
1034         garmin_data_p->flags &= ~FLAGS_DROP_DATA;
1035         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1036
1037         buffer = kmalloc(count, GFP_ATOMIC);
1038         if (!buffer) {
1039                 dev_err(&port->dev, "out of memory\n");
1040                 return -ENOMEM;
1041         }
1042
1043         urb = usb_alloc_urb(0, GFP_ATOMIC);
1044         if (!urb) {
1045                 dev_err(&port->dev, "no more free urbs\n");
1046                 kfree(buffer);
1047                 return -ENOMEM;
1048         }
1049
1050         memcpy(buffer, buf, count);
1051
1052         usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
1053
1054         usb_fill_bulk_urb(urb, serial->dev,
1055                                 usb_sndbulkpipe(serial->dev,
1056                                         port->bulk_out_endpointAddress),
1057                                 buffer, count,
1058                                 garmin_write_bulk_callback,
1059                                 dismiss_ack ? NULL : port);
1060         urb->transfer_flags |= URB_ZERO_PACKET;
1061
1062         if (GARMIN_LAYERID_APPL == getLayerId(buffer)) {
1063
1064                 spin_lock_irqsave(&garmin_data_p->lock, flags);
1065                 garmin_data_p->flags |= APP_REQ_SEEN;
1066                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1067
1068                 if (garmin_data_p->mode == MODE_GARMIN_SERIAL)  {
1069                         pkt_clear(garmin_data_p);
1070                         garmin_data_p->state = STATE_GSP_WAIT_DATA;
1071                 }
1072         }
1073
1074         /* send it down the pipe */
1075         status = usb_submit_urb(urb, GFP_ATOMIC);
1076         if (status) {
1077                 dev_err(&port->dev,
1078                    "%s - usb_submit_urb(write bulk) failed with status = %d\n",
1079                                 __func__, status);
1080                 count = status;
1081         }
1082
1083         /* we are done with this urb, so let the host driver
1084          * really free it when it is finished with it */
1085         usb_free_urb(urb);
1086
1087         return count;
1088 }
1089
1090 static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
1091                                          const unsigned char *buf, int count)
1092 {
1093         int pktid, pktsiz, len;
1094         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1095         __le32 *privpkt = (__le32 *)garmin_data_p->privpkt;
1096
1097         usb_serial_debug_data(debug, &port->dev, __func__, count, buf);
1098
1099         if (garmin_data_p->state == STATE_RESET)
1100                 return -EIO;
1101
1102         /* check for our private packets */
1103         if (count >= GARMIN_PKTHDR_LENGTH) {
1104                 len = PRIVPKTSIZ;
1105                 if (count < len)
1106                         len = count;
1107
1108                 memcpy(garmin_data_p->privpkt, buf, len);
1109
1110                 pktsiz = getDataLength(garmin_data_p->privpkt);
1111                 pktid  = getPacketId(garmin_data_p->privpkt);
1112
1113                 if (count == (GARMIN_PKTHDR_LENGTH+pktsiz)
1114                     && GARMIN_LAYERID_PRIVATE ==
1115                                 getLayerId(garmin_data_p->privpkt)) {
1116
1117                         dbg("%s - processing private request %d",
1118                                 __func__, pktid);
1119
1120                         /* drop all unfinished transfers */
1121                         garmin_clear(garmin_data_p);
1122
1123                         switch (pktid) {
1124
1125                         case PRIV_PKTID_SET_DEBUG:
1126                                 if (pktsiz != 4)
1127                                         return -EINVPKT;
1128                                 debug = __le32_to_cpu(privpkt[3]);
1129                                 dbg("%s - debug level set to 0x%X",
1130                                         __func__, debug);
1131                                 break;
1132
1133                         case PRIV_PKTID_SET_MODE:
1134                                 if (pktsiz != 4)
1135                                         return -EINVPKT;
1136                                 garmin_data_p->mode = __le32_to_cpu(privpkt[3]);
1137                                 dbg("%s - mode set to %d",
1138                                         __func__, garmin_data_p->mode);
1139                                 break;
1140
1141                         case PRIV_PKTID_INFO_REQ:
1142                                 priv_status_resp(port);
1143                                 break;
1144
1145                         case PRIV_PKTID_RESET_REQ:
1146                                 process_resetdev_request(port);
1147                                 break;
1148
1149                         case PRIV_PKTID_SET_DEF_MODE:
1150                                 if (pktsiz != 4)
1151                                         return -EINVPKT;
1152                                 initial_mode = __le32_to_cpu(privpkt[3]);
1153                                 dbg("%s - initial_mode set to %d",
1154                                         __func__,
1155                                         garmin_data_p->mode);
1156                                 break;
1157                         }
1158                         return count;
1159                 }
1160         }
1161
1162         if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
1163                 return gsp_receive(garmin_data_p, buf, count);
1164         } else {        /* MODE_NATIVE */
1165                 return nat_receive(garmin_data_p, buf, count);
1166         }
1167 }
1168
1169
1170 static int garmin_write_room(struct tty_struct *tty)
1171 {
1172         struct usb_serial_port *port = tty->driver_data;
1173         /*
1174          * Report back the bytes currently available in the output buffer.
1175          */
1176         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1177         return GPS_OUT_BUFSIZ-garmin_data_p->outsize;
1178 }
1179
1180
1181 static void garmin_read_process(struct garmin_data *garmin_data_p,
1182                                  unsigned char *data, unsigned data_length,
1183                                  int bulk_data)
1184 {
1185         unsigned long flags;
1186
1187         if (garmin_data_p->flags & FLAGS_DROP_DATA) {
1188                 /* abort-transfer cmd is actice */
1189                 dbg("%s - pkt dropped", __func__);
1190         } else if (garmin_data_p->state != STATE_DISCONNECTED &&
1191                 garmin_data_p->state != STATE_RESET) {
1192
1193                 /* if throttling is active or postprecessing is required
1194                    put the received data in the input queue, otherwise
1195                    send it directly to the tty port */
1196                 if (garmin_data_p->flags & FLAGS_QUEUING) {
1197                         pkt_add(garmin_data_p, data, data_length);
1198                 } else if (bulk_data ||
1199                            getLayerId(data) == GARMIN_LAYERID_APPL) {
1200
1201                         spin_lock_irqsave(&garmin_data_p->lock, flags);
1202                         garmin_data_p->flags |= APP_RESP_SEEN;
1203                         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1204
1205                         if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
1206                                 pkt_add(garmin_data_p, data, data_length);
1207                         } else {
1208                                 send_to_tty(garmin_data_p->port, data,
1209                                                 data_length);
1210                         }
1211                 }
1212                 /* ignore system layer packets ... */
1213         }
1214 }
1215
1216
1217 static void garmin_read_bulk_callback(struct urb *urb)
1218 {
1219         unsigned long flags;
1220         struct usb_serial_port *port = urb->context;
1221         struct usb_serial *serial =  port->serial;
1222         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1223         unsigned char *data = urb->transfer_buffer;
1224         int status = urb->status;
1225         int retval;
1226
1227         dbg("%s - port %d", __func__, port->number);
1228
1229         if (!serial) {
1230                 dbg("%s - bad serial pointer, exiting", __func__);
1231                 return;
1232         }
1233
1234         if (status) {
1235                 dbg("%s - nonzero read bulk status received: %d",
1236                         __func__, status);
1237                 return;
1238         }
1239
1240         usb_serial_debug_data(debug, &port->dev,
1241                                 __func__, urb->actual_length, data);
1242
1243         garmin_read_process(garmin_data_p, data, urb->actual_length, 1);
1244
1245         if (urb->actual_length == 0 &&
1246                         0 != (garmin_data_p->flags & FLAGS_BULK_IN_RESTART)) {
1247                 spin_lock_irqsave(&garmin_data_p->lock, flags);
1248                 garmin_data_p->flags &= ~FLAGS_BULK_IN_RESTART;
1249                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1250                 retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1251                 if (retval)
1252                         dev_err(&port->dev,
1253                                 "%s - failed resubmitting read urb, error %d\n",
1254                                 __func__, retval);
1255         } else if (urb->actual_length > 0) {
1256                 /* Continue trying to read until nothing more is received  */
1257                 if (0 == (garmin_data_p->flags & FLAGS_THROTTLED)) {
1258                         retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1259                         if (retval)
1260                                 dev_err(&port->dev,
1261                                         "%s - failed resubmitting read urb, "
1262                                         "error %d\n", __func__, retval);
1263                 }
1264         } else {
1265                 dbg("%s - end of bulk data", __func__);
1266                 spin_lock_irqsave(&garmin_data_p->lock, flags);
1267                 garmin_data_p->flags &= ~FLAGS_BULK_IN_ACTIVE;
1268                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1269         }
1270 }
1271
1272
1273 static void garmin_read_int_callback(struct urb *urb)
1274 {
1275         unsigned long flags;
1276         int retval;
1277         struct usb_serial_port *port = urb->context;
1278         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1279         unsigned char *data = urb->transfer_buffer;
1280         int status = urb->status;
1281
1282         switch (status) {
1283         case 0:
1284                 /* success */
1285                 break;
1286         case -ECONNRESET:
1287         case -ENOENT:
1288         case -ESHUTDOWN:
1289                 /* this urb is terminated, clean up */
1290                 dbg("%s - urb shutting down with status: %d",
1291                         __func__, status);
1292                 return;
1293         default:
1294                 dbg("%s - nonzero urb status received: %d",
1295                         __func__, status);
1296                 return;
1297         }
1298
1299         usb_serial_debug_data(debug, &port->dev, __func__,
1300                                 urb->actual_length, urb->transfer_buffer);
1301
1302         if (urb->actual_length == sizeof(GARMIN_BULK_IN_AVAIL_REPLY) &&
1303             0 == memcmp(data, GARMIN_BULK_IN_AVAIL_REPLY,
1304                                 sizeof(GARMIN_BULK_IN_AVAIL_REPLY))) {
1305
1306                 dbg("%s - bulk data available.", __func__);
1307
1308                 if (0 == (garmin_data_p->flags & FLAGS_BULK_IN_ACTIVE)) {
1309
1310                         /* bulk data available */
1311                         retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1312                         if (retval) {
1313                                 dev_err(&port->dev,
1314                                  "%s - failed submitting read urb, error %d\n",
1315                                                         __func__, retval);
1316                         } else {
1317                                 spin_lock_irqsave(&garmin_data_p->lock, flags);
1318                                 garmin_data_p->flags |= FLAGS_BULK_IN_ACTIVE;
1319                                 spin_unlock_irqrestore(&garmin_data_p->lock,
1320                                                                         flags);
1321                         }
1322                 } else {
1323                         /* bulk-in transfer still active */
1324                         spin_lock_irqsave(&garmin_data_p->lock, flags);
1325                         garmin_data_p->flags |= FLAGS_BULK_IN_RESTART;
1326                         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1327                 }
1328
1329         } else if (urb->actual_length == (4+sizeof(GARMIN_START_SESSION_REPLY))
1330                          && 0 == memcmp(data, GARMIN_START_SESSION_REPLY,
1331                                         sizeof(GARMIN_START_SESSION_REPLY))) {
1332
1333                 spin_lock_irqsave(&garmin_data_p->lock, flags);
1334                 garmin_data_p->flags |= FLAGS_SESSION_REPLY1_SEEN;
1335                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1336
1337                 /* save the serial number */
1338                 garmin_data_p->serial_num = __le32_to_cpup(
1339                                         (__le32 *)(data+GARMIN_PKTHDR_LENGTH));
1340
1341                 dbg("%s - start-of-session reply seen - serial %u.",
1342                         __func__, garmin_data_p->serial_num);
1343         }
1344
1345         garmin_read_process(garmin_data_p, data, urb->actual_length, 0);
1346
1347         retval = usb_submit_urb(urb, GFP_ATOMIC);
1348         if (retval)
1349                 dev_err(&urb->dev->dev,
1350                         "%s - Error %d submitting interrupt urb\n",
1351                         __func__, retval);
1352 }
1353
1354
1355 /*
1356  * Sends the next queued packt to the tty port (garmin native mode only)
1357  * and then sets a timer to call itself again until all queued data
1358  * is sent.
1359  */
1360 static int garmin_flush_queue(struct garmin_data *garmin_data_p)
1361 {
1362         unsigned long flags;
1363         struct garmin_packet *pkt;
1364
1365         if ((garmin_data_p->flags & FLAGS_THROTTLED) == 0) {
1366                 pkt = pkt_pop(garmin_data_p);
1367                 if (pkt != NULL) {
1368                         send_to_tty(garmin_data_p->port, pkt->data, pkt->size);
1369                         kfree(pkt);
1370                         mod_timer(&garmin_data_p->timer, (1)+jiffies);
1371
1372                 } else {
1373                         spin_lock_irqsave(&garmin_data_p->lock, flags);
1374                         garmin_data_p->flags &= ~FLAGS_QUEUING;
1375                         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1376                 }
1377         }
1378         return 0;
1379 }
1380
1381
1382 static void garmin_throttle(struct tty_struct *tty)
1383 {
1384         struct usb_serial_port *port = tty->driver_data;
1385         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1386
1387         dbg("%s - port %d", __func__, port->number);
1388         /* set flag, data received will be put into a queue
1389            for later processing */
1390         spin_lock_irq(&garmin_data_p->lock);
1391         garmin_data_p->flags |= FLAGS_QUEUING|FLAGS_THROTTLED;
1392         spin_unlock_irq(&garmin_data_p->lock);
1393 }
1394
1395
1396 static void garmin_unthrottle(struct tty_struct *tty)
1397 {
1398         struct usb_serial_port *port = tty->driver_data;
1399         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1400         int status;
1401
1402         dbg("%s - port %d", __func__, port->number);
1403         spin_lock_irq(&garmin_data_p->lock);
1404         garmin_data_p->flags &= ~FLAGS_THROTTLED;
1405         spin_unlock_irq(&garmin_data_p->lock);
1406
1407         /* in native mode send queued data to tty, in
1408            serial mode nothing needs to be done here */
1409         if (garmin_data_p->mode == MODE_NATIVE)
1410                 garmin_flush_queue(garmin_data_p);
1411
1412         if (0 != (garmin_data_p->flags & FLAGS_BULK_IN_ACTIVE)) {
1413                 status = usb_submit_urb(port->read_urb, GFP_KERNEL);
1414                 if (status)
1415                         dev_err(&port->dev,
1416                                 "%s - failed resubmitting read urb, error %d\n",
1417                                 __func__, status);
1418         }
1419 }
1420
1421 /*
1422  * The timer is currently only used to send queued packets to
1423  * the tty in cases where the protocol provides no own handshaking
1424  * to initiate the transfer.
1425  */
1426 static void timeout_handler(unsigned long data)
1427 {
1428         struct garmin_data *garmin_data_p = (struct garmin_data *) data;
1429
1430         /* send the next queued packet to the tty port */
1431         if (garmin_data_p->mode == MODE_NATIVE)
1432                 if (garmin_data_p->flags & FLAGS_QUEUING)
1433                         garmin_flush_queue(garmin_data_p);
1434 }
1435
1436
1437
1438 static int garmin_attach(struct usb_serial *serial)
1439 {
1440         int status = 0;
1441         struct usb_serial_port *port = serial->port[0];
1442         struct garmin_data *garmin_data_p = NULL;
1443
1444         dbg("%s", __func__);
1445
1446         garmin_data_p = kzalloc(sizeof(struct garmin_data), GFP_KERNEL);
1447         if (garmin_data_p == NULL) {
1448                 dev_err(&port->dev, "%s - Out of memory\n", __func__);
1449                 return -ENOMEM;
1450         }
1451         init_timer(&garmin_data_p->timer);
1452         spin_lock_init(&garmin_data_p->lock);
1453         INIT_LIST_HEAD(&garmin_data_p->pktlist);
1454         /* garmin_data_p->timer.expires = jiffies + session_timeout; */
1455         garmin_data_p->timer.data = (unsigned long)garmin_data_p;
1456         garmin_data_p->timer.function = timeout_handler;
1457         garmin_data_p->port = port;
1458         garmin_data_p->state = 0;
1459         garmin_data_p->flags = 0;
1460         garmin_data_p->count = 0;
1461         usb_set_serial_port_data(port, garmin_data_p);
1462
1463         status = garmin_init_session(port);
1464
1465         return status;
1466 }
1467
1468
1469 static void garmin_disconnect(struct usb_serial *serial)
1470 {
1471         struct usb_serial_port *port = serial->port[0];
1472         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1473
1474         dbg("%s", __func__);
1475
1476         usb_kill_urb(port->interrupt_in_urb);
1477         del_timer_sync(&garmin_data_p->timer);
1478 }
1479
1480
1481 static void garmin_release(struct usb_serial *serial)
1482 {
1483         struct usb_serial_port *port = serial->port[0];
1484         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1485
1486         dbg("%s", __func__);
1487
1488         kfree(garmin_data_p);
1489 }
1490
1491
1492 /* All of the device info needed */
1493 static struct usb_serial_driver garmin_device = {
1494         .driver = {
1495                 .owner       = THIS_MODULE,
1496                 .name        = "garmin_gps",
1497         },
1498         .description         = "Garmin GPS usb/tty",
1499         .id_table            = id_table,
1500         .num_ports           = 1,
1501         .open                = garmin_open,
1502         .close               = garmin_close,
1503         .throttle            = garmin_throttle,
1504         .unthrottle          = garmin_unthrottle,
1505         .attach              = garmin_attach,
1506         .disconnect          = garmin_disconnect,
1507         .release             = garmin_release,
1508         .write               = garmin_write,
1509         .write_room          = garmin_write_room,
1510         .write_bulk_callback = garmin_write_bulk_callback,
1511         .read_bulk_callback  = garmin_read_bulk_callback,
1512         .read_int_callback   = garmin_read_int_callback,
1513 };
1514
1515 static struct usb_serial_driver * const serial_drivers[] = {
1516         &garmin_device, NULL
1517 };
1518
1519 module_usb_serial_driver(garmin_driver, serial_drivers);
1520
1521 MODULE_AUTHOR(DRIVER_AUTHOR);
1522 MODULE_DESCRIPTION(DRIVER_DESC);
1523 MODULE_LICENSE("GPL");
1524
1525 module_param(debug, bool, S_IWUSR | S_IRUGO);
1526 MODULE_PARM_DESC(debug, "Debug enabled or not");
1527 module_param(initial_mode, int, S_IRUGO);
1528 MODULE_PARM_DESC(initial_mode, "Initial mode");