Linux Audio

Check our new training course

Loading...
v5.9
  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * USB Keyspan PDA / Xircom / Entrega Converter driver
  4 *
  5 * Copyright (C) 1999 - 2001 Greg Kroah-Hartman	<greg@kroah.com>
  6 * Copyright (C) 1999, 2000 Brian Warner	<warner@lothar.com>
  7 * Copyright (C) 2000 Al Borchers		<borchers@steinerpoint.com>
  8 *
  9 * See Documentation/usb/usb-serial.rst for more information on using this
 10 * driver
 11 */
 12
 13
 14#include <linux/kernel.h>
 15#include <linux/errno.h>
 16#include <linux/slab.h>
 17#include <linux/tty.h>
 18#include <linux/tty_driver.h>
 19#include <linux/tty_flip.h>
 20#include <linux/module.h>
 21#include <linux/spinlock.h>
 22#include <linux/workqueue.h>
 23#include <linux/uaccess.h>
 24#include <linux/usb.h>
 25#include <linux/usb/serial.h>
 26#include <linux/usb/ezusb.h>
 27
 28/* make a simple define to handle if we are compiling keyspan_pda or xircom support */
 29#if IS_ENABLED(CONFIG_USB_SERIAL_KEYSPAN_PDA)
 30	#define KEYSPAN
 31#else
 32	#undef KEYSPAN
 33#endif
 34#if IS_ENABLED(CONFIG_USB_SERIAL_XIRCOM)
 35	#define XIRCOM
 36#else
 37	#undef XIRCOM
 38#endif
 39
 40#define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
 41#define DRIVER_DESC "USB Keyspan PDA Converter driver"
 42
 43struct keyspan_pda_private {
 44	int			tx_room;
 45	int			tx_throttled;
 46	struct work_struct			wakeup_work;
 47	struct work_struct			unthrottle_work;
 48	struct usb_serial	*serial;
 49	struct usb_serial_port	*port;
 50};
 51
 52
 53#define KEYSPAN_VENDOR_ID		0x06cd
 54#define KEYSPAN_PDA_FAKE_ID		0x0103
 55#define KEYSPAN_PDA_ID			0x0104 /* no clue */
 56
 57/* For Xircom PGSDB9 and older Entrega version of the same device */
 58#define XIRCOM_VENDOR_ID		0x085a
 59#define XIRCOM_FAKE_ID			0x8027
 60#define XIRCOM_FAKE_ID_2		0x8025 /* "PGMFHUB" serial */
 61#define ENTREGA_VENDOR_ID		0x1645
 62#define ENTREGA_FAKE_ID			0x8093
 63
 64static const struct usb_device_id id_table_combined[] = {
 65#ifdef KEYSPAN
 66	{ USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 67#endif
 68#ifdef XIRCOM
 69	{ USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
 70	{ USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
 71	{ USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
 72#endif
 73	{ USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
 74	{ }						/* Terminating entry */
 75};
 76
 77MODULE_DEVICE_TABLE(usb, id_table_combined);
 78
 79static const struct usb_device_id id_table_std[] = {
 80	{ USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
 81	{ }						/* Terminating entry */
 82};
 83
 84#ifdef KEYSPAN
 85static const struct usb_device_id id_table_fake[] = {
 86	{ USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 87	{ }						/* Terminating entry */
 88};
 89#endif
 90
 91#ifdef XIRCOM
 92static const struct usb_device_id id_table_fake_xircom[] = {
 93	{ USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
 94	{ USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
 95	{ USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
 96	{ }
 97};
 98#endif
 99
100static void keyspan_pda_wakeup_write(struct work_struct *work)
101{
102	struct keyspan_pda_private *priv =
103		container_of(work, struct keyspan_pda_private, wakeup_work);
104	struct usb_serial_port *port = priv->port;
105
106	tty_port_tty_wakeup(&port->port);
107}
108
109static void keyspan_pda_request_unthrottle(struct work_struct *work)
110{
111	struct keyspan_pda_private *priv =
112		container_of(work, struct keyspan_pda_private, unthrottle_work);
113	struct usb_serial *serial = priv->serial;
114	int result;
115
116	/* ask the device to tell us when the tx buffer becomes
117	   sufficiently empty */
118	result = usb_control_msg(serial->dev,
119				 usb_sndctrlpipe(serial->dev, 0),
120				 7, /* request_unthrottle */
121				 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
122				 | USB_DIR_OUT,
123				 16, /* value: threshold */
124				 0, /* index */
125				 NULL,
126				 0,
127				 2000);
128	if (result < 0)
129		dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n",
130			__func__, result);
131}
132
133
134static void keyspan_pda_rx_interrupt(struct urb *urb)
135{
136	struct usb_serial_port *port = urb->context;
137	unsigned char *data = urb->transfer_buffer;
138	unsigned int len = urb->actual_length;
139	int retval;
140	int status = urb->status;
141	struct keyspan_pda_private *priv;
142	priv = usb_get_serial_port_data(port);
143
144	switch (status) {
145	case 0:
146		/* success */
147		break;
148	case -ECONNRESET:
149	case -ENOENT:
150	case -ESHUTDOWN:
151		/* this urb is terminated, clean up */
152		dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
153		return;
154	default:
155		dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
156		goto exit;
157	}
158
159	if (len < 1) {
160		dev_warn(&port->dev, "short message received\n");
161		goto exit;
162	}
163
164	/* see if the message is data or a status interrupt */
165	switch (data[0]) {
166	case 0:
167		 /* rest of message is rx data */
168		if (len < 2)
169			break;
170		tty_insert_flip_string(&port->port, data + 1, len - 1);
171		tty_flip_buffer_push(&port->port);
172		break;
173	case 1:
174		/* status interrupt */
175		if (len < 3) {
176			dev_warn(&port->dev, "short interrupt message received\n");
177			break;
178		}
179		dev_dbg(&port->dev, "rx int, d1=%d, d2=%d\n", data[1], data[2]);
180		switch (data[1]) {
181		case 1: /* modemline change */
182			break;
183		case 2: /* tx unthrottle interrupt */
184			priv->tx_throttled = 0;
185			/* queue up a wakeup at scheduler time */
186			schedule_work(&priv->wakeup_work);
187			break;
188		default:
189			break;
190		}
191		break;
192	default:
193		break;
194	}
195
196exit:
197	retval = usb_submit_urb(urb, GFP_ATOMIC);
198	if (retval)
199		dev_err(&port->dev,
200			"%s - usb_submit_urb failed with result %d\n",
201			__func__, retval);
202}
203
204
205static void keyspan_pda_rx_throttle(struct tty_struct *tty)
206{
207	/* stop receiving characters. We just turn off the URB request, and
208	   let chars pile up in the device. If we're doing hardware
209	   flowcontrol, the device will signal the other end when its buffer
210	   fills up. If we're doing XON/XOFF, this would be a good time to
211	   send an XOFF, although it might make sense to foist that off
212	   upon the device too. */
213	struct usb_serial_port *port = tty->driver_data;
214
215	usb_kill_urb(port->interrupt_in_urb);
216}
217
218
219static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
220{
221	struct usb_serial_port *port = tty->driver_data;
222	/* just restart the receive interrupt URB */
223
224	if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
225		dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
226}
227
228
229static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
230{
231	int rc;
232	int bindex;
233
234	switch (baud) {
235	case 110:
236		bindex = 0;
237		break;
238	case 300:
239		bindex = 1;
240		break;
241	case 1200:
242		bindex = 2;
243		break;
244	case 2400:
245		bindex = 3;
246		break;
247	case 4800:
248		bindex = 4;
249		break;
250	case 9600:
251		bindex = 5;
252		break;
253	case 19200:
254		bindex = 6;
255		break;
256	case 38400:
257		bindex = 7;
258		break;
259	case 57600:
260		bindex = 8;
261		break;
262	case 115200:
263		bindex = 9;
264		break;
265	default:
266		bindex = 5;	/* Default to 9600 */
267		baud = 9600;
268	}
269
270	/* rather than figure out how to sleep while waiting for this
271	   to complete, I just use the "legacy" API. */
272	rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
273			     0, /* set baud */
274			     USB_TYPE_VENDOR
275			     | USB_RECIP_INTERFACE
276			     | USB_DIR_OUT, /* type */
277			     bindex, /* value */
278			     0, /* index */
279			     NULL, /* &data */
280			     0, /* size */
281			     2000); /* timeout */
282	if (rc < 0)
283		return 0;
284	return baud;
285}
286
287
288static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
289{
290	struct usb_serial_port *port = tty->driver_data;
291	struct usb_serial *serial = port->serial;
292	int value;
293	int result;
294
295	if (break_state == -1)
296		value = 1; /* start break */
297	else
298		value = 0; /* clear break */
299	result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
300			4, /* set break */
301			USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
302			value, 0, NULL, 0, 2000);
303	if (result < 0)
304		dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
305			__func__, result);
306	/* there is something funky about this.. the TCSBRK that 'cu' performs
307	   ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
308	   seconds apart, but it feels like the break sent isn't as long as it
309	   is on /dev/ttyS0 */
310}
311
312
313static void keyspan_pda_set_termios(struct tty_struct *tty,
314		struct usb_serial_port *port, struct ktermios *old_termios)
315{
316	struct usb_serial *serial = port->serial;
317	speed_t speed;
318
319	/* cflag specifies lots of stuff: number of stop bits, parity, number
320	   of data bits, baud. What can the device actually handle?:
321	   CSTOPB (1 stop bit or 2)
322	   PARENB (parity)
323	   CSIZE (5bit .. 8bit)
324	   There is minimal hw support for parity (a PSW bit seems to hold the
325	   parity of whatever is in the accumulator). The UART either deals
326	   with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
327	   1 special, stop). So, with firmware changes, we could do:
328	   8N1: 10 bit
329	   8N2: 11 bit, extra bit always (mark?)
330	   8[EOMS]1: 11 bit, extra bit is parity
331	   7[EOMS]1: 10 bit, b0/b7 is parity
332	   7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
333
334	   HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
335	   bit.
336
337	   For now, just do baud. */
338
339	speed = tty_get_baud_rate(tty);
340	speed = keyspan_pda_setbaud(serial, speed);
341
342	if (speed == 0) {
343		dev_dbg(&port->dev, "can't handle requested baud rate\n");
344		/* It hasn't changed so.. */
345		speed = tty_termios_baud_rate(old_termios);
346	}
347	/* Only speed can change so copy the old h/w parameters
348	   then encode the new speed */
349	tty_termios_copy_hw(&tty->termios, old_termios);
350	tty_encode_baud_rate(tty, speed, speed);
351}
352
353
354/* modem control pins: DTR and RTS are outputs and can be controlled.
355   DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
356   read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
357
358static int keyspan_pda_get_modem_info(struct usb_serial *serial,
359				      unsigned char *value)
360{
361	int rc;
362	u8 *data;
363
364	data = kmalloc(1, GFP_KERNEL);
365	if (!data)
366		return -ENOMEM;
367
368	rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
369			     3, /* get pins */
370			     USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
371			     0, 0, data, 1, 2000);
372	if (rc == 1)
373		*value = *data;
374	else if (rc >= 0)
375		rc = -EIO;
376
377	kfree(data);
378	return rc;
379}
380
381
382static int keyspan_pda_set_modem_info(struct usb_serial *serial,
383				      unsigned char value)
384{
385	int rc;
386	rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
387			     3, /* set pins */
388			     USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
389			     value, 0, NULL, 0, 2000);
390	return rc;
391}
392
393static int keyspan_pda_tiocmget(struct tty_struct *tty)
394{
395	struct usb_serial_port *port = tty->driver_data;
396	struct usb_serial *serial = port->serial;
397	int rc;
398	unsigned char status;
399	int value;
400
401	rc = keyspan_pda_get_modem_info(serial, &status);
402	if (rc < 0)
403		return rc;
404	value =
405		((status & (1<<7)) ? TIOCM_DTR : 0) |
406		((status & (1<<6)) ? TIOCM_CAR : 0) |
407		((status & (1<<5)) ? TIOCM_RNG : 0) |
408		((status & (1<<4)) ? TIOCM_DSR : 0) |
409		((status & (1<<3)) ? TIOCM_CTS : 0) |
410		((status & (1<<2)) ? TIOCM_RTS : 0);
411	return value;
412}
413
414static int keyspan_pda_tiocmset(struct tty_struct *tty,
415				unsigned int set, unsigned int clear)
416{
417	struct usb_serial_port *port = tty->driver_data;
418	struct usb_serial *serial = port->serial;
419	int rc;
420	unsigned char status;
421
422	rc = keyspan_pda_get_modem_info(serial, &status);
423	if (rc < 0)
424		return rc;
425
426	if (set & TIOCM_RTS)
427		status |= (1<<2);
428	if (set & TIOCM_DTR)
429		status |= (1<<7);
430
431	if (clear & TIOCM_RTS)
432		status &= ~(1<<2);
433	if (clear & TIOCM_DTR)
434		status &= ~(1<<7);
435	rc = keyspan_pda_set_modem_info(serial, status);
436	return rc;
437}
438
439static int keyspan_pda_write(struct tty_struct *tty,
440	struct usb_serial_port *port, const unsigned char *buf, int count)
441{
442	struct usb_serial *serial = port->serial;
443	int request_unthrottle = 0;
444	int rc = 0;
445	struct keyspan_pda_private *priv;
446
447	priv = usb_get_serial_port_data(port);
448	/* guess how much room is left in the device's ring buffer, and if we
449	   want to send more than that, check first, updating our notion of
450	   what is left. If our write will result in no room left, ask the
451	   device to give us an interrupt when the room available rises above
452	   a threshold, and hold off all writers (eventually, those using
453	   select() or poll() too) until we receive that unthrottle interrupt.
454	   Block if we can't write anything at all, otherwise write as much as
455	   we can. */
456	if (count == 0) {
457		dev_dbg(&port->dev, "write request of 0 bytes\n");
458		return 0;
459	}
460
461	/* we might block because of:
462	   the TX urb is in-flight (wait until it completes)
463	   the device is full (wait until it says there is room)
464	*/
465	spin_lock_bh(&port->lock);
466	if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) {
467		spin_unlock_bh(&port->lock);
468		return 0;
469	}
470	clear_bit(0, &port->write_urbs_free);
471	spin_unlock_bh(&port->lock);
472
473	/* At this point the URB is in our control, nobody else can submit it
474	   again (the only sudden transition was the one from EINPROGRESS to
475	   finished).  Also, the tx process is not throttled. So we are
476	   ready to write. */
477
478	count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
479
480	/* Check if we might overrun the Tx buffer.   If so, ask the
481	   device how much room it really has.  This is done only on
482	   scheduler time, since usb_control_msg() sleeps. */
483	if (count > priv->tx_room && !in_interrupt()) {
484		u8 *room;
485
486		room = kmalloc(1, GFP_KERNEL);
487		if (!room) {
488			rc = -ENOMEM;
489			goto exit;
490		}
491
492		rc = usb_control_msg(serial->dev,
493				     usb_rcvctrlpipe(serial->dev, 0),
494				     6, /* write_room */
495				     USB_TYPE_VENDOR | USB_RECIP_INTERFACE
496				     | USB_DIR_IN,
497				     0, /* value: 0 means "remaining room" */
498				     0, /* index */
499				     room,
500				     1,
501				     2000);
502		if (rc > 0) {
503			dev_dbg(&port->dev, "roomquery says %d\n", *room);
504			priv->tx_room = *room;
505		}
506		kfree(room);
507		if (rc < 0) {
508			dev_dbg(&port->dev, "roomquery failed\n");
509			goto exit;
510		}
511		if (rc == 0) {
512			dev_dbg(&port->dev, "roomquery returned 0 bytes\n");
513			rc = -EIO; /* device didn't return any data */
514			goto exit;
515		}
516	}
517	if (count > priv->tx_room) {
518		/* we're about to completely fill the Tx buffer, so
519		   we'll be throttled afterwards. */
520		count = priv->tx_room;
521		request_unthrottle = 1;
522	}
523
524	if (count) {
525		/* now transfer data */
526		memcpy(port->write_urb->transfer_buffer, buf, count);
527		/* send the data out the bulk port */
528		port->write_urb->transfer_buffer_length = count;
529
530		priv->tx_room -= count;
531
532		rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
533		if (rc) {
534			dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
535			goto exit;
536		}
537	} else {
538		/* There wasn't any room left, so we are throttled until
539		   the buffer empties a bit */
540		request_unthrottle = 1;
541	}
542
543	if (request_unthrottle) {
544		priv->tx_throttled = 1; /* block writers */
545		schedule_work(&priv->unthrottle_work);
546	}
547
548	rc = count;
549exit:
550	if (rc < 0)
551		set_bit(0, &port->write_urbs_free);
552	return rc;
553}
554
555
556static void keyspan_pda_write_bulk_callback(struct urb *urb)
557{
558	struct usb_serial_port *port = urb->context;
559	struct keyspan_pda_private *priv;
560
561	set_bit(0, &port->write_urbs_free);
562	priv = usb_get_serial_port_data(port);
563
564	/* queue up a wakeup at scheduler time */
565	schedule_work(&priv->wakeup_work);
566}
567
568
569static int keyspan_pda_write_room(struct tty_struct *tty)
570{
571	struct usb_serial_port *port = tty->driver_data;
572	struct keyspan_pda_private *priv;
573	priv = usb_get_serial_port_data(port);
574	/* used by n_tty.c for processing of tabs and such. Giving it our
575	   conservative guess is probably good enough, but needs testing by
576	   running a console through the device. */
577	return priv->tx_room;
578}
579
580
581static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
582{
583	struct usb_serial_port *port = tty->driver_data;
584	struct keyspan_pda_private *priv;
585	unsigned long flags;
586	int ret = 0;
587
588	priv = usb_get_serial_port_data(port);
589
590	/* when throttled, return at least WAKEUP_CHARS to tell select() (via
591	   n_tty.c:normal_poll() ) that we're not writeable. */
592
593	spin_lock_irqsave(&port->lock, flags);
594	if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled)
595		ret = 256;
596	spin_unlock_irqrestore(&port->lock, flags);
597	return ret;
598}
599
600
601static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
602{
603	struct usb_serial *serial = port->serial;
604
605	if (on)
606		keyspan_pda_set_modem_info(serial, (1 << 7) | (1 << 2));
607	else
608		keyspan_pda_set_modem_info(serial, 0);
609}
610
611
612static int keyspan_pda_open(struct tty_struct *tty,
613					struct usb_serial_port *port)
614{
615	struct usb_serial *serial = port->serial;
616	u8 *room;
617	int rc = 0;
618	struct keyspan_pda_private *priv;
619
620	/* find out how much room is in the Tx ring */
621	room = kmalloc(1, GFP_KERNEL);
622	if (!room)
623		return -ENOMEM;
624
625	rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
626			     6, /* write_room */
627			     USB_TYPE_VENDOR | USB_RECIP_INTERFACE
628			     | USB_DIR_IN,
629			     0, /* value */
630			     0, /* index */
631			     room,
632			     1,
633			     2000);
634	if (rc < 0) {
635		dev_dbg(&port->dev, "%s - roomquery failed\n", __func__);
636		goto error;
637	}
638	if (rc == 0) {
639		dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__);
640		rc = -EIO;
641		goto error;
642	}
643	priv = usb_get_serial_port_data(port);
644	priv->tx_room = *room;
645	priv->tx_throttled = *room ? 0 : 1;
646
647	/*Start reading from the device*/
648	rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
649	if (rc) {
650		dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
651		goto error;
652	}
653error:
654	kfree(room);
655	return rc;
656}
657static void keyspan_pda_close(struct usb_serial_port *port)
658{
659	usb_kill_urb(port->write_urb);
660	usb_kill_urb(port->interrupt_in_urb);
661}
662
663
664/* download the firmware to a "fake" device (pre-renumeration) */
665static int keyspan_pda_fake_startup(struct usb_serial *serial)
666{
 
667	const char *fw_name;
668
669	/* download the firmware here ... */
670	ezusb_fx1_set_reset(serial->dev, 1);
671
672	if (0) { ; }
673#ifdef KEYSPAN
674	else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
675		fw_name = "keyspan_pda/keyspan_pda.fw";
676#endif
677#ifdef XIRCOM
678	else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
679		 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGA_VENDOR_ID))
680		fw_name = "keyspan_pda/xircom_pgs.fw";
681#endif
682	else {
683		dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
684			__func__);
685		return -ENODEV;
686	}
687
688	if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
689		dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
690			fw_name);
691		return -ENOENT;
692	}
693
694	/* after downloading firmware Renumeration will occur in a
695	  moment and the new device will bind to the real driver */
696
697	/* we want this device to fail to have a driver assigned to it. */
698	return 1;
699}
700
701#ifdef KEYSPAN
702MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
703#endif
704#ifdef XIRCOM
705MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
706#endif
707
708static int keyspan_pda_port_probe(struct usb_serial_port *port)
709{
710
711	struct keyspan_pda_private *priv;
712
713	priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
714	if (!priv)
715		return -ENOMEM;
716
717	INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
718	INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
719	priv->serial = port->serial;
720	priv->port = port;
721
722	usb_set_serial_port_data(port, priv);
723
724	return 0;
725}
726
727static int keyspan_pda_port_remove(struct usb_serial_port *port)
728{
729	struct keyspan_pda_private *priv;
730
731	priv = usb_get_serial_port_data(port);
732	kfree(priv);
733
734	return 0;
735}
736
737#ifdef KEYSPAN
738static struct usb_serial_driver keyspan_pda_fake_device = {
739	.driver = {
740		.owner =	THIS_MODULE,
741		.name =		"keyspan_pda_pre",
742	},
743	.description =		"Keyspan PDA - (prerenumeration)",
744	.id_table =		id_table_fake,
745	.num_ports =		1,
746	.attach =		keyspan_pda_fake_startup,
747};
748#endif
749
750#ifdef XIRCOM
751static struct usb_serial_driver xircom_pgs_fake_device = {
752	.driver = {
753		.owner =	THIS_MODULE,
754		.name =		"xircom_no_firm",
755	},
756	.description =		"Xircom / Entrega PGS - (prerenumeration)",
757	.id_table =		id_table_fake_xircom,
758	.num_ports =		1,
759	.attach =		keyspan_pda_fake_startup,
760};
761#endif
762
763static struct usb_serial_driver keyspan_pda_device = {
764	.driver = {
765		.owner =	THIS_MODULE,
766		.name =		"keyspan_pda",
767	},
768	.description =		"Keyspan PDA",
769	.id_table =		id_table_std,
770	.num_ports =		1,
771	.num_bulk_out =		1,
772	.num_interrupt_in =	1,
773	.dtr_rts =		keyspan_pda_dtr_rts,
774	.open =			keyspan_pda_open,
775	.close =		keyspan_pda_close,
776	.write =		keyspan_pda_write,
777	.write_room =		keyspan_pda_write_room,
778	.write_bulk_callback = 	keyspan_pda_write_bulk_callback,
779	.read_int_callback =	keyspan_pda_rx_interrupt,
780	.chars_in_buffer =	keyspan_pda_chars_in_buffer,
781	.throttle =		keyspan_pda_rx_throttle,
782	.unthrottle =		keyspan_pda_rx_unthrottle,
783	.set_termios =		keyspan_pda_set_termios,
784	.break_ctl =		keyspan_pda_break_ctl,
785	.tiocmget =		keyspan_pda_tiocmget,
786	.tiocmset =		keyspan_pda_tiocmset,
787	.port_probe =		keyspan_pda_port_probe,
788	.port_remove =		keyspan_pda_port_remove,
789};
790
791static struct usb_serial_driver * const serial_drivers[] = {
792	&keyspan_pda_device,
793#ifdef KEYSPAN
794	&keyspan_pda_fake_device,
795#endif
796#ifdef XIRCOM
797	&xircom_pgs_fake_device,
798#endif
799	NULL
800};
801
802module_usb_serial_driver(serial_drivers, id_table_combined);
803
804MODULE_AUTHOR(DRIVER_AUTHOR);
805MODULE_DESCRIPTION(DRIVER_DESC);
806MODULE_LICENSE("GPL");
v5.4
  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * USB Keyspan PDA / Xircom / Entrega Converter driver
  4 *
  5 * Copyright (C) 1999 - 2001 Greg Kroah-Hartman	<greg@kroah.com>
  6 * Copyright (C) 1999, 2000 Brian Warner	<warner@lothar.com>
  7 * Copyright (C) 2000 Al Borchers		<borchers@steinerpoint.com>
  8 *
  9 * See Documentation/usb/usb-serial.rst for more information on using this
 10 * driver
 11 */
 12
 13
 14#include <linux/kernel.h>
 15#include <linux/errno.h>
 16#include <linux/slab.h>
 17#include <linux/tty.h>
 18#include <linux/tty_driver.h>
 19#include <linux/tty_flip.h>
 20#include <linux/module.h>
 21#include <linux/spinlock.h>
 22#include <linux/workqueue.h>
 23#include <linux/uaccess.h>
 24#include <linux/usb.h>
 25#include <linux/usb/serial.h>
 26#include <linux/usb/ezusb.h>
 27
 28/* make a simple define to handle if we are compiling keyspan_pda or xircom support */
 29#if IS_ENABLED(CONFIG_USB_SERIAL_KEYSPAN_PDA)
 30	#define KEYSPAN
 31#else
 32	#undef KEYSPAN
 33#endif
 34#if IS_ENABLED(CONFIG_USB_SERIAL_XIRCOM)
 35	#define XIRCOM
 36#else
 37	#undef XIRCOM
 38#endif
 39
 40#define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
 41#define DRIVER_DESC "USB Keyspan PDA Converter driver"
 42
 43struct keyspan_pda_private {
 44	int			tx_room;
 45	int			tx_throttled;
 46	struct work_struct			wakeup_work;
 47	struct work_struct			unthrottle_work;
 48	struct usb_serial	*serial;
 49	struct usb_serial_port	*port;
 50};
 51
 52
 53#define KEYSPAN_VENDOR_ID		0x06cd
 54#define KEYSPAN_PDA_FAKE_ID		0x0103
 55#define KEYSPAN_PDA_ID			0x0104 /* no clue */
 56
 57/* For Xircom PGSDB9 and older Entrega version of the same device */
 58#define XIRCOM_VENDOR_ID		0x085a
 59#define XIRCOM_FAKE_ID			0x8027
 60#define XIRCOM_FAKE_ID_2		0x8025 /* "PGMFHUB" serial */
 61#define ENTREGA_VENDOR_ID		0x1645
 62#define ENTREGA_FAKE_ID			0x8093
 63
 64static const struct usb_device_id id_table_combined[] = {
 65#ifdef KEYSPAN
 66	{ USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 67#endif
 68#ifdef XIRCOM
 69	{ USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
 70	{ USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
 71	{ USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
 72#endif
 73	{ USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
 74	{ }						/* Terminating entry */
 75};
 76
 77MODULE_DEVICE_TABLE(usb, id_table_combined);
 78
 79static const struct usb_device_id id_table_std[] = {
 80	{ USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
 81	{ }						/* Terminating entry */
 82};
 83
 84#ifdef KEYSPAN
 85static const struct usb_device_id id_table_fake[] = {
 86	{ USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 87	{ }						/* Terminating entry */
 88};
 89#endif
 90
 91#ifdef XIRCOM
 92static const struct usb_device_id id_table_fake_xircom[] = {
 93	{ USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
 94	{ USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
 95	{ USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
 96	{ }
 97};
 98#endif
 99
100static void keyspan_pda_wakeup_write(struct work_struct *work)
101{
102	struct keyspan_pda_private *priv =
103		container_of(work, struct keyspan_pda_private, wakeup_work);
104	struct usb_serial_port *port = priv->port;
105
106	tty_port_tty_wakeup(&port->port);
107}
108
109static void keyspan_pda_request_unthrottle(struct work_struct *work)
110{
111	struct keyspan_pda_private *priv =
112		container_of(work, struct keyspan_pda_private, unthrottle_work);
113	struct usb_serial *serial = priv->serial;
114	int result;
115
116	/* ask the device to tell us when the tx buffer becomes
117	   sufficiently empty */
118	result = usb_control_msg(serial->dev,
119				 usb_sndctrlpipe(serial->dev, 0),
120				 7, /* request_unthrottle */
121				 USB_TYPE_VENDOR | USB_RECIP_INTERFACE
122				 | USB_DIR_OUT,
123				 16, /* value: threshold */
124				 0, /* index */
125				 NULL,
126				 0,
127				 2000);
128	if (result < 0)
129		dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n",
130			__func__, result);
131}
132
133
134static void keyspan_pda_rx_interrupt(struct urb *urb)
135{
136	struct usb_serial_port *port = urb->context;
137	unsigned char *data = urb->transfer_buffer;
138	unsigned int len = urb->actual_length;
139	int retval;
140	int status = urb->status;
141	struct keyspan_pda_private *priv;
142	priv = usb_get_serial_port_data(port);
143
144	switch (status) {
145	case 0:
146		/* success */
147		break;
148	case -ECONNRESET:
149	case -ENOENT:
150	case -ESHUTDOWN:
151		/* this urb is terminated, clean up */
152		dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
153		return;
154	default:
155		dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
156		goto exit;
157	}
158
159	if (len < 1) {
160		dev_warn(&port->dev, "short message received\n");
161		goto exit;
162	}
163
164	/* see if the message is data or a status interrupt */
165	switch (data[0]) {
166	case 0:
167		 /* rest of message is rx data */
168		if (len < 2)
169			break;
170		tty_insert_flip_string(&port->port, data + 1, len - 1);
171		tty_flip_buffer_push(&port->port);
172		break;
173	case 1:
174		/* status interrupt */
175		if (len < 3) {
176			dev_warn(&port->dev, "short interrupt message received\n");
177			break;
178		}
179		dev_dbg(&port->dev, "rx int, d1=%d, d2=%d\n", data[1], data[2]);
180		switch (data[1]) {
181		case 1: /* modemline change */
182			break;
183		case 2: /* tx unthrottle interrupt */
184			priv->tx_throttled = 0;
185			/* queue up a wakeup at scheduler time */
186			schedule_work(&priv->wakeup_work);
187			break;
188		default:
189			break;
190		}
191		break;
192	default:
193		break;
194	}
195
196exit:
197	retval = usb_submit_urb(urb, GFP_ATOMIC);
198	if (retval)
199		dev_err(&port->dev,
200			"%s - usb_submit_urb failed with result %d\n",
201			__func__, retval);
202}
203
204
205static void keyspan_pda_rx_throttle(struct tty_struct *tty)
206{
207	/* stop receiving characters. We just turn off the URB request, and
208	   let chars pile up in the device. If we're doing hardware
209	   flowcontrol, the device will signal the other end when its buffer
210	   fills up. If we're doing XON/XOFF, this would be a good time to
211	   send an XOFF, although it might make sense to foist that off
212	   upon the device too. */
213	struct usb_serial_port *port = tty->driver_data;
214
215	usb_kill_urb(port->interrupt_in_urb);
216}
217
218
219static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
220{
221	struct usb_serial_port *port = tty->driver_data;
222	/* just restart the receive interrupt URB */
223
224	if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
225		dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
226}
227
228
229static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
230{
231	int rc;
232	int bindex;
233
234	switch (baud) {
235	case 110:
236		bindex = 0;
237		break;
238	case 300:
239		bindex = 1;
240		break;
241	case 1200:
242		bindex = 2;
243		break;
244	case 2400:
245		bindex = 3;
246		break;
247	case 4800:
248		bindex = 4;
249		break;
250	case 9600:
251		bindex = 5;
252		break;
253	case 19200:
254		bindex = 6;
255		break;
256	case 38400:
257		bindex = 7;
258		break;
259	case 57600:
260		bindex = 8;
261		break;
262	case 115200:
263		bindex = 9;
264		break;
265	default:
266		bindex = 5;	/* Default to 9600 */
267		baud = 9600;
268	}
269
270	/* rather than figure out how to sleep while waiting for this
271	   to complete, I just use the "legacy" API. */
272	rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
273			     0, /* set baud */
274			     USB_TYPE_VENDOR
275			     | USB_RECIP_INTERFACE
276			     | USB_DIR_OUT, /* type */
277			     bindex, /* value */
278			     0, /* index */
279			     NULL, /* &data */
280			     0, /* size */
281			     2000); /* timeout */
282	if (rc < 0)
283		return 0;
284	return baud;
285}
286
287
288static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
289{
290	struct usb_serial_port *port = tty->driver_data;
291	struct usb_serial *serial = port->serial;
292	int value;
293	int result;
294
295	if (break_state == -1)
296		value = 1; /* start break */
297	else
298		value = 0; /* clear break */
299	result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
300			4, /* set break */
301			USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
302			value, 0, NULL, 0, 2000);
303	if (result < 0)
304		dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
305			__func__, result);
306	/* there is something funky about this.. the TCSBRK that 'cu' performs
307	   ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
308	   seconds apart, but it feels like the break sent isn't as long as it
309	   is on /dev/ttyS0 */
310}
311
312
313static void keyspan_pda_set_termios(struct tty_struct *tty,
314		struct usb_serial_port *port, struct ktermios *old_termios)
315{
316	struct usb_serial *serial = port->serial;
317	speed_t speed;
318
319	/* cflag specifies lots of stuff: number of stop bits, parity, number
320	   of data bits, baud. What can the device actually handle?:
321	   CSTOPB (1 stop bit or 2)
322	   PARENB (parity)
323	   CSIZE (5bit .. 8bit)
324	   There is minimal hw support for parity (a PSW bit seems to hold the
325	   parity of whatever is in the accumulator). The UART either deals
326	   with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
327	   1 special, stop). So, with firmware changes, we could do:
328	   8N1: 10 bit
329	   8N2: 11 bit, extra bit always (mark?)
330	   8[EOMS]1: 11 bit, extra bit is parity
331	   7[EOMS]1: 10 bit, b0/b7 is parity
332	   7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
333
334	   HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
335	   bit.
336
337	   For now, just do baud. */
338
339	speed = tty_get_baud_rate(tty);
340	speed = keyspan_pda_setbaud(serial, speed);
341
342	if (speed == 0) {
343		dev_dbg(&port->dev, "can't handle requested baud rate\n");
344		/* It hasn't changed so.. */
345		speed = tty_termios_baud_rate(old_termios);
346	}
347	/* Only speed can change so copy the old h/w parameters
348	   then encode the new speed */
349	tty_termios_copy_hw(&tty->termios, old_termios);
350	tty_encode_baud_rate(tty, speed, speed);
351}
352
353
354/* modem control pins: DTR and RTS are outputs and can be controlled.
355   DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
356   read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
357
358static int keyspan_pda_get_modem_info(struct usb_serial *serial,
359				      unsigned char *value)
360{
361	int rc;
362	u8 *data;
363
364	data = kmalloc(1, GFP_KERNEL);
365	if (!data)
366		return -ENOMEM;
367
368	rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
369			     3, /* get pins */
370			     USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
371			     0, 0, data, 1, 2000);
372	if (rc == 1)
373		*value = *data;
374	else if (rc >= 0)
375		rc = -EIO;
376
377	kfree(data);
378	return rc;
379}
380
381
382static int keyspan_pda_set_modem_info(struct usb_serial *serial,
383				      unsigned char value)
384{
385	int rc;
386	rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
387			     3, /* set pins */
388			     USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
389			     value, 0, NULL, 0, 2000);
390	return rc;
391}
392
393static int keyspan_pda_tiocmget(struct tty_struct *tty)
394{
395	struct usb_serial_port *port = tty->driver_data;
396	struct usb_serial *serial = port->serial;
397	int rc;
398	unsigned char status;
399	int value;
400
401	rc = keyspan_pda_get_modem_info(serial, &status);
402	if (rc < 0)
403		return rc;
404	value =
405		((status & (1<<7)) ? TIOCM_DTR : 0) |
406		((status & (1<<6)) ? TIOCM_CAR : 0) |
407		((status & (1<<5)) ? TIOCM_RNG : 0) |
408		((status & (1<<4)) ? TIOCM_DSR : 0) |
409		((status & (1<<3)) ? TIOCM_CTS : 0) |
410		((status & (1<<2)) ? TIOCM_RTS : 0);
411	return value;
412}
413
414static int keyspan_pda_tiocmset(struct tty_struct *tty,
415				unsigned int set, unsigned int clear)
416{
417	struct usb_serial_port *port = tty->driver_data;
418	struct usb_serial *serial = port->serial;
419	int rc;
420	unsigned char status;
421
422	rc = keyspan_pda_get_modem_info(serial, &status);
423	if (rc < 0)
424		return rc;
425
426	if (set & TIOCM_RTS)
427		status |= (1<<2);
428	if (set & TIOCM_DTR)
429		status |= (1<<7);
430
431	if (clear & TIOCM_RTS)
432		status &= ~(1<<2);
433	if (clear & TIOCM_DTR)
434		status &= ~(1<<7);
435	rc = keyspan_pda_set_modem_info(serial, status);
436	return rc;
437}
438
439static int keyspan_pda_write(struct tty_struct *tty,
440	struct usb_serial_port *port, const unsigned char *buf, int count)
441{
442	struct usb_serial *serial = port->serial;
443	int request_unthrottle = 0;
444	int rc = 0;
445	struct keyspan_pda_private *priv;
446
447	priv = usb_get_serial_port_data(port);
448	/* guess how much room is left in the device's ring buffer, and if we
449	   want to send more than that, check first, updating our notion of
450	   what is left. If our write will result in no room left, ask the
451	   device to give us an interrupt when the room available rises above
452	   a threshold, and hold off all writers (eventually, those using
453	   select() or poll() too) until we receive that unthrottle interrupt.
454	   Block if we can't write anything at all, otherwise write as much as
455	   we can. */
456	if (count == 0) {
457		dev_dbg(&port->dev, "write request of 0 bytes\n");
458		return 0;
459	}
460
461	/* we might block because of:
462	   the TX urb is in-flight (wait until it completes)
463	   the device is full (wait until it says there is room)
464	*/
465	spin_lock_bh(&port->lock);
466	if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) {
467		spin_unlock_bh(&port->lock);
468		return 0;
469	}
470	clear_bit(0, &port->write_urbs_free);
471	spin_unlock_bh(&port->lock);
472
473	/* At this point the URB is in our control, nobody else can submit it
474	   again (the only sudden transition was the one from EINPROGRESS to
475	   finished).  Also, the tx process is not throttled. So we are
476	   ready to write. */
477
478	count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
479
480	/* Check if we might overrun the Tx buffer.   If so, ask the
481	   device how much room it really has.  This is done only on
482	   scheduler time, since usb_control_msg() sleeps. */
483	if (count > priv->tx_room && !in_interrupt()) {
484		u8 *room;
485
486		room = kmalloc(1, GFP_KERNEL);
487		if (!room) {
488			rc = -ENOMEM;
489			goto exit;
490		}
491
492		rc = usb_control_msg(serial->dev,
493				     usb_rcvctrlpipe(serial->dev, 0),
494				     6, /* write_room */
495				     USB_TYPE_VENDOR | USB_RECIP_INTERFACE
496				     | USB_DIR_IN,
497				     0, /* value: 0 means "remaining room" */
498				     0, /* index */
499				     room,
500				     1,
501				     2000);
502		if (rc > 0) {
503			dev_dbg(&port->dev, "roomquery says %d\n", *room);
504			priv->tx_room = *room;
505		}
506		kfree(room);
507		if (rc < 0) {
508			dev_dbg(&port->dev, "roomquery failed\n");
509			goto exit;
510		}
511		if (rc == 0) {
512			dev_dbg(&port->dev, "roomquery returned 0 bytes\n");
513			rc = -EIO; /* device didn't return any data */
514			goto exit;
515		}
516	}
517	if (count > priv->tx_room) {
518		/* we're about to completely fill the Tx buffer, so
519		   we'll be throttled afterwards. */
520		count = priv->tx_room;
521		request_unthrottle = 1;
522	}
523
524	if (count) {
525		/* now transfer data */
526		memcpy(port->write_urb->transfer_buffer, buf, count);
527		/* send the data out the bulk port */
528		port->write_urb->transfer_buffer_length = count;
529
530		priv->tx_room -= count;
531
532		rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
533		if (rc) {
534			dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
535			goto exit;
536		}
537	} else {
538		/* There wasn't any room left, so we are throttled until
539		   the buffer empties a bit */
540		request_unthrottle = 1;
541	}
542
543	if (request_unthrottle) {
544		priv->tx_throttled = 1; /* block writers */
545		schedule_work(&priv->unthrottle_work);
546	}
547
548	rc = count;
549exit:
550	if (rc < 0)
551		set_bit(0, &port->write_urbs_free);
552	return rc;
553}
554
555
556static void keyspan_pda_write_bulk_callback(struct urb *urb)
557{
558	struct usb_serial_port *port = urb->context;
559	struct keyspan_pda_private *priv;
560
561	set_bit(0, &port->write_urbs_free);
562	priv = usb_get_serial_port_data(port);
563
564	/* queue up a wakeup at scheduler time */
565	schedule_work(&priv->wakeup_work);
566}
567
568
569static int keyspan_pda_write_room(struct tty_struct *tty)
570{
571	struct usb_serial_port *port = tty->driver_data;
572	struct keyspan_pda_private *priv;
573	priv = usb_get_serial_port_data(port);
574	/* used by n_tty.c for processing of tabs and such. Giving it our
575	   conservative guess is probably good enough, but needs testing by
576	   running a console through the device. */
577	return priv->tx_room;
578}
579
580
581static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
582{
583	struct usb_serial_port *port = tty->driver_data;
584	struct keyspan_pda_private *priv;
585	unsigned long flags;
586	int ret = 0;
587
588	priv = usb_get_serial_port_data(port);
589
590	/* when throttled, return at least WAKEUP_CHARS to tell select() (via
591	   n_tty.c:normal_poll() ) that we're not writeable. */
592
593	spin_lock_irqsave(&port->lock, flags);
594	if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled)
595		ret = 256;
596	spin_unlock_irqrestore(&port->lock, flags);
597	return ret;
598}
599
600
601static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
602{
603	struct usb_serial *serial = port->serial;
604
605	if (on)
606		keyspan_pda_set_modem_info(serial, (1 << 7) | (1 << 2));
607	else
608		keyspan_pda_set_modem_info(serial, 0);
609}
610
611
612static int keyspan_pda_open(struct tty_struct *tty,
613					struct usb_serial_port *port)
614{
615	struct usb_serial *serial = port->serial;
616	u8 *room;
617	int rc = 0;
618	struct keyspan_pda_private *priv;
619
620	/* find out how much room is in the Tx ring */
621	room = kmalloc(1, GFP_KERNEL);
622	if (!room)
623		return -ENOMEM;
624
625	rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
626			     6, /* write_room */
627			     USB_TYPE_VENDOR | USB_RECIP_INTERFACE
628			     | USB_DIR_IN,
629			     0, /* value */
630			     0, /* index */
631			     room,
632			     1,
633			     2000);
634	if (rc < 0) {
635		dev_dbg(&port->dev, "%s - roomquery failed\n", __func__);
636		goto error;
637	}
638	if (rc == 0) {
639		dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__);
640		rc = -EIO;
641		goto error;
642	}
643	priv = usb_get_serial_port_data(port);
644	priv->tx_room = *room;
645	priv->tx_throttled = *room ? 0 : 1;
646
647	/*Start reading from the device*/
648	rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
649	if (rc) {
650		dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
651		goto error;
652	}
653error:
654	kfree(room);
655	return rc;
656}
657static void keyspan_pda_close(struct usb_serial_port *port)
658{
659	usb_kill_urb(port->write_urb);
660	usb_kill_urb(port->interrupt_in_urb);
661}
662
663
664/* download the firmware to a "fake" device (pre-renumeration) */
665static int keyspan_pda_fake_startup(struct usb_serial *serial)
666{
667	int response;
668	const char *fw_name;
669
670	/* download the firmware here ... */
671	response = ezusb_fx1_set_reset(serial->dev, 1);
672
673	if (0) { ; }
674#ifdef KEYSPAN
675	else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
676		fw_name = "keyspan_pda/keyspan_pda.fw";
677#endif
678#ifdef XIRCOM
679	else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
680		 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGA_VENDOR_ID))
681		fw_name = "keyspan_pda/xircom_pgs.fw";
682#endif
683	else {
684		dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
685			__func__);
686		return -ENODEV;
687	}
688
689	if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
690		dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
691			fw_name);
692		return -ENOENT;
693	}
694
695	/* after downloading firmware Renumeration will occur in a
696	  moment and the new device will bind to the real driver */
697
698	/* we want this device to fail to have a driver assigned to it. */
699	return 1;
700}
701
702#ifdef KEYSPAN
703MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
704#endif
705#ifdef XIRCOM
706MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
707#endif
708
709static int keyspan_pda_port_probe(struct usb_serial_port *port)
710{
711
712	struct keyspan_pda_private *priv;
713
714	priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
715	if (!priv)
716		return -ENOMEM;
717
718	INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
719	INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
720	priv->serial = port->serial;
721	priv->port = port;
722
723	usb_set_serial_port_data(port, priv);
724
725	return 0;
726}
727
728static int keyspan_pda_port_remove(struct usb_serial_port *port)
729{
730	struct keyspan_pda_private *priv;
731
732	priv = usb_get_serial_port_data(port);
733	kfree(priv);
734
735	return 0;
736}
737
738#ifdef KEYSPAN
739static struct usb_serial_driver keyspan_pda_fake_device = {
740	.driver = {
741		.owner =	THIS_MODULE,
742		.name =		"keyspan_pda_pre",
743	},
744	.description =		"Keyspan PDA - (prerenumeration)",
745	.id_table =		id_table_fake,
746	.num_ports =		1,
747	.attach =		keyspan_pda_fake_startup,
748};
749#endif
750
751#ifdef XIRCOM
752static struct usb_serial_driver xircom_pgs_fake_device = {
753	.driver = {
754		.owner =	THIS_MODULE,
755		.name =		"xircom_no_firm",
756	},
757	.description =		"Xircom / Entrega PGS - (prerenumeration)",
758	.id_table =		id_table_fake_xircom,
759	.num_ports =		1,
760	.attach =		keyspan_pda_fake_startup,
761};
762#endif
763
764static struct usb_serial_driver keyspan_pda_device = {
765	.driver = {
766		.owner =	THIS_MODULE,
767		.name =		"keyspan_pda",
768	},
769	.description =		"Keyspan PDA",
770	.id_table =		id_table_std,
771	.num_ports =		1,
772	.num_bulk_out =		1,
773	.num_interrupt_in =	1,
774	.dtr_rts =		keyspan_pda_dtr_rts,
775	.open =			keyspan_pda_open,
776	.close =		keyspan_pda_close,
777	.write =		keyspan_pda_write,
778	.write_room =		keyspan_pda_write_room,
779	.write_bulk_callback = 	keyspan_pda_write_bulk_callback,
780	.read_int_callback =	keyspan_pda_rx_interrupt,
781	.chars_in_buffer =	keyspan_pda_chars_in_buffer,
782	.throttle =		keyspan_pda_rx_throttle,
783	.unthrottle =		keyspan_pda_rx_unthrottle,
784	.set_termios =		keyspan_pda_set_termios,
785	.break_ctl =		keyspan_pda_break_ctl,
786	.tiocmget =		keyspan_pda_tiocmget,
787	.tiocmset =		keyspan_pda_tiocmset,
788	.port_probe =		keyspan_pda_port_probe,
789	.port_remove =		keyspan_pda_port_remove,
790};
791
792static struct usb_serial_driver * const serial_drivers[] = {
793	&keyspan_pda_device,
794#ifdef KEYSPAN
795	&keyspan_pda_fake_device,
796#endif
797#ifdef XIRCOM
798	&xircom_pgs_fake_device,
799#endif
800	NULL
801};
802
803module_usb_serial_driver(serial_drivers, id_table_combined);
804
805MODULE_AUTHOR(DRIVER_AUTHOR);
806MODULE_DESCRIPTION(DRIVER_DESC);
807MODULE_LICENSE("GPL");