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