Loading...
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 | /*
* USB ZyXEL omni.net LCD PLUS driver
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* See Documentation/usb/usb-serial.txt for more information on using this driver
*
* Please report both successes and troubles to the author at omninet@kroah.com
*
* (11/01/2000) Adam J. Richter
* usb_device_id table support
*
* (10/05/2000) gkh
* Fixed bug with urb->dev not being set properly, now that the usb
* core needs it.
*
* (08/28/2000) gkh
* Added locks for SMP safeness.
* Fixed MOD_INC and MOD_DEC logic and the ability to open a port more
* than once.
* Fixed potential race in omninet_write_bulk_callback
*
* (07/19/2000) gkh
* Added module_init and module_exit functions to handle the fact that this
* driver is a loadable module now.
*
*/
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/signal.h>
#include <linux/errno.h>
#include <linux/poll.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/fcntl.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#ifdef CONFIG_USB_SERIAL_DEBUG
#define isalpha(x) ( ( x > 96 && x < 123) || ( x > 64 && x < 91) || (x > 47 && x < 58) )
#define DEBUG
#else
#undef DEBUG
#endif
#include <linux/usb.h>
#include "usb-serial.h"
#define ZYXEL_VENDOR_ID 0x0586
#define ZYXEL_OMNINET_ID 0x1000
/* function prototypes */
static int omninet_open (struct usb_serial_port *port, struct file *filp);
static void omninet_close (struct usb_serial_port *port, struct file *filp);
static void omninet_read_bulk_callback (struct urb *urb);
static void omninet_write_bulk_callback (struct urb *urb);
static int omninet_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count);
static int omninet_write_room (struct usb_serial_port *port);
static void omninet_shutdown (struct usb_serial *serial);
static __devinitdata struct usb_device_id id_table [] = {
{ USB_DEVICE(ZYXEL_VENDOR_ID, ZYXEL_OMNINET_ID) },
{ } /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, id_table);
struct usb_serial_device_type zyxel_omninet_device = {
name: "ZyXEL - omni.net lcd plus usb",
id_table: id_table,
needs_interrupt_in: MUST_HAVE,
needs_bulk_in: MUST_HAVE,
needs_bulk_out: MUST_HAVE,
num_interrupt_in: 1,
num_bulk_in: 1,
num_bulk_out: 2,
num_ports: 1,
open: omninet_open,
close: omninet_close,
write: omninet_write,
write_room: omninet_write_room,
read_bulk_callback: omninet_read_bulk_callback,
write_bulk_callback: omninet_write_bulk_callback,
shutdown: omninet_shutdown,
};
/* The protocol.
*
* The omni.net always exchange 64 bytes of data with the host. The first
* four bytes are the control header, you can see it in the above structure.
*
* oh_seq is a sequence number. Don't know if/how it's used.
* oh_len is the length of the data bytes in the packet.
* oh_xxx Bit-mapped, related to handshaking and status info.
* I normally set it to 0x03 in trasmitted frames.
* 7: Active when the TA is in a CONNECTed state.
* 6: unknown
* 5: handshaking, unknown
* 4: handshaking, unknown
* 3: unknown, usually 0
* 2: unknown, usually 0
* 1: handshaking, unknown, usually set to 1 in trasmitted frames
* 0: handshaking, unknown, usually set to 1 in trasmitted frames
* oh_pad Probably a pad byte.
*
* After the header you will find data bytes if oh_len was greater than zero.
*
*/
struct omninet_header
{
__u8 oh_seq;
__u8 oh_len;
__u8 oh_xxx;
__u8 oh_pad;
};
struct omninet_data
{
__u8 od_outseq; // Sequence number for bulk_out URBs
};
static int omninet_open (struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial;
struct usb_serial_port *wport;
struct omninet_data *od;
unsigned long flags;
int result;
if (port_paranoia_check (port, __FUNCTION__))
return -ENODEV;
dbg(__FUNCTION__ " - port %d", port->number);
serial = get_usb_serial (port, __FUNCTION__);
if (!serial)
return -ENODEV;
spin_lock_irqsave (&port->port_lock, flags);
MOD_INC_USE_COUNT;
++port->open_count;
if (!port->active) {
port->active = 1;
od = kmalloc( sizeof(struct omninet_data), GFP_KERNEL );
if( !od ) {
err(__FUNCTION__"- kmalloc(%d) failed.", sizeof(struct omninet_data));
--port->open_count;
port->active = 0;
spin_unlock_irqrestore (&port->port_lock, flags);
MOD_DEC_USE_COUNT;
return -ENOMEM;
}
port->private = od;
wport = &serial->port[1];
wport->tty = port->tty;
/* Start reading from the device */
FILL_BULK_URB(port->read_urb, serial->dev,
usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
omninet_read_bulk_callback, port);
result = usb_submit_urb(port->read_urb);
if (result)
err(__FUNCTION__ " - failed submitting read urb, error %d", result);
}
spin_unlock_irqrestore (&port->port_lock, flags);
return (0);
}
static void omninet_close (struct usb_serial_port *port, struct file * filp)
{
struct usb_serial *serial;
struct usb_serial_port *wport;
struct omninet_data *od;
unsigned long flags;
if (port_paranoia_check (port, __FUNCTION__))
return;
dbg(__FUNCTION__ " - port %d", port->number);
serial = get_usb_serial (port, __FUNCTION__);
if (!serial)
return;
spin_lock_irqsave (&port->port_lock, flags);
--port->open_count;
MOD_DEC_USE_COUNT;
if (port->open_count <= 0) {
od = (struct omninet_data *)port->private;
wport = &serial->port[1];
usb_unlink_urb (wport->write_urb);
usb_unlink_urb (port->read_urb);
port->active = 0;
port->open_count = 0;
if (od)
kfree(od);
}
spin_unlock_irqrestore (&port->port_lock, flags);
}
#define OMNINET_DATAOFFSET 0x04
#define OMNINET_HEADERLEN sizeof(struct omninet_header)
#define OMNINET_BULKOUTSIZE (64 - OMNINET_HEADERLEN)
static void omninet_read_bulk_callback (struct urb *urb)
{
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
unsigned char *data = urb->transfer_buffer;
struct omninet_header *header = (struct omninet_header *) &data[0];
int i;
int result;
// dbg("omninet_read_bulk_callback");
if (!serial) {
dbg(__FUNCTION__ " - bad serial pointer, exiting");
return;
}
if (urb->status) {
dbg(__FUNCTION__ " - nonzero read bulk status received: %d", urb->status);
return;
}
#ifdef DEBUG
if(header->oh_xxx != 0x30) {
if (urb->actual_length) {
printk (KERN_DEBUG __FILE__ ": omninet_read %d: ", header->oh_len);
for (i = 0; i < (header->oh_len + OMNINET_HEADERLEN); i++) {
printk ("%.2x ", data[i]);
}
printk ("\n");
}
}
#endif
if (urb->actual_length && header->oh_len) {
for (i = 0; i < header->oh_len; i++) {
tty_insert_flip_char(port->tty, data[OMNINET_DATAOFFSET + i], 0);
}
tty_flip_buffer_push(port->tty);
}
/* Continue trying to always read */
FILL_BULK_URB(urb, serial->dev,
usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
urb->transfer_buffer, urb->transfer_buffer_length,
omninet_read_bulk_callback, port);
result = usb_submit_urb(urb);
if (result)
err(__FUNCTION__ " - failed resubmitting read urb, error %d", result);
return;
}
static int omninet_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count)
{
struct usb_serial *serial = port->serial;
struct usb_serial_port *wport = &serial->port[1];
struct omninet_data *od = (struct omninet_data *) port->private;
struct omninet_header *header = (struct omninet_header *) wport->write_urb->transfer_buffer;
unsigned long flags;
int result;
// dbg("omninet_write port %d", port->number);
if (count == 0) {
dbg(__FUNCTION__" - write request of 0 bytes");
return (0);
}
if (wport->write_urb->status == -EINPROGRESS) {
dbg (__FUNCTION__" - already writing");
return (0);
}
usb_serial_debug_data (__FILE__, __FUNCTION__, count, buf);
spin_lock_irqsave (&port->port_lock, flags);
count = (count > OMNINET_BULKOUTSIZE) ? OMNINET_BULKOUTSIZE : count;
if (from_user) {
copy_from_user(wport->write_urb->transfer_buffer + OMNINET_DATAOFFSET, buf, count);
}
else {
memcpy (wport->write_urb->transfer_buffer + OMNINET_DATAOFFSET, buf, count);
}
header->oh_seq = od->od_outseq++;
header->oh_len = count;
header->oh_xxx = 0x03;
header->oh_pad = 0x00;
/* send the data out the bulk port, always 64 bytes */
wport->write_urb->transfer_buffer_length = 64;
wport->write_urb->dev = serial->dev;
result = usb_submit_urb(wport->write_urb);
if (result) {
err(__FUNCTION__ " - failed submitting write urb, error %d", result);
spin_unlock_irqrestore (&port->port_lock, flags);
return 0;
}
// dbg("omninet_write returns %d", count);
spin_unlock_irqrestore (&port->port_lock, flags);
return (count);
}
static int omninet_write_room (struct usb_serial_port *port)
{
struct usb_serial *serial = port->serial;
struct usb_serial_port *wport = &serial->port[1];
int room = 0; // Default: no room
if (wport->write_urb->status != -EINPROGRESS)
room = wport->bulk_out_size - OMNINET_HEADERLEN;
// dbg("omninet_write_room returns %d", room);
return (room);
}
static void omninet_write_bulk_callback (struct urb *urb)
{
/* struct omninet_header *header = (struct omninet_header *) urb->transfer_buffer; */
struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
struct usb_serial *serial;
// dbg("omninet_write_bulk_callback, port %0x\n", port);
if (port_paranoia_check (port, __FUNCTION__)) {
return;
}
serial = port->serial;
if (serial_paranoia_check (serial, __FUNCTION__)) {
return;
}
if (urb->status) {
dbg(__FUNCTION__" - nonzero write bulk status received: %d", urb->status);
return;
}
queue_task(&port->tqueue, &tq_immediate);
mark_bh(IMMEDIATE_BH);
// dbg("omninet_write_bulk_callback, tty %0x\n", tty);
return;
}
static void omninet_shutdown (struct usb_serial *serial)
{
dbg (__FUNCTION__);
while (serial->port[0].open_count > 0) {
omninet_close (&serial->port[0], NULL);
}
}
static int __init omninet_init (void)
{
usb_serial_register (&zyxel_omninet_device);
return 0;
}
static void __exit omninet_exit (void)
{
usb_serial_deregister (&zyxel_omninet_device);
}
module_init(omninet_init);
module_exit(omninet_exit);
|