garmin_gps.c 38.2 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 * Garmin GPS driver
 *
4
 * Copyright (C) 2006-2011 Hermann Kneissel herkne@gmx.de
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 <linux/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 43 44 45 46 47 48 49 50

/* the mode to be set when the port ist opened */
static int initial_mode = 1;

#define GARMIN_VENDOR_ID             0x091E

/*
 * Version Information
 */

#define VERSION_MAJOR	0
51
#define VERSION_MINOR	36
Linus Torvalds's avatar
Linus Torvalds committed
52 53

#define _STR(s) #s
Alan Cox's avatar
Alan Cox committed
54
#define _DRIVER_VERSION(a, b) "v" _STR(a) "." _STR(b)
Linus Torvalds's avatar
Linus Torvalds committed
55 56 57 58 59 60 61 62
#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
63
/* size of the header of a packet using the usb protocol */
Linus Torvalds's avatar
Linus Torvalds committed
64 65
#define GARMIN_PKTHDR_LENGTH	12

Alan Cox's avatar
Alan Cox committed
66 67
/* 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
68

Alan Cox's avatar
Alan Cox committed
69 70
/*  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
71

Alan Cox's avatar
Alan Cox committed
72 73 74 75 76 77 78
/* 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
79

Alan Cox's avatar
Alan Cox committed
80 81
/* 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
82

Alan Cox's avatar
Alan Cox committed
83 84 85
/* 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
86 87
#define GSP_INITIAL_OFFSET (GARMIN_PKTHDR_LENGTH-2)

Alan Cox's avatar
Alan Cox committed
88
/* max. size of incoming private packets (header+1 param) */
Linus Torvalds's avatar
Linus Torvalds committed
89 90 91 92
#define PRIVPKTSIZ (GARMIN_PKTHDR_LENGTH+4)

#define GARMIN_LAYERID_TRANSPORT  0
#define GARMIN_LAYERID_APPL      20
Alan Cox's avatar
Alan Cox committed
93
/* our own layer-id to use for some control mechanisms */
Linus Torvalds's avatar
Linus Torvalds committed
94 95 96 97 98 99 100
#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
101
/* packet ids used in private layer */
Linus Torvalds's avatar
Linus Torvalds committed
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
#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
119 120
	/* the real size of the data array, always > 0 */
	int               size;
Linus Torvalds's avatar
Linus Torvalds committed
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
	__u8              data[1];
};

/* structure used to keep the current state of the driver */
struct garmin_data {
	__u8   state;
	__u16  flags;
	__u8   mode;
	__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];
	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
160
/* Flags used in garmin_data.flags: */
Linus Torvalds's avatar
Linus Torvalds committed
161 162 163 164
#define FLAGS_SESSION_REPLY_MASK  0x00C0
#define FLAGS_SESSION_REPLY1_SEEN 0x0080
#define FLAGS_SESSION_REPLY2_SEEN 0x0040
#define FLAGS_BULK_IN_ACTIVE      0x0020
165 166
#define FLAGS_BULK_IN_RESTART     0x0010
#define FLAGS_THROTTLED           0x0008
167 168
#define APP_REQ_SEEN              0x0004
#define APP_RESP_SEEN             0x0002
Linus Torvalds's avatar
Linus Torvalds committed
169 170 171 172 173 174 175 176 177 178 179 180 181 182
#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 */
183 184
static int gsp_next_packet(struct garmin_data *garmin_data_p);
static int garmin_write_bulk(struct usb_serial_port *port,
185 186
			     const unsigned char *buf, int count,
			     int dismiss_ack);
Linus Torvalds's avatar
Linus Torvalds committed
187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209

/* 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_REPLY[]
	= { 0, 0, 0, 0,  6, 0, 0, 0, 4, 0, 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 };



210
static const struct usb_device_id id_table[] = {
Alan Cox's avatar
Alan Cox committed
211 212 213
	/* 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
214 215
	{ }					/* Terminating entry */
};
Alan Cox's avatar
Alan Cox committed
216
MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds's avatar
Linus Torvalds committed
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240


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
241 242 243 244
	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
245 246 247 248 249 250 251 252
		return 1;
	else
		return 0;
}



static void send_to_tty(struct usb_serial_port *port,
253
			char *data, unsigned int actual_length)
Linus Torvalds's avatar
Linus Torvalds committed
254
{
255
	if (actual_length) {
256
		usb_serial_debug_data(&port->dev, __func__, actual_length, data);
257
		tty_insert_flip_string(&port->port, data, actual_length);
258
		tty_flip_buffer_push(&port->port);
Linus Torvalds's avatar
Linus Torvalds committed
259 260 261 262 263 264 265 266 267 268 269
	}
}


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

/*
 * queue a received (usb-)packet for later processing
 */
Alan Cox's avatar
Alan Cox committed
270
static int pkt_add(struct garmin_data *garmin_data_p,
271
		   unsigned char *data, unsigned int data_length)
