drivers/usb/acm.c

   1 /*
   2  * USB Abstract Control Model based on Brad Keryan's USB busmouse driver
   3  *
   4  * (C) Copyright 1999 Armin Fuerst <fuerst@in.tum.de>
   5  * (C) Copyright 1999 Pavel Machek <pavel@suse.cz>
   6  * (C) Copyright 1999 Johannes Erdfelt <jerdfelt@valinux.com>
   7  *
   8  * version 0.9: Johanness Erdfelt converted this to urb interface.
   9  *
  10  * version 0.8: Fixed endianity bug, some cleanups. I really hate to have
  11  * half of driver in form if (...) { info("x"); return y; }
  12  *                                              Pavel Machek <pavel@suse.cz>
  13  *
  14  * version 0.7: Added usb flow control. Fixed bug in uhci.c (what idiot
  15  * wrote this code? ...Oops that was me). Fixed module cleanup. Did some
  16  * testing at 3Com => zmodem uload+download works, pppd had trouble but
  17  * seems to work now. Changed Menuconfig texts "Communications Device
  18  * Class (ACM)" might be a bit more intuitive. Ported to 2.3.13-1 prepatch.
  19  * (2/8/99)
  20  *
  21  * version 0.6: Modularized driver, added disconnect code, improved
  22  * assignment of device to tty minor number.
  23  * (21/7/99)
  24  *
  25  * version 0.5: Driver now generates a tty instead of a simple character
  26  * device. Moved async bulk transfer to 2.3.10 kernel version. fixed a bug
  27  * in uhci_td_allocate. Commenetd out getstringtable which causes crash.
  28  * (13/7/99)
  29  *
  30  * version 0.4: Small fixes in the FIFO, cleanup. Updated Bulk transfer in
  31  * uhci.c. Should have the correct interface now.
  32  * (6/6/99)
  33  *
  34  * version 0.3: Major changes. Changed Bulk transfer to interrupt based
  35  * transfer. Using FIFO Buffers now. Consistent handling of open/close
  36  * file state and detected/nondetected device. File operations behave
  37  * according to this. Driver is able to send+receive now! Heureka!
  38  * (27/5/99)
  39  *
  40  * version 0.2: Improved Bulk transfer. TX led now flashes every time data is
  41  * sent. Send Encapsulated Data is not needed, nor does it do anything.
  42  * Why's that ?!? Thanks to Thomas Sailer for his close look at the bulk code.
  43  * He told me about some importand bugs. (5/21/99)
  44  *
  45  * version 0.1: Bulk transfer for uhci seems to work now, no dangling tds any
  46  * more. TX led of the ISDN TA flashed the first time. Does this mean it works?
  47  * The interrupt of the ctrl endpoint crashes the kernel => no read possible
  48  * (5/19/99)
  49  *
  50  * version 0.0: Driver sets up configuration, sets up data pipes, opens misc
  51  * device. No actual data transfer is done, since we don't have bulk transfer,
  52  * yet. Purely skeleton for now. (5/8/99)
  53  */
  54
  55 #include <linux/kernel.h>
  56 #include <linux/sched.h>
  57 #include <linux/signal.h>
  58 #include <linux/errno.h>
  59 #include <linux/poll.h>
  60 #include <linux/init.h>
  61 #include <linux/malloc.h>
  62 #include <linux/fcntl.h>
  63 #include <linux/tty_driver.h>
  64 #include <linux/tty_flip.h>
  65 #include <linux/tty.h>
  66 #include <linux/module.h>
  67
  68 #include "usb.h"
  69
  70 #define NR_PORTS 3
  71 #define ACM_MAJOR 166   /* Wow, major is now officially allocated */
  72
  73 //#define info(message...) printk(KERN_DEBUG message)
  74 #define info(message...)
  75
  76 #define CTRL_STAT_DTR   1
  77 #define CTRL_STAT_RTS   2
  78
  79 static struct usb_driver acm_driver;
  80
  81 static int acm_refcount;
  82
  83 static struct tty_driver acm_tty_driver;
  84 static struct tty_struct *acm_tty[NR_PORTS];
  85 static struct termios *acm_termios[NR_PORTS];
  86 static struct termios *acm_termios_locked[NR_PORTS];
  87 static struct acm_state acm_state_table[NR_PORTS];
  88
  89 struct acm_state {
  90         struct usb_device *dev;                         //the coresponding usb device
  91         int cfgnum;                                     //configuration number on this device
  92         struct tty_struct *tty;                         //the coresponding tty
  93         char present;                                   //a device for this struct was detected => this tty is used
  94         char active;                                    //someone has this acm's device open
  95         unsigned int ctrlstate;                         //Status of the serial control lines  (handshake,...)
  96         unsigned int linecoding;                        //Status of the line coding (Bits, Stop, Parity)
  97         int writesize, readsize, ctrlsize;              //size of the usb buffers
  98         char *writebuffer, *readbuffer, *ctrlbuffer;    //the usb buffers
  99         char writing, reading;                          //flag if transfer is running
 100         unsigned int readendp,writeendp,ctrlendp;       //endpoints and
 101         unsigned int readpipe,writepipe,ctrlpipe;       //pipes (are one of these obsolete?)
 102         urb_t *readurb, *writeurb, *ctrlurb;
 103         unsigned ctrlinterval;                          //interval to poll from device
 104 };
 105
 106 #define ACM_READY (acm->present && acm->active)
 107
 108 //functions for various ACM requests
 109
 110 void Set_Control_Line_Status(unsigned int status, struct acm_state *acm)
 111 {
 112         struct usb_device *dev = acm->dev;
 113         int ret;
 114
 115         info("Set_control_Line_Status\n");
 116
 117         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0x22, 0x22,
 118                 status, 0, NULL, 0, HZ);
 119         if (ret < 0)
 120                 printk(KERN_ERR "acm: Set_Control_Line_Status failed\n");
 121
 122         acm->ctrlstate = status;
 123 }
 124
 125 void Set_Line_Coding(unsigned int coding, struct acm_state *acm)
 126 {
 127         struct usb_device *dev = acm->dev;
 128         int ret;
 129
 130         info("Set_Line_Coding\n");
 131
 132         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), 0x30, 0x22,
 133                 coding, 0, NULL, 0, HZ);
 134
 135         acm->linecoding = coding;
 136 }
 137
 138 //Interrupt handler for various usb events
 139 static void acm_irq(urb_t *urb)
 140 {
 141         struct acm_state *acm = (struct acm_state *)urb->context;
 142         unsigned char *data = urb->transfer_buffer;
 143         devrequest *dr;
 144
 145         info("ACM_USB_IRQ\n");
 146
 147         if (urb->status < 0) {
 148                 printk(KERN_DEBUG "acm_irq: strange status received: %d\n", urb->status);
 149                 return;
 150         }
 151
 152         if (!acm->present)
 153                 return;
 154         if (!acm->active)
 155                 return;
 156
 157         dr = (devrequest *)data;
 158         data += sizeof(dr);
 159
 160 #if 0
 161         printk("reqtype: %02X\n",dr->requesttype);
 162         printk("request: %02X\n",dr->request);
 163         printk("wValue: %02X\n",dr->value);
 164         printk("wIndex: %02X\n",dr->index);
 165         printk("wLength: %02X\n",dr->length);
 166 #endif
 167
 168         switch(dr->request) {
 169         case 0x00: /* Network connection */
 170                 printk(KERN_DEBUG "Network connection: ");
 171                 if (dr->request==0) printk(KERN_DEBUG "disconnected\n");
 172                 if (dr->request==1) printk(KERN_DEBUG "connected\n");
 173                 break;
 174
 175         case 0x01: /* Response available */
 176                 printk(KERN_DEBUG "Response available\n");
 177                 break;
 178
 179         case 0x20: /* Set serial line state */
 180                 printk(KERN_DEBUG "acm.c: Set serial control line state\n");
 181                 if ((dr->index==1) && (dr->length==2)) {
 182                         acm->ctrlstate = data[0] || (data[1] << 16);
 183                         printk(KERN_DEBUG "Serstate: %02X\n", acm->ctrlstate);
 184                 }
 185                 break;
 186         }
 187
 188         return;
 189 }
 190
 191 static void acm_read_irq(urb_t *urb)
 192 {
 193         struct acm_state *acm = (struct acm_state *)urb->context;
 194         struct tty_struct *tty = acm->tty;
 195         unsigned char *data = acm->readbuffer;
 196         int i;
 197
 198         info("ACM_READ_IRQ: state %d, %d bytes\n", urb->status, urb->actual_length);
 199         if (urb->status) {
 200                 printk("acm_read_irq: strange state received: %d\n", urb->status);
 201                 return;
 202         }
 203
 204         if (!ACM_READY)
 205                 return;
 206
 207         for (i=0;i<urb->actual_length;i++)
 208                 tty_insert_flip_char(tty,data[i],0);
 209         tty_flip_buffer_push(tty);
 210
 211         usb_submit_urb(urb);
 212
 213         return;
 214 }
 215
 216 static void acm_write_irq(urb_t *urb)
 217 {
 218         struct acm_state *acm = (struct acm_state *)urb->context;
 219         struct tty_struct *tty = acm->tty;
 220
 221         info("ACM_WRITE_IRQ\n");
 222
 223         if (!ACM_READY)
 224                 return;
 225
 226         acm->writing = 0;
 227         if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup)
 228                 (tty->ldisc.write_wakeup)(tty);
 229         wake_up_interruptible(&tty->write_wait);
 230
 231         return;
 232 }
 233
 234 /*TTY STUFF*/
 235 static int rs_open(struct tty_struct *tty, struct file *filp)
 236 {
 237         struct acm_state *acm;
 238         int ret;
 239
 240         info("USB_FILE_OPEN\n");
 241
 242         tty->driver_data = acm =
 243                 &acm_state_table[MINOR(tty->device) - tty->driver.minor_start];
 244         acm->tty = tty;
 245
 246         if (!acm->present)
 247                 return -EINVAL;
 248
 249         if (acm->active++)
 250                 return 0;
 251
 252         MOD_INC_USE_COUNT;
 253
 254         /* Start reading from the device */
 255         FILL_INT_URB(acm->ctrlurb, acm->dev, acm->ctrlpipe,
 256                 acm->ctrlbuffer, acm->ctrlsize,
 257                 acm_irq, acm, acm->ctrlinterval);
 258         ret = usb_submit_urb(acm->ctrlurb);
 259         if (ret)
 260                 printk(KERN_ERR "acm: usb_submit_urb(INT) failed (%d)\n", ret);
 261         acm->reading = 1;
 262
 263         FILL_BULK_URB(acm->readurb, acm->dev, acm->readpipe, acm->readbuffer,
 264                 acm->readsize, acm_read_irq, acm);
 265         ret = usb_submit_urb(acm->readurb);
 266
 267         if (ret)
 268                 printk(KERN_ERR "acm: usb_submit_urb(READ) failed (%d)\n", ret);
 269         acm->reading = 1;
 270
 271         Set_Control_Line_Status(CTRL_STAT_DTR | CTRL_STAT_RTS, acm);
 272
 273         return 0;
 274 }
 275
 276 static void rs_close(struct tty_struct *tty, struct file *filp)
 277 {
 278         struct acm_state *acm = (struct acm_state *)tty->driver_data;
 279
 280         info("rs_close\n");
 281
 282         if (!acm->present)
 283                 return;
 284
 285         if (--acm->active)
 286                 goto early;
 287
 288         Set_Control_Line_Status(0, acm);
 289
 290         if (acm->writing) {
 291                 if (acm->writeurb)
 292                         usb_unlink_urb(acm->writeurb);
 293                 acm->writing = 0;
 294         }
 295         if (acm->reading) {
 296                 if (acm->readurb)
 297                         usb_unlink_urb(acm->readurb);
 298                 acm->reading = 0;
 299         }
 300
 301 early:
 302         MOD_DEC_USE_COUNT;
 303 }
 304
 305 static int rs_write(struct tty_struct *tty, int from_user,
 306                     const unsigned char *buf, int count)
 307 {
 308         struct acm_state *acm = (struct acm_state *)tty->driver_data;
 309         int written, ret;
 310
 311         info("rs_write\n");
 312
 313         if (!ACM_READY)
 314                 return -EINVAL;
 315
 316         if (acm->writing) {
 317                 info("already writing\n");
 318                 return 0;
 319         }
 320
 321         written = (count>acm->writesize) ? acm->writesize : count;
 322
 323         if (from_user)
 324                 copy_from_user(acm->writebuffer, buf, written);
 325         else
 326                 memcpy(acm->writebuffer, buf, written);
 327
 328         //start the transfer
 329         acm->writing = 1;
 330
 331         FILL_BULK_URB(acm->writeurb, acm->dev, acm->writepipe, acm->writebuffer,
 332                 written, acm_write_irq, acm);
 333         ret = usb_submit_urb(acm->writeurb);
 334         if (ret)
 335                 printk("acm: usb_submit_urb(WRITE) failed: %d\n", ret);
 336
 337         return written;
 338 }
 339
 340 static void rs_put_char(struct tty_struct *tty, unsigned char ch)
 341 {
 342         printk(KERN_DEBUG "acm: rs_put_char: Who called this unsupported routine?\n");
 343         BUG();
 344 }
 345
 346 static int rs_write_room(struct tty_struct *tty)
 347 {
 348         struct acm_state *acm = (struct acm_state *)tty->driver_data;
 349
 350         info("rs_write_room\n");
 351
 352         if (!ACM_READY)
 353                 return -EINVAL;
 354
 355         return acm->writing ? 0 : acm->writesize;
 356 }
 357
 358 static int rs_chars_in_buffer(struct tty_struct *tty)
 359 {
 360         struct acm_state *acm = (struct acm_state *)tty->driver_data;
 361
 362 //      info("rs_chars_in_buffer\n");
 363
 364         if (!ACM_READY)
 365                 return -EINVAL;
 366
 367         return acm->writing ? acm->writesize : 0;
 368 }
 369
 370 static void rs_throttle(struct tty_struct *tty)
 371 {
 372         struct acm_state *acm = (struct acm_state *)tty->driver_data;
 373
 374         info("rs_throttle\n");
 375
 376         if (!ACM_READY)
 377                 return;
 378 /*
 379         if (I_IXOFF(tty))
 380                 rs_send_xchar(tty, STOP_CHAR(tty));
 381 */
 382         if (tty->termios->c_cflag & CRTSCTS)
 383                 Set_Control_Line_Status(acm->ctrlstate & ~CTRL_STAT_RTS, acm);
 384 }
 385
 386 static void rs_unthrottle(struct tty_struct *tty)
 387 {
 388         struct acm_state *acm = (struct acm_state *) tty->driver_data;
 389
 390         info("rs_unthrottle\n");
 391
 392         if (!ACM_READY)
 393                 return;
 394 /*
 395         if (I_IXOFF(tty))
 396                 rs_send_xchar(tty, STOP_CHAR(tty));
 397 */
 398         if (tty->termios->c_cflag & CRTSCTS)
 399                 Set_Control_Line_Status(acm->ctrlstate | CTRL_STAT_RTS, acm);
 400 }
 401
 402 static int get_free_acm(void)
 403 {
 404         int i;
 405
 406         for (i = 0; i < NR_PORTS; i++) {
 407                 if (!acm_state_table[i].present)
 408                         return i;
 409         }
 410         return -1;
 411 }
 412
 413 static void * acm_probe(struct usb_device *dev, unsigned int ifnum)
 414 {
 415         struct acm_state *acm;
 416         struct usb_interface_descriptor *interface;
 417         struct usb_endpoint_descriptor *endpoint;
 418         int cfgnum,acmno;
 419         int swapped=0;
 420
 421         info("acm_probe\n");
 422
 423         if (0>(acmno=get_free_acm())) {
 424                 info("Too many acm devices connected\n");
 425                 return NULL;
 426         }
 427         acm = &acm_state_table[acmno];
 428
 429         /* Only use CDC */
 430         if (dev->descriptor.bDeviceClass != 2 ||
 431             dev->descriptor.bDeviceSubClass != 0 ||
 432             dev->descriptor.bDeviceProtocol != 0)
 433                 return NULL;
 434
 435 #define IFCLASS(if) ((if->bInterfaceClass << 24) | (if->bInterfaceSubClass << 16) | (if->bInterfaceProtocol << 8) | (if->bNumEndpoints))
 436
 437         /* FIXME: should the driver really be doing the configuration
 438          * selecting or should the usbcore?  [different configurations
 439          * can have different bandwidth requirements] -greg */
 440
 441         printk("Acm: found device with right class...\n" );
 442
 443         /* Now scan all configs for a ACM configuration */
 444         for (cfgnum=0;cfgnum<dev->descriptor.bNumConfigurations;cfgnum++) {
 445                 /* The first one should be Communications interface? */
 446                 interface = &dev->config[cfgnum].interface[0].altsetting[0];
 447                 if (IFCLASS(interface) != 0x02020101)
 448                         continue;
 449
 450                 /* Which uses an interrupt input */
 451                 endpoint = &interface->endpoint[0];
 452                 if ((endpoint->bEndpointAddress & 0x80) != 0x80 ||
 453                     (endpoint->bmAttributes & 3) != 3)
 454                         continue;
 455
 456                 /* The second one should be a Data interface? */
 457                 interface = &dev->config[cfgnum].interface[1].altsetting[0];
 458                 if (interface->bInterfaceClass != 10 ||
 459                     interface->bNumEndpoints != 2)
 460                         continue;
 461
 462                 /* make sure both interfaces are available for our use */
 463                 if (usb_interface_claimed(&dev->config[cfgnum].interface[0]) ||
 464                     usb_interface_claimed(&dev->config[cfgnum].interface[1])) {
 465                         printk("usb-acm: required interface already has a driver\n");
 466                         continue;
 467                 }
 468
 469                 endpoint = &interface->endpoint[0];
 470                 if ((endpoint->bEndpointAddress & 0x80) != 0x80)
 471                         swapped = 1;
 472
 473                 /*With a bulk input */
 474                 endpoint = &interface->endpoint[0^swapped];
 475                 if ((endpoint->bEndpointAddress & 0x80) != 0x80 ||
 476                     (endpoint->bmAttributes & 3) != 2)
 477                         continue;
 478
 479                 /*And a bulk output */
 480                 endpoint = &interface->endpoint[1^swapped];
 481                 if ((endpoint->bEndpointAddress & 0x80) == 0x80 ||
 482                     (endpoint->bmAttributes & 3) != 2)
 483                         continue;
 484
 485                 printk("USB ACM %d found on config %d\n", acmno, cfgnum);
 486                 usb_set_configuration(dev, dev->config[cfgnum].bConfigurationValue);
 487
 488                 acm->dev=dev;
 489
 490                 acm->readendp=dev->config[cfgnum].interface[1].altsetting[0].endpoint[0^swapped].bEndpointAddress;
 491                 acm->readpipe=usb_rcvbulkpipe(dev,acm->readendp);
 492                 acm->readbuffer=kmalloc(acm->readsize=dev->config[cfgnum].interface[1].altsetting[0].endpoint[0^swapped].wMaxPacketSize,GFP_KERNEL);
 493                 acm->reading=0;
 494                 if (!acm->readbuffer) {
 495                         printk("ACM: Couldn't allocate readbuffer\n");
 496                         return NULL;
 497                 }
 498                 acm->readurb = usb_alloc_urb(0);
 499                 if (!acm->readurb) {
 500                         printk("acm: couldn't allocate read urb\n");
 501                         return NULL;
 502                 }
 503
 504                 acm->writeendp=dev->config[cfgnum].interface[1].altsetting[0].endpoint[1^swapped].bEndpointAddress;
 505                 acm->writepipe=usb_sndbulkpipe(dev,acm->writeendp);
 506                 acm->writebuffer=kmalloc(acm->writesize=dev->config[cfgnum].interface[1].altsetting[0].endpoint[1^swapped].wMaxPacketSize, GFP_KERNEL);
 507                 acm->writing=0;
 508                 if (!acm->writebuffer) {
 509                         printk("ACM: Couldn't allocate writebuffer\n");
 510                         kfree(acm->readbuffer);
 511                         return NULL;
 512                 }
 513                 acm->writeurb = usb_alloc_urb(0);
 514                 if (!acm->writeurb) {
 515                         printk("acm: couldn't allocate write urb\n");
 516                         return NULL;
 517                 }
 518
 519                 acm->ctrlbuffer=kmalloc(acm->ctrlsize=dev->config[cfgnum].interface[0].altsetting[0].endpoint[0].wMaxPacketSize, GFP_KERNEL);
 520                 acm->ctrlendp=dev->config[cfgnum].interface[0].altsetting[0].endpoint[0].bEndpointAddress;
 521                 acm->ctrlpipe=usb_rcvintpipe(acm->dev,acm->ctrlendp);
 522                 acm->ctrlinterval=dev->config[cfgnum].interface[0].altsetting[0].endpoint[0].bInterval;
 523                 if (!acm->ctrlbuffer) {
 524                         printk("acm: couldn't allocate ctrlbuffer\n");
 525                         return NULL;
 526                 }
 527                 acm->ctrlurb = usb_alloc_urb(0);
 528                 if (!acm->ctrlurb) {
 529                         printk("acm: couldn't allocate write urb\n");
 530                         return NULL;
 531                 }
 532
 533                 acm->cfgnum = cfgnum;
 534                 acm->present=1;
 535                 MOD_INC_USE_COUNT;
 536
 537                 usb_driver_claim_interface(&acm_driver,
 538                                 &dev->config[cfgnum].interface[0], acm);
 539                 usb_driver_claim_interface(&acm_driver,
 540                                 &dev->config[cfgnum].interface[1], acm);
 541                 return acm;
 542         }
 543         return NULL;
 544 }
 545
 546 static void acm_disconnect(struct usb_device *dev, void *ptr)
 547 {
 548         struct acm_state *acm = ptr;
 549
 550         info("acm_disconnect\n");
 551
 552         if (!acm->present)
 553                 return;
 554
 555         acm->active=0;
 556         acm->present=0;
 557         if (acm->writing)
 558                 acm->writing=0;
 559         if (acm->reading)
 560                 acm->reading=0;
 561
 562         if (acm->ctrlurb) {
 563                 usb_unlink_urb(acm->ctrlurb);
 564                 usb_free_urb(acm->ctrlurb);
 565                 acm->ctrlurb = NULL;
 566         }
 567         if (acm->readurb) {
 568                 usb_unlink_urb(acm->readurb);
 569                 usb_free_urb(acm->readurb);
 570                 acm->readurb = NULL;
 571         }
 572         if (acm->writeurb) {
 573                 usb_unlink_urb(acm->writeurb);
 574                 usb_free_urb(acm->writeurb);
 575                 acm->writeurb = NULL;
 576         }
 577         //BUG: What to do if a device is open?? Notify process or not allow cleanup?
 578         kfree(acm->writebuffer);
 579         kfree(acm->readbuffer);
 580         kfree(acm->ctrlbuffer);
 581
 582         /* release the interfaces so that other drivers can have at them */
 583         usb_driver_release_interface(&acm_driver,
 584                                 &dev->config[acm->cfgnum].interface[0]);
 585         usb_driver_release_interface(&acm_driver,
 586                                 &dev->config[acm->cfgnum].interface[1]);
 587
 588         MOD_DEC_USE_COUNT;
 589 }
 590
 591 /*USB DRIVER STUFF*/
 592 static struct usb_driver acm_driver = {
 593         "acm",
 594         acm_probe,
 595         acm_disconnect,
 596         { NULL, NULL }
 597 };
 598
 599 int usb_acm_init(void)
 600 {
 601         int cnt;
 602
 603         info("usb_acm_init\n");
 604
 605         //INITIALIZE GLOBAL DATA STRUCTURES
 606         for (cnt = 0; cnt < NR_PORTS; cnt++)
 607                 memset(&acm_state_table[cnt], 0, sizeof(struct acm_state));
 608
 609         //REGISTER TTY DRIVER
 610         memset(&acm_tty_driver, 0, sizeof(struct tty_driver));
 611         acm_tty_driver.magic = TTY_DRIVER_MAGIC;
 612         acm_tty_driver.driver_name = "usb";
 613         acm_tty_driver.name = "ttyACM";
 614         acm_tty_driver.major = ACM_MAJOR;
 615         acm_tty_driver.minor_start = 0;
 616         acm_tty_driver.num = NR_PORTS;
 617         acm_tty_driver.type = TTY_DRIVER_TYPE_SERIAL;
 618         acm_tty_driver.subtype = SERIAL_TYPE_NORMAL;
 619         acm_tty_driver.init_termios = tty_std_termios;
 620         acm_tty_driver.init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 621         acm_tty_driver.flags = TTY_DRIVER_REAL_RAW;
 622         acm_tty_driver.refcount = &acm_refcount;
 623         acm_tty_driver.table = acm_tty;
 624         acm_tty_driver.termios = acm_termios;
 625         acm_tty_driver.termios_locked = acm_termios_locked;
 626
 627         acm_tty_driver.open = rs_open;
 628         acm_tty_driver.close = rs_close;
 629         acm_tty_driver.write = rs_write;
 630         acm_tty_driver.put_char = rs_put_char;
 631         acm_tty_driver.flush_chars = NULL; //rs_flush_chars;
 632         acm_tty_driver.write_room = rs_write_room;
 633         acm_tty_driver.ioctl = NULL; //rs_ioctl
 634         acm_tty_driver.set_termios = NULL; //rs_set_termios;
 635         acm_tty_driver.set_ldisc = NULL;
 636         acm_tty_driver.throttle = rs_throttle;
 637         acm_tty_driver.unthrottle = rs_unthrottle;
 638         acm_tty_driver.stop = NULL; //rs_stop;
 639         acm_tty_driver.start = NULL; //rs_start;
 640         acm_tty_driver.hangup = NULL; //rs_hangup;
 641         acm_tty_driver.break_ctl = NULL; //rs_break;
 642         acm_tty_driver.wait_until_sent = NULL; //rs_wait_until_sent;
 643         acm_tty_driver.send_xchar = NULL; //rs_send_xchar;
 644         acm_tty_driver.read_proc = NULL; //rs_read_proc;
 645         acm_tty_driver.chars_in_buffer = rs_chars_in_buffer;
 646         acm_tty_driver.flush_buffer = NULL; //rs_flush_buffer;
 647         if (tty_register_driver(&acm_tty_driver)) {
 648                 printk(KERN_ERR "acm: failed to register tty driver\n");
 649                 return -EPERM;
 650         }
 651
 652         if (usb_register(&acm_driver) < 0) {
 653                 tty_unregister_driver(&acm_tty_driver);
 654                 return -1;
 655         }
 656
 657         printk(KERN_INFO "USB ACM registered.\n");
 658         return 0;
 659 }
 660
 661 void usb_acm_cleanup(void)
 662 {
 663         int i;
 664         struct acm_state *acm;
 665
 666         info("usb_acm_cleanup\n");
 667
 668         for (i=0;i<NR_PORTS;i++) {
 669                 acm=&acm_state_table[i];
 670                 if (acm->present) {
 671                         printk("disconnecting %d\n",i);
 672                         acm_disconnect(acm->dev, acm);
 673                 }
 674         }
 675         tty_unregister_driver(&acm_tty_driver);
 676
 677         usb_deregister(&acm_driver);
 678
 679 }
 680
 681 #ifdef MODULE
 682 int init_module(void)
 683 {
 684         return usb_acm_init();
 685 }
 686
 687 void cleanup_module(void)
 688 {
 689         usb_acm_cleanup();
 690 }
 691 #endif