Here is version 0.20 of the garmin gps driver patch for review, fixing the problems reported by oliver neukum. Hermann Kneissel
diff -Naur linux-2.6.9/drivers/usb/serial/garmin_gps.c linux-2.6.9-gps/drivers/usb/serial/garmin_gps.c --- linux-2.6.9/drivers/usb/serial/garmin_gps.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.9-gps/drivers/usb/serial/garmin_gps.c 2004-10-19 20:25:23.059968273 +0200 @@ -0,0 +1,1882 @@ +/* + * Garmin GPS driver + * + * Copyright (C) 2004 Hermann Kneissel [EMAIL PROTECTED] + * + * The latest version of the driver can be found at + * http://sourceforge.net/projects/garmin-gps/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111 USA + */ + +#include <linux/config.h> +#include <linux/kernel.h> +#include <linux/errno.h> +#include <linux/init.h> +#include <linux/slab.h> +#include <linux/timer.h> +#include <linux/tty.h> +#include <linux/tty_driver.h> +#include <linux/tty_flip.h> +#include <linux/module.h> +#include <linux/spinlock.h> +#include <asm/uaccess.h> +#include <linux/usb.h> + +#ifdef CONFIG_USB_SERIAL_DEBUG + static int debug = 1; +#else + static int debug; +#endif + +/* the mode to be set whenthe port ist opened */ +static int initial_mode = 1; + +#include "usb-serial.h" + +#define GARMIN_VENDOR_ID 0x091E + +/* + * Version Information + */ + +#define VERSION_MAJOR 0 +#define VERSION_MINOR 20 + +#define _STR(s) #s +#define _DRIVER_VERSION(a,b) "v" _STR(a) "." _STR(b) +#define DRIVER_VERSION _DRIVER_VERSION(VERSION_MAJOR, VERSION_MINOR) +#define DRIVER_AUTHOR "hermann kneissel" +#define DRIVER_DESC "garmin gps driver" + +/* debug flags */ +#define DEBUG_DRIVER 0x0001 +#define DEBUG_QUEUE 0x0002 +#define DEBUG_PROT_GSP 0x0010 +#define DEBUG_PROT_NATIVE 0x0040 +#define DEBUG_DATA_USB 0x0100 +#define DEBUG_DATA_TTY 0x0200 +#define DEBUG_DATA_GSP 0x0400 + +/* error codes returned by the driver */ +#define EINVPKT 1000 /* invalid packet structure */ + + + +struct garmin_data; + +/* function prototypes */ +static int garmin_open(struct usb_serial_port *port, struct file *filp); +static void garmin_close(struct usb_serial_port *port, struct file *filp); +static int garmin_write(struct usb_serial_port *port, + int from_user, const unsigned char *buf, int count); +static int garmin_flush_queue(struct garmin_data * garmin_data_p); +static int garmin_write_room(struct usb_serial_port *port); +static int garmin_chars_in_buffer(struct usb_serial_port *port); +static void garmin_throttle(struct usb_serial_port *port); +static void garmin_unthrottle(struct usb_serial_port *port); +static int gpsmap_probe(struct usb_serial *serial, + const struct usb_device_id *id); +static void garmin_shutdown(struct usb_serial *serial); +static int garmin_ioctl(struct usb_serial_port *port, struct file * file, + unsigned int cmd, unsigned long arg); +static void garmin_set_termios(struct usb_serial_port *port, + struct termios *old_termios); +static void garmin_write_bulk_callback(struct urb *urb, struct pt_regs *regs); +static void garmin_read_bulk_callback(struct urb *urb, struct pt_regs *regs); +static void garmin_read_int_callback(struct urb *urb, struct pt_regs *regs); +static int garmin_attach(struct usb_serial *serial); +static int garmin_probe(struct usb_serial *serial, + const struct usb_device_id *id); +static int garmin_write_bulk(struct usb_serial_port *port, int from_user, + const unsigned char *buf, int count); +static int process_resetdev_request(struct usb_serial_port *port); +static void gsp_next_packet(struct garmin_data * garmin_data_p); + + +/* Parameters that may be passed into the module. */ +static int vendor = -1; +static int product = -1; + +/* some special packets to be send or received */ +static unsigned char const GARMIN_START_SESSION_REQ[] + = { 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0 }; +static unsigned char const GARMIN_START_SESSION_REQ2[] + = { 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0 }; +static unsigned char const GARMIN_START_SESSION_REPLY[] + = { 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0 }; +static unsigned char const GARMIN_SESSION_ACTIVE_REPLY[] + = { 0, 0, 0, 0, 17, 0, 0, 0, 4, 0, 0, 0, 0, 16, 0, 0 }; +static unsigned char const GARMIN_BULK_IN_AVAIL_REPLY[] + = { 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0 }; +static unsigned char const GARMIN_APP_LAYER_REPLY[] + = { 0x14, 0, 0, 0 }; +static unsigned char const GARMIN_START_PVT_REQ[] + = { 20, 0, 0, 0, 10, 0, 0, 0, 2, 0, 0, 0, 49, 0 }; +static unsigned char const GARMIN_STOP_PVT_REQ[] + = { 20, 0, 0, 0, 10, 0, 0, 0, 2, 0, 0, 0, 50, 0 }; +static unsigned char const GARMIN_STOP_TRANSFER_REQ[] + = { 20, 0, 0, 0, 10, 0, 0, 0, 2, 0, 0, 0, 0, 0 }; +static unsigned char const GARMIN_STOP_TRANSFER_REQ_V2[] + = { 20, 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0 }; +static unsigned char const PRIVATE_REQ[] + = { 0x4B, 0x6E, 0x10, 0x01, 0xFF, 0, 0, 0, 0xFF, 0, 0, 0 }; + +// size of a buffer able to hold a complete (incl. stuffing) packet +#define GPSBUFSIZ 512 +// max. size of our private packets +#define PRIVPKTSIZ 64 + +#define GARMIN_LAYERID_TRANSPORT 0 +#define GARMIN_LAYERID_APPL 20 +// our own layer-id to use for some control mechanisms +#define GARMIN_LAYERID_PRIVATE 0x01106E4B + +#define GARMIN_PKTID_PVT_DATA 51 +#define GARMIN_PKTID_L001_COMMAND_DATA 10 + +#define CMND_ABORT_TRANSFER 0 + +// packet ids used in private layer +#define PRIV_PKTID_SET_DEBUG 1 +#define PRIV_PKTID_SET_MODE 2 +#define PRIV_PKTID_INFO_REQ 3 +#define PRIV_PKTID_INFO_RESP 4 +#define PRIV_PKTID_RESET_REQ 5 +#define PRIV_PKTID_SET_DEF_MODE 6 + +#define GARMIN_PKTHDR_LENGTH 12 + +#define ETX 0x03 +#define DLE 0x10 +#define ACK 0x06 +#define NAK 0x15 + + + +static struct usb_device_id id_table [] = { + /* same device id for GPSmap60C and GPS18 */ + { USB_DEVICE(GARMIN_VENDOR_ID, 3 ), + .driver_info = (kernel_ulong_t)&gpsmap_probe }, + { }, /* optional parameter entry */ + { } /* Terminating entry */ +}; + +static struct usb_device_id id_table_combined [] = { + { USB_DEVICE(GARMIN_VENDOR_ID, 3) }, + { }, /* optional parameter entry */ + { } /* Terminating entry */ +}; + +MODULE_DEVICE_TABLE (usb, id_table_combined); + +static struct usb_driver garmin_driver = { + .owner = THIS_MODULE, + .name = "garmin_gps", + .probe = usb_serial_probe, + .disconnect = usb_serial_disconnect, + .id_table = id_table_combined, +}; + +/* All of the device info needed */ +static struct usb_serial_device_type garmin_device = { + .owner = THIS_MODULE, + .name = "Garmin GPS usb/tty", + .short_name = "garmin_gps", + .id_table = id_table, + .num_interrupt_in = 1, + .num_bulk_in = 1, + .num_bulk_out = 1, + .num_ports = 1, + .open = garmin_open, + .close = garmin_close, + .throttle = garmin_throttle, + .unthrottle = garmin_unthrottle, + .attach = garmin_attach, + .probe = garmin_probe, + .shutdown = garmin_shutdown, + .ioctl = garmin_ioctl, + .set_termios = garmin_set_termios, + .write = garmin_write, + .write_room = garmin_write_room, + .chars_in_buffer = garmin_chars_in_buffer, + .write_bulk_callback = garmin_write_bulk_callback, + .read_bulk_callback = garmin_read_bulk_callback, + .read_int_callback = garmin_read_int_callback, +}; + +static int bytes_in; +static int bytes_out; + +/* structure used to queue incoming packets */ +struct garmin_packet { + struct list_head list; + int seq; + int size; // the real size of the data array, always > 0 + __u8 data[1]; +}; + +/* structure used to keep the current state of the driver */ +struct garmin_data { + __u8 state; + __u16 flags; + __u8 mode; + __u8 ignorePkts; + __u8 count; + __u8 pkt_id; + __u8 serial_num[4]; + struct timer_list timer; + struct usb_serial_port *port; + int seq_counter; + int insize; + int outsize; + __u8 inbuffer [GPSBUFSIZ]; /* tty -> usb */ + __u8 outbuffer[GPSBUFSIZ]; /* usb -> tty */ + spinlock_t lock; + struct list_head pktlist; +}; + + +#define STATE_NEW 0 +#define STATE_INITIAL_DELAY 1 +#define STATE_TIMEOUT 2 +#define STATE_SESSION_REQ1 3 +#define STATE_SESSION_REQ2 4 +#define STATE_ACTIVE 5 + +#define STATE_RESET 8 +#define STATE_DISCONNECTED 9 +#define STATE_WAIT_TTY_ACK 10 +#define STATE_GSP_WAIT_DATA 11 + +#define MODE_NATIVE 0 +#define MODE_GARMIN_SERIAL 1 + +// Flags used in garmin_data.flags: +#define FLAGS_SESSION_REPLY_MASK 0x00C0 +#define FLAGS_SESSION_REPLY1_SEEN 0x0080 +#define FLAGS_SESSION_REPLY2_SEEN 0x0040 +#define FLAGS_BULK_IN_ACTIVE 0x0020 +#define FLAGS_THROTTLED 0x0010 +#define CLEAR_HALT_REQUIRED 0x0001 + +#define FLAGS_QUEUING 0x0100 +#define FLAGS_APP_RESP_SEEN 0x0200 +#define FLAGS_APP_REQ_SEEN 0x0400 +#define FLAGS_DROP_DATA 0x0800 + +#define FLAGS_GSP_SKIP 0x1000 +#define FLAGS_GSP_DLESEEN 0x2000 + + +#undef dbg +#define dbg_drv(garmin_data_p, format, arg...) \ + do { \ + if (debug&DEBUG_DRIVER) \ + dev_printk(KERN_DEBUG, &garmin_data_p->port->dev, \ + format "\n" , ## arg); \ + } while (0) + +#define dbg_gsp(garmin_data_p, format, arg...) \ + do { \ + if (debug&DEBUG_PROT_GSP) \ + dev_printk(KERN_DEBUG, &garmin_data_p->port->dev, \ + format "\n", ## arg); \ + } while (0) + +#define dbg_queue(garmin_data_p, format, arg...) \ + do { \ + if (debug&DEBUG_QUEUE) \ + dev_printk(KERN_DEBUG, &garmin_data_p->port->dev, \ + format "\n", ## arg); \ + } while (0) + +#define dbg_nat(garmin_data_p, format, arg...) \ + do { \ + if (debug&DEBUG_PROT_NATIVE) \ + dev_printk(KERN_DEBUG, &garmin_data_p->port->dev, \ + format "\n" , ## arg); \ + } while (0) + +static inline int garmin_debug_data(int debug, + struct device *dev, + const char *function, + int size, + const unsigned char *data) +{ + int i; + + if (debug) { + dev_printk(KERN_DEBUG, dev, + "%s - length = %d, data = ", function, size); + for (i = 0; i < size; ++i) + printk ("%.2x ", data[i]); + printk ("\n"); + } + return debug; +} + + +static inline int get_int(const unsigned char *buf) +{ + return (0xFF & buf[0]) | ((0xFF & buf[1]) << 8) | + ((0xFF & buf[2]) << 16) | ((0xFF & buf[3]) << 24); +} + + +static inline int get_short(const unsigned char *buf) +{ + return (0xFF & buf[0]) | ((0xFF & buf[1]) << 8); +} + + +static inline void set_int(unsigned char *buf, int value) +{ + buf[0] = 0xFF & value; + buf[1] = 0xFF & (value >> 8); + buf[2] = 0xFF & (value >> 16); + buf[3] = 0xFF & (value >> 24); +} + + +static inline int noResponseFromAppLayer(struct garmin_data * garmin_data_p) +{ + return ((garmin_data_p->flags + & (FLAGS_APP_REQ_SEEN|FLAGS_APP_RESP_SEEN)) + == FLAGS_APP_REQ_SEEN); +} + + +/* + * check if the usb-packet in buf contains an abort-transfer command. + * (if yes, all queued data will be dropped) + */ +static inline int isAbortTrfCmnd(const unsigned char *buf) +{ + if (0 == memcmp(buf, GARMIN_STOP_TRANSFER_REQ, + sizeof(GARMIN_STOP_TRANSFER_REQ)) || + 0 == memcmp(buf, GARMIN_STOP_TRANSFER_REQ_V2, + sizeof(GARMIN_STOP_TRANSFER_REQ_V2))) + return 1; + else + return 0; +} + + +static struct list_head *list_first(struct list_head *head) +{ + return head->next; +} + + + +static void send_to_tty(struct usb_serial_port *port, + char *data, unsigned int actual_length) +{ + struct tty_struct *tty = port->tty; + int i; + + if (tty && actual_length) { + + garmin_debug_data (debug & DEBUG_DATA_TTY, &port->dev, + __FUNCTION__, + actual_length, data); + + for (i = 0; i < actual_length ; ++i) { + /* if we insert more than TTY_FLIPBUF_SIZE characters, + we drop them. */ + if(tty->flip.count >= TTY_FLIPBUF_SIZE) { + tty_flip_buffer_push(tty); + } + /* this doesn't actually push the data through unless + tty->low_latency is set */ + tty_insert_flip_char(tty, data[i], 0); + } + tty_flip_buffer_push(tty); + } + bytes_in += actual_length; +} + + +/****************************************************************************** + * packet queue handling + ******************************************************************************/ + +/* + * queue a received (usb-)packet for later processing + */ +static int pkt_add(struct garmin_data * garmin_data_p, + unsigned char *data, unsigned int data_length) +{ + int result = 0; + unsigned long flags; + struct garmin_packet *pkt; + + /* process only packets containg data ... */ + if (data_length) { + garmin_data_p->flags |= FLAGS_QUEUING; + pkt = kmalloc(sizeof(struct garmin_packet)+data_length, + GFP_ATOMIC); + if (pkt == 0) { + dev_err(&garmin_data_p->port->dev, "out of memory\n"); + return 0; + } + pkt->size = data_length; + memcpy(pkt->data, data, data_length); + + spin_lock_irqsave(&garmin_data_p->lock, flags); + result = list_empty(&garmin_data_p->pktlist); + pkt->seq = garmin_data_p->seq_counter++; + list_add_tail(&pkt->list, &garmin_data_p->pktlist); + spin_unlock_irqrestore(&garmin_data_p->lock, flags); + + /* in serial mode, if someone is waiting for data from + the device, iconvert and send the next packet to tty. */ + if (result && (garmin_data_p->state == STATE_GSP_WAIT_DATA)) { + gsp_next_packet(garmin_data_p); + } + } + return result; +} + + +/* get the next pending packet */ +static struct garmin_packet *pkt_pop(struct garmin_data * garmin_data_p) +{ + unsigned long flags; + struct garmin_packet *result = 0; + + spin_lock_irqsave(&garmin_data_p->lock, flags); + if (!list_empty(&garmin_data_p->pktlist)) { + result = (struct garmin_packet *) + list_first(&garmin_data_p->pktlist); + list_del(&result->list); + } + spin_unlock_irqrestore(&garmin_data_p->lock, flags); + return result; +} + + +/* free up all queued data */ +static void pkt_clear(struct garmin_data * garmin_data_p) +{ + unsigned long flags; + struct garmin_packet *result = 0; + + dbg_drv(garmin_data_p, "%s", __FUNCTION__); + + spin_lock_irqsave(&garmin_data_p->lock, flags); + while (!list_empty(&garmin_data_p->pktlist)) { + result = (struct garmin_packet *) + list_first(&garmin_data_p->pktlist); + list_del(&result->list); + kfree(result); + } + spin_unlock_irqrestore(&garmin_data_p->lock, flags); +} + + +/****************************************************************************** + * garmin serial protocol handling handling + ******************************************************************************/ + + +/* send a packet back to the tty */ +static int gsp_send_packet(struct garmin_data * garmin_data_p, __u8 pkt_id, + unsigned data_length, unsigned char *data) +{ + __u8 pkt[512]; + __u8 cksum = 0; + __u8 *ptr = pkt; + unsigned l = 0; + unsigned i = 0; + + dbg_gsp(garmin_data_p, + "%s - pkt-id: 0x%X, %d bytes.", __FUNCTION__, + 0xFF & pkt_id, data_length); + + if (data_length && data_length < 256) { + + *ptr++ = DLE; + *ptr++ = pkt_id; + cksum += pkt_id; + + *ptr++ = data_length; + cksum += data_length; + if (data_length == DLE) { + *ptr++ = DLE; + } + + while (i < data_length) { + *ptr++ = data[i]; + cksum += data[i]; + if (data[i] == DLE) { + *ptr++ = DLE; + } + i++; + } + + *ptr++ = 0xff & (-cksum); + *ptr++ = DLE; + *ptr++ = ETX; + + l = ptr-pkt; + + send_to_tty(garmin_data_p->port, pkt, l); + } + return 0; +} + + +/* send an ack packet back to the tty */ +static int gsp_send_ack(struct garmin_data * garmin_data_p, __u8 pkt_id) +{ + __u8 pkt[2]; + + dbg_gsp(garmin_data_p, + "%s - pkt-id: 0x%X.", __FUNCTION__, 0xFF & pkt_id); + + pkt[0] = pkt_id; + pkt[1] = 0; + return gsp_send_packet(garmin_data_p, ACK, 2, pkt); +} + + + +/* + * called for a complete packet received from tty layer + * buf -> serial packet + */ +static int gsp_rec_packet(struct garmin_data * garmin_data_p, + const unsigned char *buf, int count) +{ + __u8 usbpacket[512]; + __u8 *data = usbpacket+GARMIN_PKTHDR_LENGTH; + int cksum = 0; + int i = 1; + int n = 0; + int size = buf[1]; + + garmin_debug_data (debug & DEBUG_DATA_GSP, &garmin_data_p->port->dev, + __FUNCTION__, count, buf); + + set_int(usbpacket, GARMIN_LAYERID_APPL); + set_int(usbpacket+4, buf[0]); + set_int(usbpacket+8, buf[1]); + + cksum += buf[0]; // id + cksum += buf[1]; // len + i++; + + while (n < size) { + if (i >= count) { + dbg_gsp(garmin_data_p, + "%s - packet too small, " + "expected %d byte, got %d", + __FUNCTION__, size, count); + return -EINVPKT; + } + *data++ = buf[i]; + cksum += buf[i]; + i++; + n++; + } + + garmin_write_bulk (garmin_data_p->port, 0, usbpacket, + GARMIN_PKTHDR_LENGTH+size); + + /* if this was an abort-transfer command, flush all + queued data. */ + if (isAbortTrfCmnd(usbpacket)) { + garmin_data_p->flags |= FLAGS_DROP_DATA; + pkt_clear(garmin_data_p); + } + + return count; +} + + + +/* + * Called for data received from tty + * + * buf contains the datas read, it may span more than one packet or even + * incomplete packets + * + * input record should be a serial-record, but it may not be complete. + * Copy it into our local buffer, until an etx is seen (or an error + * occurs). + * Once the record is complete, convert into a usb packet and send it + * to the bulk pipe, send an ack back to the tty. + * + * If the input is an ack, just send the last queued packet to the + * tty layer. + * + * if the input is an abort command, drop all queued data. + */ + +static int gsp_receive(struct garmin_data * garmin_data_p, + int from_user, const unsigned char *buf, int count) +{ + __u8 buffer[GPSBUFSIZ]; + int offs = 0; + int ack_or_nak_seen = 0; + int i,len; + __u8 *dest = garmin_data_p->inbuffer; + int size = garmin_data_p->insize; + int dleSeen = garmin_data_p->flags & FLAGS_GSP_DLESEEN; + int skip = garmin_data_p->flags & FLAGS_GSP_SKIP; + + dbg_gsp(garmin_data_p, + "%s - dle=%d skip=%d size=%d count=%d", + __FUNCTION__, dleSeen, skip, size, count); + + while (offs < count) { + len = GPSBUFSIZ; + if ((offs+len) > count) + len = count-offs; + + if (from_user) { + if (copy_from_user(buffer, buf+offs, len)) + return -EFAULT; + } else { + memcpy(buffer, buf+offs, len); + } + offs += len; + + i=0; + while (i < len) { + if (buffer[i] == DLE) { + if (skip) { /* start of a new pkt */ + skip = 0; + size = 0; + dleSeen = 1; + } else if (dleSeen) { + dest[size++] = buffer[i]; + dleSeen = 0; + } else { + dleSeen = 1; + } + } else if (buffer[i] == ETX) { + if (dleSeen) { + /* packet complete */ + if (dest[0] == ACK) { + ack_or_nak_seen = ACK; + dbg_gsp(garmin_data_p, + "ACK packet complete."); + } else if (dest[0] == NAK) { + ack_or_nak_seen = NAK; + dbg_gsp(garmin_data_p, + "NAK packet complete."); + } else { + dbg_gsp(garmin_data_p, + "packet complete " + "- id=0x%X.", + 0xFF & dest[0]); + gsp_rec_packet(garmin_data_p, + dest, + size); + } + + skip = 1; + size = 0; + dleSeen = 0; + } else { + dest[size++] = buffer[i]; + } + } else if (!skip) { + + if (dleSeen) { + dbg_gsp(garmin_data_p, + "non-masked DLE at %d" + " - restarting", i); + size = 0; + dleSeen = 0; + } + + dest[size++] = buffer[i]; + } + + if (size >= GPSBUFSIZ) { + dbg_gsp(garmin_data_p, + "%s - packet too large.", __FUNCTION__); + skip = 1; + size = 0; + dleSeen = 0; + } + + i++; + } + } + + garmin_data_p->insize = size; + + // copy flags back to structure + if (skip) + garmin_data_p->flags |= FLAGS_GSP_SKIP; + else + garmin_data_p->flags &= ~FLAGS_GSP_SKIP; + + if (dleSeen) + garmin_data_p->flags |= FLAGS_GSP_DLESEEN; + else + garmin_data_p->flags &= ~FLAGS_GSP_DLESEEN; + + if (ack_or_nak_seen) { + garmin_data_p->state = STATE_GSP_WAIT_DATA; + gsp_next_packet(garmin_data_p); + } + + return count; +} + + + + +/* + * Sends a usb packet to the tty + * + * Assumes, that all packages and at an usb-packet boundary. + * + * return -1 on error, 0 if packet is incomplete or > 0 if packet was sent + */ +int gsp_send(struct garmin_data * garmin_data_p, const unsigned char *buf, + int count) +{ + char buffer[GPSBUFSIZ]; + int cksum = 0; + int i=0; + int k; + int len; + + dbg_gsp(garmin_data_p, + "%s - state %d - %d bytes.", __FUNCTION__, + garmin_data_p->state, count); + + len = garmin_data_p->outsize; + if ((len+count) > GPSBUFSIZ) { + dbg_gsp(garmin_data_p, "packet too large"); + garmin_data_p->outsize = 0; + return -4; + } + + memcpy(garmin_data_p->outbuffer+len, buf, count); + len += count; + garmin_data_p->outsize = len; + + if (len >= GARMIN_PKTHDR_LENGTH) { + k = GARMIN_PKTHDR_LENGTH + (garmin_data_p->outbuffer[8] & 0xff); + if (len < k) + return 0; + } + + garmin_data_p->outsize = 0; + buf = garmin_data_p->outbuffer; + count = len; + + if (debug & DEBUG_DATA_GSP) + garmin_debug_data (1, &garmin_data_p->port->dev, __FUNCTION__, + len, buf); + else + dbg_gsp(garmin_data_p, + "%s - pkt id=0x%x complete.", __FUNCTION__, + get_int(buf+4)); + + if (GARMIN_LAYERID_APPL != get_int(buf)) { + dbg_gsp(garmin_data_p, + "not an application packet (%d)", get_int(buf)); + return -1; + } + + if (get_int(buf+4) > 255) { + dbg_gsp(garmin_data_p, + "packet-id %d too large", get_int(buf+4)); + return -2; + } + + if (get_int(buf+8) > 255) { + dbg_gsp(garmin_data_p, + "packet-size %d too large", get_int(buf+8)); + return -3; + } + + if (buf[4] == 0xFD) { + } + + buffer[i++] = DLE; + buffer[i++] = buf[4]; + cksum += buf[4]; + len = 0xFF & buf[8]; + buffer[i++] = len; + cksum += len; + if (len == DLE) + buffer[i++] = DLE; + + len += GARMIN_PKTHDR_LENGTH; + for (k=GARMIN_PKTHDR_LENGTH; k<len; k++) { + buffer[i++] = buf[k]; + cksum += buf[k]; + if (buf[k] == DLE) + buffer[i++] = DLE; + } + + cksum = 0xFF & -cksum; + buffer[i++] = cksum; + if (cksum == DLE) + buffer[i++] = DLE; + buffer[i++] = DLE; + buffer[i++] = ETX; + + send_to_tty(garmin_data_p->port, buffer, i); + + garmin_data_p->pkt_id = buf[4]; + garmin_data_p->state = STATE_WAIT_TTY_ACK; + + return i; +} + + + + + +/* + * Process the next pending data packet - if there is one + */ +static void gsp_next_packet(struct garmin_data * garmin_data_p) +{ + struct garmin_packet *pkt = 0; + + while ((pkt = pkt_pop(garmin_data_p)) != 0) + { + dbg_queue(garmin_data_p, + "%s - next pkt: %d", __FUNCTION__, pkt->seq); + if (gsp_send(garmin_data_p, pkt->data, pkt->size) > 0) { + kfree(pkt); + return; + } + kfree(pkt); + } +} + + + + +/****************************************************************************** + * garmin native mode + ******************************************************************************/ + + +/* + * Called for data received from tty + * + * The input data is expected to be in garmin usb-packet format. + * + * buf contains the datas read, it may span more than one packet + * or even incomplete packets + */ +static int nat_receive(struct garmin_data * garmin_data_p, + int from_user, + const unsigned char *buf, int count) +{ + __u8 * dest; + int offs = 0; + int result = count; + int len; + + while (offs < count) { + // if buffer contains header, copy rest of data + if (garmin_data_p->insize >= GARMIN_PKTHDR_LENGTH) + len = GARMIN_PKTHDR_LENGTH + +get_int(garmin_data_p->inbuffer+8); + else + len = GARMIN_PKTHDR_LENGTH; + + if (len >= GPSBUFSIZ) { + /* seem to be an invalid packet, ignore rest of input */ + dbg_nat(garmin_data_p, + "%s - packet size too large: %d", + __FUNCTION__, len); + garmin_data_p->insize = 0; + count = 0; + result = -EINVPKT; + } else { + len -= garmin_data_p->insize; + if (len > (count-offs)) + len = (count-offs); + if (len > 0) { + dest = garmin_data_p->inbuffer + +garmin_data_p->insize; + if (from_user) { + if (copy_from_user(dest, buf+offs, len)) + return -EFAULT; + + } else { + memcpy(dest, buf+offs, len); + } + garmin_data_p->insize += len; + offs += len; + } + } + + /* do we have a complete packet ? */ + if (garmin_data_p->insize >= GARMIN_PKTHDR_LENGTH) { + len = GARMIN_PKTHDR_LENGTH+ + get_int(garmin_data_p->inbuffer+8); + if (garmin_data_p->insize >= len) { + garmin_write_bulk (garmin_data_p->port, 0, + garmin_data_p->inbuffer, + len); + garmin_data_p->insize = 0; + + /* if this was an abort-transfer command, + flush all queued data. */ + if (isAbortTrfCmnd(garmin_data_p->inbuffer)) { + garmin_data_p->flags |= FLAGS_DROP_DATA; + pkt_clear(garmin_data_p); + } + } + } + } + return result; +} + + +/****************************************************************************** + * private packets + ******************************************************************************/ + +static void priv_status_resp(struct usb_serial_port *port) +{ + struct garmin_data * garmin_data_p = + (struct garmin_data *) usb_get_serial_port_data(port); + __u8 pkt[GARMIN_PKTHDR_LENGTH+12]; + + set_int(pkt, GARMIN_LAYERID_PRIVATE); + set_int(pkt+4, PRIV_PKTID_INFO_RESP); + set_int(pkt+8, 12); + set_int(pkt+12, VERSION_MAJOR << 16 | VERSION_MINOR); + set_int(pkt+16, garmin_data_p->mode); + memcpy(pkt+20, garmin_data_p->serial_num, 4); + + send_to_tty(port, pkt, sizeof(pkt)); +} + + +/****************************************************************************** + * Timer callback + ******************************************************************************/ + +static void timeout_handler(unsigned long data) +{ + struct garmin_data *garmin_data_p = (struct garmin_data *) data; + + /* send the next queued packet to the tty port */ + if (garmin_data_p->mode == MODE_NATIVE) + if (garmin_data_p->flags & FLAGS_QUEUING) + garmin_flush_queue(garmin_data_p); +} + +/****************************************************************************** + * Garmin specific driver functions + ******************************************************************************/ + +/* + * clear all cached data + */ +static int garmin_clear(struct garmin_data * garmin_data_p) +{ + int status = 0; + + struct usb_serial_port *port = garmin_data_p->port; + + if (port != 0 && garmin_data_p->flags & FLAGS_APP_RESP_SEEN) { + /* send a terminate command */ + status = garmin_write_bulk(port, 0, GARMIN_STOP_TRANSFER_REQ, + sizeof(GARMIN_STOP_TRANSFER_REQ)); + } + + /* flush all queued data */ + pkt_clear(garmin_data_p); + + garmin_data_p->insize = 0; + garmin_data_p->outsize = 0; + + return status; +} + + + + + + +static int garmin_init_session(struct usb_serial_port *port) +{ + struct usb_serial *serial = port->serial; + struct garmin_data * garmin_data_p = + (struct garmin_data *) usb_get_serial_port_data(port); + int status = 0; + + if (status == 0) { + usb_unlink_urb (port->interrupt_in_urb); + + dbg_drv(garmin_data_p, + "%s - adding interrupt input", __FUNCTION__); + port->interrupt_in_urb->dev = serial->dev; + status = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); + if (status) + dev_err(&serial->dev->dev, + "%s - failed submitting interrupt urb," + " error %d\n", + __FUNCTION__, status); + } + + if (status == 0) { + dbg_drv(garmin_data_p, + "%s - starting session ...", __FUNCTION__); + garmin_data_p->state = STATE_ACTIVE; + status = garmin_write_bulk(port, 0, GARMIN_START_SESSION_REQ, + sizeof(GARMIN_START_SESSION_REQ)); + + if (status >= 0) { + + garmin_data_p->ignorePkts++; + + /* not needed, but the win32 driver does it too ... */ + status = garmin_write_bulk(port, 0, + GARMIN_START_SESSION_REQ2, + sizeof(GARMIN_START_SESSION_REQ2)); + if (status >= 0) { + status = 0; + garmin_data_p->ignorePkts++; + } + } + } + + return status; +} + + + + + +static int garmin_open (struct usb_serial_port *port, struct file *filp) +{ + int status = 0; + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + + dbg_drv(garmin_data_p, + "%s - port %d", __FUNCTION__, port->number); + + bytes_in = 0; + bytes_out = 0; + + /* + * Force low_latency on so that our tty_push actually forces the data + * through, otherwise it is scheduled, and with high data rates (like + * with OHCI) data can get lost. + */ + if (port->tty) + port->tty->low_latency = 1; + + garmin_data_p->mode = initial_mode; + garmin_data_p->count = 0; + garmin_data_p->flags = 0; + + /* shutdown any bulk reads that might be going on */ + usb_unlink_urb (port->write_urb); + usb_unlink_urb (port->read_urb); + + if (garmin_data_p->state == STATE_RESET) { + status = garmin_init_session(port); + } + + garmin_data_p->state = STATE_ACTIVE; + + return status; +} + + +static void garmin_close (struct usb_serial_port *port, struct file * filp) +{ + int status; + struct usb_serial *serial = port->serial; + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + + dbg_drv(garmin_data_p, + "%s - port %d - mode=%d state=%d flags=0x%X", __FUNCTION__, + port->number, garmin_data_p->mode, + garmin_data_p->state, garmin_data_p->flags); + + if (!serial) + return; + + garmin_clear(garmin_data_p); + + /* shutdown our urbs */ + status = usb_unlink_urb (port->read_urb); + if (status) + dbg_drv(garmin_data_p, + "%s - port %d - error %d during unlink read_urb", + __FUNCTION__, port->number, status); + + status = usb_unlink_urb (port->write_urb); + if (status) + dbg_drv(garmin_data_p, + "%s - port %d - error %d during unlink write_urb", + __FUNCTION__, port->number, status); + + if (noResponseFromAppLayer(garmin_data_p) || + ((garmin_data_p->flags & CLEAR_HALT_REQUIRED) != 0)) { + process_resetdev_request(port); + garmin_data_p->state = STATE_RESET; + } else { + garmin_data_p->state = STATE_DISCONNECTED; + } + + /* Uncomment the following line if you want to see some statistics + in your syslog + dev_info (&port->dev, "Bytes In = %d Bytes Out = %d\n", + bytes_in, bytes_out); + */ +} + + +static int process_resetdev_request(struct usb_serial_port *port) +{ + int status; + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + + garmin_data_p->flags &= ~(CLEAR_HALT_REQUIRED); + garmin_data_p->state = STATE_RESET; + memset(garmin_data_p->serial_num, 0, 4); + + usb_unlink_urb (port->interrupt_in_urb); + dbg_drv(garmin_data_p, "%s - usb_reset_device", __FUNCTION__ ); + status = usb_reset_device(port->serial->dev); + if (status) + dbg_drv(garmin_data_p, + "%s - usb_reset_device failed: %d", + __FUNCTION__, status); + return status; +} + + + +static int garmin_write_bulk (struct usb_serial_port *port, int from_user, + const unsigned char *buf, int count) +{ + struct usb_serial *serial = port->serial; + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + struct urb *urb; + unsigned char *buffer; + int status; + + dbg_drv(garmin_data_p, + "%s - port %d, state %d", __FUNCTION__, port->number, + garmin_data_p->state); + + garmin_data_p->flags &= ~FLAGS_DROP_DATA; + + buffer = kmalloc (count, GFP_ATOMIC); + if (!buffer) { + dev_err(&port->dev, "out of memory\n"); + return -ENOMEM; + } + + urb = usb_alloc_urb(0, GFP_ATOMIC); + if (!urb) { + dev_err(&port->dev, "no more free urbs\n"); + kfree (buffer); + return -ENOMEM; + } + + if (from_user) { + if (copy_from_user (buffer, buf, count)) { + kfree (buffer); + usb_free_urb (urb); + return -EFAULT; + } + } else { + memcpy (buffer, buf, count); + } + + garmin_debug_data (debug & DEBUG_DATA_USB, &port->dev, __FUNCTION__, + count, buffer); + + usb_fill_bulk_urb (urb, serial->dev, + usb_sndbulkpipe (serial->dev, + port->bulk_out_endpointAddress), + buffer, count, + garmin_write_bulk_callback, port); + urb->transfer_flags |= URB_ZERO_PACKET; + + if (GARMIN_LAYERID_APPL == get_int(buffer)) { + garmin_data_p->flags |= FLAGS_APP_REQ_SEEN; + if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { + pkt_clear(garmin_data_p); + garmin_data_p->state = STATE_GSP_WAIT_DATA; + } + } + + /* send it down the pipe */ + status = usb_submit_urb(urb, GFP_ATOMIC); + if (status) { + dev_err(&port->dev, + "%s - usb_submit_urb(write bulk) " + "failed with status = %d\n", + __FUNCTION__, status); + count = status; + } else { + + if (GARMIN_LAYERID_APPL == get_int(buffer) + && (garmin_data_p->mode == MODE_GARMIN_SERIAL)) { + + gsp_send_ack(garmin_data_p, buffer[4]); + } + + bytes_out += count; + } + + /* we are done with this urb, so let the host driver + * really free it when it is finished with it */ + usb_free_urb (urb); + + return count; +} + + + +static int garmin_write (struct usb_serial_port *port, int from_user, + const unsigned char *buf, int count) +{ + __u8 privpkt[PRIVPKTSIZ]; + int pktid, pktsiz, len; + struct garmin_data * garmin_data_p = + (struct garmin_data *) usb_get_serial_port_data(port); + + dbg_drv(garmin_data_p, + "%s - port %d, state %d, mode %d", __FUNCTION__, + port->number, garmin_data_p->state, garmin_data_p->mode); + + garmin_debug_data (debug & DEBUG_DATA_TTY, &port->dev, __FUNCTION__, + count, buf); + + /* check for our private packets */ + if (count >= GARMIN_PKTHDR_LENGTH) { + + len = PRIVPKTSIZ; + if (count < len) + len = count; + + if (from_user) { + if (copy_from_user(privpkt, buf, len)) + return -EFAULT; + } else { + memcpy(privpkt, buf, len); + } + + pktsiz = get_int(privpkt+8); + + if (count == (GARMIN_PKTHDR_LENGTH+pktsiz) + && GARMIN_LAYERID_PRIVATE == get_int(privpkt)) { + + pktid = get_int(privpkt+4); + dbg_drv(garmin_data_p, + "%s - processing private request %d", + __FUNCTION__, pktid); + + // drop all unfinished transfers + garmin_clear(garmin_data_p); + + switch(pktid) { + + case PRIV_PKTID_SET_DEBUG: + if (pktsiz != 4) + return -EINVPKT; + debug = get_int(privpkt+12); + dbg_drv(garmin_data_p, + "%s - debug level set to 0x%X", + __FUNCTION__, debug); + break; + + case PRIV_PKTID_SET_MODE: + if (pktsiz != 4) + return -EINVPKT; + garmin_data_p->mode = get_int(privpkt+12); + dbg_drv(garmin_data_p, + "%s - mode set to %d", + __FUNCTION__, garmin_data_p->mode); + break; + + case PRIV_PKTID_INFO_REQ: + priv_status_resp(port); + break; + + case PRIV_PKTID_RESET_REQ: + garmin_data_p->flags |= FLAGS_APP_REQ_SEEN; + break; + + case PRIV_PKTID_SET_DEF_MODE: + if (pktsiz != 4) + return -EINVPKT; + initial_mode = get_int(privpkt+12); + dbg_drv(garmin_data_p, + "%s - initial_mode set to %d", + __FUNCTION__, + garmin_data_p->mode); + break; + } + return count; + } + } + + if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { + + return gsp_receive(garmin_data_p, from_user, buf, count); + + } else { /* MODE_NATIVE */ + + return nat_receive(garmin_data_p, from_user, buf, count); + //return garmin_write_bulk(port, from_user, buf, count); + } +} + + +static int garmin_write_room (struct usb_serial_port *port) +{ + /* + * We really can take anything the user throws at us + * but let's pick a nice big number to tell the tty + * layer that we have lots of free space + */ + return 2048; +} + + +static int garmin_chars_in_buffer (struct usb_serial_port *port) +{ + /* + * We can't really account for how much data we + * have sent out, but hasn't made it through to the + * device, so just tell the tty layer that everything + * is flushed. + */ + return 0; +} + + +static void garmin_write_bulk_callback (struct urb *urb, struct pt_regs *regs) +{ + struct usb_serial_port *port = (struct usb_serial_port *)urb->context; + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + + /* free up the transfer buffer, as usb_free_urb() does not do this */ + kfree (urb->transfer_buffer); + + dbg_drv(garmin_data_p, "%s - port %d", __FUNCTION__, port->number); + + if (urb->status) { + dbg_drv(garmin_data_p, + "%s - nonzero write bulk status received: %d", + __FUNCTION__, urb->status); + garmin_data_p->flags |= CLEAR_HALT_REQUIRED; + } + + schedule_work(&port->work); +} + + +static void garmin_read_bulk_callback (struct urb *urb, struct pt_regs *regs) +{ + struct usb_serial_port *port = (struct usb_serial_port *)urb->context; + struct usb_serial *serial = port->serial; + unsigned char *data = urb->transfer_buffer; + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + int status; + + dbg_drv(garmin_data_p, "%s - port %d", __FUNCTION__, port->number); + + if (!serial) { + dbg_drv(garmin_data_p, + "%s - bad serial pointer, exiting", __FUNCTION__); + return; + } + + if (urb->status) { + dbg_drv(garmin_data_p, + "%s - nonzero read bulk status received: %d", + __FUNCTION__, urb->status); + return; + } + + garmin_debug_data (debug & DEBUG_DATA_USB, &port->dev, __FUNCTION__, + urb->actual_length, data); + + send_to_tty(port, data, urb->actual_length); + + /* Continue trying to read until nothing more is received */ + if (urb->actual_length > 0) { + usb_fill_bulk_urb (port->read_urb, serial->dev, + usb_rcvbulkpipe (serial->dev, + port->bulk_in_endpointAddress), + port->read_urb->transfer_buffer, + port->read_urb->transfer_buffer_length, + garmin_read_bulk_callback, port); + status = usb_submit_urb(port->read_urb, GFP_ATOMIC); + if (status) + dev_err(&port->dev, + "%s - failed resubmitting read urb, error %d\n", + __FUNCTION__, status); + } + return; +} + +static void garmin_read_int_callback (struct urb *urb, struct pt_regs *regs) +{ + int status; + struct usb_serial_port *port = (struct usb_serial_port *)urb->context; + struct usb_serial *serial = port->serial; + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + unsigned char *data = urb->transfer_buffer; + + switch (urb->status) { + case 0: + /* success */ + break; + case -ECONNRESET: + case -ENOENT: + case -ESHUTDOWN: + /* this urb is terminated, clean up */ + dbg_drv(garmin_data_p, "%s - urb shutting down with status: %d", + __FUNCTION__, urb->status); + return; + default: + dbg_drv(garmin_data_p, "%s - nonzero urb status received: %d", + __FUNCTION__, urb->status); + return; + } + + garmin_debug_data (debug & DEBUG_DATA_USB, &port->dev, __FUNCTION__, + urb->actual_length, urb->transfer_buffer); + + if (urb->actual_length == sizeof(GARMIN_BULK_IN_AVAIL_REPLY) && + 0 == memcmp(data, GARMIN_BULK_IN_AVAIL_REPLY, + sizeof(GARMIN_BULK_IN_AVAIL_REPLY))) { + + dbg_drv(garmin_data_p, + "%s - bulk data available.", __FUNCTION__); + + /* bulk data available */ + usb_fill_bulk_urb (port->read_urb, serial->dev, + usb_rcvbulkpipe (serial->dev, + port->bulk_in_endpointAddress), + port->read_urb->transfer_buffer, + port->read_urb->transfer_buffer_length, + garmin_read_bulk_callback, port); + status = usb_submit_urb(port->read_urb, GFP_KERNEL); + if (status) { + dev_err(&port->dev, + "%s - failed submitting read urb, error %d\n", + __FUNCTION__, status); + } + + } else if (urb->actual_length == (4+sizeof(GARMIN_START_SESSION_REPLY)) + && 0 == memcmp(data, GARMIN_START_SESSION_REPLY, + sizeof(GARMIN_START_SESSION_REPLY))) { + + garmin_data_p->flags |= FLAGS_SESSION_REPLY1_SEEN; + /* save the serial number */ + memcpy(garmin_data_p->serial_num, data+GARMIN_PKTHDR_LENGTH, 4); + dbg_drv(garmin_data_p, + "%s - start-of-session reply seen - serial %u.", + __FUNCTION__, get_int(garmin_data_p->serial_num)); + + } + + if (garmin_data_p->ignorePkts) { + /* this reply belongs to a request generated by the driver, + ignore it. */ + dbg_drv(garmin_data_p, + "%s - pkt ignored (%d)", + __FUNCTION__, garmin_data_p->ignorePkts); + garmin_data_p->ignorePkts--; + } else if (garmin_data_p->flags & FLAGS_DROP_DATA) { + /* abort-transfer cmd is actice */ + dbg_drv(garmin_data_p, + "%s - pkt dropped", __FUNCTION__); + } else if (garmin_data_p->state != STATE_DISCONNECTED && + garmin_data_p->state != STATE_RESET ) { + + /* remember any appl.layer packets, so we know + if a reset is required or not when closing + the device */ + if (0 == memcmp(data, GARMIN_APP_LAYER_REPLY, + sizeof(GARMIN_APP_LAYER_REPLY))) + garmin_data_p->flags |= FLAGS_APP_RESP_SEEN; + + /* if throttling is active or postprecessing is required + put the received data in th input queue, otherwise + send it directly to the tty port */ + if (garmin_data_p->flags & FLAGS_QUEUING) { + pkt_add(garmin_data_p, data, + urb->actual_length); + } else if (garmin_data_p->mode == MODE_GARMIN_SERIAL) { + if (get_int(data) == GARMIN_LAYERID_APPL) { + pkt_add(garmin_data_p, data, + urb->actual_length); + } + } else { + send_to_tty(port, data, urb->actual_length); + } + } + + port->interrupt_in_urb->dev = port->serial->dev; + status = usb_submit_urb (urb, GFP_ATOMIC); + if (status) + dev_err(&urb->dev->dev, + "%s - Error %d submitting interrupt urb\n", + __FUNCTION__, status); +} + + +/* + * Sends the next queued packt to the tty port (garmin native mode only) + * and then sets a timer to call itself again until all queued data + * is sent. + */ +static int garmin_flush_queue(struct garmin_data * garmin_data_p) +{ + struct garmin_packet *pkt; + + if ((garmin_data_p->flags & FLAGS_THROTTLED) == 0) { + pkt = pkt_pop(garmin_data_p); + if (pkt != 0) { + + send_to_tty(garmin_data_p->port, pkt->data, pkt->size); + kfree(pkt); + mod_timer(&garmin_data_p->timer, (1)+jiffies); + + } else { + garmin_data_p->flags &= ~FLAGS_QUEUING; + } + } + return 0; +} + + +static void garmin_throttle (struct usb_serial_port *port) +{ + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + + dbg_drv(garmin_data_p, "%s - port %d", __FUNCTION__, port->number); + /* set flag, data received will be put into a queue + for later processing */ + garmin_data_p->flags |= FLAGS_QUEUING|FLAGS_THROTTLED; +} + + +static void garmin_unthrottle (struct usb_serial_port *port) +{ + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + + dbg_drv(garmin_data_p, "%s - port %d", __FUNCTION__, port->number); + garmin_data_p->flags &= ~FLAGS_THROTTLED; + + /* in native mode send queued data to tty, in + serial mode nothing needs to be done here */ + if (garmin_data_p->mode == MODE_NATIVE) + garmin_flush_queue(garmin_data_p); +} + + +static int gpsmap_probe (struct usb_serial *serial, + const struct usb_device_id *id) +{ + return 0; +} + + +static int garmin_probe (struct usb_serial *serial, + const struct usb_device_id *id) +{ + int retval = 0; + int (*startup) (struct usb_serial *, const struct usb_device_id *); + + if (serial->dev->actconfig->desc.bConfigurationValue != 1) { + err("active config #%d != 1 ??", + serial->dev->actconfig->desc.bConfigurationValue); + return -ENODEV; + } + + if (id->driver_info) { + startup = (void *)id->driver_info; + retval = startup(serial, id); + } + + return retval; +} + + +static int garmin_attach (struct usb_serial *serial) +{ + int status = 0; + struct usb_serial_port *port = serial->port[0]; + struct garmin_data * garmin_data_p = 0; + + garmin_data_p = kmalloc (sizeof(struct garmin_data), GFP_KERNEL); + if (garmin_data_p == NULL) { + dev_err(&port->dev, "%s - Out of memory\n", __FUNCTION__); + return -ENOMEM; + } + memset (garmin_data_p, 0, sizeof(struct garmin_data)); + init_timer(&garmin_data_p->timer); + spin_lock_init(&garmin_data_p->lock); + INIT_LIST_HEAD(&garmin_data_p->pktlist); + //garmin_data_p->timer.expires = jiffies + session_timeout; + garmin_data_p->timer.data = (unsigned long)garmin_data_p; + garmin_data_p->timer.function = timeout_handler; + garmin_data_p->port = port; + garmin_data_p->state = 0; + garmin_data_p->count = 0; + usb_set_serial_port_data(port, garmin_data_p); + + status = garmin_init_session(port); + + return status; +} + + +static void garmin_shutdown (struct usb_serial *serial) +{ + int status = 0; + struct usb_serial_port *port = serial->port[0]; + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + + status = usb_unlink_urb (port->interrupt_in_urb); + if (status) + dbg_drv(garmin_data_p, + "%s - port %d - " + "error %d during unlink interrupt_in_urb", + __FUNCTION__, port->number, status); + + dbg_drv(garmin_data_p, "%s", __FUNCTION__); + + del_timer_sync(&garmin_data_p->timer); + kfree (garmin_data_p); + usb_set_serial_port_data(port, NULL); +} + + +/* + * does nothing useful at the moment + */ +static int garmin_ioctl (struct usb_serial_port *port, + struct file * file, unsigned int cmd, + unsigned long arg) +{ + unsigned int status = 0; + void * user_p = (void *) arg; + + switch(cmd) + { + case TIOCSERGETLSR: + status = TIOCSER_TEMT; + if (copy_to_user(user_p, &status, sizeof(int))) + return -EFAULT; + return 0; + + default: + return -ENOIOCTLCMD; + } +} + + +/* This function is all nice and good, + but we don't change anything based on it :) */ +static void garmin_set_termios (struct usb_serial_port *port, + struct termios *old_termios) +{ + struct garmin_data * garmin_data_p + = (struct garmin_data *) usb_get_serial_port_data(port); + unsigned int cflag; + + dbg_drv(garmin_data_p, "%s - port %d", __FUNCTION__, port->number); + + if ((!port->tty) || (!port->tty->termios)) { + dbg_drv(garmin_data_p, "%s - no tty structures", __FUNCTION__); + return; + } + + cflag = port->tty->termios->c_cflag; + /* check that they really want us to change something */ + if (old_termios) { + if ((cflag == old_termios->c_cflag) && + (RELEVANT_IFLAG(port->tty->termios->c_iflag) + == RELEVANT_IFLAG(old_termios->c_iflag))) { + dbg_drv(garmin_data_p, + "%s - nothing to change...", __FUNCTION__); + return; + } + } + + /* get the byte size */ + switch (cflag & CSIZE) { + case CS5: + dbg_drv(garmin_data_p, + "%s - data bits = 5", __FUNCTION__); + break; + case CS6: + dbg_drv(garmin_data_p, + "%s - data bits = 6", __FUNCTION__); + break; + case CS7: + dbg_drv(garmin_data_p, + "%s - data bits = 7", __FUNCTION__); + break; + default: + case CS8: + dbg_drv(garmin_data_p, + "%s - data bits = 8", __FUNCTION__); + break; + } + + /* determine the parity */ + if (cflag & PARENB) + if (cflag & PARODD) + dbg_drv(garmin_data_p, + "%s - parity = odd", __FUNCTION__); + else + dbg_drv(garmin_data_p, + "%s - parity = even", __FUNCTION__); + else + dbg_drv(garmin_data_p, + "%s - parity = none", __FUNCTION__); + + /* figure out the stop bits requested */ + if (cflag & CSTOPB) + dbg_drv(garmin_data_p, "%s - stop bits = 2", __FUNCTION__); + else + dbg_drv(garmin_data_p, "%s - stop bits = 1", __FUNCTION__); + + + /* figure out the flow control settings */ + if (cflag & CRTSCTS) + dbg_drv(garmin_data_p, "%s - RTS/CTS is enabled", __FUNCTION__); + else + dbg_drv(garmin_data_p, "%s - RTS/CTS is disabled",__FUNCTION__); + + /* determine software flow control */ + if (I_IXOFF(port->tty)) + dbg_drv(garmin_data_p, + "%s - XON/XOFF is enabled, XON = %2x, XOFF = %2x", + __FUNCTION__, START_CHAR(port->tty), + STOP_CHAR(port->tty)); + else + dbg_drv(garmin_data_p, + "%s - XON/XOFF is disabled", __FUNCTION__); + + /* get the baud rate wanted */ + dbg_drv(garmin_data_p, + "%s - baud rate = %d", __FUNCTION__, + tty_get_baud_rate(port->tty)); + + return; +} + + + +static int __init garmin_init (void) +{ + int i, retval; + + /* Only if parameters were passed to us */ + if ((vendor>0) && (product>0)) { + struct usb_device_id usb_dev_temp[]= + {{USB_DEVICE(vendor, product), + .driver_info = (kernel_ulong_t)&gpsmap_probe }}; + + /* Find the last entry in id_table */ + for (i=0; ; i++) { + if (id_table[i].idVendor==0) { + id_table[i] = usb_dev_temp[0]; + break; + } + } + /* Find the last entry in id_table_combined */ + for (i=0; ; i++) { + if (id_table_combined[i].idVendor==0) { + id_table_combined[i] = usb_dev_temp[0]; + break; + } + } + info("Untested USB device specified at time of module insertion"); + info("Warning: This is not guaranteed to work"); + info("Using a newer kernel is preferred to this method"); + info("Adding garmin-gps support for unknown device: 0x%x/0x%x", + vendor, product); + } + retval = usb_serial_register(&garmin_device); + if (retval) + goto failed_garmin_register; + retval = usb_register(&garmin_driver); + if (retval) + goto failed_usb_register; + info(DRIVER_DESC " " DRIVER_VERSION); + + return 0; +failed_usb_register: + usb_serial_deregister(&garmin_device); +failed_garmin_register: + return retval; +} + + +static void __exit garmin_exit (void) +{ + usb_deregister (&garmin_driver); + usb_serial_deregister (&garmin_device); +} + + + + +module_init(garmin_init); +module_exit(garmin_exit); + +MODULE_AUTHOR( DRIVER_AUTHOR ); +MODULE_DESCRIPTION( DRIVER_DESC ); +MODULE_LICENSE("GPL"); + +MODULE_PARM(debug, "i"); +MODULE_PARM_DESC(debug, "Debug enabled or not"); +MODULE_PARM(initial_mode, "i"); +MODULE_PARM_DESC(initial_mode, "Initial mode"); + +MODULE_PARM(vendor, "i"); +MODULE_PARM_DESC(vendor, "User specified vendor ID"); +MODULE_PARM(product, "i"); +MODULE_PARM_DESC(product, "User specified product ID"); + + diff -Naur linux-2.6.9/drivers/usb/serial/Kconfig linux-2.6.9-gps/drivers/usb/serial/Kconfig --- linux-2.6.9/drivers/usb/serial/Kconfig 2004-10-18 23:54:40.000000000 +0200 +++ linux-2.6.9-gps/drivers/usb/serial/Kconfig 2004-10-19 20:24:51.999313133 +0200 @@ -127,6 +127,19 @@ To compile this driver as a module, choose M here: the module will be called visor. +config USB_SERIAL_GARMIN + tristate "Garmin GPS driver" + depends on USB_SERIAL + help + Say Y here if you want to connect to your Garmin GPS. + Should work with most Garmin GPS devices which have a native USB port. + + See <http://sourceforge.net/projects/garmin-gps> for the latest + version of the driver. + + To compile this driver as a module, choose M here: the + module will be called garmin_gps. + config USB_SERIAL_IPAQ tristate "USB PocketPC PDA Driver" depends on USB_SERIAL diff -Naur linux-2.6.9/drivers/usb/serial/Makefile linux-2.6.9-gps/drivers/usb/serial/Makefile --- linux-2.6.9/drivers/usb/serial/Makefile 2004-10-18 23:53:22.000000000 +0200 +++ linux-2.6.9-gps/drivers/usb/serial/Makefile 2004-10-19 20:24:52.000312993 +0200 @@ -29,6 +29,7 @@ obj-$(CONFIG_USB_SERIAL_PL2303) += pl2303.o obj-$(CONFIG_USB_SERIAL_SAFE) += safe_serial.o obj-$(CONFIG_USB_SERIAL_VISOR) += visor.o +obj-$(CONFIG_USB_SERIAL_GARMIN) += garmin_gps.o obj-$(CONFIG_USB_SERIAL_WHITEHEAT) += whiteheat.o obj-$(CONFIG_USB_SERIAL_XIRCOM) += keyspan_pda.o