Linus Torvalds's avatar
Linus Torvalds committed
272
{
273
	int state = 0;
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276 277 278 279 280
	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
281
								GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
282 283 284 285 286 287 288 289
		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);
290
		garmin_data_p->flags |= FLAGS_QUEUING;
Linus Torvalds's avatar
Linus Torvalds committed
291 292 293
		result = list_empty(&garmin_data_p->pktlist);
		pkt->seq = garmin_data_p->seq_counter++;
		list_add_tail(&pkt->list, &garmin_data_p->pktlist);
294
		state = garmin_data_p->state;
Linus Torvalds's avatar
Linus Torvalds committed
295 296
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);

297 298 299
		dev_dbg(&garmin_data_p->port->dev,
			"%s - added: pkt: %d - %d bytes\n", __func__,
			pkt->seq, data_length);
300

Linus Torvalds's avatar
Linus Torvalds committed
301
		/* in serial mode, if someone is waiting for data from
302
		   the device, convert and send the next packet to tty. */
Alan Cox's avatar
Alan Cox committed
303
		if (result && (state == STATE_GSP_WAIT_DATA))
Linus Torvalds's avatar
Linus Torvalds committed
304 305 306 307 308 309 310
			gsp_next_packet(garmin_data_p);
	}
	return result;
}


