garmin_gps.c 41.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 * Garmin GPS driver
 *
4
 * Copyright (C) 2006,2007 Hermann Kneissel herkne@users.sourceforge.net
Linus Torvalds's avatar
Linus Torvalds committed
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
 *
 * The latest version of the driver can be found at
 * http://sourceforge.net/projects/garmin-gps/
 *
 * This driver has been derived from v2.1 of the visor driver.
 *
 * 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/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>
Alan Cox's avatar
Alan Cox committed
36
#include <linux/uaccess.h>
37
#include <asm/atomic.h>
Linus Torvalds's avatar
Linus Torvalds committed
38
#include <linux/usb.h>
39
#include <linux/usb/serial.h>
Linus Torvalds's avatar
Linus Torvalds committed
40

41 42
#include <linux/version.h>

Linus Torvalds's avatar
Linus Torvalds committed
43 44 45 46
/* the mode to be set when the port ist opened */
static int initial_mode = 1;

/* debug flag */
Alan Cox's avatar
Alan Cox committed
47
static int debug;
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50 51 52 53 54 55

#define GARMIN_VENDOR_ID             0x091E

/*
 * Version Information
 */

#define VERSION_MAJOR	0
56
#define VERSION_MINOR	31
Linus Torvalds's avatar
Linus Torvalds committed
57 58

#define _STR(s) #s
Alan Cox's avatar
Alan Cox committed
59
#define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b)
Linus Torvalds's avatar
Linus Torvalds committed
60 61 62 63 64 65 66 67
#define DRIVER_VERSION _DRIVER_VERSION(VERSION_MAJOR, VERSION_MINOR)
#define DRIVER_AUTHOR "hermann kneissel"
#define DRIVER_DESC "garmin gps driver"

/* error codes returned by the driver */
#define EINVPKT	1000	/* invalid packet structure */


Alan Cox's avatar
Alan Cox committed
68
/* size of the header of a packet using the usb protocol */
Linus Torvalds's avatar
Linus Torvalds committed
69 70
#define GARMIN_PKTHDR_LENGTH	12

Alan Cox's avatar
Alan Cox committed
71 72
/* max. possible size of a packet using the serial protocol */
#define MAX_SERIAL_PKT_SIZ (3 + 255 + 3)
Linus Torvalds's avatar
Linus Torvalds committed
73

Alan Cox's avatar
Alan Cox committed
74 75
/*  max. possible size of a packet with worst case stuffing */
#define MAX_SERIAL_PKT_SIZ_STUFFED (MAX_SERIAL_PKT_SIZ + 256)
Linus Torvalds's avatar
Linus Torvalds committed
76

Alan Cox's avatar
Alan Cox committed
77 78 79 80 81 82 83
/* size of a buffer able to hold a complete (no stuffing) packet
 * (the document protocol does not contain packets with a larger
 *  size, but in theory a packet may be 64k+12 bytes - if in
 *  later protocol versions larger packet sizes occur, this value
 *  should be increased accordingly, so the input buffer is always
 *  large enough the store a complete packet inclusive header) */
#define GPS_IN_BUFSIZ  (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ)
Linus Torvalds's avatar
Linus Torvalds committed
84

Alan Cox's avatar
Alan Cox committed
85 86
/* size of a buffer able to hold a complete (incl. stuffing) packet */
#define GPS_OUT_BUFSIZ (GARMIN_PKTHDR_LENGTH+MAX_SERIAL_PKT_SIZ_STUFFED)
Linus Torvalds's avatar
Linus Torvalds committed
87

Alan Cox's avatar
Alan Cox committed
88 89 90
/* where to place the packet id of a serial packet, so we can
 * prepend the usb-packet header without the need to move the
 * packets data */
Linus Torvalds's avatar
Linus Torvalds committed
91 92
#define GSP_INITIAL_OFFSET (GARMIN_PKTHDR_LENGTH-2)

Alan Cox's avatar
Alan Cox committed
93
/* max. size of incoming private packets (header+1 param) */
Linus Torvalds's avatar
Linus Torvalds committed
94 95 96 97
#define PRIVPKTSIZ (GARMIN_PKTHDR_LENGTH+4)

#define GARMIN_LAYERID_TRANSPORT  0
#define GARMIN_LAYERID_APPL      20
Alan Cox's avatar
Alan Cox committed
98
/* our own layer-id to use for some control mechanisms */
Linus Torvalds's avatar
Linus Torvalds committed
99 100 101 102 103 104 105
#define GARMIN_LAYERID_PRIVATE	0x01106E4B

#define GARMIN_PKTID_PVT_DATA	51
#define GARMIN_PKTID_L001_COMMAND_DATA 10

#define CMND_ABORT_TRANSFER 0

Alan Cox's avatar
Alan Cox committed
106
/* packet ids used in private layer */
Linus Torvalds's avatar
Linus Torvalds committed
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
#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 ETX	0x03
#define DLE	0x10
#define ACK	0x06
#define NAK	0x15

/* structure used to queue incoming packets */
struct garmin_packet {
	struct list_head  list;
	int               seq;
Alan Cox's avatar
Alan Cox committed
124 125
	/* the real size of the data array, always > 0 */
	int               size;
Linus Torvalds's avatar
Linus Torvalds committed
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
	__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;
	__u32  serial_num;
	struct timer_list timer;
	struct usb_serial_port *port;
	int    seq_counter;
	int    insize;
	int    outsize;
	__u8   inbuffer [GPS_IN_BUFSIZ];  /* tty -> usb */
	__u8   outbuffer[GPS_OUT_BUFSIZ]; /* usb -> tty */
	__u8   privpkt[4*6];
146 147
	atomic_t req_count;
	atomic_t resp_count;
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
	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

Alan Cox's avatar
Alan Cox committed
168
/* Flags used in garmin_data.flags: */
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171 172
#define FLAGS_SESSION_REPLY_MASK  0x00C0
#define FLAGS_SESSION_REPLY1_SEEN 0x0080
#define FLAGS_SESSION_REPLY2_SEEN 0x0040
#define FLAGS_BULK_IN_ACTIVE      0x0020
173 174
#define FLAGS_BULK_IN_RESTART     0x0010
#define FLAGS_THROTTLED           0x0008
Linus Torvalds's avatar
Linus Torvalds committed
175 176 177 178 179 180 181 182 183 184 185 186 187 188
#define CLEAR_HALT_REQUIRED       0x0001

#define FLAGS_QUEUING             0x0100
#define FLAGS_DROP_DATA           0x0800

#define FLAGS_GSP_SKIP            0x1000
#define FLAGS_GSP_DLESEEN         0x2000






/* function prototypes */
Alan Cox's avatar
Alan Cox committed
189
static void gsp_next_packet(struct garmin_data *garmin_data_p);
Linus Torvalds's avatar
Linus Torvalds committed
190
static int  garmin_write_bulk(struct usb_serial_port *port,
191 192
			     const unsigned char *buf, int count,
			     int dismiss_ack);
Linus Torvalds's avatar
Linus Torvalds committed
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220

/* 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 };



static struct usb_device_id id_table [] = {
Alan Cox's avatar
Alan Cox committed
221 222 223
	/* the same device id seems to be used by all
	   usb enabled GPS devices */
	{ USB_DEVICE(GARMIN_VENDOR_ID, 3) },
Linus Torvalds's avatar
Linus Torvalds committed
224 225 226
	{ }					/* Terminating entry */
};

Alan Cox's avatar
Alan Cox committed
227
MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds's avatar
Linus Torvalds committed
228 229 230 231 232 233

