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>
Arun Sharma's avatar
Arun Sharma committed
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
		count = status;
1052
		kfree(buffer);
Linus Torvalds's avatar
Linus Torvalds committed
1053 1054 1055 1056
	}

	/* 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
1057
	usb_free_urb(urb);
Linus Torvalds's avatar
Linus Torvalds committed
1058 1059 1060 1061

	return count;
}

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

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

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

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

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

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

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

			case PRIV_PKTID_INFO_REQ:
				priv_status_resp(port);
				break;

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

			case PRIV_PKTID_SET_DEF_MODE:
				if (pktsiz != 4)
					return -EINVPKT;
				initial_mode = __le32_to_cpu(privpkt[3]);
1117
				dev_dbg(dev, "%s - initial_mode set to %d\n",
1118
					__func__,
Linus Torvalds's avatar
Linus Torvalds committed
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
					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
1134
static int garmin_write_room(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
1135
{
Alan Cox's avatar
Alan Cox committed
1136
	struct usb_serial_port *port = tty->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
1137 1138 1139
	/*
	 * Report back the bytes currently available in the output buffer.
	 */
Alan Cox's avatar
Alan Cox committed
1140
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1141 1142 1143 1144
	return GPS_OUT_BUFSIZ-garmin_data_p->outsize;
}


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

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

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

			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
1170
				pkt_add(garmin_data_p, data, data_length);
1171 1172 1173 1174
			} else {
				send_to_tty(garmin_data_p->port, data,
						data_length);
			}
Linus Torvalds's avatar
Linus Torvalds committed
1175
		}
1176
		/* ignore system layer packets ... */
Linus Torvalds's avatar
Linus Torvalds committed
1177 1178 1179 1180
	}
}


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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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


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

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


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

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

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

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

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



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

1396
	garmin_data_p = kzalloc(sizeof(struct garmin_data), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
1397
	if (garmin_data_p == NULL) {
1398
		dev_err(&port->dev, "%s - Out of memory\n", __func__);
Linus Torvalds's avatar
Linus Torvalds committed
1399 1400 1401 1402 1403
		return -ENOMEM;
	}
	init_timer(&garmin_data_p->timer);
	spin_lock_init(&garmin_data_p->lock);
	INIT_LIST_HEAD(&garmin_data_p->pktlist);
Alan Cox's avatar
Alan Cox committed
1404
	/* garmin_data_p->timer.expires = jiffies + session_timeout; */
Linus Torvalds's avatar
Linus Torvalds committed
1405 1406 1407 1408
	garmin_data_p->timer.data = (unsigned long)garmin_data_p;
	garmin_data_p->timer.function = timeout_handler;
	garmin_data_p->port = port;
	garmin_data_p->state = 0;
1409
	garmin_data_p->flags = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1410 1411 1412 1413 1414 1415 1416 1417 1418
	garmin_data_p->count = 0;
	usb_set_serial_port_data(port, garmin_data_p);

	status = garmin_init_session(port);

	return status;
}


1419
static int garmin_port_remove(struct usb_serial_port *port)
Linus Torvalds's avatar
Linus Torvalds committed
1420
{
Alan Cox's avatar
Alan Cox committed
1421
	struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
Linus Torvalds's avatar
Linus Torvalds committed
1422

Alan Cox's avatar
Alan Cox committed
1423
	usb_kill_urb(port->interrupt_in_urb);
Linus Torvalds's avatar
Linus Torvalds committed
1424
	del_timer_sync(&garmin_data_p->timer);
Alan Cox's avatar
Alan Cox committed
1425
	kfree(garmin_data_p);
1426
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1427 1428 1429 1430
}


/* All of the device info needed */
1431
static struct usb_serial_driver garmin_device = {
1432
	.driver = {
1433 1434
		.owner       = THIS_MODULE,
		.name        = "garmin_gps",
1435
	},
1436
	.description         = "Garmin GPS usb/tty",
Linus Torvalds's avatar
Linus Torvalds committed
1437 1438 1439 1440 1441 1442
	.id_table            = id_table,
	.num_ports           = 1,
	.open                = garmin_open,
	.close               = garmin_close,
	.throttle            = garmin_throttle,
	.unthrottle          = garmin_unthrottle,
1443 1444
	.port_probe		= garmin_port_probe,
	.port_remove		= garmin_port_remove,
Linus Torvalds's avatar
Linus Torvalds committed
1445 1446 1447 1448 1449 1450 1451
	.write               = garmin_write,
	.write_room          = garmin_write_room,
	.write_bulk_callback = garmin_write_bulk_callback,
	.read_bulk_callback  = garmin_read_bulk_callback,
	.read_int_callback   = garmin_read_int_callback,
};

1452 1453 1454
static struct usb_serial_driver * const serial_drivers[] = {
	&garmin_device, NULL
};
Linus Torvalds's avatar
Linus Torvalds committed
1455

1456
module_usb_serial_driver(serial_drivers, id_table);
Linus Torvalds's avatar
Linus Torvalds committed
1457

Alan Cox's avatar
Alan Cox committed
1458 1459
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds's avatar
Linus Torvalds committed
1460 1461 1462 1463
MODULE_LICENSE("GPL");

module_param(initial_mode, int, S_IRUGO);
MODULE_PARM_DESC(initial_mode, "Initial mode");