← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/usb/serial/keyspan_pda.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

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