/* get the next pending packet */
Alan Cox's avatar
Alan Cox committed
311
static struct garmin_packet *pkt_pop(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
{
	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
327
static void pkt_clear(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
{
	unsigned long flags;
	struct garmin_packet *result = NULL;

	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
347
static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
Linus Torvalds's avatar
Linus Torvalds committed
348 349
{
	__u8 pkt[10];
350 351 352
	__u8 cksum = 0;
	__u8 *ptr = pkt;
	unsigned  l = 0;
Linus Torvalds's avatar
Linus Torvalds committed
353

354 355
	dev_dbg(&garmin_data_p->port->dev, "%s - pkt-id: 0x%X.\n", __func__,
		0xFF & pkt_id);
Linus Torvalds's avatar
Linus Torvalds committed
356 357 358 359 360 361 362 363 364 365 366

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

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

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

Alan Cox's avatar
Alan Cox committed
367
	if (pkt_id == DLE)
Linus Torvalds's avatar
Linus Torvalds committed
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
		*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
 *
386
 * the complete packet (pktid ... cksum) is in garmin_data_p->inbuf starting
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389
 * at GSP_INITIAL_OFFSET.
 *
 * count - number of bytes in the input buffer including space reserved for
Alan Cox's avatar
Alan Cox committed
390
 *         the usb header: GSP_INITIAL_OFFSET + number of bytes in packet
Linus Torvalds's avatar
Linus Torvalds committed
391 392
 *         (including pkt-id, data-length a. cksum)
 */
Alan Cox's avatar
Alan Cox committed
393
static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
Linus Torvalds's avatar
Linus Torvalds committed
394
{
395
	struct device *dev = &garmin_data_p->port->dev;
396
	unsigned long flags;
Alan Cox's avatar
Alan Cox committed
397
	const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
398
	__le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
Linus Torvalds's avatar
Linus Torvalds committed
399 400 401 402 403
	int cksum = 0;
	int n = 0;
	int pktid = recpkt[0];
	int size = recpkt[1];

404 405
	usb_serial_debug_data(&garmin_data_p->port->dev, __func__,
			      count-GSP_INITIAL_OFFSET, recpkt);
Linus Torvalds's avatar
Linus Torvalds committed
406 407

	if (size != (count-GSP_INITIAL_OFFSET-3)) {
408
		dev_dbg(dev, "%s - invalid size, expected %d bytes, got %d\n",
409
			__func__, size, (count-GSP_INITIAL_OFFSET-3));
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414 415
		return -EINVPKT;
	}

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

Alan Cox's avatar
Alan Cox committed
416 417
	/* sanity check, remove after test ... */
	if ((__u8 *)&(usbdata[3]) != recpkt) {
418 419
		dev_dbg(dev, "%s - ptr mismatch %p - %p\n", __func__,
			&(usbdata[4]), recpkt);
Linus Torvalds's avatar
Linus Torvalds committed
420 421 422 423 424 425 426 427
		return -EINVPKT;
	}

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

428
	if ((0xff & (cksum + *recpkt)) != 0) {
429
		dev_dbg(dev, "%s - invalid checksum, expected %02x, got %02x\n",
430
			__func__, 0xff & -cksum, 0xff & *recpkt);
431 432
		return -EINVPKT;
	}
Linus Torvalds's avatar
Linus Torvalds committed
433 434 435 436 437

	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
438
	garmin_write_bulk(garmin_data_p->port, garmin_data_p->inbuffer,
439
			   GARMIN_PKTHDR_LENGTH+size, 0);
Linus Torvalds's avatar
Linus Torvalds committed
440 441 442 443

	/* if this was an abort-transfer command, flush all
	   queued data. */
	if (isAbortTrfCmnd(garmin_data_p->inbuffer)) {
444
		spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
445
		garmin_data_p->flags |= FLAGS_DROP_DATA;
446
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
		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
473
static int gsp_receive(struct garmin_data *garmin_data_p,
474
		       const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
475
{
476
	struct device *dev = &garmin_data_p->port->dev;
477
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
478 479
	int offs = 0;
	int ack_or_nak_seen = 0;
480 481
	__u8 *dest;
	int size;
Alan Cox's avatar
Alan Cox committed
482
	/* dleSeen: set if last byte read was a DLE */
483
	int dleSeen;
Alan Cox's avatar
Alan Cox committed
484 485 486
	/* skip: if set, skip incoming data until possible start of
	 *       new packet
	 */
487
	int skip;
Linus Torvalds's avatar
Linus Torvalds committed
488 489
	__u8 data;

490 491 492 493 494 495 496
	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);

497
	/* dev_dbg(dev, "%s - dle=%d skip=%d size=%d count=%d\n",
498
		__func__, dleSeen, skip, size, count); */
Linus Torvalds's avatar
Linus Torvalds committed
499

Alan Cox's avatar
Alan Cox committed
500
	if (size == 0)
Linus Torvalds's avatar
Linus Torvalds committed
501 502 503 504 505
		size = GSP_INITIAL_OFFSET;

	while (offs < count) {

		data = *(buf+offs);
Alan Cox's avatar
Alan Cox committed
506
		offs++;
Linus Torvalds's avatar
Linus Torvalds committed
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526

		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;
527
					dev_dbg(dev, "ACK packet complete.\n");
Linus Torvalds's avatar
Linus Torvalds committed
528 529
				} else if (data == NAK) {
					ack_or_nak_seen = NAK;
530
					dev_dbg(dev, "NAK packet complete.\n");
Linus Torvalds's avatar
Linus Torvalds committed
531
				} else {
532
					dev_dbg(dev, "packet complete - id=0x%X.\n",
Alan Cox's avatar
Alan Cox committed
533
						0xFF & data);
Linus Torvalds's avatar
Linus Torvalds committed
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553
					gsp_rec_packet(garmin_data_p, size);
				}

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

			if (dleSeen) {
				size = GSP_INITIAL_OFFSET;
				dleSeen = 0;
			}

			dest[size++] = data;
		}

		if (size >= GPS_IN_BUFSIZ) {
554
			dev_dbg(dev, "%s - packet too large.\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
555 556 557 558 559 560
			skip = 1;
			size = GSP_INITIAL_OFFSET;
			dleSeen = 0;
		}
	}

561 562
	spin_lock_irqsave(&garmin_data_p->lock, flags);

Linus Torvalds's avatar
Linus Torvalds committed
563 564
	garmin_data_p->insize = size;

Alan Cox's avatar
Alan Cox committed
565
	/* copy flags back to structure */
Linus Torvalds's avatar
Linus Torvalds committed
566 567 568 569 570 571 572 573 574 575
	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;

576 577
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);

578 579 580 581 582 583
	if (ack_or_nak_seen) {
		if (gsp_next_packet(garmin_data_p) > 0)
			garmin_data_p->state = STATE_ACTIVE;
		else
			garmin_data_p->state = STATE_GSP_WAIT_DATA;
	}
Linus Torvalds's avatar
Linus Torvalds committed
584 585 586 587 588 589 590 591 592 593 594 595
	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
596
static int gsp_send(struct garmin_data *garmin_data_p,
Linus Torvalds's avatar
Linus Torvalds committed
597 598
		    const unsigned char *buf, int count)
{
599
	struct device *dev = &garmin_data_p->port->dev;
Linus Torvalds's avatar
Linus Torvalds committed
600 601 602 603 604
	const unsigned char *src;
	unsigned char *dst;
	int pktid = 0;
	int datalen = 0;
	int cksum = 0;
Alan Cox's avatar
Alan Cox committed
605
	int i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
606 607
	int k;

608 609
	dev_dbg(dev, "%s - state %d - %d bytes.\n", __func__,
		garmin_data_p->state, count);
Linus Torvalds's avatar
Linus Torvalds committed
610 611 612

	k = garmin_data_p->outsize;
	if ((k+count) > GPS_OUT_BUFSIZ) {
613
		dev_dbg(dev, "packet too large\n");
Linus Torvalds's avatar
Linus Torvalds committed
614 615 616 617 618 619 620 621 622 623
		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
624
		datalen = getDataLength(garmin_data_p->outbuffer);
Linus Torvalds's avatar
Linus Torvalds committed
625 626 627 628 629 630 631
		i = GARMIN_PKTHDR_LENGTH + datalen;
		if (k < i)
			return 0;
	} else {
		return 0;
	}

632
	dev_dbg(dev, "%s - %d bytes in buffer, %d bytes in pkt.\n", __func__, k, i);
Linus Torvalds's avatar
Linus Torvalds committed
633 634 635

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

636 637
	usb_serial_debug_data(&garmin_data_p->port->dev, __func__, k,
			      garmin_data_p->outbuffer);
Linus Torvalds's avatar
Linus Torvalds committed
638 639 640 641

	garmin_data_p->outsize = 0;

	if (GARMIN_LAYERID_APPL != getLayerId(garmin_data_p->outbuffer)) {
642
		dev_dbg(dev, "not an application packet (%d)\n",
Alan Cox's avatar
Alan Cox committed
643
				getLayerId(garmin_data_p->outbuffer));
Linus Torvalds's avatar
Linus Torvalds committed
644 645 646 647
		return -1;
	}

	if (pktid > 255) {
648
		dev_dbg(dev, "packet-id %d too large\n", pktid);
Linus Torvalds's avatar
Linus Torvalds committed
649 650 651 652
		return -2;
	}

	if (datalen > 255) {
653
		dev_dbg(dev, "packet-size %d too large\n", datalen);
Linus Torvalds's avatar
Linus Torvalds committed
654 655 656 657 658 659 660
		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
661
	for (i = 0; i < datalen; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
662 663 664 665 666 667
		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
668
		/* can't add stuffing DLEs in place, move data to end
669
		   of buffer ... */
Linus Torvalds's avatar
Linus Torvalds committed
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684
		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
685
	for (i = 0; i < datalen; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
686 687 688 689 690 691
		__u8 c = *src++;
		*dst++ = c;
		cksum += c;
		if (c == DLE)
			*dst++ = DLE;
	}
Alan Cox's avatar
Alan Cox committed
692

Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
	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
 */
714
static int gsp_next_packet(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
715
{
716
	int result = 0;
Linus Torvalds's avatar
Linus Torvalds committed
717 718 719
	struct garmin_packet *pkt = NULL;

	while ((pkt = pkt_pop(garmin_data_p)) != NULL) {
720
		dev_dbg(&garmin_data_p->port->dev, "%s - next pkt: %d\n", __func__, pkt->seq);
721 722
		result = gsp_send(garmin_data_p, pkt->data, pkt->size);
		if (result > 0) {
Linus Torvalds's avatar
Linus Torvalds committed
723
			kfree(pkt);
724
			return result;
Linus Torvalds's avatar
Linus Torvalds committed
725 726 727
		}
		kfree(pkt);
	}
728
	return result;
Linus Torvalds's avatar
Linus Torvalds committed
729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745
}



/******************************************************************************
 * 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
746
static int nat_receive(struct garmin_data *garmin_data_p,
747
		       const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
748
{
749
	unsigned long flags;
Alan Cox's avatar
Alan Cox committed
750
	__u8 *dest;
Linus Torvalds's avatar
Linus Torvalds committed
751 752 753 754 755
	int offs = 0;
	int result = count;
	int len;

	while (offs < count) {
Alan Cox's avatar
Alan Cox committed
756
		/* if buffer contains header, copy rest of data */
Linus Torvalds's avatar
Linus Torvalds committed
757 758 759 760 761 762 763
		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
764 765
			/* seems to be an invalid packet, ignore rest
			   of input */
766 767 768
			dev_dbg(&garmin_data_p->port->dev,
				"%s - packet size too large: %d\n",
				__func__, len);
Linus Torvalds's avatar
Linus Torvalds committed
769 770 771 772 773 774 775 776 777
			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
778
						+ garmin_data_p->insize;
Linus Torvalds's avatar
Linus Torvalds committed
779 780 781 782 783 784 785 786 787 788 789
				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
790 791 792
				garmin_write_bulk(garmin_data_p->port,
						   garmin_data_p->inbuffer,
						   len, 0);
Linus Torvalds's avatar
Linus Torvalds committed
793 794 795 796 797
				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
798 799
					spin_lock_irqsave(&garmin_data_p->lock,
									flags);
Linus Torvalds's avatar
Linus Torvalds committed
800
					garmin_data_p->flags |= FLAGS_DROP_DATA;
Alan Cox's avatar
Alan Cox committed
801 802
					spin_unlock_irqrestore(
						&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
					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
818
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
819 820 821 822 823 824 825 826 827
	__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
828
	send_to_tty(port, (__u8 *)pkt, 6 * 4);
Linus Torvalds's avatar
Linus Torvalds committed
829 830 831 832 833 834 835 836 837
}


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

static int process_resetdev_request(struct usb_serial_port *port)
{
838
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
839
	int status;
Alan Cox's avatar
Alan Cox committed
840
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
841

842
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
843 844 845
	garmin_data_p->flags &= ~(CLEAR_HALT_REQUIRED);
	garmin_data_p->state = STATE_RESET;
	garmin_data_p->serial_num = 0;
846
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
847

Alan Cox's avatar
Alan Cox committed
848
	usb_kill_urb(port->interrupt_in_urb);
849
	dev_dbg(&port->dev, "%s - usb_reset_device\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
850 851
	status = usb_reset_device(port->serial->dev);
	if (status)
852
		dev_dbg(&port->dev, "%s - usb_reset_device failed: %d\n",
853
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
854 855 856 857 858 859 860 861
	return status;
}



/*
 * clear all cached data
 */
Alan Cox's avatar
Alan Cox committed
862
static int garmin_clear(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
863
{
864
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
865 866 867 868 869
	int status = 0;

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

870
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
871 872
	garmin_data_p->insize = 0;
	garmin_data_p->outsize = 0;
873
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
874 875 876 877 878 879 880 881

	return status;
}


static int garmin_init_session(struct usb_serial_port *port)
{
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
882
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
883
	int status = 0;
884
	int i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
885 886

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

889
		dev_dbg(&serial->dev->dev, "%s - adding interrupt input\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
890 891 892
		status = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
		if (status)
			dev_err(&serial->dev->dev,
Alan Cox's avatar
Alan Cox committed
893 894
			  "%s - failed submitting interrupt urb, error %d\n",
							__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
895 896
	}

897 898 899 900
	/*
	 * using the initialization method from gpsbabel. See comments in
	 * gpsbabel/jeeps/gpslibusb.c gusb_reset_toggles()
	 */
Linus Torvalds's avatar
Linus Torvalds committed
901
	if (status == 0) {
902
		dev_dbg(&serial->dev->dev, "%s - starting session ...\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
903 904
		garmin_data_p->state = STATE_ACTIVE;

905
		for (i = 0; i < 3; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
906
			status = garmin_write_bulk(port,
907 908 909 910 911
					GARMIN_START_SESSION_REQ,
					sizeof(GARMIN_START_SESSION_REQ), 0);

			if (status < 0)
				break;
Linus Torvalds's avatar
Linus Torvalds committed
912
		}
913 914 915

		if (status > 0)
			status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
916 917 918 919 920 921 922
	}

	return status;
}



923
static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds's avatar
Linus Torvalds committed
924
{
925
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
926
	int status = 0;
Alan Cox's avatar
Alan Cox committed
927
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
928

929
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
930 931
	garmin_data_p->mode  = initial_mode;
	garmin_data_p->count = 0;
932
	garmin_data_p->flags &= FLAGS_SESSION_REPLY1_SEEN;
933
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
934 935

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

Alan Cox's avatar
Alan Cox committed
939
	if (garmin_data_p->state == STATE_RESET)
Linus Torvalds's avatar
Linus Torvalds committed
940 941 942 943 944 945 946
		status = garmin_init_session(port);

	garmin_data_p->state = STATE_ACTIVE;
	return status;
}


947
static void garmin_close(struct usb_serial_port *port)
Linus Torvalds's avatar
Linus Torvalds committed
948
{
Alan Cox's avatar
Alan Cox committed
949
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
950

951 952
	dev_dbg(&port->dev, "%s - port %d - mode=%d state=%d flags=0x%X\n",
		__func__, port->number, garmin_data_p->mode,
Linus Torvalds's avatar
Linus Torvalds committed
953 954
		garmin_data_p->state, garmin_data_p->flags);

955
	garmin_clear(garmin_data_p);
Linus Torvalds's avatar
Linus Torvalds committed
956 957

	/* shutdown our urbs */
Alan Cox's avatar
Alan Cox committed
958 959
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
Linus Torvalds's avatar
Linus Torvalds committed
960

961 962
	/* keep reset state so we know that we must start a new session */
	if (garmin_data_p->state != STATE_RESET)
Linus Torvalds's avatar
Linus Torvalds committed
963 964 965
		garmin_data_p->state = STATE_DISCONNECTED;
}

966

Alan Cox's avatar
Alan Cox committed
967
static void garmin_write_bulk_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
968
{
969
	struct usb_serial_port *port = urb->context;
Linus Torvalds's avatar
Linus Torvalds committed
970

971
	if (port) {
Alan Cox's avatar
Alan Cox committed
972 973
		struct garmin_data *garmin_data_p =
					usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
974

975
		if (GARMIN_LAYERID_APPL == getLayerId(urb->transfer_buffer)) {
976

977 978 979 980
			if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
				gsp_send_ack(garmin_data_p,
					((__u8 *)urb->transfer_buffer)[4]);
			}
981 982
		}
		usb_serial_port_softint(port);
Linus Torvalds's avatar
Linus Torvalds committed
983 984
	}

Alan Cox's avatar
Alan Cox committed
985 986
	/* Ignore errors that resulted from garmin_write_bulk with
	   dismiss_ack = 1 */
987 988

	/* free up the transfer buffer, as usb_free_urb() does not do this */
Alan Cox's avatar
Alan Cox committed
989
	kfree(urb->transfer_buffer);
Linus Torvalds's avatar
Linus Torvalds committed
990 991 992
}


Alan Cox's avatar
Alan Cox committed
993
static int garmin_write_bulk(struct usb_serial_port *port,
994 995
			      const unsigned char *buf, int count,
			      int dismiss_ack)
Linus Torvalds's avatar
Linus Torvalds committed
996
{
997
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
998
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
999
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1000 1001 1002 1003
	struct urb *urb;
	unsigned char *buffer;
	int status;

1004
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1005
	garmin_data_p->flags &= ~FLAGS_DROP_DATA;
1006
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1007

Alan Cox's avatar
Alan Cox committed
1008
	buffer = kmalloc(count, GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
1009 1010 1011 1012 1013 1014 1015 1016
	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
1017
		kfree(buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1018 1019 1020
		return -ENOMEM;
	}

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

1023
	usb_serial_debug_data(&port->dev, __func__, count, buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1024

Alan Cox's avatar
Alan Cox committed
1025 1026 1027
	usb_fill_bulk_urb(urb, serial->dev,
				usb_sndbulkpipe(serial->dev,
					port->bulk_out_endpointAddress),
Linus Torvalds's avatar
Linus Torvalds committed
1028
				buffer, count,
1029 1030
				garmin_write_bulk_callback,
				dismiss_ack ? NULL : port);
Linus Torvalds's avatar
Linus Torvalds committed
1031 1032 1033
	urb->transfer_flags |= URB_ZERO_PACKET;

	if (GARMIN_LAYERID_APPL == getLayerId(buffer)) {
1034 1035 1036 1037 1038

		spin_lock_irqsave(&garmin_data_p->lock, flags);
		garmin_data_p->flags |= APP_REQ_SEEN;
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);

Linus Torvalds's avatar
Linus Torvalds committed
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
		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
1049
		   "%s - usb_submit_urb(write bulk) failed with status = %d\n",
1050
				__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1051 1052 1053 1054 1055
		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
1056
	usb_free_urb(urb);
Linus Torvalds's avatar
Linus Torvalds committed
1057 1058 1059 1060

	return count;
}

Alan Cox's avatar
Alan Cox committed
1061
static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
Alan Cox's avatar
Alan Cox committed
1062
					 const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
1063
{
1064
	struct device *dev = &port->dev;
Linus Torvalds's avatar
Linus Torvalds committed
1065
	int pktid, pktsiz, len;
Alan Cox's avatar
Alan Cox committed
1066
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1067 1068
	__le32 *privpkt = (__le32 *)garmin_data_p->privpkt;

1069
	usb_serial_debug_data(dev, __func__, count, buf);
Linus Torvalds's avatar
Linus Torvalds committed
1070

1071 1072 1073
	if (garmin_data_p->state == STATE_RESET)
		return -EIO;

Linus Torvalds's avatar
Linus Torvalds committed
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
	/* 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
1086 1087
		    && GARMIN_LAYERID_PRIVATE ==
				getLayerId(garmin_data_p->privpkt)) {
Linus Torvalds's avatar
Linus Torvalds committed
1088

1089
			dev_dbg(dev, "%s - processing private request %d\n",
1090
				__func__, pktid);
Linus Torvalds's avatar
Linus Torvalds committed
1091

Alan Cox's avatar
Alan Cox committed
1092
			/* drop all unfinished transfers */
Linus Torvalds's avatar
Linus Torvalds committed
1093 1094
			garmin_clear(garmin_data_p);

Alan Cox's avatar
Alan Cox committed
1095
			switch (pktid) {
Linus Torvalds's avatar
Linus Torvalds committed
1096 1097 1098 1099
			case PRIV_PKTID_SET_MODE:
				if (pktsiz != 4)
					return -EINVPKT;
				garmin_data_p->mode = __le32_to_cpu(privpkt[3]);
1100
				dev_dbg(dev, "%s - mode set to %d\n",
1101
					__func__, garmin_data_p->mode);
Linus Torvalds's avatar
Linus Torvalds committed
1102 1103 1104 1105 1106 1107 1108
				break;

			case PRIV_PKTID_INFO_REQ:
				priv_status_resp(port);
				break;

			case PRIV_PKTID_RESET_REQ:
1109
				process_resetdev_request(port);
Linus Torvalds's avatar
Linus Torvalds committed
1110 1111 1112 1113 1114 1115
				break;

			case PRIV_PKTID_SET_DEF_MODE:
				if (pktsiz != 4)
					return -EINVPKT;
				initial_mode = __le32_to_cpu(privpkt[3]);
1116
				dev_dbg(dev, "%s - initial_mode set to %d\n",
1117
					__func__,
Linus Torvalds's avatar
Linus Torvalds committed
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
					garmin_data_p->mode);
				break;
			}
			return count;
		}
	}

	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
1133
static int garmin_write_room(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
1134
{
Alan Cox's avatar
Alan Cox committed
1135
	struct usb_serial_port *port = tty->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
1136 1137 1138
	/*
	 * Report back the bytes currently available in the output buffer.
	 */
Alan Cox's avatar
Alan Cox committed
1139
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1140 1141 1142 1143
	return GPS_OUT_BUFSIZ-garmin_data_p->outsize;
}


Alan Cox's avatar
Alan Cox committed
1144
static void garmin_read_process(struct garmin_data *garmin_data_p,
1145 1146
				 unsigned char *data, unsigned data_length,
				 int bulk_data)
Linus Torvalds's avatar
Linus Torvalds committed
1147
{
1148 1149
	unsigned long flags;

Linus Torvalds's avatar
Linus Torvalds committed
1150 1151
	if (garmin_data_p->flags & FLAGS_DROP_DATA) {
		/* abort-transfer cmd is actice */
1152
		dev_dbg(&garmin_data_p->port->dev, "%s - pkt dropped\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1153
	} else if (garmin_data_p->state != STATE_DISCONNECTED &&
Alan Cox's avatar
Alan Cox committed
1154
		garmin_data_p->state != STATE_RESET) {
Linus Torvalds's avatar
Linus Torvalds committed
1155 1156

		/* if throttling is active or postprecessing is required
1157
		   put the received data in the input queue, otherwise
Linus Torvalds's avatar
Linus Torvalds committed
1158 1159 1160
		   send it directly to the tty port */
		if (garmin_data_p->flags & FLAGS_QUEUING) {
			pkt_add(garmin_data_p, data, data_length);
1161
		} else if (bulk_data ||
1162
			   getLayerId(data) == GARMIN_LAYERID_APPL) {
1163 1164 1165 1166 1167 1168

			spin_lock_irqsave(&garmin_data_p->lock, flags);
			garmin_data_p->flags |= APP_RESP_SEEN;
			spin_unlock_irqrestore(&garmin_data_p->lock, flags);

			if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
Linus Torvalds's avatar
Linus Torvalds committed
1169
				pkt_add(garmin_data_p, data, data_length);
1170 1171 1172 1173
			} else {
				send_to_tty(garmin_data_p->port, data,
						data_length);
			}
Linus Torvalds's avatar
Linus Torvalds committed
1174
		}
1175
		/* ignore system layer packets ... */
Linus Torvalds's avatar
Linus Torvalds committed
1176 1177 1178 1179
	}
}


Alan Cox's avatar
Alan Cox committed
1180
static void garmin_read_bulk_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
1181
{
1182
	unsigned long flags;
1183
	struct usb_serial_port *port = urb->context;
Alan Cox's avatar
Alan Cox committed
1184
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1185
	unsigned char *data = urb->transfer_buffer;
1186 1187
	int status = urb->status;
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
1188

1189
	if (status) {
1190
		dev_dbg(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n",
1191
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1192 1193 1194
		return;
	}

1195
	usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
Linus Torvalds's avatar
Linus Torvalds committed
1196

1197
	garmin_read_process(garmin_data_p, data, urb->actual_length, 1);
Linus Torvalds's avatar
Linus Torvalds committed
1198

1199 1200 1201 1202 1203
	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);
1204 1205
		retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
		if (retval)
Linus Torvalds's avatar
Linus Torvalds committed
1206 1207
			dev_err(&port->dev,
				"%s - failed resubmitting read urb, error %d\n",
1208
				__func__, retval);
1209 1210 1211
	} else if (urb->actual_length > 0) {
		/* Continue trying to read until nothing more is received  */
		if (0 == (garmin_data_p->flags & FLAGS_THROTTLED)) {
1212 1213
			retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
			if (retval)
1214
				dev_err(&port->dev,
1215 1216
					"%s - failed resubmitting read urb, error %d\n",
					__func__, retval);
1217 1218
		}
	} else {
1219
		dev_dbg(&port->dev, "%s - end of bulk data\n", __func__);
1220 1221 1222
		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
1223 1224 1225 1226
	}
}


Alan Cox's avatar
Alan Cox committed
1227
static void garmin_read_int_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
1228
{
1229
	unsigned long flags;
1230
	int retval;
1231
	struct usb_serial_port *port = urb->context;
Alan Cox's avatar
Alan Cox committed
1232
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1233
	unsigned char *data = urb->transfer_buffer;
1234
	int status = urb->status;
Linus Torvalds's avatar
Linus Torvalds committed
1235

1236
	switch (status) {
Linus Torvalds's avatar
Linus Torvalds committed
1237 1238 1239 1240 1241 1242 1243
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
1244
		dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
1245
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1246 1247
		return;
	default:
1248
		dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n",
1249
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1250 1251 1252
		return;
	}

1253 1254
	usb_serial_debug_data(&port->dev, __func__, urb->actual_length,
			      urb->transfer_buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1255 1256 1257

	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
1258
				sizeof(GARMIN_BULK_IN_AVAIL_REPLY))) {
Linus Torvalds's avatar
Linus Torvalds committed
1259

1260
		dev_dbg(&port->dev, "%s - bulk data available.\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1261

1262 1263 1264
		if (0 == (garmin_data_p->flags & FLAGS_BULK_IN_ACTIVE)) {

			/* bulk data available */
1265 1266
			retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
			if (retval) {
1267
				dev_err(&port->dev,
Alan Cox's avatar
Alan Cox committed
1268 1269
				 "%s - failed submitting read urb, error %d\n",
							__func__, retval);
1270 1271 1272
			} else {
				spin_lock_irqsave(&garmin_data_p->lock, flags);
				garmin_data_p->flags |= FLAGS_BULK_IN_ACTIVE;
Alan Cox's avatar
Alan Cox committed
1273 1274
				spin_unlock_irqrestore(&garmin_data_p->lock,
									flags);
1275 1276 1277 1278 1279 1280
			}
		} 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
1281 1282 1283 1284
		}

	} 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
1285
					sizeof(GARMIN_START_SESSION_REPLY))) {
Linus Torvalds's avatar
Linus Torvalds committed
1286

1287
		spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1288
		garmin_data_p->flags |= FLAGS_SESSION_REPLY1_SEEN;
1289
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1290 1291

		/* save the serial number */
Alan Cox's avatar
Alan Cox committed
1292 1293
		garmin_data_p->serial_num = __le32_to_cpup(
					(__le32 *)(data+GARMIN_PKTHDR_LENGTH));
Linus Torvalds's avatar
Linus Torvalds committed
1294

1295
		dev_dbg(&port->dev, "%s - start-of-session reply seen - serial %u.\n",
1296
			__func__, garmin_data_p->serial_num);
Linus Torvalds's avatar
Linus Torvalds committed
1297 1298
	}

1299
	garmin_read_process(garmin_data_p, data, urb->actual_length, 0);
Linus Torvalds's avatar
Linus Torvalds committed
1300

Alan Cox's avatar
Alan Cox committed
1301
	retval = usb_submit_urb(urb, GFP_ATOMIC);
1302
	if (retval)
Linus Torvalds's avatar
Linus Torvalds committed
1303 1304
		dev_err(&urb->dev->dev,
			"%s - Error %d submitting interrupt urb\n",
1305
			__func__, retval);
Linus Torvalds's avatar
Linus Torvalds committed
1306 1307 1308 1309 1310 1311 1312 1313
}


/*
 * 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
1314
static int garmin_flush_queue(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
1315
{
1316
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
	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 {
1327
			spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1328
			garmin_data_p->flags &= ~FLAGS_QUEUING;
1329
			spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1330 1331 1332 1333 1334 1335
		}
	}
	return 0;
}


Alan Cox's avatar
Alan Cox committed
1336
static void garmin_throttle(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
1337
{
Alan Cox's avatar
Alan Cox committed
1338
	struct usb_serial_port *port = tty->driver_data;
Alan Cox's avatar
Alan Cox committed
1339
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1340 1341 1342

	/* set flag, data received will be put into a queue
	   for later processing */
1343
	spin_lock_irq(&garmin_data_p->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1344
	garmin_data_p->flags |= FLAGS_QUEUING|FLAGS_THROTTLED;
1345
	spin_unlock_irq(&garmin_data_p->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1346 1347 1348
}


Alan Cox's avatar
Alan Cox committed
1349
static void garmin_unthrottle(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
1350
{
Alan Cox's avatar
Alan Cox committed
1351
	struct usb_serial_port *port = tty->driver_data;
Alan Cox's avatar
Alan Cox committed
1352
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
1353
	int status;
Linus Torvalds's avatar
Linus Torvalds committed
1354

1355
	spin_lock_irq(&garmin_data_p->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1356
	garmin_data_p->flags &= ~FLAGS_THROTTLED;
1357
	spin_unlock_irq(&garmin_data_p->lock);
Linus Torvalds's avatar
Linus Torvalds committed
1358 1359 1360 1361 1362

	/* 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);
1363 1364

	if (0 != (garmin_data_p->flags & FLAGS_BULK_IN_ACTIVE)) {
1365
		status = usb_submit_urb(port->read_urb, GFP_KERNEL);
1366 1367 1368
		if (status)
			dev_err(&port->dev,
				"%s - failed resubmitting read urb, error %d\n",
1369
				__func__, status);
1370
	}
Linus Torvalds's avatar
Linus Torvalds committed
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389
}

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



1390
static int garmin_port_probe(struct usb_serial_port *port)
Linus Torvalds's avatar
Linus Torvalds committed
1391
{
1392 1393
	int status;
	struct garmin_data *garmin_data_p;
Linus Torvalds's avatar
Linus Torvalds committed
1394

1395
	garmin_data_p = kzalloc(sizeof(struct garmin_data), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
1396
	if (garmin_data_p == NULL) {
1397
		dev_err(&port->dev, "%s - Out of memory\n", __func__);