garmin_gps.c 39.9 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 * Garmin GPS driver
 *
4
 * Copyright (C) 2006-2009 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 43 44

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

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

#define GARMIN_VENDOR_ID             0x091E

/*
 * Version Information
 */

#define VERSION_MAJOR	0
54
#define VERSION_MINOR	33
Linus Torvalds's avatar
Linus Torvalds committed
55 56

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

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

Alan Cox's avatar
Alan Cox committed
72 73
/*  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
74

Alan Cox's avatar
Alan Cox committed
75 76 77 78 79 80 81
/* 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
82

Alan Cox's avatar
Alan Cox committed
83 84
/* 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
85

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

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

#define GARMIN_LAYERID_TRANSPORT  0
#define GARMIN_LAYERID_APPL      20
Alan Cox's avatar
Alan Cox committed
96
/* our own layer-id to use for some control mechanisms */
Linus Torvalds's avatar
Linus Torvalds committed
97 98 99 100 101 102 103
#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
104
/* packet ids used in private layer */
Linus Torvalds's avatar
Linus Torvalds committed
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
#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
122 123
	/* the real size of the data array, always > 0 */
	int               size;
Linus Torvalds's avatar
Linus Torvalds committed
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 160 161 162
	__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
163
/* Flags used in garmin_data.flags: */
Linus Torvalds's avatar
Linus Torvalds committed
164 165 166 167
#define FLAGS_SESSION_REPLY_MASK  0x00C0
#define FLAGS_SESSION_REPLY1_SEEN 0x0080
#define FLAGS_SESSION_REPLY2_SEEN 0x0040
#define FLAGS_BULK_IN_ACTIVE      0x0020
168 169
#define FLAGS_BULK_IN_RESTART     0x0010
#define FLAGS_THROTTLED           0x0008
170 171
#define APP_REQ_SEEN              0x0004
#define APP_RESP_SEEN             0x0002
Linus Torvalds's avatar
Linus Torvalds committed
172 173 174 175 176 177 178 179 180 181 182 183 184 185
#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 */
186 187
static int gsp_next_packet(struct garmin_data *garmin_data_p);
static int garmin_write_bulk(struct usb_serial_port *port,
188 189
			     const unsigned char *buf, int count,
			     int dismiss_ack);
Linus Torvalds's avatar
Linus Torvalds committed
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213

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



static struct usb_device_id id_table [] = {
Alan Cox's avatar
Alan Cox committed
214 215 216
	/* 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
217 218 219
	{ }					/* Terminating entry */
};

Alan Cox's avatar
Alan Cox committed
220
MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds's avatar
Linus Torvalds committed
221 222 223 224 225 226

static struct usb_driver garmin_driver = {
	.name =		"garmin_gps",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	id_table,
227
	.no_dynamic_id = 1,
Linus Torvalds's avatar
Linus Torvalds committed
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
};


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
253 254 255 256
	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
257 258 259 260 261 262 263 264
		return 1;
	else
		return 0;
}



static void send_to_tty(struct usb_serial_port *port,
265
			char *data, unsigned int actual_length)
Linus Torvalds's avatar
Linus Torvalds committed
266
{
Alan Cox's avatar
Alan Cox committed
267
	struct tty_struct *tty = tty_port_tty_get(&port->port);
Linus Torvalds's avatar
Linus Torvalds committed
268 269 270

	if (tty && actual_length) {

Alan Cox's avatar
Alan Cox committed
271
		usb_serial_debug_data(debug, &port->dev,
272
					__func__, actual_length, data);
Linus Torvalds's avatar
Linus Torvalds committed
273

Alan Cox's avatar
Alan Cox committed
274 275
		tty_buffer_request_room(tty, actual_length);
		tty_insert_flip_string(tty, data, actual_length);
Linus Torvalds's avatar
Linus Torvalds committed
276 277
		tty_flip_buffer_push(tty);
	}
Alan Cox's avatar
Alan Cox committed
278
	tty_kref_put(tty);
Linus Torvalds's avatar
Linus Torvalds committed
279 280 281 282 283 284 285 286 287 288
}


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