static struct usb_driver garmin_driver = {
	.name =		"garmin_gps",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	id_table,
234
	.no_dynamic_id = 1,
Linus Torvalds's avatar
Linus Torvalds committed
235 236 237
};


Alan Cox's avatar
Alan Cox committed
238
static inline int noResponseFromAppLayer(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
239
{
Alan Cox's avatar
Alan Cox committed
240 241
	return atomic_read(&garmin_data_p->req_count) ==
				atomic_read(&garmin_data_p->resp_count);
Linus Torvalds's avatar
Linus Torvalds committed
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266
}


static inline int getLayerId(const __u8 *usbPacket)
{
	return __le32_to_cpup((__le32 *)(usbPacket));
}

static inline int getPacketId(const __u8 *usbPacket)
{
	return __le32_to_cpup((__le32 *)(usbPacket+4));
}

static inline int getDataLength(const __u8 *usbPacket)
{
	return __le32_to_cpup((__le32 *)(usbPacket+8));
}


/*
 * 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)
{
Alan Cox's avatar
Alan Cox committed
267 268 269 270
	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)))
Linus Torvalds's avatar
Linus Torvalds committed
271 272 273 274 275 276 277 278
		return 1;
	else
		return 0;
}



static void send_to_tty(struct usb_serial_port *port,
279
			char *data, unsigned int actual_length)
Linus Torvalds's avatar
Linus Torvalds committed
280
{
Alan Cox's avatar
Alan Cox committed
281
	struct tty_struct *tty = port->port.tty;
Linus Torvalds's avatar
Linus Torvalds committed
282 283 284

	if (tty && actual_length) {

Alan Cox's avatar
Alan Cox committed
285
		usb_serial_debug_data(debug, &port->dev,
286
					__func__, actual_length, data);
Linus Torvalds's avatar
Linus Torvalds committed
287

288 289
		tty_buffer_request_room(tty, actual_length);
		tty_insert_flip_string(tty, data, actual_length);
Linus Torvalds's avatar
Linus Torvalds committed
290 291 292 293 294 295 296 297 298 299 300 301
		tty_flip_buffer_push(tty);
	}
}


/******************************************************************************
 * packet queue handling
 ******************************************************************************/

/*
 * queue a received (usb-)packet for later processing
 */
Alan Cox's avatar
Alan Cox committed
302
static int pkt_add(struct garmin_data *garmin_data_p,
303
		   unsigned char *data, unsigned int data_length)
Linus Torvalds's avatar
Linus Torvalds committed
304
{
305
	int state = 0;
Linus Torvalds's avatar
Linus Torvalds committed
306 307 308 309 310 311 312
	int result = 0;
	unsigned long flags;
	struct garmin_packet *pkt;

	/* process only packets containg data ... */
	if (data_length) {
		pkt = kmalloc(sizeof(struct garmin_packet)+data_length,
Alan Cox's avatar
Alan Cox committed
313
								GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
314 315 316 317 318 319 320 321
		if (pkt == NULL) {
			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);
322
		garmin_data_p->flags |= FLAGS_QUEUING;
Linus Torvalds's avatar
Linus Torvalds committed
323 324 325
		result = list_empty(&garmin_data_p->pktlist);
		pkt->seq = garmin_data_p->seq_counter++;
		list_add_tail(&pkt->list, &garmin_data_p->pktlist);
326
		state = garmin_data_p->state;
Linus Torvalds's avatar
Linus Torvalds committed
327 328 329 330
		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. */
Alan Cox's avatar
Alan Cox committed
331
		if (result && (state == STATE_GSP_WAIT_DATA))
Linus Torvalds's avatar
Linus Torvalds committed
332 333 334 335 336 337 338
			gsp_next_packet(garmin_data_p);
	}
	return result;
}


/* get the next pending packet */
Alan Cox's avatar
Alan Cox committed
339
static struct garmin_packet *pkt_pop(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354
{
	unsigned long flags;
	struct garmin_packet *result = NULL;

	spin_lock_irqsave(&garmin_data_p->lock, flags);
	if (!list_empty(&garmin_data_p->pktlist)) {
		result = (struct garmin_packet *)garmin_data_p->pktlist.next;
		list_del(&result->list);
	}
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
	return result;
}


/* free up all queued data */
Alan Cox's avatar
Alan Cox committed
355
static void pkt_clear(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
356 357 358 359
{
	unsigned long flags;
	struct garmin_packet *result = NULL;

360
	dbg("%s", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376

	spin_lock_irqsave(&garmin_data_p->lock, flags);
	while (!list_empty(&garmin_data_p->pktlist)) {
		result = (struct garmin_packet *)garmin_data_p->pktlist.next;
		list_del(&result->list);
		kfree(result);
	}
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
}


/******************************************************************************
 * garmin serial protocol handling handling
 ******************************************************************************/

/* send an ack packet back to the tty */
Alan Cox's avatar
Alan Cox committed
377
static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
Linus Torvalds's avatar
Linus Torvalds committed
378 379
{
	__u8 pkt[10];
380 381 382
	__u8 cksum = 0;
	__u8 *ptr = pkt;
	unsigned  l = 0;
Linus Torvalds's avatar
Linus Torvalds committed
383

384
	dbg("%s - pkt-id: 0x%X.", __func__, 0xFF & pkt_id);
Linus Torvalds's avatar
Linus Torvalds committed
385 386 387 388 389 390 391 392 393 394 395

	*ptr++ = DLE;
	*ptr++ = ACK;
	cksum += ACK;

	*ptr++ = 2;
	cksum += 2;

	*ptr++ = pkt_id;
	cksum += pkt_id;

Alan Cox's avatar
Alan Cox committed
396
	if (pkt_id == DLE)
Linus Torvalds's avatar
Linus Torvalds committed
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
		*ptr++ = DLE;

	*ptr++ = 0;
	*ptr++ = 0xFF & (-cksum);
	*ptr++ = DLE;
	*ptr++ = ETX;

	l = ptr-pkt;

	send_to_tty(garmin_data_p->port, pkt, l);
	return 0;
}



/*
 * called for a complete packet received from tty layer
 *
 * the complete packet (pkzid ... cksum) is in garmin_data_p->inbuf starting
 * at GSP_INITIAL_OFFSET.
 *
 * count - number of bytes in the input buffer including space reserved for
Alan Cox's avatar
Alan Cox committed
419
 *         the usb header: GSP_INITIAL_OFFSET + number of bytes in packet
Linus Torvalds's avatar
Linus Torvalds committed
420 421
 *         (including pkt-id, data-length a. cksum)
 */
Alan Cox's avatar
Alan Cox committed
422
static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
Linus Torvalds's avatar
Linus Torvalds committed
423
{
Alan Cox's avatar
Alan Cox committed
424
	const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
425
	__le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
Linus Torvalds's avatar
Linus Torvalds committed
426 427 428 429 430 431 432

	int cksum = 0;
	int n = 0;
	int pktid = recpkt[0];
	int size = recpkt[1];

	usb_serial_debug_data(debug, &garmin_data_p->port->dev,
433
			       __func__, count-GSP_INITIAL_OFFSET, recpkt);
Linus Torvalds's avatar
Linus Torvalds committed
434 435 436

	if (size != (count-GSP_INITIAL_OFFSET-3)) {
		dbg("%s - invalid size, expected %d bytes, got %d",
437
			__func__, size, (count-GSP_INITIAL_OFFSET-3));
Linus Torvalds's avatar
Linus Torvalds committed
438 439 440 441 442 443
		return -EINVPKT;
	}

	cksum += *recpkt++;
	cksum += *recpkt++;

Alan Cox's avatar
Alan Cox committed
444 445
	/* sanity check, remove after test ... */
	if ((__u8 *)&(usbdata[3]) != recpkt) {
Linus Torvalds's avatar
Linus Torvalds committed
446
		dbg("%s - ptr mismatch %p - %p",
447
			__func__, &(usbdata[4]), recpkt);
Linus Torvalds's avatar
Linus Torvalds committed
448 449 450 451 452 453 454 455
		return -EINVPKT;
	}

	while (n < size) {
		cksum += *recpkt++;
		n++;
	}

456 457
	if ((0xff & (cksum + *recpkt)) != 0) {
		dbg("%s - invalid checksum, expected %02x, got %02x",
458
			__func__, 0xff & -cksum, 0xff & *recpkt);
459 460
		return -EINVPKT;
	}
Linus Torvalds's avatar
Linus Torvalds committed
461 462 463 464 465

	usbdata[0] = __cpu_to_le32(GARMIN_LAYERID_APPL);
	usbdata[1] = __cpu_to_le32(pktid);
	usbdata[2] = __cpu_to_le32(size);

Alan Cox's avatar
Alan Cox committed
466
	garmin_write_bulk(garmin_data_p->port, garmin_data_p->inbuffer,
467
			   GARMIN_PKTHDR_LENGTH+size, 0);
Linus Torvalds's avatar
Linus Torvalds committed
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498

	/* 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 count;
}



/*
 * Called for data received from tty
 *
 * buf contains the data 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.
 */

Alan Cox's avatar
Alan Cox committed
499
static int gsp_receive(struct garmin_data *garmin_data_p,
500
		       const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
501
{
502
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
503 504 505
	int offs = 0;
	int ack_or_nak_seen = 0;
	int i = 0;
506 507
	__u8 *dest;
	int size;
Alan Cox's avatar
Alan Cox committed
508
	/* dleSeen: set if last byte read was a DLE */
509
	int dleSeen;
Alan Cox's avatar
Alan Cox committed
510 511 512
	/* skip: if set, skip incoming data until possible start of
	 *       new packet
	 */
513
	int skip;
Linus Torvalds's avatar
Linus Torvalds committed
514 515
	__u8 data;

516 517 518 519 520 521 522
	spin_lock_irqsave(&garmin_data_p->lock, flags);
	dest = garmin_data_p->inbuffer;
	size = garmin_data_p->insize;
	dleSeen = garmin_data_p->flags & FLAGS_GSP_DLESEEN;
	skip = garmin_data_p->flags & FLAGS_GSP_SKIP;
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);

Linus Torvalds's avatar
Linus Torvalds committed
523
	dbg("%s - dle=%d skip=%d size=%d count=%d",
524
		__func__, dleSeen, skip, size, count);
Linus Torvalds's avatar
Linus Torvalds committed
525

Alan Cox's avatar
Alan Cox committed
526
	if (size == 0)
Linus Torvalds's avatar
Linus Torvalds committed
527 528 529 530 531
		size = GSP_INITIAL_OFFSET;

	while (offs < count) {

		data = *(buf+offs);
Alan Cox's avatar
Alan Cox committed
532
		offs++;
Linus Torvalds's avatar
Linus Torvalds committed
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557

		if (data == DLE) {
			if (skip) { /* start of a new pkt */
				skip = 0;
				size = GSP_INITIAL_OFFSET;
				dleSeen = 1;
			} else if (dleSeen) {
				dest[size++] = data;
				dleSeen = 0;
			} else {
				dleSeen = 1;
			}
		} else if (data == ETX) {
			if (dleSeen) {
				/* packet complete */

				data = dest[GSP_INITIAL_OFFSET];

				if (data == ACK) {
					ack_or_nak_seen = ACK;
					dbg("ACK packet complete.");
				} else if (data == NAK) {
					ack_or_nak_seen = NAK;
					dbg("NAK packet complete.");
				} else {
Alan Cox's avatar
Alan Cox committed
558 559
					dbg("packet complete - id=0x%X.",
						0xFF & data);
Linus Torvalds's avatar
Linus Torvalds committed
560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
					gsp_rec_packet(garmin_data_p, size);
				}

				skip = 1;
				size = GSP_INITIAL_OFFSET;
				dleSeen = 0;
			} else {
				dest[size++] = data;
			}
		} else if (!skip) {

			if (dleSeen) {
				dbg("non-masked DLE at %d - restarting", i);
				size = GSP_INITIAL_OFFSET;
				dleSeen = 0;
			}

			dest[size++] = data;
		}

		if (size >= GPS_IN_BUFSIZ) {
581
			dbg("%s - packet too large.", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
582 583 584 585 586 587
			skip = 1;
			size = GSP_INITIAL_OFFSET;
			dleSeen = 0;
		}
	}

588 589
	spin_lock_irqsave(&garmin_data_p->lock, flags);

Linus Torvalds's avatar
Linus Torvalds committed
590 591
	garmin_data_p->insize = size;

Alan Cox's avatar
Alan Cox committed
592
	/* copy flags back to structure */
Linus Torvalds's avatar
Linus Torvalds committed
593 594 595 596 597 598 599 600 601 602
	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;

Alan Cox's avatar
Alan Cox committed
603
	if (ack_or_nak_seen)
Linus Torvalds's avatar
Linus Torvalds committed
604
		garmin_data_p->state = STATE_GSP_WAIT_DATA;
605 606 607

	spin_unlock_irqrestore(&garmin_data_p->lock, flags);

Alan Cox's avatar
Alan Cox committed
608
	if (ack_or_nak_seen)
Linus Torvalds's avatar
Linus Torvalds committed
609 610 611 612 613 614 615 616 617 618 619 620 621 622
		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 <0 on error, 0 if packet is incomplete or > 0 if packet was sent
 */
Alan Cox's avatar
Alan Cox committed
623
static int gsp_send(struct garmin_data *garmin_data_p,
Linus Torvalds's avatar
Linus Torvalds committed
624 625 626 627 628 629 630
		    const unsigned char *buf, int count)
{
	const unsigned char *src;
	unsigned char *dst;
	int pktid = 0;
	int datalen = 0;
	int cksum = 0;
Alan Cox's avatar
Alan Cox committed
631
	int i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
632 633
	int k;

634
	dbg("%s - state %d - %d bytes.", __func__,
Alan Cox's avatar
Alan Cox committed
635
					garmin_data_p->state, count);
Linus Torvalds's avatar
Linus Torvalds committed
636 637 638 639 640 641 642 643 644 645 646 647 648 649

	k = garmin_data_p->outsize;
	if ((k+count) > GPS_OUT_BUFSIZ) {
		dbg("packet too large");
		garmin_data_p->outsize = 0;
		return -4;
	}

	memcpy(garmin_data_p->outbuffer+k, buf, count);
	k += count;
	garmin_data_p->outsize = k;

	if (k >= GARMIN_PKTHDR_LENGTH) {
		pktid  = getPacketId(garmin_data_p->outbuffer);
Alan Cox's avatar
Alan Cox committed
650
		datalen = getDataLength(garmin_data_p->outbuffer);
Linus Torvalds's avatar
Linus Torvalds committed
651 652 653 654 655 656 657
		i = GARMIN_PKTHDR_LENGTH + datalen;
		if (k < i)
			return 0;
	} else {
		return 0;
	}

Alan Cox's avatar
Alan Cox committed
658
	dbg("%s - %d bytes in buffer, %d bytes in pkt.", __func__, k, i);
Linus Torvalds's avatar
Linus Torvalds committed
659 660 661 662

	/* garmin_data_p->outbuffer now contains a complete packet */

	usb_serial_debug_data(debug, &garmin_data_p->port->dev,
Alan Cox's avatar
Alan Cox committed
663
				__func__, k, garmin_data_p->outbuffer);
Linus Torvalds's avatar
Linus Torvalds committed
664 665 666 667

	garmin_data_p->outsize = 0;

	if (GARMIN_LAYERID_APPL != getLayerId(garmin_data_p->outbuffer)) {
Alan Cox's avatar
Alan Cox committed
668 669
		dbg("not an application packet (%d)",
				getLayerId(garmin_data_p->outbuffer));
Linus Torvalds's avatar
Linus Torvalds committed
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
		return -1;
	}

	if (pktid > 255) {
		dbg("packet-id %d too large", pktid);
		return -2;
	}

	if (datalen > 255) {
		dbg("packet-size %d too large", datalen);
		return -3;
	}

	/* the serial protocol should be able to handle this packet */

	k = 0;
	src = garmin_data_p->outbuffer+GARMIN_PKTHDR_LENGTH;
Alan Cox's avatar
Alan Cox committed
687
	for (i = 0; i < datalen; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
688 689 690 691 692 693
		if (*src++ == DLE)
			k++;
	}

	src = garmin_data_p->outbuffer+GARMIN_PKTHDR_LENGTH;
	if (k > (GARMIN_PKTHDR_LENGTH-2)) {
Alan Cox's avatar
Alan Cox committed
694
		/* can't add stuffing DLEs in place, move data to end
695
		   of buffer ... */
Linus Torvalds's avatar
Linus Torvalds committed
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710
		dst = garmin_data_p->outbuffer+GPS_OUT_BUFSIZ-datalen;
		memcpy(dst, src, datalen);
		src = dst;
	}

	dst = garmin_data_p->outbuffer;

	*dst++ = DLE;
	*dst++ = pktid;
	cksum += pktid;
	*dst++ = datalen;
	cksum += datalen;
	if (datalen == DLE)
		*dst++ = DLE;

Alan Cox's avatar
Alan Cox committed
711
	for (i = 0; i < datalen; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
712 713 714 715 716 717
		__u8 c = *src++;
		*dst++ = c;
		cksum += c;
		if (c == DLE)
			*dst++ = DLE;
	}
Alan Cox's avatar
Alan Cox committed
718

Linus Torvalds's avatar
Linus Torvalds committed
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
	cksum = 0xFF & -cksum;
	*dst++ = cksum;
	if (cksum == DLE)
		*dst++ = DLE;
	*dst++ = DLE;
	*dst++ = ETX;

	i = dst-garmin_data_p->outbuffer;

	send_to_tty(garmin_data_p->port, garmin_data_p->outbuffer, i);

	garmin_data_p->pkt_id = pktid;
	garmin_data_p->state  = STATE_WAIT_TTY_ACK;

	return i;
}





/*
 * Process the next pending data packet - if there is one
 */
Alan Cox's avatar
Alan Cox committed
743
static void gsp_next_packet(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
744 745 746 747
{
	struct garmin_packet *pkt = NULL;

	while ((pkt = pkt_pop(garmin_data_p)) != NULL) {
748
		dbg("%s - next pkt: %d", __func__, pkt->seq);
Linus Torvalds's avatar
Linus Torvalds committed
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
		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 data read, it may span more than one packet
 * or even incomplete packets
 */
Alan Cox's avatar
Alan Cox committed
773
static int nat_receive(struct garmin_data *garmin_data_p,
774
		       const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
775
{
776
	unsigned long flags;
Alan Cox's avatar
Alan Cox committed
777
	__u8 *dest;
Linus Torvalds's avatar
Linus Torvalds committed
778 779 780 781 782
	int offs = 0;
	int result = count;
	int len;

	while (offs < count) {
Alan Cox's avatar
Alan Cox committed
783
		/* if buffer contains header, copy rest of data */
Linus Torvalds's avatar
Linus Torvalds committed
784 785 786 787 788 789 790
		if (garmin_data_p->insize >= GARMIN_PKTHDR_LENGTH)
			len = GARMIN_PKTHDR_LENGTH
			      +getDataLength(garmin_data_p->inbuffer);
		else
			len = GARMIN_PKTHDR_LENGTH;

		if (len >= GPS_IN_BUFSIZ) {
Alan Cox's avatar
Alan Cox committed
791 792 793
			/* seems to be an invalid packet, ignore rest
			   of input */
			dbg("%s - packet size too large: %d", __func__, len);
Linus Torvalds's avatar
Linus Torvalds committed
794 795 796 797 798 799 800 801 802
			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
Alan Cox's avatar
Alan Cox committed
803
						+ garmin_data_p->insize;
Linus Torvalds's avatar
Linus Torvalds committed
804 805 806 807 808 809 810 811 812 813 814
				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+
			   getDataLength(garmin_data_p->inbuffer);
			if (garmin_data_p->insize >= len) {
Alan Cox's avatar
Alan Cox committed
815 816 817
				garmin_write_bulk(garmin_data_p->port,
						   garmin_data_p->inbuffer,
						   len, 0);
Linus Torvalds's avatar
Linus Torvalds committed
818 819 820 821 822
				garmin_data_p->insize = 0;

				/* if this was an abort-transfer command,
				   flush all queued data. */
				if (isAbortTrfCmnd(garmin_data_p->inbuffer)) {
Alan Cox's avatar
Alan Cox committed
823 824
					spin_lock_irqsave(&garmin_data_p->lock,
									flags);
Linus Torvalds's avatar
Linus Torvalds committed
825
					garmin_data_p->flags |= FLAGS_DROP_DATA;
Alan Cox's avatar
Alan Cox committed
826 827
					spin_unlock_irqrestore(
						&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842
					pkt_clear(garmin_data_p);
				}
			}
		}
	}
	return result;
}


/******************************************************************************
 * private packets
 ******************************************************************************/

static void priv_status_resp(struct usb_serial_port *port)
{
Alan Cox's avatar
Alan Cox committed
843
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
844 845 846 847 848 849 850 851 852
	__le32 *pkt = (__le32 *)garmin_data_p->privpkt;

	pkt[0] = __cpu_to_le32(GARMIN_LAYERID_PRIVATE);
	pkt[1] = __cpu_to_le32(PRIV_PKTID_INFO_RESP);
	pkt[2] = __cpu_to_le32(12);
	pkt[3] = __cpu_to_le32(VERSION_MAJOR << 16 | VERSION_MINOR);
	pkt[4] = __cpu_to_le32(garmin_data_p->mode);
	pkt[5] = __cpu_to_le32(garmin_data_p->serial_num);

Alan Cox's avatar
Alan Cox committed
853
	send_to_tty(port, (__u8 *)pkt, 6 * 4);
Linus Torvalds's avatar
Linus Torvalds committed
854 855 856 857 858 859 860 861 862
}


/******************************************************************************
 * Garmin specific driver functions
 ******************************************************************************/

static int process_resetdev_request(struct usb_serial_port *port)
{
863
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
864
	int status;
Alan Cox's avatar
Alan Cox committed
865
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
866

867
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
868 869 870
	garmin_data_p->flags &= ~(CLEAR_HALT_REQUIRED);
	garmin_data_p->state = STATE_RESET;
	garmin_data_p->serial_num = 0;
871
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
872

Alan Cox's avatar
Alan Cox committed
873 874
	usb_kill_urb(port->interrupt_in_urb);
	dbg("%s - usb_reset_device", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
875 876 877
	status = usb_reset_device(port->serial->dev);
	if (status)
		dbg("%s - usb_reset_device failed: %d",
878
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
879 880 881 882 883 884 885 886
	return status;
}



/*
 * clear all cached data
 */
Alan Cox's avatar
Alan Cox committed
887
static int garmin_clear(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
888
{
889
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
890 891 892 893
	int status = 0;

	struct usb_serial_port *port = garmin_data_p->port;

894
	if (port != NULL && atomic_read(&garmin_data_p->resp_count)) {
Linus Torvalds's avatar
Linus Torvalds committed
895 896
		/* send a terminate command */
		status = garmin_write_bulk(port, GARMIN_STOP_TRANSFER_REQ,
Alan Cox's avatar
Alan Cox committed
897
					sizeof(GARMIN_STOP_TRANSFER_REQ), 1);
Linus Torvalds's avatar
Linus Torvalds committed
898 899 900 901 902
	}

	/* flush all queued data */
	pkt_clear(garmin_data_p);

903
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
904 905
	garmin_data_p->insize = 0;
	garmin_data_p->outsize = 0;
906
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
907 908 909 910 911 912 913 914 915 916 917

	return status;
}






static int garmin_init_session(struct usb_serial_port *port)
{
918
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
919
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
920
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
921 922 923
	int status = 0;

	if (status == 0) {
Alan Cox's avatar
Alan Cox committed
924
		usb_kill_urb(port->interrupt_in_urb);
Linus Torvalds's avatar
Linus Torvalds committed
925

926
		dbg("%s - adding interrupt input", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
927 928 929 930
		port->interrupt_in_urb->dev = serial->dev;
		status = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
		if (status)
			dev_err(&serial->dev->dev,
Alan Cox's avatar
Alan Cox committed
931 932
			  "%s - failed submitting interrupt urb, error %d\n",
							__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
933 934 935
	}

	if (status == 0) {
936
		dbg("%s - starting session ...", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
937 938
		garmin_data_p->state = STATE_ACTIVE;
		status = garmin_write_bulk(port, GARMIN_START_SESSION_REQ,
Alan Cox's avatar
Alan Cox committed
939
					sizeof(GARMIN_START_SESSION_REQ), 0);
Linus Torvalds's avatar
Linus Torvalds committed
940 941 942

		if (status >= 0) {

943
			spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
944
			garmin_data_p->ignorePkts++;
945
			spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
946 947 948

			/* not needed, but the win32 driver does it too ... */
			status = garmin_write_bulk(port,
Alan Cox's avatar
Alan Cox committed
949 950
					GARMIN_START_SESSION_REQ2,
					sizeof(GARMIN_START_SESSION_REQ2), 0);
Linus Torvalds's avatar
Linus Torvalds committed
951 952
			if (status >= 0) {
				status = 0;
953
				spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
954
				garmin_data_p->ignorePkts++;
Alan Cox's avatar
Alan Cox committed
955 956
				spin_unlock_irqrestore(&garmin_data_p->lock,
									flags);
Linus Torvalds's avatar
Linus Torvalds committed
957 958 959 960 961 962 963 964 965 966 967
			}
		}
	}

	return status;
}





Alan Cox's avatar
Alan Cox committed
968
static int garmin_open(struct tty_struct *tty,
Alan Cox's avatar
Alan Cox committed
969
			struct usb_serial_port *port, struct file *filp)
Linus Torvalds's avatar
Linus Torvalds committed
970
{
971
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
972
	int status = 0;
Alan Cox's avatar
Alan Cox committed
973
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
974

975
	dbg("%s - port %d", __func__, port->number);
Linus Torvalds's avatar
Linus Torvalds committed
976 977 978 979 980 981

	/*
	 * 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.
	 */
Alan Cox's avatar
Alan Cox committed
982 983
	if (tty)
		tty->low_latency = 1;
Linus Torvalds's avatar
Linus Torvalds committed
984

985
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
986 987 988
	garmin_data_p->mode  = initial_mode;
	garmin_data_p->count = 0;
	garmin_data_p->flags = 0;
989 990
	atomic_set(&garmin_data_p->req_count, 0);
	atomic_set(&garmin_data_p->resp_count, 0);
991
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
992 993

	/* shutdown any bulk reads that might be going on */
Alan Cox's avatar
Alan Cox committed
994 995
	usb_kill_urb(port->write_urb);
	usb_kill_urb(port->read_urb);
Linus Torvalds's avatar
Linus Torvalds committed
996

Alan Cox's avatar
Alan Cox committed
997
	if (garmin_data_p->state == STATE_RESET)
Linus Torvalds's avatar
Linus Torvalds committed
998 999 1000 1001 1002 1003 1004
		status = garmin_init_session(port);

	garmin_data_p->state = STATE_ACTIVE;
	return status;
}


Alan Cox's avatar
Alan Cox committed
1005
static void garmin_close(struct tty_struct *tty,
Alan Cox's avatar
Alan Cox committed
1006
			struct usb_serial_port *port, struct file *filp)
Linus Torvalds's avatar
Linus Torvalds committed
1007 1008
{
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
1009
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1010

1011
	dbg("%s - port %d - mode=%d state=%d flags=0x%X", __func__,
Linus Torvalds's avatar
Linus Torvalds committed
1012 1013 1014 1015 1016 1017
		port->number, garmin_data_p->mode,
		garmin_data_p->state, garmin_data_p->flags);

	if (!serial)
		return;

1018 1019 1020
	mutex_lock(&port->serial->disc_mutex);
	if (!port->serial->disconnected)
		garmin_clear(garmin_data_p);
Linus Torvalds's avatar
Linus Torvalds committed
1021 1022

	/* shutdown our urbs */
Alan Cox's avatar
Alan Cox committed
1023 1024
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
Linus Torvalds's avatar
Linus Torvalds committed
1025

1026 1027 1028 1029 1030 1031 1032 1033
	if (!port->serial->disconnected) {
		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;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1034 1035 1036
	} else {
		garmin_data_p->state = STATE_DISCONNECTED;
	}
1037
	mutex_unlock(&port->serial->disc_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
1038 1039
}

Alan Cox's avatar
Alan Cox committed
1040
static void garmin_write_bulk_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
1041
{
1042
	unsigned long flags;
1043
	struct usb_serial_port *port = urb->context;
1044
	int status = urb->status;
Linus Torvalds's avatar
Linus Torvalds committed
1045

1046
	if (port) {
Alan Cox's avatar
Alan Cox committed
1047 1048
		struct garmin_data *garmin_data_p =
					usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1049

1050
		dbg("%s - port %d", __func__, port->number);
Linus Torvalds's avatar
Linus Torvalds committed
1051

1052 1053
		if (GARMIN_LAYERID_APPL == getLayerId(urb->transfer_buffer)
		    && (garmin_data_p->mode == MODE_GARMIN_SERIAL))  {
Alan Cox's avatar
Alan Cox committed
1054 1055
			gsp_send_ack(garmin_data_p,
					((__u8 *)urb->transfer_buffer)[4]);
1056 1057 1058 1059
		}

		if (status) {
			dbg("%s - nonzero write bulk status received: %d",
1060
			    __func__, urb->status);
1061 1062 1063 1064 1065 1066
			spin_lock_irqsave(&garmin_data_p->lock, flags);
			garmin_data_p->flags |= CLEAR_HALT_REQUIRED;
			spin_unlock_irqrestore(&garmin_data_p->lock, flags);
		}

		usb_serial_port_softint(port);
Linus Torvalds's avatar
Linus Torvalds committed
1067 1068
	}

Alan Cox's avatar
Alan Cox committed
1069 1070
	/* Ignore errors that resulted from garmin_write_bulk with
	   dismiss_ack = 1 */
1071 1072

	/* free up the transfer buffer, as usb_free_urb() does not do this */
Alan Cox's avatar
Alan Cox committed
1073
	kfree(urb->transfer_buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1074 1075 1076
}


Alan Cox's avatar
Alan Cox committed
1077
static int garmin_write_bulk(struct usb_serial_port *port,
1078 1079
			      const unsigned char *buf, int count,
			      int dismiss_ack)
Linus Torvalds's avatar
Linus Torvalds committed
1080
{
1081
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1082
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
1083
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1084 1085 1086 1087
	struct urb *urb;
	unsigned char *buffer;
	int status;

1088
	dbg("%s - port %d, state %d", __func__, port->number,
Linus Torvalds's avatar
Linus Torvalds committed
1089 1090
		garmin_data_p->state);

1091
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1092
	garmin_data_p->flags &= ~FLAGS_DROP_DATA;
1093
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1094

Alan Cox's avatar
Alan Cox committed
1095
	buffer = kmalloc(count, GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
1096 1097 1098 1099 1100 1101 1102 1103
	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");
Alan Cox's avatar
Alan Cox committed
1104
		kfree(buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1105 1106 1107
		return -ENOMEM;
	}

Alan Cox's avatar
Alan Cox committed
1108
	memcpy(buffer, buf, count);
Linus Torvalds's avatar
Linus Torvalds committed
1109

1110
	usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1111

Alan Cox's avatar
Alan Cox committed
1112 1113 1114
	usb_fill_bulk_urb(urb, serial->dev,
				usb_sndbulkpipe(serial->dev,
					port->bulk_out_endpointAddress),
Linus Torvalds's avatar
Linus Torvalds committed
1115
				buffer, count,
1116 1117
				garmin_write_bulk_callback,
				dismiss_ack ? NULL : port);
Linus Torvalds's avatar
Linus Torvalds committed
1118 1119 1120
	urb->transfer_flags |= URB_ZERO_PACKET;

	if (GARMIN_LAYERID_APPL == getLayerId(buffer)) {
1121
		atomic_inc(&garmin_data_p->req_count);
Linus Torvalds's avatar
Linus Torvalds committed
1122 1123 1124 1125 1126 1127 1128 1129 1130 1131
		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,
Alan Cox's avatar
Alan Cox committed
1132
		   "%s - usb_submit_urb(write bulk) failed with status = %d\n",
1133
				__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1134 1135 1136 1137 1138
		count = status;
	}

	/* we are done with this urb, so let the host driver
	 * really free it when it is finished with it */
Alan Cox's avatar
Alan Cox committed
1139
	usb_free_urb(urb);
Linus Torvalds's avatar
Linus Torvalds committed
1140 1141 1142 1143

	return count;
}

Alan Cox's avatar
Alan Cox committed
1144
static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
Alan Cox's avatar
Alan Cox committed
1145
					 const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
1146 1147
{
	int pktid, pktsiz, len;
Alan Cox's avatar
Alan Cox committed
1148
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1149 1150
	__le32 *privpkt = (__le32 *)garmin_data_p->privpkt;

1151
	usb_serial_debug_data(debug, &port->dev, __func__, count, buf);
Linus Torvalds's avatar
Linus Torvalds committed
1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164

	/* check for our private packets */
	if (count >= GARMIN_PKTHDR_LENGTH) {
		len = PRIVPKTSIZ;
		if (count < len)
			len = count;

		memcpy(garmin_data_p->privpkt, buf, len);

		pktsiz = getDataLength(garmin_data_p->privpkt);
		pktid  = getPacketId(garmin_data_p->privpkt);

		if (count == (GARMIN_PKTHDR_LENGTH+pktsiz)
Alan Cox's avatar
Alan Cox committed
1165 1166
		    && GARMIN_LAYERID_PRIVATE ==
				getLayerId(garmin_data_p->privpkt)) {
Linus Torvalds's avatar
Linus Torvalds committed
1167 1168

			dbg("%s - processing private request %d",
1169
				__func__, pktid);
Linus Torvalds's avatar
Linus Torvalds committed
1170

Alan Cox's avatar
Alan Cox committed
1171
			/* drop all unfinished transfers */
Linus Torvalds's avatar
Linus Torvalds committed
1172 1173
			garmin_clear(garmin_data_p);

Alan Cox's avatar
Alan Cox committed
1174
			switch (pktid) {
Linus Torvalds's avatar
Linus Torvalds committed
1175 1176 1177 1178 1179 1180

			case PRIV_PKTID_SET_DEBUG:
				if (pktsiz != 4)
					return -EINVPKT;
				debug = __le32_to_cpu(privpkt[3]);
				dbg("%s - debug level set to 0x%X",
1181
					__func__, debug);
Linus Torvalds's avatar
Linus Torvalds committed
1182 1183 1184 1185 1186 1187 1188
				break;

			case PRIV_PKTID_SET_MODE:
				if (pktsiz != 4)
					return -EINVPKT;
				garmin_data_p->mode = __le32_to_cpu(privpkt[3]);
				dbg("%s - mode set to %d",
1189
					__func__, garmin_data_p->mode);
Linus Torvalds's avatar
Linus Torvalds committed
1190 1191 1192 1193 1194 1195 1196
				break;

			case PRIV_PKTID_INFO_REQ:
				priv_status_resp(port);
				break;

			case PRIV_PKTID_RESET_REQ:
1197
				atomic_inc(&garmin_data_p->req_count);
Linus Torvalds's avatar
Linus Torvalds committed
1198 1199 1200 1201 1202 1203 1204
				break;

			case PRIV_PKTID_SET_DEF_MODE:
				if (pktsiz != 4)
					return -EINVPKT;
				initial_mode = __le32_to_cpu(privpkt[3]);
				dbg("%s - initial_mode set to %d",
1205
					__func__,
Linus Torvalds's avatar
Linus Torvalds committed
1206 1207 1208 1209 1210 1211 1212
					garmin_data_p->mode);
				break;
			}
			return count;
		}
	}

1213 1214
	garmin_data_p->ignorePkts = 0;

Linus Torvalds's avatar
Linus Torvalds committed
1215 1216 1217 1218 1219 1220 1221 1222
	if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
		return gsp_receive(garmin_data_p, buf, count);
	} else {	/* MODE_NATIVE */
		return nat_receive(garmin_data_p, buf, count);
	}
}


Alan Cox's avatar
Alan Cox committed
1223
static int garmin_write_room(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
1224
{
Alan Cox's avatar
Alan Cox committed
1225
	struct usb_serial_port *port = tty->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
1226 1227 1228
	/*
	 * Report back the bytes currently available in the output buffer.
	 */
Alan Cox's avatar
Alan Cox committed
1229
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1230 1231 1232 1233
	return GPS_OUT_BUFSIZ-garmin_data_p->outsize;
}


Alan Cox's avatar
Alan Cox committed
1234
static void garmin_read_process(struct garmin_data *garmin_data_p,
Linus Torvalds's avatar
Linus Torvalds committed
1235 1236 1237 1238
				 unsigned char *data, unsigned data_length)
{
	if (garmin_data_p->flags & FLAGS_DROP_DATA) {
		/* abort-transfer cmd is actice */
1239
		dbg("%s - pkt dropped", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1240
	} else if (garmin_data_p->state != STATE_DISCONNECTED &&
Alan Cox's avatar
Alan Cox committed
1241
		garmin_data_p->state != STATE_RESET) {
Linus Torvalds's avatar
Linus Torvalds committed
1242 1243 1244 1245 1246

		/* 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,
Alan Cox's avatar
Alan Cox committed
1247
				sizeof(GARMIN_APP_LAYER_REPLY))) {
1248
			atomic_inc(&garmin_data_p->resp_count);
1249
		}
Linus Torvalds's avatar
Linus Torvalds committed
1250 1251

		/* if throttling is active or postprecessing is required
1252
		   put the received data in the input queue, otherwise
Linus Torvalds's avatar
Linus Torvalds committed
1253 1254 1255 1256
		   send it directly to the tty port */
		if (garmin_data_p->flags & FLAGS_QUEUING) {
			pkt_add(garmin_data_p, data, data_length);
		} else if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
Alan Cox's avatar
Alan Cox committed
1257
			if (getLayerId(data) == GARMIN_LAYERID_APPL)
Linus Torvalds's avatar
Linus Torvalds committed
1258 1259 1260 1261 1262 1263 1264 1265
				pkt_add(garmin_data_p, data, data_length);
		} else {
			send_to_tty(garmin_data_p->port, data, data_length);
		}
	}
}


Alan Cox's avatar
Alan Cox committed
1266
static void garmin_read_bulk_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
1267
{
1268
	unsigned long flags;
1269
	struct usb_serial_port *port = urb->context;
Linus Torvalds's avatar
Linus Torvalds committed
1270
	struct usb_serial *serial =  port->serial;
Alan Cox's avatar
Alan Cox committed
1271
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1272
	unsigned char *data = urb->transfer_buffer;
1273 1274
	int status = urb->status;
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
1275

1276
	dbg("%s - port %d", __func__, port->number);
Linus Torvalds's avatar
Linus Torvalds committed
1277 1278

	if (!serial) {
1279
		dbg("%s - bad serial pointer, exiting", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1280 1281 1282
		return;
	}

1283
	if (status) {
Linus Torvalds's avatar
Linus Torvalds committed
1284
		dbg("%s - nonzero read bulk status received: %d",
1285
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1286 1287 1288
		return;
	}

Alan Cox's avatar
Alan Cox committed
1289
	usb_serial_debug_data(debug, &port->dev,
1290
				__func__, urb->actual_length, data);
Linus Torvalds's avatar
Linus Torvalds committed
1291 1292 1293

	garmin_read_process(garmin_data_p, data, urb->actual_length);

1294 1295 1296 1297 1298
	if (urb->actual_length == 0 &&
			0 != (garmin_data_p->flags & FLAGS_BULK_IN_RESTART)) {
		spin_lock_irqsave(&garmin_data_p->lock, flags);
		garmin_data_p->flags &= ~FLAGS_BULK_IN_RESTART;
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);
1299 1300
		retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
		if (retval)
Linus Torvalds's avatar
Linus Torvalds committed
1301 1302
			dev_err(&port->dev,
				"%s - failed resubmitting read urb, error %d\n",
1303
				__func__, retval);
1304 1305 1306
	} else if (urb->actual_length > 0) {
		/* Continue trying to read until nothing more is received  */
		if (0 == (garmin_data_p->flags & FLAGS_THROTTLED)) {
1307 1308
			retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
			if (retval)
1309
				dev_err(&port->dev,
1310
					"%s - failed resubmitting read urb, "
1311
					"error %d\n", __func__, retval);
1312 1313
		}
	} else {
1314
		dbg("%s - end of bulk data", __func__);
1315 1316 1317
		spin_lock_irqsave(&garmin_data_p->lock, flags);
		garmin_data_p->flags &= ~FLAGS_BULK_IN_ACTIVE;
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1318 1319 1320 1321 1322
	}
	return;
}


Alan Cox's avatar
Alan Cox committed
1323
static void garmin_read_int_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
1324
{
1325
	unsigned long flags;
1326
	int retval;
1327
	struct usb_serial_port *port = urb->context;
Linus Torvalds's avatar
Linus Torvalds committed
1328
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
1329
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1330
	unsigned char *data = urb->transfer_buffer;
1331
	int status = urb->status;
Linus Torvalds's avatar
Linus Torvalds committed
1332

1333
	switch (status) {
Linus Torvalds's avatar
Linus Torvalds committed
1334 1335 1336 1337 1338 1339 1340 1341
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dbg("%s - urb shutting down with status: %d",
1342
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1343 1344 1345
		return;
	default:
		dbg("%s - nonzero urb status received: %d",
1346
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1347 1348 1349
		return;
	}

1350
	usb_serial_debug_data(debug, &port->dev, __func__,
Linus Torvalds's avatar
Linus Torvalds committed
1351 1352 1353 1354
				urb->actual_length, urb->transfer_buffer);

	if (urb->actual_length == sizeof(GARMIN_BULK_IN_AVAIL_REPLY) &&
	    0 == memcmp(data, GARMIN_BULK_IN_AVAIL_REPLY,
Alan Cox's avatar
Alan Cox committed
1355
				sizeof(GARMIN_BULK_IN_AVAIL_REPLY))) {
Linus Torvalds's avatar
Linus Torvalds committed
1356

1357
		dbg("%s - bulk data available.", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1358

1359 1360 1361
		if (0 == (garmin_data_p->flags & FLAGS_BULK_IN_ACTIVE)) {

			/* bulk data available */
Alan Cox's avatar
Alan Cox committed
1362 1363 1364
			usb_fill_bulk_urb(port->read_urb, serial->dev,
					usb_rcvbulkpipe(serial->dev,
						port->bulk_in_endpointAddress),
1365 1366 1367
					port->read_urb->transfer_buffer,
					port->read_urb->transfer_buffer_length,
					garmin_read_bulk_callback, port);
1368 1369
			retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
			if (retval) {
1370
				dev_err(&port->dev,
Alan Cox's avatar
Alan Cox committed
1371 1372
				 "%s - failed submitting read urb, error %d\n",
							__func__, retval);
1373 1374 1375 1376 1377
			} else {
				spin_lock_irqsave(&garmin_data_p->lock, flags);
				garmin_data_p->flags |= FLAGS_BULK_IN_ACTIVE;
				/* do not send this packet to the user */
				garmin_data_p->ignorePkts = 1;
Alan Cox's avatar
Alan Cox committed
1378 1379
				spin_unlock_irqrestore(&garmin_data_p->lock,
									flags);
1380 1381 1382 1383 1384 1385
			}
		} else {
			/* bulk-in transfer still active */
			spin_lock_irqsave(&garmin_data_p->lock, flags);
			garmin_data_p->flags |= FLAGS_BULK_IN_RESTART;
			spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1386 1387 1388 1389
		}

	} else if (urb->actual_length == (4+sizeof(GARMIN_START_SESSION_REPLY))
			 && 0 == memcmp(data, GARMIN_START_SESSION_REPLY,
Alan Cox's avatar
Alan Cox committed
1390
					sizeof(GARMIN_START_SESSION_REPLY))) {
Linus Torvalds's avatar
Linus Torvalds committed
1391

1392
		spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1393
		garmin_data_p->flags |= FLAGS_SESSION_REPLY1_SEEN;
1394
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1395 1396

		/* save the serial number */
Alan Cox's avatar
Alan Cox committed
1397 1398
		garmin_data_p->serial_num = __le32_to_cpup(
					(__le32 *)(data+GARMIN_PKTHDR_LENGTH));
Linus Torvalds's avatar
Linus Torvalds committed
1399 1400

		dbg("%s - start-of-session reply seen - serial %u.",
1401
			__func__, garmin_data_p->serial_num);
Linus Torvalds's avatar
Linus Torvalds committed
1402 1403 1404 1405 1406 1407
	}

	if (garmin_data_p->ignorePkts) {
		/* this reply belongs to a request generated by the driver,
		   ignore it. */
		dbg("%s - pkt ignored (%d)",
1408
			__func__, garmin_data_p->ignorePkts);
1409
		spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1410
		garmin_data_p->ignorePkts--;
1411
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1412 1413 1414 1415 1416
	} else {
		garmin_read_process(garmin_data_p, data, urb->actual_length);
	}

	port->interrupt_in_urb->dev = port->serial->dev;
Alan Cox's avatar
Alan Cox committed
1417
	retval = usb_submit_urb(urb, GFP_ATOMIC);
1418
	if (retval)
Linus Torvalds's avatar
Linus Torvalds committed
1419 1420
		dev_err(&urb->dev->dev,
			"%s - Error %d submitting interrupt urb\n",
1421
			__func__, retval);
Linus Torvalds's avatar
Linus Torvalds committed
1422 1423 1424 1425 1426 1427 1428 1429
}


/*
 * 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.
 */
Alan Cox's avatar
Alan Cox committed
1430
static int garmin_flush_queue(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
1431
{
1432
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
	struct garmin_packet *pkt;

	if ((garmin_data_p->flags & FLAGS_THROTTLED) == 0) {
		pkt = pkt_pop(garmin_data_p);
		if (pkt != NULL) {
			send_to_tty(garmin_data_p->port, pkt->data, pkt->size);
			kfree(pkt);
			mod_timer(&garmin_data_p->timer, (1)+jiffies);

		} else {
1443
			spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1444
			garmin_data_p->flags &= ~FLAGS_QUEUING;
1445
			spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1446 1447 1448 1449 1450 1451
		}
	}
	return 0;
}


Alan Cox's avatar
Alan Cox committed
1452
static void garmin_throttle(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
1453
{
Alan Cox's avatar
Alan Cox committed
1454
	struct usb_serial_port *port = tty->driver_data;
Alan Cox's avatar
Alan Cox committed
1455
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Alan Cox's avatar
Alan Cox committed
1456
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1457

1458
	dbg("%s - port %d", __func__, port->number);
Linus Torvalds's avatar
Linus Torvalds committed
1459 1460
	/* set flag, data received will be put into a queue
	   for later processing */
1461
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1462
	garmin_data_p->flags |= FLAGS_QUEUING|FLAGS_THROTTLED;
1463
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1464 1465 1466
}


Alan Cox's avatar
Alan Cox committed
1467
static void garmin_unthrottle(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
1468
{
Alan Cox's avatar
Alan Cox committed
1469
	struct usb_serial_port *port = tty->driver_data;
Alan Cox's avatar
Alan Cox committed
1470
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Alan Cox's avatar
Alan Cox committed
1471
	unsigned long flags;
1472
	int status;
Linus Torvalds's avatar
Linus Torvalds committed
1473

1474
	dbg("%s - port %d", __func__, port->number);
1475
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1476
	garmin_data_p->flags &= ~FLAGS_THROTTLED;
1477
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1478 1479 1480 1481 1482

	/* 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);
1483 1484 1485 1486 1487 1488

	if (0 != (garmin_data_p->flags & FLAGS_BULK_IN_ACTIVE)) {
		status = usb_submit_urb(port->read_urb, GFP_ATOMIC);
		if (status)
			dev_err(&port->dev,
				"%s - failed resubmitting read urb, error %d\n",
1489
				__func__, status);
1490
	}
Linus Torvalds's avatar
Linus Torvalds committed
1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
}

/*
 * The timer is currently only used to send queued packets to
 * the tty in cases where the protocol provides no own handshaking
 * to initiate the transfer.
 */
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);
}



Alan Cox's avatar
Alan Cox committed
1510
static int garmin_attach(struct usb_serial *serial)
Linus Torvalds's avatar
Linus Torvalds committed
1511 1512 1513
{
	int status = 0;
	struct usb_serial_port *port = serial->port[0];
Alan Cox's avatar
Alan Cox committed
1514
	struct garmin_data *garmin_data_p = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
1515

1516
	dbg("%s", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1517

1518
	garmin_data_p = kzalloc(sizeof(struct garmin_data), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
1519
	if (garmin_data_p == NULL) {
1520
		dev_err(&port->dev, "%s - Out of memory\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1521 1522 1523 1524 1525
		return -ENOMEM;
	}
	init_timer(&garmin_data_p->timer);
	spin_lock_init(&garmin_data_p->lock);
	INIT_LIST_HEAD(&garmin_data_p->pktlist);
Alan Cox's avatar
Alan Cox committed
1526
	/* garmin_data_p->timer.expires = jiffies + session_timeout; */
Linus Torvalds's avatar
Linus Torvalds committed
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
	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;
}


Alan Cox's avatar
Alan Cox committed
1540
static void garmin_shutdown(struct usb_serial *serial)
Linus Torvalds's avatar
Linus Torvalds committed
1541 1542
{
	struct usb_serial_port *port = serial->port[0];
Alan Cox's avatar
Alan Cox committed
1543
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1544

1545
	dbg("%s", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1546

Alan Cox's avatar
Alan Cox committed
1547
	usb_kill_urb(port->interrupt_in_urb);
Linus Torvalds's avatar
Linus Torvalds committed
1548
	del_timer_sync(&garmin_data_p->timer);
Alan Cox's avatar
Alan Cox committed
1549
	kfree(garmin_data_p);
Linus Torvalds's avatar
Linus Torvalds committed
1550 1551 1552 1553 1554
	usb_set_serial_port_data(port, NULL);
}


/* All of the device info needed */
1555
static struct usb_serial_driver garmin_device = {
1556
	.driver = {
1557 1558
		.owner       = THIS_MODULE,
		.name        = "garmin_gps",
1559
	},
1560
	.description         = "Garmin GPS usb/tty",
1561
	.usb_driver          = &garmin_driver,
Linus Torvalds's avatar
Linus Torvalds committed
1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577
	.id_table            = id_table,
	.num_ports           = 1,
	.open                = garmin_open,
	.close               = garmin_close,
	.throttle            = garmin_throttle,
	.unthrottle          = garmin_unthrottle,
	.attach              = garmin_attach,
	.shutdown            = garmin_shutdown,
	.write               = garmin_write,
	.write_room          = garmin_write_room,
	.write_bulk_callback = garmin_write_bulk_callback,
	.read_bulk_callback  = garmin_read_bulk_callback,
	.read_int_callback   = garmin_read_int_callback,
};


1578

Alan Cox's avatar
Alan Cox committed
1579
static int __init garmin_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
{
	int retval;

	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;
}


Alan Cox's avatar
Alan Cox committed
1599
static void __exit garmin_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
1600
{
Alan Cox's avatar
Alan Cox committed
1601 1602
	usb_deregister(&garmin_driver);
	usb_serial_deregister(&garmin_device);
Linus Torvalds's avatar
Linus Torvalds committed
1603 1604 1605 1606 1607 1608 1609 1610
}




module_init(garmin_init);
module_exit(garmin_exit);

Alan Cox's avatar
Alan Cox committed
1611 1612
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds's avatar
Linus Torvalds committed
1613 1614 1615 1616 1617 1618 1619
MODULE_LICENSE("GPL");

module_param(debug, bool, S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(debug, "Debug enabled or not");
module_param(initial_mode, int, S_IRUGO);
MODULE_PARM_DESC(initial_mode, "Initial mode");