4 * Copyright (C) 2006,2007 Hermann Kneissel herkne@users.sourceforge.net
6 * The latest version of the driver can be found at
7 * http://sourceforge.net/projects/garmin-gps/
9 * This driver has been derived from v2.1 of the visor driver.
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.
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.
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
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 <asm/uaccess.h>
37 #include <asm/atomic.h>
38 #include <linux/usb.h>
39 #include <linux/usb/serial.h>
41 #include <linux/version.h>
43 /* the mode to be set when the port ist opened */
44 static int initial_mode
= 1;
49 #define GARMIN_VENDOR_ID 0x091E
55 #define VERSION_MAJOR 0
56 #define VERSION_MINOR 31
59 #define _DRIVER_VERSION(a,b) "v" _STR(a) "." _STR(b)
60 #define DRIVER_VERSION _DRIVER_VERSION(VERSION_MAJOR, VERSION_MINOR)
61 #define DRIVER_AUTHOR "hermann kneissel"
62 #define DRIVER_DESC "garmin gps driver"
64 /* error codes returned by the driver */
65 #define EINVPKT 1000 /* invalid packet structure */
68 // size of the header of a packet using the usb protocol
69 #define GARMIN_PKTHDR_LENGTH 12
71 // max. possible size of a packet using the serial protocol
72 #define MAX_SERIAL_PKT_SIZ (3+255+3)
74 // max. possible size of a packet with worst case stuffing
75 #define MAX_SERIAL_PKT_SIZ_STUFFED MAX_SERIAL_PKT_SIZ+256
77 // size of a buffer able to hold a complete (no stuffing) packet
78 // (the document protocol does not contain packets with a larger
79 // size, but in theory a packet may be 64k+12 bytes - if in
80 // later protocol versions larger packet sizes occur, this value
81 // should be increased accordingly, so the input buffer is always
82 // large enough the store a complete packet inclusive header)
83 #define GPS_IN_BUFSIZ (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ)
85 // size of a buffer able to hold a complete (incl. stuffing) packet
86 #define GPS_OUT_BUFSIZ (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ_STUFFED)
88 // where to place the packet id of a serial packet, so we can
89 // prepend the usb-packet header without the need to move the
91 #define GSP_INITIAL_OFFSET (GARMIN_PKTHDR_LENGTH-2)
93 // max. size of incoming private packets (header+1 param)
94 #define PRIVPKTSIZ (GARMIN_PKTHDR_LENGTH+4)
96 #define GARMIN_LAYERID_TRANSPORT 0
97 #define GARMIN_LAYERID_APPL 20
98 // our own layer-id to use for some control mechanisms
99 #define GARMIN_LAYERID_PRIVATE 0x01106E4B
101 #define GARMIN_PKTID_PVT_DATA 51
102 #define GARMIN_PKTID_L001_COMMAND_DATA 10
104 #define CMND_ABORT_TRANSFER 0
106 // packet ids used in private layer
107 #define PRIV_PKTID_SET_DEBUG 1
108 #define PRIV_PKTID_SET_MODE 2
109 #define PRIV_PKTID_INFO_REQ 3
110 #define PRIV_PKTID_INFO_RESP 4
111 #define PRIV_PKTID_RESET_REQ 5
112 #define PRIV_PKTID_SET_DEF_MODE 6
120 /* structure used to queue incoming packets */
121 struct garmin_packet
{
122 struct list_head list
;
124 int size
; // the real size of the data array, always > 0
128 /* structure used to keep the current state of the driver */
137 struct timer_list timer
;
138 struct usb_serial_port
*port
;
142 __u8 inbuffer
[GPS_IN_BUFSIZ
]; /* tty -> usb */
143 __u8 outbuffer
[GPS_OUT_BUFSIZ
]; /* usb -> tty */
148 struct list_head pktlist
;
153 #define STATE_INITIAL_DELAY 1
154 #define STATE_TIMEOUT 2
155 #define STATE_SESSION_REQ1 3
156 #define STATE_SESSION_REQ2 4
157 #define STATE_ACTIVE 5
159 #define STATE_RESET 8
160 #define STATE_DISCONNECTED 9
161 #define STATE_WAIT_TTY_ACK 10
162 #define STATE_GSP_WAIT_DATA 11
164 #define MODE_NATIVE 0
165 #define MODE_GARMIN_SERIAL 1
167 // Flags used in garmin_data.flags:
168 #define FLAGS_SESSION_REPLY_MASK 0x00C0
169 #define FLAGS_SESSION_REPLY1_SEEN 0x0080
170 #define FLAGS_SESSION_REPLY2_SEEN 0x0040
171 #define FLAGS_BULK_IN_ACTIVE 0x0020
172 #define FLAGS_BULK_IN_RESTART 0x0010
173 #define FLAGS_THROTTLED 0x0008
174 #define CLEAR_HALT_REQUIRED 0x0001
176 #define FLAGS_QUEUING 0x0100
177 #define FLAGS_DROP_DATA 0x0800
179 #define FLAGS_GSP_SKIP 0x1000
180 #define FLAGS_GSP_DLESEEN 0x2000
187 /* function prototypes */
188 static void gsp_next_packet(struct garmin_data
* garmin_data_p
);
189 static int garmin_write_bulk(struct usb_serial_port
*port
,
190 const unsigned char *buf
, int count
,
193 /* some special packets to be send or received */
194 static unsigned char const GARMIN_START_SESSION_REQ
[]
195 = { 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0 };
196 static unsigned char const GARMIN_START_SESSION_REQ2
[]
197 = { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 };
198 static unsigned char const GARMIN_START_SESSION_REPLY
[]
199 = { 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0 };
200 static unsigned char const GARMIN_SESSION_ACTIVE_REPLY
[]
201 = { 0, 0, 0, 0, 17, 0, 0, 0, 4, 0, 0, 0, 0, 16, 0, 0 };
202 static unsigned char const GARMIN_BULK_IN_AVAIL_REPLY
[]
203 = { 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 };
204 static unsigned char const GARMIN_APP_LAYER_REPLY
[]
206 static unsigned char const GARMIN_START_PVT_REQ
[]
207 = { 20, 0, 0, 0, 10, 0, 0, 0, 2, 0, 0, 0, 49, 0 };
208 static unsigned char const GARMIN_STOP_PVT_REQ
[]
209 = { 20, 0, 0, 0, 10, 0, 0, 0, 2, 0, 0, 0, 50, 0 };
210 static unsigned char const GARMIN_STOP_TRANSFER_REQ
[]
211 = { 20, 0, 0, 0, 10, 0, 0, 0, 2, 0, 0, 0, 0, 0 };
212 static unsigned char const GARMIN_STOP_TRANSFER_REQ_V2
[]
213 = { 20, 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0 };
214 static unsigned char const PRIVATE_REQ
[]
215 = { 0x4B, 0x6E, 0x10, 0x01, 0xFF, 0, 0, 0, 0xFF, 0, 0, 0 };
219 static struct usb_device_id id_table
[] = {
220 /* the same device id seems to be used by all usb enabled gps devices */
221 { USB_DEVICE(GARMIN_VENDOR_ID
, 3 ) },
222 { } /* Terminating entry */
225 MODULE_DEVICE_TABLE (usb
, id_table
);
227 static struct usb_driver garmin_driver
= {
228 .name
= "garmin_gps",
229 .probe
= usb_serial_probe
,
230 .disconnect
= usb_serial_disconnect
,
231 .id_table
= id_table
,
236 static inline int noResponseFromAppLayer(struct garmin_data
* garmin_data_p
)
238 return atomic_read(&garmin_data_p
->req_count
) == atomic_read(&garmin_data_p
->resp_count
);
242 static inline int getLayerId(const __u8
*usbPacket
)
244 return __le32_to_cpup((__le32
*)(usbPacket
));
247 static inline int getPacketId(const __u8
*usbPacket
)
249 return __le32_to_cpup((__le32
*)(usbPacket
+4));
252 static inline int getDataLength(const __u8
*usbPacket
)
254 return __le32_to_cpup((__le32
*)(usbPacket
+8));
259 * check if the usb-packet in buf contains an abort-transfer command.
260 * (if yes, all queued data will be dropped)
262 static inline int isAbortTrfCmnd(const unsigned char *buf
)
264 if (0 == memcmp(buf
, GARMIN_STOP_TRANSFER_REQ
,
265 sizeof(GARMIN_STOP_TRANSFER_REQ
)) ||
266 0 == memcmp(buf
, GARMIN_STOP_TRANSFER_REQ_V2
,
267 sizeof(GARMIN_STOP_TRANSFER_REQ_V2
)))
275 static void send_to_tty(struct usb_serial_port
*port
,
276 char *data
, unsigned int actual_length
)
278 struct tty_struct
*tty
= port
->tty
;
280 if (tty
&& actual_length
) {
282 usb_serial_debug_data(debug
, &port
->dev
,
283 __func__
, actual_length
, data
);
285 tty_buffer_request_room(tty
, actual_length
);
286 tty_insert_flip_string(tty
, data
, actual_length
);
287 tty_flip_buffer_push(tty
);
292 /******************************************************************************
293 * packet queue handling
294 ******************************************************************************/
297 * queue a received (usb-)packet for later processing
299 static int pkt_add(struct garmin_data
* garmin_data_p
,
300 unsigned char *data
, unsigned int data_length
)
305 struct garmin_packet
*pkt
;
307 /* process only packets containg data ... */
309 pkt
= kmalloc(sizeof(struct garmin_packet
)+data_length
,
312 dev_err(&garmin_data_p
->port
->dev
, "out of memory\n");
315 pkt
->size
= data_length
;
316 memcpy(pkt
->data
, data
, data_length
);
318 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
319 garmin_data_p
->flags
|= FLAGS_QUEUING
;
320 result
= list_empty(&garmin_data_p
->pktlist
);
321 pkt
->seq
= garmin_data_p
->seq_counter
++;
322 list_add_tail(&pkt
->list
, &garmin_data_p
->pktlist
);
323 state
= garmin_data_p
->state
;
324 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
326 /* in serial mode, if someone is waiting for data from
327 the device, iconvert and send the next packet to tty. */
328 if (result
&& (state
== STATE_GSP_WAIT_DATA
)) {
329 gsp_next_packet(garmin_data_p
);
336 /* get the next pending packet */
337 static struct garmin_packet
*pkt_pop(struct garmin_data
* garmin_data_p
)
340 struct garmin_packet
*result
= NULL
;
342 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
343 if (!list_empty(&garmin_data_p
->pktlist
)) {
344 result
= (struct garmin_packet
*)garmin_data_p
->pktlist
.next
;
345 list_del(&result
->list
);
347 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
352 /* free up all queued data */
353 static void pkt_clear(struct garmin_data
* garmin_data_p
)
356 struct garmin_packet
*result
= NULL
;
360 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
361 while (!list_empty(&garmin_data_p
->pktlist
)) {
362 result
= (struct garmin_packet
*)garmin_data_p
->pktlist
.next
;
363 list_del(&result
->list
);
366 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
370 /******************************************************************************
371 * garmin serial protocol handling handling
372 ******************************************************************************/
374 /* send an ack packet back to the tty */
375 static int gsp_send_ack(struct garmin_data
* garmin_data_p
, __u8 pkt_id
)
382 dbg("%s - pkt-id: 0x%X.", __func__
, 0xFF & pkt_id
);
399 *ptr
++ = 0xFF & (-cksum
);
405 send_to_tty(garmin_data_p
->port
, pkt
, l
);
412 * called for a complete packet received from tty layer
414 * the complete packet (pkzid ... cksum) is in garmin_data_p->inbuf starting
415 * at GSP_INITIAL_OFFSET.
417 * count - number of bytes in the input buffer including space reserved for
418 * the usb header: GSP_INITIAL_OFFSET + number of bytes in packet
419 * (including pkt-id, data-length a. cksum)
421 static int gsp_rec_packet(struct garmin_data
* garmin_data_p
, int count
)
423 const __u8
* recpkt
= garmin_data_p
->inbuffer
+GSP_INITIAL_OFFSET
;
424 __le32
*usbdata
= (__le32
*) garmin_data_p
->inbuffer
;
428 int pktid
= recpkt
[0];
429 int size
= recpkt
[1];
431 usb_serial_debug_data(debug
, &garmin_data_p
->port
->dev
,
432 __func__
, count
-GSP_INITIAL_OFFSET
, recpkt
);
434 if (size
!= (count
-GSP_INITIAL_OFFSET
-3)) {
435 dbg("%s - invalid size, expected %d bytes, got %d",
436 __func__
, size
, (count
-GSP_INITIAL_OFFSET
-3));
443 // sanity check, remove after test ...
444 if ((__u8
*)&(usbdata
[3]) != recpkt
) {
445 dbg("%s - ptr mismatch %p - %p",
446 __func__
, &(usbdata
[4]), recpkt
);
455 if ((0xff & (cksum
+ *recpkt
)) != 0) {
456 dbg("%s - invalid checksum, expected %02x, got %02x",
457 __func__
, 0xff & -cksum
, 0xff & *recpkt
);
461 usbdata
[0] = __cpu_to_le32(GARMIN_LAYERID_APPL
);
462 usbdata
[1] = __cpu_to_le32(pktid
);
463 usbdata
[2] = __cpu_to_le32(size
);
465 garmin_write_bulk (garmin_data_p
->port
, garmin_data_p
->inbuffer
,
466 GARMIN_PKTHDR_LENGTH
+size
, 0);
468 /* if this was an abort-transfer command, flush all
470 if (isAbortTrfCmnd(garmin_data_p
->inbuffer
)) {
471 garmin_data_p
->flags
|= FLAGS_DROP_DATA
;
472 pkt_clear(garmin_data_p
);
481 * Called for data received from tty
483 * buf contains the data read, it may span more than one packet or even
486 * input record should be a serial-record, but it may not be complete.
487 * Copy it into our local buffer, until an etx is seen (or an error
489 * Once the record is complete, convert into a usb packet and send it
490 * to the bulk pipe, send an ack back to the tty.
492 * If the input is an ack, just send the last queued packet to the
495 * if the input is an abort command, drop all queued data.
498 static int gsp_receive(struct garmin_data
* garmin_data_p
,
499 const unsigned char *buf
, int count
)
503 int ack_or_nak_seen
= 0;
507 // dleSeen: set if last byte read was a DLE
509 // skip: if set, skip incoming data until possible start of
514 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
515 dest
= garmin_data_p
->inbuffer
;
516 size
= garmin_data_p
->insize
;
517 dleSeen
= garmin_data_p
->flags
& FLAGS_GSP_DLESEEN
;
518 skip
= garmin_data_p
->flags
& FLAGS_GSP_SKIP
;
519 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
521 dbg("%s - dle=%d skip=%d size=%d count=%d",
522 __func__
, dleSeen
, skip
, size
, count
);
525 size
= GSP_INITIAL_OFFSET
;
528 while (offs
< count
) {
534 if (skip
) { /* start of a new pkt */
536 size
= GSP_INITIAL_OFFSET
;
538 } else if (dleSeen
) {
544 } else if (data
== ETX
) {
546 /* packet complete */
548 data
= dest
[GSP_INITIAL_OFFSET
];
551 ack_or_nak_seen
= ACK
;
552 dbg("ACK packet complete.");
553 } else if (data
== NAK
) {
554 ack_or_nak_seen
= NAK
;
555 dbg("NAK packet complete.");
557 dbg("packet complete "
560 gsp_rec_packet(garmin_data_p
, size
);
564 size
= GSP_INITIAL_OFFSET
;
572 dbg("non-masked DLE at %d - restarting", i
);
573 size
= GSP_INITIAL_OFFSET
;
580 if (size
>= GPS_IN_BUFSIZ
) {
581 dbg("%s - packet too large.", __func__
);
583 size
= GSP_INITIAL_OFFSET
;
588 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
590 garmin_data_p
->insize
= size
;
592 // copy flags back to structure
594 garmin_data_p
->flags
|= FLAGS_GSP_SKIP
;
596 garmin_data_p
->flags
&= ~FLAGS_GSP_SKIP
;
599 garmin_data_p
->flags
|= FLAGS_GSP_DLESEEN
;
601 garmin_data_p
->flags
&= ~FLAGS_GSP_DLESEEN
;
603 if (ack_or_nak_seen
) {
604 garmin_data_p
->state
= STATE_GSP_WAIT_DATA
;
607 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
609 if (ack_or_nak_seen
) {
610 gsp_next_packet(garmin_data_p
);
620 * Sends a usb packet to the tty
622 * Assumes, that all packages and at an usb-packet boundary.
624 * return <0 on error, 0 if packet is incomplete or > 0 if packet was sent
626 static int gsp_send(struct garmin_data
* garmin_data_p
,
627 const unsigned char *buf
, int count
)
629 const unsigned char *src
;
637 dbg("%s - state %d - %d bytes.", __func__
,
638 garmin_data_p
->state
, count
);
640 k
= garmin_data_p
->outsize
;
641 if ((k
+count
) > GPS_OUT_BUFSIZ
) {
642 dbg("packet too large");
643 garmin_data_p
->outsize
= 0;
647 memcpy(garmin_data_p
->outbuffer
+k
, buf
, count
);
649 garmin_data_p
->outsize
= k
;
651 if (k
>= GARMIN_PKTHDR_LENGTH
) {
652 pktid
= getPacketId(garmin_data_p
->outbuffer
);
653 datalen
= getDataLength(garmin_data_p
->outbuffer
);
654 i
= GARMIN_PKTHDR_LENGTH
+ datalen
;
661 dbg("%s - %d bytes in buffer, %d bytes in pkt.", __func__
,
664 /* garmin_data_p->outbuffer now contains a complete packet */
666 usb_serial_debug_data(debug
, &garmin_data_p
->port
->dev
,
667 __func__
, k
, garmin_data_p
->outbuffer
);
669 garmin_data_p
->outsize
= 0;
671 if (GARMIN_LAYERID_APPL
!= getLayerId(garmin_data_p
->outbuffer
)) {
672 dbg("not an application packet (%d)",
673 getLayerId(garmin_data_p
->outbuffer
));
678 dbg("packet-id %d too large", pktid
);
683 dbg("packet-size %d too large", datalen
);
687 /* the serial protocol should be able to handle this packet */
690 src
= garmin_data_p
->outbuffer
+GARMIN_PKTHDR_LENGTH
;
691 for (i
=0; i
<datalen
; i
++) {
696 src
= garmin_data_p
->outbuffer
+GARMIN_PKTHDR_LENGTH
;
697 if (k
> (GARMIN_PKTHDR_LENGTH
-2)) {
698 /* can't add stuffing DLEs in place, move data to end
700 dst
= garmin_data_p
->outbuffer
+GPS_OUT_BUFSIZ
-datalen
;
701 memcpy(dst
, src
, datalen
);
705 dst
= garmin_data_p
->outbuffer
;
715 for (i
=0; i
<datalen
; i
++) {
723 cksum
= 0xFF & -cksum
;
730 i
= dst
-garmin_data_p
->outbuffer
;
732 send_to_tty(garmin_data_p
->port
, garmin_data_p
->outbuffer
, i
);
734 garmin_data_p
->pkt_id
= pktid
;
735 garmin_data_p
->state
= STATE_WAIT_TTY_ACK
;
745 * Process the next pending data packet - if there is one
747 static void gsp_next_packet(struct garmin_data
* garmin_data_p
)
749 struct garmin_packet
*pkt
= NULL
;
751 while ((pkt
= pkt_pop(garmin_data_p
)) != NULL
) {
752 dbg("%s - next pkt: %d", __func__
, pkt
->seq
);
753 if (gsp_send(garmin_data_p
, pkt
->data
, pkt
->size
) > 0) {
764 /******************************************************************************
766 ******************************************************************************/
770 * Called for data received from tty
772 * The input data is expected to be in garmin usb-packet format.
774 * buf contains the data read, it may span more than one packet
775 * or even incomplete packets
777 static int nat_receive(struct garmin_data
* garmin_data_p
,
778 const unsigned char *buf
, int count
)
786 while (offs
< count
) {
787 // if buffer contains header, copy rest of data
788 if (garmin_data_p
->insize
>= GARMIN_PKTHDR_LENGTH
)
789 len
= GARMIN_PKTHDR_LENGTH
790 +getDataLength(garmin_data_p
->inbuffer
);
792 len
= GARMIN_PKTHDR_LENGTH
;
794 if (len
>= GPS_IN_BUFSIZ
) {
795 /* seem to be an invalid packet, ignore rest of input */
796 dbg("%s - packet size too large: %d",
798 garmin_data_p
->insize
= 0;
802 len
-= garmin_data_p
->insize
;
803 if (len
> (count
-offs
))
806 dest
= garmin_data_p
->inbuffer
807 +garmin_data_p
->insize
;
808 memcpy(dest
, buf
+offs
, len
);
809 garmin_data_p
->insize
+= len
;
814 /* do we have a complete packet ? */
815 if (garmin_data_p
->insize
>= GARMIN_PKTHDR_LENGTH
) {
816 len
= GARMIN_PKTHDR_LENGTH
+
817 getDataLength(garmin_data_p
->inbuffer
);
818 if (garmin_data_p
->insize
>= len
) {
819 garmin_write_bulk (garmin_data_p
->port
,
820 garmin_data_p
->inbuffer
,
822 garmin_data_p
->insize
= 0;
824 /* if this was an abort-transfer command,
825 flush all queued data. */
826 if (isAbortTrfCmnd(garmin_data_p
->inbuffer
)) {
827 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
828 garmin_data_p
->flags
|= FLAGS_DROP_DATA
;
829 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
830 pkt_clear(garmin_data_p
);
839 /******************************************************************************
841 ******************************************************************************/
843 static void priv_status_resp(struct usb_serial_port
*port
)
845 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
846 __le32
*pkt
= (__le32
*)garmin_data_p
->privpkt
;
848 pkt
[0] = __cpu_to_le32(GARMIN_LAYERID_PRIVATE
);
849 pkt
[1] = __cpu_to_le32(PRIV_PKTID_INFO_RESP
);
850 pkt
[2] = __cpu_to_le32(12);
851 pkt
[3] = __cpu_to_le32(VERSION_MAJOR
<< 16 | VERSION_MINOR
);
852 pkt
[4] = __cpu_to_le32(garmin_data_p
->mode
);
853 pkt
[5] = __cpu_to_le32(garmin_data_p
->serial_num
);
855 send_to_tty(port
, (__u8
*)pkt
, 6*4);
859 /******************************************************************************
860 * Garmin specific driver functions
861 ******************************************************************************/
863 static int process_resetdev_request(struct usb_serial_port
*port
)
867 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
869 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
870 garmin_data_p
->flags
&= ~(CLEAR_HALT_REQUIRED
);
871 garmin_data_p
->state
= STATE_RESET
;
872 garmin_data_p
->serial_num
= 0;
873 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
875 usb_kill_urb (port
->interrupt_in_urb
);
876 dbg("%s - usb_reset_device", __func__
);
877 status
= usb_reset_device(port
->serial
->dev
);
879 dbg("%s - usb_reset_device failed: %d",
887 * clear all cached data
889 static int garmin_clear(struct garmin_data
* garmin_data_p
)
894 struct usb_serial_port
*port
= garmin_data_p
->port
;
896 if (port
!= NULL
&& atomic_read(&garmin_data_p
->resp_count
)) {
897 /* send a terminate command */
898 status
= garmin_write_bulk(port
, GARMIN_STOP_TRANSFER_REQ
,
899 sizeof(GARMIN_STOP_TRANSFER_REQ
),
903 /* flush all queued data */
904 pkt_clear(garmin_data_p
);
906 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
907 garmin_data_p
->insize
= 0;
908 garmin_data_p
->outsize
= 0;
909 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
919 static int garmin_init_session(struct usb_serial_port
*port
)
922 struct usb_serial
*serial
= port
->serial
;
923 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
927 usb_kill_urb (port
->interrupt_in_urb
);
929 dbg("%s - adding interrupt input", __func__
);
930 port
->interrupt_in_urb
->dev
= serial
->dev
;
931 status
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
933 dev_err(&serial
->dev
->dev
,
934 "%s - failed submitting interrupt urb,"
940 dbg("%s - starting session ...", __func__
);
941 garmin_data_p
->state
= STATE_ACTIVE
;
942 status
= garmin_write_bulk(port
, GARMIN_START_SESSION_REQ
,
943 sizeof(GARMIN_START_SESSION_REQ
),
948 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
949 garmin_data_p
->ignorePkts
++;
950 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
952 /* not needed, but the win32 driver does it too ... */
953 status
= garmin_write_bulk(port
,
954 GARMIN_START_SESSION_REQ2
,
955 sizeof(GARMIN_START_SESSION_REQ2
),
959 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
960 garmin_data_p
->ignorePkts
++;
961 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
973 static int garmin_open (struct usb_serial_port
*port
, struct file
*filp
)
977 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
979 dbg("%s - port %d", __func__
, port
->number
);
982 * Force low_latency on so that our tty_push actually forces the data
983 * through, otherwise it is scheduled, and with high data rates (like
984 * with OHCI) data can get lost.
987 port
->tty
->low_latency
= 1;
989 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
990 garmin_data_p
->mode
= initial_mode
;
991 garmin_data_p
->count
= 0;
992 garmin_data_p
->flags
= 0;
993 atomic_set(&garmin_data_p
->req_count
, 0);
994 atomic_set(&garmin_data_p
->resp_count
, 0);
995 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
997 /* shutdown any bulk reads that might be going on */
998 usb_kill_urb (port
->write_urb
);
999 usb_kill_urb (port
->read_urb
);
1001 if (garmin_data_p
->state
== STATE_RESET
) {
1002 status
= garmin_init_session(port
);
1005 garmin_data_p
->state
= STATE_ACTIVE
;
1011 static void garmin_close (struct usb_serial_port
*port
, struct file
* filp
)
1013 struct usb_serial
*serial
= port
->serial
;
1014 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1016 dbg("%s - port %d - mode=%d state=%d flags=0x%X", __func__
,
1017 port
->number
, garmin_data_p
->mode
,
1018 garmin_data_p
->state
, garmin_data_p
->flags
);
1023 mutex_lock(&port
->serial
->disc_mutex
);
1024 if (!port
->serial
->disconnected
)
1025 garmin_clear(garmin_data_p
);
1027 /* shutdown our urbs */
1028 usb_kill_urb (port
->read_urb
);
1029 usb_kill_urb (port
->write_urb
);
1031 if (!port
->serial
->disconnected
) {
1032 if (noResponseFromAppLayer(garmin_data_p
) ||
1033 ((garmin_data_p
->flags
& CLEAR_HALT_REQUIRED
) != 0)) {
1034 process_resetdev_request(port
);
1035 garmin_data_p
->state
= STATE_RESET
;
1037 garmin_data_p
->state
= STATE_DISCONNECTED
;
1040 garmin_data_p
->state
= STATE_DISCONNECTED
;
1042 mutex_unlock(&port
->serial
->disc_mutex
);
1046 static void garmin_write_bulk_callback (struct urb
*urb
)
1048 unsigned long flags
;
1049 struct usb_serial_port
*port
= urb
->context
;
1050 int status
= urb
->status
;
1053 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1055 dbg("%s - port %d", __func__
, port
->number
);
1057 if (GARMIN_LAYERID_APPL
== getLayerId(urb
->transfer_buffer
)
1058 && (garmin_data_p
->mode
== MODE_GARMIN_SERIAL
)) {
1059 gsp_send_ack(garmin_data_p
, ((__u8
*)urb
->transfer_buffer
)[4]);
1063 dbg("%s - nonzero write bulk status received: %d",
1064 __func__
, urb
->status
);
1065 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1066 garmin_data_p
->flags
|= CLEAR_HALT_REQUIRED
;
1067 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1070 usb_serial_port_softint(port
);
1073 /* Ignore errors that resulted from garmin_write_bulk with dismiss_ack=1 */
1075 /* free up the transfer buffer, as usb_free_urb() does not do this */
1076 kfree (urb
->transfer_buffer
);
1080 static int garmin_write_bulk (struct usb_serial_port
*port
,
1081 const unsigned char *buf
, int count
,
1084 unsigned long flags
;
1085 struct usb_serial
*serial
= port
->serial
;
1086 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1088 unsigned char *buffer
;
1091 dbg("%s - port %d, state %d", __func__
, port
->number
,
1092 garmin_data_p
->state
);
1094 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1095 garmin_data_p
->flags
&= ~FLAGS_DROP_DATA
;
1096 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1098 buffer
= kmalloc (count
, GFP_ATOMIC
);
1100 dev_err(&port
->dev
, "out of memory\n");
1104 urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1106 dev_err(&port
->dev
, "no more free urbs\n");
1111 memcpy (buffer
, buf
, count
);
1113 usb_serial_debug_data(debug
, &port
->dev
, __func__
, count
, buffer
);
1115 usb_fill_bulk_urb (urb
, serial
->dev
,
1116 usb_sndbulkpipe (serial
->dev
,
1117 port
->bulk_out_endpointAddress
),
1119 garmin_write_bulk_callback
,
1120 dismiss_ack
? NULL
: port
);
1121 urb
->transfer_flags
|= URB_ZERO_PACKET
;
1123 if (GARMIN_LAYERID_APPL
== getLayerId(buffer
)) {
1124 atomic_inc(&garmin_data_p
->req_count
);
1125 if (garmin_data_p
->mode
== MODE_GARMIN_SERIAL
) {
1126 pkt_clear(garmin_data_p
);
1127 garmin_data_p
->state
= STATE_GSP_WAIT_DATA
;
1131 /* send it down the pipe */
1132 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
1135 "%s - usb_submit_urb(write bulk) "
1136 "failed with status = %d\n",
1141 /* we are done with this urb, so let the host driver
1142 * really free it when it is finished with it */
1150 static int garmin_write (struct usb_serial_port
*port
,
1151 const unsigned char *buf
, int count
)
1153 int pktid
, pktsiz
, len
;
1154 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1155 __le32
*privpkt
= (__le32
*)garmin_data_p
->privpkt
;
1157 usb_serial_debug_data(debug
, &port
->dev
, __func__
, count
, buf
);
1159 /* check for our private packets */
1160 if (count
>= GARMIN_PKTHDR_LENGTH
) {
1166 memcpy(garmin_data_p
->privpkt
, buf
, len
);
1168 pktsiz
= getDataLength(garmin_data_p
->privpkt
);
1169 pktid
= getPacketId(garmin_data_p
->privpkt
);
1171 if (count
== (GARMIN_PKTHDR_LENGTH
+pktsiz
)
1172 && GARMIN_LAYERID_PRIVATE
== getLayerId(garmin_data_p
->privpkt
)) {
1174 dbg("%s - processing private request %d",
1177 // drop all unfinished transfers
1178 garmin_clear(garmin_data_p
);
1182 case PRIV_PKTID_SET_DEBUG
:
1185 debug
= __le32_to_cpu(privpkt
[3]);
1186 dbg("%s - debug level set to 0x%X",
1190 case PRIV_PKTID_SET_MODE
:
1193 garmin_data_p
->mode
= __le32_to_cpu(privpkt
[3]);
1194 dbg("%s - mode set to %d",
1195 __func__
, garmin_data_p
->mode
);
1198 case PRIV_PKTID_INFO_REQ
:
1199 priv_status_resp(port
);
1202 case PRIV_PKTID_RESET_REQ
:
1203 atomic_inc(&garmin_data_p
->req_count
);
1206 case PRIV_PKTID_SET_DEF_MODE
:
1209 initial_mode
= __le32_to_cpu(privpkt
[3]);
1210 dbg("%s - initial_mode set to %d",
1212 garmin_data_p
->mode
);
1219 garmin_data_p
->ignorePkts
= 0;
1221 if (garmin_data_p
->mode
== MODE_GARMIN_SERIAL
) {
1222 return gsp_receive(garmin_data_p
, buf
, count
);
1223 } else { /* MODE_NATIVE */
1224 return nat_receive(garmin_data_p
, buf
, count
);
1229 static int garmin_write_room (struct usb_serial_port
*port
)
1232 * Report back the bytes currently available in the output buffer.
1234 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1235 return GPS_OUT_BUFSIZ
-garmin_data_p
->outsize
;
1239 static int garmin_chars_in_buffer (struct usb_serial_port
*port
)
1242 * Report back the number of bytes currently in our input buffer.
1243 * Will this lock up the driver - the buffer contains an incomplete
1244 * package which will not be written to the device until it
1245 * has been completed ?
1247 //struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
1248 //return garmin_data_p->insize;
1253 static void garmin_read_process(struct garmin_data
* garmin_data_p
,
1254 unsigned char *data
, unsigned data_length
)
1256 if (garmin_data_p
->flags
& FLAGS_DROP_DATA
) {
1257 /* abort-transfer cmd is actice */
1258 dbg("%s - pkt dropped", __func__
);
1259 } else if (garmin_data_p
->state
!= STATE_DISCONNECTED
&&
1260 garmin_data_p
->state
!= STATE_RESET
) {
1262 /* remember any appl.layer packets, so we know
1263 if a reset is required or not when closing
1265 if (0 == memcmp(data
, GARMIN_APP_LAYER_REPLY
,
1266 sizeof(GARMIN_APP_LAYER_REPLY
))) {
1267 atomic_inc(&garmin_data_p
->resp_count
);
1270 /* if throttling is active or postprecessing is required
1271 put the received data in the input queue, otherwise
1272 send it directly to the tty port */
1273 if (garmin_data_p
->flags
& FLAGS_QUEUING
) {
1274 pkt_add(garmin_data_p
, data
, data_length
);
1275 } else if (garmin_data_p
->mode
== MODE_GARMIN_SERIAL
) {
1276 if (getLayerId(data
) == GARMIN_LAYERID_APPL
) {
1277 pkt_add(garmin_data_p
, data
, data_length
);
1280 send_to_tty(garmin_data_p
->port
, data
, data_length
);
1286 static void garmin_read_bulk_callback (struct urb
*urb
)
1288 unsigned long flags
;
1289 struct usb_serial_port
*port
= urb
->context
;
1290 struct usb_serial
*serial
= port
->serial
;
1291 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1292 unsigned char *data
= urb
->transfer_buffer
;
1293 int status
= urb
->status
;
1296 dbg("%s - port %d", __func__
, port
->number
);
1299 dbg("%s - bad serial pointer, exiting", __func__
);
1304 dbg("%s - nonzero read bulk status received: %d",
1309 usb_serial_debug_data(debug
, &port
->dev
,
1310 __func__
, urb
->actual_length
, data
);
1312 garmin_read_process(garmin_data_p
, data
, urb
->actual_length
);
1314 if (urb
->actual_length
== 0 &&
1315 0 != (garmin_data_p
->flags
& FLAGS_BULK_IN_RESTART
)) {
1316 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1317 garmin_data_p
->flags
&= ~FLAGS_BULK_IN_RESTART
;
1318 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1319 retval
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
1322 "%s - failed resubmitting read urb, error %d\n",
1324 } else if (urb
->actual_length
> 0) {
1325 /* Continue trying to read until nothing more is received */
1326 if (0 == (garmin_data_p
->flags
& FLAGS_THROTTLED
)) {
1327 retval
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
1330 "%s - failed resubmitting read urb, "
1331 "error %d\n", __func__
, retval
);
1334 dbg("%s - end of bulk data", __func__
);
1335 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1336 garmin_data_p
->flags
&= ~FLAGS_BULK_IN_ACTIVE
;
1337 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1343 static void garmin_read_int_callback (struct urb
*urb
)
1345 unsigned long flags
;
1347 struct usb_serial_port
*port
= urb
->context
;
1348 struct usb_serial
*serial
= port
->serial
;
1349 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1350 unsigned char *data
= urb
->transfer_buffer
;
1351 int status
= urb
->status
;
1360 /* this urb is terminated, clean up */
1361 dbg("%s - urb shutting down with status: %d",
1365 dbg("%s - nonzero urb status received: %d",
1370 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
1371 urb
->actual_length
, urb
->transfer_buffer
);
1373 if (urb
->actual_length
== sizeof(GARMIN_BULK_IN_AVAIL_REPLY
) &&
1374 0 == memcmp(data
, GARMIN_BULK_IN_AVAIL_REPLY
,
1375 sizeof(GARMIN_BULK_IN_AVAIL_REPLY
))) {
1377 dbg("%s - bulk data available.", __func__
);
1379 if (0 == (garmin_data_p
->flags
& FLAGS_BULK_IN_ACTIVE
)) {
1381 /* bulk data available */
1382 usb_fill_bulk_urb (port
->read_urb
, serial
->dev
,
1383 usb_rcvbulkpipe (serial
->dev
,
1384 port
->bulk_in_endpointAddress
),
1385 port
->read_urb
->transfer_buffer
,
1386 port
->read_urb
->transfer_buffer_length
,
1387 garmin_read_bulk_callback
, port
);
1388 retval
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
1391 "%s - failed submitting read urb, error %d\n",
1394 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1395 garmin_data_p
->flags
|= FLAGS_BULK_IN_ACTIVE
;
1396 /* do not send this packet to the user */
1397 garmin_data_p
->ignorePkts
= 1;
1398 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1401 /* bulk-in transfer still active */
1402 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1403 garmin_data_p
->flags
|= FLAGS_BULK_IN_RESTART
;
1404 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1407 } else if (urb
->actual_length
== (4+sizeof(GARMIN_START_SESSION_REPLY
))
1408 && 0 == memcmp(data
, GARMIN_START_SESSION_REPLY
,
1409 sizeof(GARMIN_START_SESSION_REPLY
))) {
1411 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1412 garmin_data_p
->flags
|= FLAGS_SESSION_REPLY1_SEEN
;
1413 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1415 /* save the serial number */
1416 garmin_data_p
->serial_num
1417 = __le32_to_cpup((__le32
*)(data
+GARMIN_PKTHDR_LENGTH
));
1419 dbg("%s - start-of-session reply seen - serial %u.",
1420 __func__
, garmin_data_p
->serial_num
);
1423 if (garmin_data_p
->ignorePkts
) {
1424 /* this reply belongs to a request generated by the driver,
1426 dbg("%s - pkt ignored (%d)",
1427 __func__
, garmin_data_p
->ignorePkts
);
1428 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1429 garmin_data_p
->ignorePkts
--;
1430 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1432 garmin_read_process(garmin_data_p
, data
, urb
->actual_length
);
1435 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1436 retval
= usb_submit_urb (urb
, GFP_ATOMIC
);
1438 dev_err(&urb
->dev
->dev
,
1439 "%s - Error %d submitting interrupt urb\n",
1445 * Sends the next queued packt to the tty port (garmin native mode only)
1446 * and then sets a timer to call itself again until all queued data
1449 static int garmin_flush_queue(struct garmin_data
* garmin_data_p
)
1451 unsigned long flags
;
1452 struct garmin_packet
*pkt
;
1454 if ((garmin_data_p
->flags
& FLAGS_THROTTLED
) == 0) {
1455 pkt
= pkt_pop(garmin_data_p
);
1457 send_to_tty(garmin_data_p
->port
, pkt
->data
, pkt
->size
);
1459 mod_timer(&garmin_data_p
->timer
, (1)+jiffies
);
1462 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1463 garmin_data_p
->flags
&= ~FLAGS_QUEUING
;
1464 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1471 static void garmin_throttle (struct usb_serial_port
*port
)
1473 unsigned long flags
;
1474 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1476 dbg("%s - port %d", __func__
, port
->number
);
1477 /* set flag, data received will be put into a queue
1478 for later processing */
1479 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1480 garmin_data_p
->flags
|= FLAGS_QUEUING
|FLAGS_THROTTLED
;
1481 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1485 static void garmin_unthrottle (struct usb_serial_port
*port
)
1487 unsigned long flags
;
1488 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1491 dbg("%s - port %d", __func__
, port
->number
);
1492 spin_lock_irqsave(&garmin_data_p
->lock
, flags
);
1493 garmin_data_p
->flags
&= ~FLAGS_THROTTLED
;
1494 spin_unlock_irqrestore(&garmin_data_p
->lock
, flags
);
1496 /* in native mode send queued data to tty, in
1497 serial mode nothing needs to be done here */
1498 if (garmin_data_p
->mode
== MODE_NATIVE
)
1499 garmin_flush_queue(garmin_data_p
);
1501 if (0 != (garmin_data_p
->flags
& FLAGS_BULK_IN_ACTIVE
)) {
1502 status
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
1505 "%s - failed resubmitting read urb, error %d\n",
1513 * The timer is currently only used to send queued packets to
1514 * the tty in cases where the protocol provides no own handshaking
1515 * to initiate the transfer.
1517 static void timeout_handler(unsigned long data
)
1519 struct garmin_data
*garmin_data_p
= (struct garmin_data
*) data
;
1521 /* send the next queued packet to the tty port */
1522 if (garmin_data_p
->mode
== MODE_NATIVE
)
1523 if (garmin_data_p
->flags
& FLAGS_QUEUING
)
1524 garmin_flush_queue(garmin_data_p
);
1529 static int garmin_attach (struct usb_serial
*serial
)
1532 struct usb_serial_port
*port
= serial
->port
[0];
1533 struct garmin_data
* garmin_data_p
= NULL
;
1535 dbg("%s", __func__
);
1537 garmin_data_p
= kzalloc(sizeof(struct garmin_data
), GFP_KERNEL
);
1538 if (garmin_data_p
== NULL
) {
1539 dev_err(&port
->dev
, "%s - Out of memory\n", __func__
);
1542 init_timer(&garmin_data_p
->timer
);
1543 spin_lock_init(&garmin_data_p
->lock
);
1544 INIT_LIST_HEAD(&garmin_data_p
->pktlist
);
1545 //garmin_data_p->timer.expires = jiffies + session_timeout;
1546 garmin_data_p
->timer
.data
= (unsigned long)garmin_data_p
;
1547 garmin_data_p
->timer
.function
= timeout_handler
;
1548 garmin_data_p
->port
= port
;
1549 garmin_data_p
->state
= 0;
1550 garmin_data_p
->count
= 0;
1551 usb_set_serial_port_data(port
, garmin_data_p
);
1553 status
= garmin_init_session(port
);
1559 static void garmin_shutdown (struct usb_serial
*serial
)
1561 struct usb_serial_port
*port
= serial
->port
[0];
1562 struct garmin_data
* garmin_data_p
= usb_get_serial_port_data(port
);
1564 dbg("%s", __func__
);
1566 usb_kill_urb (port
->interrupt_in_urb
);
1567 del_timer_sync(&garmin_data_p
->timer
);
1568 kfree (garmin_data_p
);
1569 usb_set_serial_port_data(port
, NULL
);
1573 /* All of the device info needed */
1574 static struct usb_serial_driver garmin_device
= {
1576 .owner
= THIS_MODULE
,
1577 .name
= "garmin_gps",
1579 .description
= "Garmin GPS usb/tty",
1580 .usb_driver
= &garmin_driver
,
1581 .id_table
= id_table
,
1583 .open
= garmin_open
,
1584 .close
= garmin_close
,
1585 .throttle
= garmin_throttle
,
1586 .unthrottle
= garmin_unthrottle
,
1587 .attach
= garmin_attach
,
1588 .shutdown
= garmin_shutdown
,
1589 .write
= garmin_write
,
1590 .write_room
= garmin_write_room
,
1591 .chars_in_buffer
= garmin_chars_in_buffer
,
1592 .write_bulk_callback
= garmin_write_bulk_callback
,
1593 .read_bulk_callback
= garmin_read_bulk_callback
,
1594 .read_int_callback
= garmin_read_int_callback
,
1599 static int __init
garmin_init (void)
1603 retval
= usb_serial_register(&garmin_device
);
1605 goto failed_garmin_register
;
1606 retval
= usb_register(&garmin_driver
);
1608 goto failed_usb_register
;
1609 info(DRIVER_DESC
" " DRIVER_VERSION
);
1612 failed_usb_register
:
1613 usb_serial_deregister(&garmin_device
);
1614 failed_garmin_register
:
1619 static void __exit
garmin_exit (void)
1621 usb_deregister (&garmin_driver
);
1622 usb_serial_deregister (&garmin_device
);
1628 module_init(garmin_init
);
1629 module_exit(garmin_exit
);
1631 MODULE_AUTHOR( DRIVER_AUTHOR
);
1632 MODULE_DESCRIPTION( DRIVER_DESC
);
1633 MODULE_LICENSE("GPL");
1635 module_param(debug
, bool, S_IWUSR
| S_IRUGO
);
1636 MODULE_PARM_DESC(debug
, "Debug enabled or not");
1637 module_param(initial_mode
, int, S_IRUGO
);
1638 MODULE_PARM_DESC(initial_mode
, "Initial mode");