/*
 * queue a received (usb-)packet for later processing
 */
Alan Cox's avatar
Alan Cox committed
289
static int pkt_add(struct garmin_data *garmin_data_p,
290
		   unsigned char *data, unsigned int data_length)
Linus Torvalds's avatar
Linus Torvalds committed
291
{
292
	int state = 0;
Linus Torvalds's avatar
Linus Torvalds committed
293 294 295 296 297 298 299
	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
300
								GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
301 302 303 304 305 306 307 308
		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);
309
		garmin_data_p->flags |= FLAGS_QUEUING;
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312
		result = list_empty(&garmin_data_p->pktlist);
		pkt->seq = garmin_data_p->seq_counter++;
		list_add_tail(&pkt->list, &garmin_data_p->pktlist);
313
		state = garmin_data_p->state;
Linus Torvalds's avatar
Linus Torvalds committed
314 315
		spin_unlock_irqrestore(&garmin_data_p->lock, flags);

316 317 318
		dbg("%s - added: pkt: %d - %d bytes",
			__func__, pkt->seq, data_length);

Linus Torvalds's avatar
Linus Torvalds committed
319
		/* in serial mode, if someone is waiting for data from
320
		   the device, convert and send the next packet to tty. */
Alan Cox's avatar
Alan Cox committed
321
		if (result && (state == STATE_GSP_WAIT_DATA))
Linus Torvalds's avatar
Linus Torvalds committed
322 323 324 325 326 327 328
			gsp_next_packet(garmin_data_p);
	}
	return result;
}


