xref: /openbmc/linux/drivers/usb/serial/keyspan_pda.c (revision a20eefae)
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 
43 struct 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 
64 static 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 
77 MODULE_DEVICE_TABLE(usb, id_table_combined);
78 
79 static 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
85 static 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
92 static 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 
100 static 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 
109 static 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 
134 static 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 
196 exit:
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 
205 static 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 
219 static 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 
229 static 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 
288 static 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 
313 static 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 
358 static 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 
382 static 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 
393 static 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 
414 static 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 
439 static 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;
549 exit:
550 	if (rc < 0)
551 		set_bit(0, &port->write_urbs_free);
552 	return rc;
553 }
554 
555 
556 static 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 
569 static 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 
581 static 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 
601 static 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 
612 static 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 	}
653 error:
654 	kfree(room);
655 	return rc;
656 }
657 static 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) */
665 static 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
703 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
704 #endif
705 #ifdef XIRCOM
706 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
707 #endif
708 
709 static 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 
728 static 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
739 static 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
752 static 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 
764 static 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 
792 static 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 
803 module_usb_serial_driver(serial_drivers, id_table_combined);
804 
805 MODULE_AUTHOR(DRIVER_AUTHOR);
806 MODULE_DESCRIPTION(DRIVER_DESC);
807 MODULE_LICENSE("GPL");
808