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