/* get the next pending packet */
Alan Cox's avatar
Alan Cox committed
329
static struct garmin_packet *pkt_pop(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
{
	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
345
static void pkt_clear(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
346 347 348 349
{
	unsigned long flags;
	struct garmin_packet *result = NULL;

350
	dbg("%s", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366

	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
367
static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
Linus Torvalds's avatar
Linus Torvalds committed
368 369
{
	__u8 pkt[10];
370 371 372
	__u8 cksum = 0;
	__u8 *ptr = pkt;
	unsigned  l = 0;
Linus Torvalds's avatar
Linus Torvalds committed
373

374
	dbg("%s - pkt-id: 0x%X.", __func__, 0xFF & pkt_id);
Linus Torvalds's avatar
Linus Torvalds committed
375 376 377 378 379 380 381 382 383 384 385

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

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

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

Alan Cox's avatar
Alan Cox committed
386
	if (pkt_id == DLE)
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
		*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
 *
405
 * the complete packet (pktid ... cksum) is in garmin_data_p->inbuf starting
Linus Torvalds's avatar
Linus Torvalds committed
406 407 408
 * at GSP_INITIAL_OFFSET.
 *
 * count - number of bytes in the input buffer including space reserved for
Alan Cox's avatar
Alan Cox committed
409
 *         the usb header: GSP_INITIAL_OFFSET + number of bytes in packet
Linus Torvalds's avatar
Linus Torvalds committed
410 411
 *         (including pkt-id, data-length a. cksum)
 */
Alan Cox's avatar
Alan Cox committed
412
static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
Linus Torvalds's avatar
Linus Torvalds committed
413
{
Alan Cox's avatar
Alan Cox committed
414
	const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
415
	__le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
Linus Torvalds's avatar
Linus Torvalds committed
416 417 418 419 420 421 422

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

	usb_serial_debug_data(debug, &garmin_data_p->port->dev,
423
			       __func__, count-GSP_INITIAL_OFFSET, recpkt);
Linus Torvalds's avatar
Linus Torvalds committed
424 425 426

	if (size != (count-GSP_INITIAL_OFFSET-3)) {
		dbg("%s - invalid size, expected %d bytes, got %d",
427
			__func__, size, (count-GSP_INITIAL_OFFSET-3));
Linus Torvalds's avatar
Linus Torvalds committed
428 429 430 431 432 433
		return -EINVPKT;
	}

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

Alan Cox's avatar
Alan Cox committed
434 435
	/* sanity check, remove after test ... */
	if ((__u8 *)&(usbdata[3]) != recpkt) {
Linus Torvalds's avatar
Linus Torvalds committed
436
		dbg("%s - ptr mismatch %p - %p",
437
			__func__, &(usbdata[4]), recpkt);
Linus Torvalds's avatar
Linus Torvalds committed
438 439 440 441 442 443 444 445
		return -EINVPKT;
	}

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

446 447
	if ((0xff & (cksum + *recpkt)) != 0) {
		dbg("%s - invalid checksum, expected %02x, got %02x",
448
			__func__, 0xff & -cksum, 0xff & *recpkt);
449 450
		return -EINVPKT;
	}
Linus Torvalds's avatar
Linus Torvalds committed
451 452 453 454 455

	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
456
	garmin_write_bulk(garmin_data_p->port, garmin_data_p->inbuffer,
457
			   GARMIN_PKTHDR_LENGTH+size, 0);
Linus Torvalds's avatar
Linus Torvalds committed
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488

	/* 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
489
static int gsp_receive(struct garmin_data *garmin_data_p,
490
		       const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
491
{
492
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
493 494
	int offs = 0;
	int ack_or_nak_seen = 0;
495 496
	__u8 *dest;
	int size;
Alan Cox's avatar
Alan Cox committed
497
	/* dleSeen: set if last byte read was a DLE */
498
	int dleSeen;
Alan Cox's avatar
Alan Cox committed
499 500 501
	/* skip: if set, skip incoming data until possible start of
	 *       new packet
	 */
502
	int skip;
Linus Torvalds's avatar
Linus Torvalds committed
503 504
	__u8 data;

505 506 507 508 509 510 511
	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);

512 513
	/* dbg("%s - dle=%d skip=%d size=%d count=%d",
		__func__, dleSeen, skip, size, count); */
Linus Torvalds's avatar
Linus Torvalds committed
514

Alan Cox's avatar
Alan Cox committed
515
	if (size == 0)
Linus Torvalds's avatar
Linus Torvalds committed
516 517 518 519 520
		size = GSP_INITIAL_OFFSET;

	while (offs < count) {

		data = *(buf+offs);
Alan Cox's avatar
Alan Cox committed
521
		offs++;
Linus Torvalds's avatar
Linus Torvalds committed
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546

		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
547 548
					dbg("packet complete - id=0x%X.",
						0xFF & data);
Linus Torvalds's avatar
Linus Torvalds committed
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
					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) {
569
			dbg("%s - packet too large.", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
570 571 572 573 574 575
			skip = 1;
			size = GSP_INITIAL_OFFSET;
			dleSeen = 0;
		}
	}

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

Linus Torvalds's avatar
Linus Torvalds committed
578 579
	garmin_data_p->insize = size;

Alan Cox's avatar
Alan Cox committed
580
	/* copy flags back to structure */
Linus Torvalds's avatar
Linus Torvalds committed
581 582 583 584 585 586 587 588 589 590
	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;

591 592
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);

593 594 595 596 597 598
	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
599 600 601 602 603 604 605 606 607 608 609 610
	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
611
static int gsp_send(struct garmin_data *garmin_data_p,
Linus Torvalds's avatar
Linus Torvalds committed
612 613 614 615 616 617 618
		    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
619
	int i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
620 621
	int k;

622
	dbg("%s - state %d - %d bytes.", __func__,
Alan Cox's avatar
Alan Cox committed
623
					garmin_data_p->state, count);
Linus Torvalds's avatar
Linus Torvalds committed
624 625 626 627 628 629 630 631 632 633 634 635 636 637

	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
638
		datalen = getDataLength(garmin_data_p->outbuffer);
Linus Torvalds's avatar
Linus Torvalds committed
639 640 641 642 643 644 645
		i = GARMIN_PKTHDR_LENGTH + datalen;
		if (k < i)
			return 0;
	} else {
		return 0;
	}

Alan Cox's avatar
Alan Cox committed
646
	dbg("%s - %d bytes in buffer, %d bytes in pkt.", __func__, k, i);
Linus Torvalds's avatar
Linus Torvalds committed
647 648 649 650

	/* 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
651
				__func__, k, garmin_data_p->outbuffer);
Linus Torvalds's avatar
Linus Torvalds committed
652 653 654 655

	garmin_data_p->outsize = 0;

	if (GARMIN_LAYERID_APPL != getLayerId(garmin_data_p->outbuffer)) {
Alan Cox's avatar
Alan Cox committed
656 657
		dbg("not an application packet (%d)",
				getLayerId(garmin_data_p->outbuffer));
Linus Torvalds's avatar
Linus Torvalds committed
658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
		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
675
	for (i = 0; i < datalen; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
676 677 678 679 680 681
		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
682
		/* can't add stuffing DLEs in place, move data to end
683
		   of buffer ... */
Linus Torvalds's avatar
Linus Torvalds committed
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
		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
699
	for (i = 0; i < datalen; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
700 701 702 703 704 705
		__u8 c = *src++;
		*dst++ = c;
		cksum += c;
		if (c == DLE)
			*dst++ = DLE;
	}
Alan Cox's avatar
Alan Cox committed
706

Linus Torvalds's avatar
Linus Torvalds committed
707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727
	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
 */
728
static int gsp_next_packet(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
729
{
730
	int result = 0;
Linus Torvalds's avatar
Linus Torvalds committed
731 732 733
	struct garmin_packet *pkt = NULL;

	while ((pkt = pkt_pop(garmin_data_p)) != NULL) {
734
		dbg("%s - next pkt: %d", __func__, pkt->seq);
735 736
		result = gsp_send(garmin_data_p, pkt->data, pkt->size);
		if (result > 0) {
Linus Torvalds's avatar
Linus Torvalds committed
737
			kfree(pkt);
738
			return result;
Linus Torvalds's avatar
Linus Torvalds committed
739 740 741
		}
		kfree(pkt);
	}
742
	return result;
Linus Torvalds's avatar
Linus Torvalds committed
743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
}



/******************************************************************************
 * 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
760
static int nat_receive(struct garmin_data *garmin_data_p,
761
		       const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
762
{
763
	unsigned long flags;
Alan Cox's avatar
Alan Cox committed
764
	__u8 *dest;
Linus Torvalds's avatar
Linus Torvalds committed
765 766 767 768 769
	int offs = 0;
	int result = count;
	int len;

	while (offs < count) {
Alan Cox's avatar
Alan Cox committed
770
		/* if buffer contains header, copy rest of data */
Linus Torvalds's avatar
Linus Torvalds committed
771 772 773 774 775 776 777
		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
778 779 780
			/* 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
781 782 783 784 785 786 787 788 789
			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
790
						+ garmin_data_p->insize;
Linus Torvalds's avatar
Linus Torvalds committed
791 792 793 794 795 796 797 798 799 800 801
				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
802 803 804
				garmin_write_bulk(garmin_data_p->port,
						   garmin_data_p->inbuffer,
						   len, 0);
Linus Torvalds's avatar
Linus Torvalds committed
805 806 807 808 809
				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
810 811
					spin_lock_irqsave(&garmin_data_p->lock,
									flags);
Linus Torvalds's avatar
Linus Torvalds committed
812
					garmin_data_p->flags |= FLAGS_DROP_DATA;
Alan Cox's avatar
Alan Cox committed
813 814
					spin_unlock_irqrestore(
						&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
					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
830
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
831 832 833 834 835 836 837 838 839
	__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
840
	send_to_tty(port, (__u8 *)pkt, 6 * 4);
Linus Torvalds's avatar
Linus Torvalds committed
841 842 843 844 845 846 847 848 849
}


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

static int process_resetdev_request(struct usb_serial_port *port)
{
850
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
851
	int status;
Alan Cox's avatar
Alan Cox committed
852
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
853

854
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
855 856 857
	garmin_data_p->flags &= ~(CLEAR_HALT_REQUIRED);
	garmin_data_p->state = STATE_RESET;
	garmin_data_p->serial_num = 0;
858
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
859

Alan Cox's avatar
Alan Cox committed
860 861
	usb_kill_urb(port->interrupt_in_urb);
	dbg("%s - usb_reset_device", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
862 863 864
	status = usb_reset_device(port->serial->dev);
	if (status)
		dbg("%s - usb_reset_device failed: %d",
865
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
866 867 868 869 870 871 872 873
	return status;
}



/*
 * clear all cached data
 */
Alan Cox's avatar
Alan Cox committed
874
static int garmin_clear(struct garmin_data *garmin_data_p)
Linus Torvalds's avatar
Linus Torvalds committed
875
{
876
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
877 878 879 880 881
	int status = 0;

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

882
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
883 884
	garmin_data_p->insize = 0;
	garmin_data_p->outsize = 0;
885
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
886 887 888 889 890 891 892 893

	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
894
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
895
	int status = 0;
896
	int i = 0;
Linus Torvalds's avatar
Linus Torvalds committed
897 898

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

901
		dbg("%s - adding interrupt input", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
902 903 904 905
		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
906 907
			  "%s - failed submitting interrupt urb, error %d\n",
							__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
908 909
	}

910 911 912 913
	/*
	 * using the initialization method from gpsbabel. See comments in
	 * gpsbabel/jeeps/gpslibusb.c gusb_reset_toggles()
	 */
Linus Torvalds's avatar
Linus Torvalds committed
914
	if (status == 0) {
915
		dbg("%s - starting session ...", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
916 917
		garmin_data_p->state = STATE_ACTIVE;

918
		for (i = 0; i < 3; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
919
			status = garmin_write_bulk(port,
920 921 922 923 924
					GARMIN_START_SESSION_REQ,
					sizeof(GARMIN_START_SESSION_REQ), 0);

			if (status < 0)
				break;
Linus Torvalds's avatar
Linus Torvalds committed
925
		}
926 927 928

		if (status > 0)
			status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
929 930 931 932 933 934 935
	}

	return status;
}



936
static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds's avatar
Linus Torvalds committed
937
{
938
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
939
	int status = 0;
Alan Cox's avatar
Alan Cox committed
940
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
941

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

944
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
945 946 947
	garmin_data_p->mode  = initial_mode;
	garmin_data_p->count = 0;
	garmin_data_p->flags = 0;
948
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
949 950

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

Alan Cox's avatar
Alan Cox committed
954
	if (garmin_data_p->state == STATE_RESET)
Linus Torvalds's avatar
Linus Torvalds committed
955 956 957 958 959 960 961
		status = garmin_init_session(port);

	garmin_data_p->state = STATE_ACTIVE;
	return status;
}


962
static void garmin_close(struct usb_serial_port *port)
Linus Torvalds's avatar
Linus Torvalds committed
963 964
{
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
965
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
966

967
	dbg("%s - port %d - mode=%d state=%d flags=0x%X", __func__,
Linus Torvalds's avatar
Linus Torvalds committed
968 969 970 971 972 973
		port->number, garmin_data_p->mode,
		garmin_data_p->state, garmin_data_p->flags);

	if (!serial)
		return;

974
	mutex_lock(&port->serial->disc_mutex);
975

976 977
	if (!port->serial->disconnected)
		garmin_clear(garmin_data_p);
Linus Torvalds's avatar
Linus Torvalds committed
978 979

	/* shutdown our urbs */
Alan Cox's avatar
Alan Cox committed
980 981
	usb_kill_urb(port->read_urb);
	usb_kill_urb(port->write_urb);
Linus Torvalds's avatar
Linus Torvalds committed
982

983 984
	/* 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
985
		garmin_data_p->state = STATE_DISCONNECTED;
986

987
	mutex_unlock(&port->serial->disc_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
988 989
}

990

Alan Cox's avatar
Alan Cox committed
991
static void garmin_write_bulk_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
992
{
993
	struct usb_serial_port *port = urb->context;
Linus Torvalds's avatar
Linus Torvalds committed
994

995
	if (port) {
Alan Cox's avatar
Alan Cox committed
996 997
		struct garmin_data *garmin_data_p =
					usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
998

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

1001
		if (GARMIN_LAYERID_APPL == getLayerId(urb->transfer_buffer)) {
1002

1003 1004 1005 1006
			if (garmin_data_p->mode == MODE_GARMIN_SERIAL) {
				gsp_send_ack(garmin_data_p,
					((__u8 *)urb->transfer_buffer)[4]);
			}
1007 1008
		}
		usb_serial_port_softint(port);
Linus Torvalds's avatar
Linus Torvalds committed
1009 1010
	}

Alan Cox's avatar
Alan Cox committed
1011 1012
	/* Ignore errors that resulted from garmin_write_bulk with
	   dismiss_ack = 1 */
1013 1014

	/* free up the transfer buffer, as usb_free_urb() does not do this */
Alan Cox's avatar
Alan Cox committed
1015
	kfree(urb->transfer_buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1016 1017 1018
}


Alan Cox's avatar
Alan Cox committed
1019
static int garmin_write_bulk(struct usb_serial_port *port,
1020 1021
			      const unsigned char *buf, int count,
			      int dismiss_ack)
Linus Torvalds's avatar
Linus Torvalds committed
1022
{
1023
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1024
	struct usb_serial *serial = port->serial;
Alan Cox's avatar
Alan Cox committed
1025
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1026 1027 1028 1029
	struct urb *urb;
	unsigned char *buffer;
	int status;

1030
	dbg("%s - port %d, state %d", __func__, port->number,
Linus Torvalds's avatar
Linus Torvalds committed
1031 1032
		garmin_data_p->state);

1033
	spin_lock_irqsave(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1034
	garmin_data_p->flags &= ~FLAGS_DROP_DATA;
1035
	spin_unlock_irqrestore(&garmin_data_p->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
1036

Alan Cox's avatar
Alan Cox committed
1037
	buffer = kmalloc(count, GFP_ATOMIC);
Linus Torvalds's avatar
Linus Torvalds committed
1038 1039 1040 1041 1042 1043 1044 1045
	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
1046
		kfree(buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1047 1048 1049
		return -ENOMEM;
	}

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

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

Alan Cox's avatar
Alan Cox committed
1054 1055 1056
	usb_fill_bulk_urb(urb, serial->dev,
				usb_sndbulkpipe(serial->dev,
					port->bulk_out_endpointAddress),
Linus Torvalds's avatar
Linus Torvalds committed
1057
				buffer, count,
1058 1059
				garmin_write_bulk_callback,
				dismiss_ack ? NULL : port);
Linus Torvalds's avatar
Linus Torvalds committed
1060 1061 1062
	urb->transfer_flags |= URB_ZERO_PACKET;

	if (GARMIN_LAYERID_APPL == getLayerId(buffer)) {
1063 1064 1065 1066 1067

		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
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
		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
1078
		   "%s - usb_submit_urb(write bulk) failed with status = %d\n",
1079
				__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
1080 1081 1082 1083 1084
		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
1085
	usb_free_urb(urb);
Linus Torvalds's avatar
Linus Torvalds committed
1086 1087 1088 1089

	return count;
}

Alan Cox's avatar
Alan Cox committed
1090
static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
Alan Cox's avatar
Alan Cox committed
1091
					 const unsigned char *buf, int count)
Linus Torvalds's avatar
Linus Torvalds committed
1092 1093
{
	int pktid, pktsiz, len;
Alan Cox's avatar
Alan Cox committed
1094
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1095 1096
	__le32 *privpkt = (__le32 *)garmin_data_p->privpkt;

1097
	usb_serial_debug_data(debug, &port->dev, __func__, count, buf);
Linus Torvalds's avatar
Linus Torvalds committed
1098

1099 1100 1101
	if (garmin_data_p->state == STATE_RESET)
		return -EIO;

Linus Torvalds's avatar
Linus Torvalds committed
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
	/* 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
1114 1115
		    && GARMIN_LAYERID_PRIVATE ==
				getLayerId(garmin_data_p->privpkt)) {
Linus Torvalds's avatar
Linus Torvalds committed
1116 1117

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

Alan Cox's avatar
Alan Cox committed
1120
			/* drop all unfinished transfers */
Linus Torvalds's avatar
Linus Torvalds committed
1121 1122
			garmin_clear(garmin_data_p);

Alan Cox's avatar
Alan Cox committed
1123
			switch (pktid) {
Linus Torvalds's avatar
Linus Torvalds committed
1124 1125 1126 1127 1128 1129

			case PRIV_PKTID_SET_DEBUG:
				if (pktsiz != 4)
					return -EINVPKT;
				debug = __le32_to_cpu(privpkt[3]);
				dbg("%s - debug level set to 0x%X",
1130
					__func__, debug);
Linus Torvalds's avatar
Linus Torvalds committed
1131 1132 1133 1134 1135 1136 1137
				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",
1138
					__func__, garmin_data_p->mode);
Linus Torvalds's avatar
Linus Torvalds committed
1139 1140 1141 1142 1143 1144 1145
				break;

			case PRIV_PKTID_INFO_REQ:
				priv_status_resp(port);
				break;

			case PRIV_PKTID_RESET_REQ:
1146
				process_resetdev_request(port);
Linus Torvalds's avatar
Linus Torvalds committed
1147 1148 1149 1150 1151 1152 1153
				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",
1154
					__func__,
Linus Torvalds's avatar
Linus Torvalds committed
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
					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
1170
static int garmin_write_room(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
1171
{
Alan Cox's avatar
Alan Cox committed
1172
	struct usb_serial_port *port = tty->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
1173 1174 1175
	/*
	 * Report back the bytes currently available in the output buffer.
	 */
Alan Cox's avatar
Alan Cox committed
1176
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1177 1178 1179 1180
	return GPS_OUT_BUFSIZ-garmin_data_p->outsize;
}


Alan Cox's avatar
Alan Cox committed
1181
static void garmin_read_process(struct garmin_data *garmin_data_p,
Linus Torvalds's avatar
Linus Torvalds committed
1182 1183
				 unsigned char *data, unsigned data_length)
{
1184 1185
	unsigned long flags;

Linus Torvalds's avatar
Linus Torvalds committed
1186 1187
	if (garmin_data_p->flags & FLAGS_DROP_DATA) {
		/* abort-transfer cmd is actice */
1188
		dbg("%s - pkt dropped", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1189
	} else if (garmin_data_p->state != STATE_DISCONNECTED &&
Alan Cox's avatar
Alan Cox committed
1190
		garmin_data_p->state != STATE_RESET) {
Linus Torvalds's avatar
Linus Torvalds committed
1191 1192

		/* if throttling is active or postprecessing is required
1193
		   put the received data in the input queue, otherwise
Linus Torvalds's avatar
Linus Torvalds committed
1194 1195 1196
		   send it directly to the tty port */
		if (garmin_data_p->flags & FLAGS_QUEUING) {
			pkt_add(garmin_data_p, data, data_length);
1197 1198 1199 1200 1201 1202 1203
		} else if (getLayerId(data) == GARMIN_LAYERID_APPL) {

			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
1204
				pkt_add(garmin_data_p, data, data_length);
1205 1206 1207 1208
			} else {
				send_to_tty(garmin_data_p->port, data,
						data_length);
			}
Linus Torvalds's avatar
Linus Torvalds committed
1209
		}
1210
		/* ignore system layer packets ... */
Linus Torvalds's avatar
Linus Torvalds committed
1211 1212 1213 1214
	}
}


Alan Cox's avatar
Alan Cox committed
1215
static void garmin_read_bulk_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
1216
{
1217
	unsigned long flags;
1218
	struct usb_serial_port *port = urb->context;
Linus Torvalds's avatar
Linus Torvalds committed
1219
	struct usb_serial *serial =  port->serial;
Alan Cox's avatar
Alan Cox committed
1220
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1221
	unsigned char *data = urb->transfer_buffer;
1222 1223