2 * USB Empeg empeg-car player driver
4 * Copyright (C) 2000, 2001
5 * Gary Brubaker (xavyer@ix.netcom.com)
7 * Copyright (C) 1999 - 2001
8 * Greg Kroah-Hartman (greg@kroah.com)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License, as published by
12 * the Free Software Foundation, version 2.
14 * See Documentation/usb/usb-serial.txt for more information on using this
18 * remove unused code in empeg_close() (thanks to Oliver Neukum for
19 * pointing this out) and rewrote empeg_set_termios().
22 * switched from using spinlock to a semaphore, which fixes lots of
26 * Identify version on module load.
29 * Added write_room() and chars_in_buffer() support.
32 * Moved termio stuff inside the port->active check.
33 * Moved MOD_DEC_USE_COUNT to end of empeg_close().
36 * Added tty->ldisc.set_termios(port, tty, NULL) to empeg_open().
37 * This notifies the tty driver that the termios have changed.
40 * Moved tty->low_latency = 1 from empeg_read_bulk_callback() to
41 * empeg_open() (It only needs to be set once - Doh!)
44 * Updated to work with id_table structure.
47 * Forked this from visor.c, and hacked it up to work with an
48 * Empeg ltd. empeg-car player. Constructive criticism welcomed.
49 * I would like to say, 'Thank You' to Greg Kroah-Hartman for the
50 * use of his code, and for his guidance, advice and patience. :)
51 * A 'Thank You' is in order for John Ripley of Empeg ltd for his
52 * advice, and patience too.
56 #include <linux/kernel.h>
57 #include <linux/errno.h>
58 #include <linux/init.h>
59 #include <linux/slab.h>
60 #include <linux/tty.h>
61 #include <linux/tty_driver.h>
62 #include <linux/tty_flip.h>
63 #include <linux/module.h>
64 #include <linux/spinlock.h>
65 #include <linux/uaccess.h>
66 #include <linux/usb.h>
67 #include <linux/usb/serial.h>
74 #define DRIVER_VERSION "v1.2"
75 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Gary Brubaker <xavyer@ix.netcom.com>"
76 #define DRIVER_DESC "USB Empeg Mark I/II Driver"
78 #define EMPEG_VENDOR_ID 0x084f
79 #define EMPEG_PRODUCT_ID 0x0001
81 /* function prototypes for an empeg-car player */
82 static int empeg_open(struct tty_struct
*tty
, struct usb_serial_port
*port
,
84 static void empeg_close(struct usb_serial_port
*port
);
85 static int empeg_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
86 const unsigned char *buf
,
88 static int empeg_write_room(struct tty_struct
*tty
);
89 static int empeg_chars_in_buffer(struct tty_struct
*tty
);
90 static void empeg_throttle(struct tty_struct
*tty
);
91 static void empeg_unthrottle(struct tty_struct
*tty
);
92 static int empeg_startup(struct usb_serial
*serial
);
93 static void empeg_shutdown(struct usb_serial
*serial
);
94 static void empeg_set_termios(struct tty_struct
*tty
,
95 struct usb_serial_port
*port
, struct ktermios
*old_termios
);
96 static void empeg_write_bulk_callback(struct urb
*urb
);
97 static void empeg_read_bulk_callback(struct urb
*urb
);
99 static struct usb_device_id id_table
[] = {
100 { USB_DEVICE(EMPEG_VENDOR_ID
, EMPEG_PRODUCT_ID
) },
101 { } /* Terminating entry */
104 MODULE_DEVICE_TABLE(usb
, id_table
);
106 static struct usb_driver empeg_driver
= {
108 .probe
= usb_serial_probe
,
109 .disconnect
= usb_serial_disconnect
,
110 .id_table
= id_table
,
114 static struct usb_serial_driver empeg_device
= {
116 .owner
= THIS_MODULE
,
119 .id_table
= id_table
,
120 .usb_driver
= &empeg_driver
,
123 .close
= empeg_close
,
124 .throttle
= empeg_throttle
,
125 .unthrottle
= empeg_unthrottle
,
126 .attach
= empeg_startup
,
127 .shutdown
= empeg_shutdown
,
128 .set_termios
= empeg_set_termios
,
129 .write
= empeg_write
,
130 .write_room
= empeg_write_room
,
131 .chars_in_buffer
= empeg_chars_in_buffer
,
132 .write_bulk_callback
= empeg_write_bulk_callback
,
133 .read_bulk_callback
= empeg_read_bulk_callback
,
137 #define URB_TRANSFER_BUFFER_SIZE 4096
139 static struct urb
*write_urb_pool
[NUM_URBS
];
140 static spinlock_t write_urb_pool_lock
;
142 static int bytes_out
;
144 /******************************************************************************
145 * Empeg specific driver functions
146 ******************************************************************************/
147 static int empeg_open(struct tty_struct
*tty
, struct usb_serial_port
*port
,
150 struct usb_serial
*serial
= port
->serial
;
153 dbg("%s - port %d", __func__
, port
->number
);
155 /* Force default termio settings */
156 empeg_set_termios(tty
, port
, NULL
) ;
161 /* Start reading from the device */
165 usb_rcvbulkpipe(serial
->dev
,
166 port
->bulk_in_endpointAddress
),
167 port
->read_urb
->transfer_buffer
,
168 port
->read_urb
->transfer_buffer_length
,
169 empeg_read_bulk_callback
,
172 result
= usb_submit_urb(port
->read_urb
, GFP_KERNEL
);
176 "%s - failed submitting read urb, error %d\n",
183 static void empeg_close(struct usb_serial_port
*port
)
185 dbg("%s - port %d", __func__
, port
->number
);
187 /* shutdown our bulk read */
188 usb_kill_urb(port
->read_urb
);
189 /* Uncomment the following line if you want to see some statistics in your syslog */
190 /* dev_info (&port->dev, "Bytes In = %d Bytes Out = %d\n", bytes_in, bytes_out); */
194 static int empeg_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
195 const unsigned char *buf
, int count
)
197 struct usb_serial
*serial
= port
->serial
;
199 const unsigned char *current_position
= buf
;
206 dbg("%s - port %d", __func__
, port
->number
);
209 /* try to find a free urb in our list of them */
212 spin_lock_irqsave(&write_urb_pool_lock
, flags
);
214 for (i
= 0; i
< NUM_URBS
; ++i
) {
215 if (write_urb_pool
[i
]->status
!= -EINPROGRESS
) {
216 urb
= write_urb_pool
[i
];
221 spin_unlock_irqrestore(&write_urb_pool_lock
, flags
);
224 dbg("%s - no more free urbs", __func__
);
228 if (urb
->transfer_buffer
== NULL
) {
229 urb
->transfer_buffer
= kmalloc(URB_TRANSFER_BUFFER_SIZE
, GFP_ATOMIC
);
230 if (urb
->transfer_buffer
== NULL
) {
232 "%s no more kernel memory...\n",
238 transfer_size
= min(count
, URB_TRANSFER_BUFFER_SIZE
);
240 memcpy(urb
->transfer_buffer
, current_position
, transfer_size
);
242 usb_serial_debug_data(debug
, &port
->dev
, __func__
, transfer_size
, urb
->transfer_buffer
);
244 /* build up our urb */
248 usb_sndbulkpipe(serial
->dev
,
249 port
->bulk_out_endpointAddress
),
250 urb
->transfer_buffer
,
252 empeg_write_bulk_callback
,
255 /* send it down the pipe */
256 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
258 dev_err(&port
->dev
, "%s - usb_submit_urb(write bulk) failed with status = %d\n", __func__
, status
);
263 current_position
+= transfer_size
;
264 bytes_sent
+= transfer_size
;
265 count
-= transfer_size
;
266 bytes_out
+= transfer_size
;
274 static int empeg_write_room(struct tty_struct
*tty
)
276 struct usb_serial_port
*port
= tty
->driver_data
;
281 dbg("%s - port %d", __func__
, port
->number
);
283 spin_lock_irqsave(&write_urb_pool_lock
, flags
);
284 /* tally up the number of bytes available */
285 for (i
= 0; i
< NUM_URBS
; ++i
) {
286 if (write_urb_pool
[i
]->status
!= -EINPROGRESS
)
287 room
+= URB_TRANSFER_BUFFER_SIZE
;
289 spin_unlock_irqrestore(&write_urb_pool_lock
, flags
);
290 dbg("%s - returns %d", __func__
, room
);
296 static int empeg_chars_in_buffer(struct tty_struct
*tty
)
298 struct usb_serial_port
*port
= tty
->driver_data
;
303 dbg("%s - port %d", __func__
, port
->number
);
305 spin_lock_irqsave(&write_urb_pool_lock
, flags
);
307 /* tally up the number of bytes waiting */
308 for (i
= 0; i
< NUM_URBS
; ++i
) {
309 if (write_urb_pool
[i
]->status
== -EINPROGRESS
)
310 chars
+= URB_TRANSFER_BUFFER_SIZE
;
313 spin_unlock_irqrestore(&write_urb_pool_lock
, flags
);
314 dbg("%s - returns %d", __func__
, chars
);
319 static void empeg_write_bulk_callback(struct urb
*urb
)
321 struct usb_serial_port
*port
= urb
->context
;
322 int status
= urb
->status
;
324 dbg("%s - port %d", __func__
, port
->number
);
327 dbg("%s - nonzero write bulk status received: %d",
332 usb_serial_port_softint(port
);
336 static void empeg_read_bulk_callback(struct urb
*urb
)
338 struct usb_serial_port
*port
= urb
->context
;
339 struct tty_struct
*tty
;
340 unsigned char *data
= urb
->transfer_buffer
;
342 int status
= urb
->status
;
344 dbg("%s - port %d", __func__
, port
->number
);
347 dbg("%s - nonzero read bulk status received: %d",
352 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
353 urb
->actual_length
, data
);
354 tty
= tty_port_tty_get(&port
->port
);
356 if (urb
->actual_length
) {
357 tty_buffer_request_room(tty
, urb
->actual_length
);
358 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
359 tty_flip_buffer_push(tty
);
360 bytes_in
+= urb
->actual_length
;
364 /* Continue trying to always read */
368 usb_rcvbulkpipe(port
->serial
->dev
,
369 port
->bulk_in_endpointAddress
),
370 port
->read_urb
->transfer_buffer
,
371 port
->read_urb
->transfer_buffer_length
,
372 empeg_read_bulk_callback
,
375 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
378 dev_err(&urb
->dev
->dev
,
379 "%s - failed resubmitting read urb, error %d\n",
387 static void empeg_throttle(struct tty_struct
*tty
)
389 struct usb_serial_port
*port
= tty
->driver_data
;
390 dbg("%s - port %d", __func__
, port
->number
);
391 usb_kill_urb(port
->read_urb
);
395 static void empeg_unthrottle(struct tty_struct
*tty
)
397 struct usb_serial_port
*port
= tty
->driver_data
;
399 dbg("%s - port %d", __func__
, port
->number
);
401 port
->read_urb
->dev
= port
->serial
->dev
;
402 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
405 "%s - failed submitting read urb, error %d\n",
410 static int empeg_startup(struct usb_serial
*serial
)
416 if (serial
->dev
->actconfig
->desc
.bConfigurationValue
!= 1) {
417 dev_err(&serial
->dev
->dev
, "active config #%d != 1 ??\n",
418 serial
->dev
->actconfig
->desc
.bConfigurationValue
);
421 dbg("%s - reset config", __func__
);
422 r
= usb_reset_configuration(serial
->dev
);
424 /* continue on with initialization */
430 static void empeg_shutdown(struct usb_serial
*serial
)
436 static void empeg_set_termios(struct tty_struct
*tty
,
437 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
439 struct ktermios
*termios
= tty
->termios
;
440 dbg("%s - port %d", __func__
, port
->number
);
443 * The empeg-car player wants these particular tty settings.
444 * You could, for example, change the baud rate, however the
445 * player only supports 115200 (currently), so there is really
446 * no point in support for changes to the tty settings.
449 * The default requirements for this device are:
452 &= ~(IGNBRK
/* disable ignore break */
453 | BRKINT
/* disable break causes interrupt */
454 | PARMRK
/* disable mark parity errors */
455 | ISTRIP
/* disable clear high bit of input characters */
456 | INLCR
/* disable translate NL to CR */
457 | IGNCR
/* disable ignore CR */
458 | ICRNL
/* disable translate CR to NL */
459 | IXON
); /* disable enable XON/XOFF flow control */
462 &= ~OPOST
; /* disable postprocess output characters */
465 &= ~(ECHO
/* disable echo input characters */
466 | ECHONL
/* disable echo new line */
467 | ICANON
/* disable erase, kill, werase, and rprnt special characters */
468 | ISIG
/* disable interrupt, quit, and suspend special characters */
469 | IEXTEN
); /* disable non-POSIX special characters */
472 &= ~(CSIZE
/* no size */
473 | PARENB
/* disable parity bit */
474 | CBAUD
); /* clear current baud rate */
477 |= CS8
; /* character size 8 bits */
479 tty_encode_baud_rate(tty
, 115200, 115200);
483 static int __init
empeg_init(void)
488 /* create our write urb pool and transfer buffers */
489 spin_lock_init(&write_urb_pool_lock
);
490 for (i
= 0; i
< NUM_URBS
; ++i
) {
491 urb
= usb_alloc_urb(0, GFP_KERNEL
);
492 write_urb_pool
[i
] = urb
;
494 printk(KERN_ERR
"empeg: No more urbs???\n");
498 urb
->transfer_buffer
= kmalloc(URB_TRANSFER_BUFFER_SIZE
,
500 if (!urb
->transfer_buffer
) {
501 printk(KERN_ERR
"empeg: %s - out of memory for urb "
502 "buffers.", __func__
);
507 retval
= usb_serial_register(&empeg_device
);
509 goto failed_usb_serial_register
;
510 retval
= usb_register(&empeg_driver
);
512 goto failed_usb_register
;
514 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
519 usb_serial_deregister(&empeg_device
);
520 failed_usb_serial_register
:
521 for (i
= 0; i
< NUM_URBS
; ++i
) {
522 if (write_urb_pool
[i
]) {
523 kfree(write_urb_pool
[i
]->transfer_buffer
);
524 usb_free_urb(write_urb_pool
[i
]);
531 static void __exit
empeg_exit(void)
536 usb_deregister(&empeg_driver
);
537 usb_serial_deregister(&empeg_device
);
539 spin_lock_irqsave(&write_urb_pool_lock
, flags
);
541 for (i
= 0; i
< NUM_URBS
; ++i
) {
542 if (write_urb_pool
[i
]) {
543 /* FIXME - uncomment the following usb_kill_urb call
544 * when the host controllers get fixed to set urb->dev
545 * = NULL after the urb is finished. Otherwise this
547 /* usb_kill_urb(write_urb_pool[i]); */
548 kfree(write_urb_pool
[i
]->transfer_buffer
);
549 usb_free_urb(write_urb_pool
[i
]);
552 spin_unlock_irqrestore(&write_urb_pool_lock
, flags
);
556 module_init(empeg_init
);
557 module_exit(empeg_exit
);
559 MODULE_AUTHOR(DRIVER_AUTHOR
);
560 MODULE_DESCRIPTION(DRIVER_DESC
);
561 MODULE_LICENSE("GPL");
563 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
564 MODULE_PARM_DESC(debug
, "Debug enabled or not");