drivers/isdn/gigaset/ser-gigaset.c

   1 /* This is the serial hardware link layer (HLL) for the Gigaset 307x isdn
   2  * DECT base (aka Sinus 45 isdn) using the RS232 DECT data module M101,
   3  * written as a line discipline.
   4  *
   5  * =====================================================================
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of
   9  * the License, or (at your option) any later version.
  10  * =====================================================================
  11  */
  12
  13 #include "gigaset.h"
  14
  15 #include <linux/module.h>
  16 #include <linux/moduleparam.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/tty.h>
  19 #include <linux/completion.h>
  20
  21 /* Version Information */
  22 #define DRIVER_AUTHOR "Tilman Schmidt"
  23 #define DRIVER_DESC "Serial Driver for Gigaset 307x using Siemens M101"
  24
  25 #define GIGASET_MINORS     1
  26 #define GIGASET_MINOR      0
  27 #define GIGASET_MODULENAME "ser_gigaset"
  28 #define GIGASET_DEVNAME    "ttyGS"
  29
  30 /* length limit according to Siemens 3070usb-protokoll.doc ch. 2.1 */
  31 #define IF_WRITEBUF 264
  32
  33 MODULE_AUTHOR(DRIVER_AUTHOR);
  34 MODULE_DESCRIPTION(DRIVER_DESC);
  35 MODULE_LICENSE("GPL");
  36 MODULE_ALIAS_LDISC(N_GIGASET_M101);
  37
  38 static int startmode = SM_ISDN;
  39 module_param(startmode, int, S_IRUGO);
  40 MODULE_PARM_DESC(startmode, "initial operation mode");
  41 static int cidmode = 1;
  42 module_param(cidmode, int, S_IRUGO);
  43 MODULE_PARM_DESC(cidmode, "stay in CID mode when idle");
  44
  45 static struct gigaset_driver *driver;
  46
  47 struct ser_cardstate {
  48         struct platform_device  dev;
  49         struct tty_struct       *tty;
  50         atomic_t                refcnt;
  51         struct completion       dead_cmp;
  52 };
  53
  54 static struct platform_driver device_driver = {
  55         .driver = {
  56                 .name = GIGASET_MODULENAME,
  57         },
  58 };
  59
  60 static void flush_send_queue(struct cardstate *);
  61
  62 /* transmit data from current open skb
  63  * result: number of bytes sent or error code < 0
  64  */
  65 static int write_modem(struct cardstate *cs)
  66 {
  67         struct tty_struct *tty = cs->hw.ser->tty;
  68         struct bc_state *bcs = &cs->bcs[0];     /* only one channel */
  69         struct sk_buff *skb = bcs->tx_skb;
  70         int sent = -EOPNOTSUPP;
  71
  72         if (!tty || !tty->driver || !skb)
  73                 return -EINVAL;
  74
  75         if (!skb->len) {
  76                 dev_kfree_skb_any(skb);
  77                 bcs->tx_skb = NULL;
  78                 return -EINVAL;
  79         }
  80
  81         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
  82         if (tty->ops->write)
  83                 sent = tty->ops->write(tty, skb->data, skb->len);
  84         gig_dbg(DEBUG_OUTPUT, "write_modem: sent %d", sent);
  85         if (sent < 0) {
  86                 /* error */
  87                 flush_send_queue(cs);
  88                 return sent;
  89         }
  90         skb_pull(skb, sent);
  91         if (!skb->len) {
  92                 /* skb sent completely */
  93                 gigaset_skb_sent(bcs, skb);
  94
  95                 gig_dbg(DEBUG_INTR, "kfree skb (Adr: %lx)!",
  96                         (unsigned long) skb);
  97                 dev_kfree_skb_any(skb);
  98                 bcs->tx_skb = NULL;
  99         }
 100         return sent;
 101 }
 102
 103 /*
 104  * transmit first queued command buffer
 105  * result: number of bytes sent or error code < 0
 106  */
 107 static int send_cb(struct cardstate *cs)
 108 {
 109         struct tty_struct *tty = cs->hw.ser->tty;
 110         struct cmdbuf_t *cb, *tcb;
 111         unsigned long flags;
 112         int sent = 0;
 113
 114         if (!tty || !tty->driver)
 115                 return -EFAULT;
 116
 117         cb = cs->cmdbuf;
 118         if (!cb)
 119                 return 0;       /* nothing to do */
 120
 121         if (cb->len) {
 122                 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 123                 sent = tty->ops->write(tty, cb->buf + cb->offset, cb->len);
 124                 if (sent < 0) {
 125                         /* error */
 126                         gig_dbg(DEBUG_OUTPUT, "send_cb: write error %d", sent);
 127                         flush_send_queue(cs);
 128                         return sent;
 129                 }
 130                 cb->offset += sent;
 131                 cb->len -= sent;
 132                 gig_dbg(DEBUG_OUTPUT, "send_cb: sent %d, left %u, queued %u",
 133                         sent, cb->len, cs->cmdbytes);
 134         }
 135
 136         while (cb && !cb->len) {
 137                 spin_lock_irqsave(&cs->cmdlock, flags);
 138                 cs->cmdbytes -= cs->curlen;
 139                 tcb = cb;
 140                 cs->cmdbuf = cb = cb->next;
 141                 if (cb) {
 142                         cb->prev = NULL;
 143                         cs->curlen = cb->len;
 144                 } else {
 145                         cs->lastcmdbuf = NULL;
 146                         cs->curlen = 0;
 147                 }
 148                 spin_unlock_irqrestore(&cs->cmdlock, flags);
 149
 150                 if (tcb->wake_tasklet)
 151                         tasklet_schedule(tcb->wake_tasklet);
 152                 kfree(tcb);
 153         }
 154         return sent;
 155 }
 156
 157 /*
 158  * send queue tasklet
 159  * If there is already a skb opened, put data to the transfer buffer
 160  * by calling "write_modem".
 161  * Otherwise take a new skb out of the queue.
 162  */
 163 static void gigaset_modem_fill(unsigned long data)
 164 {
 165         struct cardstate *cs = (struct cardstate *) data;
 166         struct bc_state *bcs;
 167         struct sk_buff *nextskb;
 168         int sent = 0;
 169
 170         if (!cs) {
 171                 gig_dbg(DEBUG_OUTPUT, "%s: no cardstate", __func__);
 172                 return;
 173         }
 174         bcs = cs->bcs;
 175         if (!bcs) {
 176                 gig_dbg(DEBUG_OUTPUT, "%s: no cardstate", __func__);
 177                 return;
 178         }
 179         if (!bcs->tx_skb) {
 180                 /* no skb is being sent; send command if any */
 181                 sent = send_cb(cs);
 182                 gig_dbg(DEBUG_OUTPUT, "%s: send_cb -> %d", __func__, sent);
 183                 if (sent)
 184                         /* something sent or error */
 185                         return;
 186
 187                 /* no command to send; get skb */
 188                 nextskb = skb_dequeue(&bcs->squeue);
 189                 if (!nextskb)
 190                         /* no skb either, nothing to do */
 191                         return;
 192                 bcs->tx_skb = nextskb;
 193
 194                 gig_dbg(DEBUG_INTR, "Dequeued skb (Adr: %lx)",
 195                         (unsigned long) bcs->tx_skb);
 196         }
 197
 198         /* send skb */
 199         gig_dbg(DEBUG_OUTPUT, "%s: tx_skb", __func__);
 200         if (write_modem(cs) < 0)
 201                 gig_dbg(DEBUG_OUTPUT, "%s: write_modem failed", __func__);
 202 }
 203
 204 /*
 205  * throw away all data queued for sending
 206  */
 207 static void flush_send_queue(struct cardstate *cs)
 208 {
 209         struct sk_buff *skb;
 210         struct cmdbuf_t *cb;
 211         unsigned long flags;
 212
 213         /* command queue */
 214         spin_lock_irqsave(&cs->cmdlock, flags);
 215         while ((cb = cs->cmdbuf) != NULL) {
 216                 cs->cmdbuf = cb->next;
 217                 if (cb->wake_tasklet)
 218                         tasklet_schedule(cb->wake_tasklet);
 219                 kfree(cb);
 220         }
 221         cs->cmdbuf = cs->lastcmdbuf = NULL;
 222         cs->cmdbytes = cs->curlen = 0;
 223         spin_unlock_irqrestore(&cs->cmdlock, flags);
 224
 225         /* data queue */
 226         if (cs->bcs->tx_skb)
 227                 dev_kfree_skb_any(cs->bcs->tx_skb);
 228         while ((skb = skb_dequeue(&cs->bcs->squeue)) != NULL)
 229                 dev_kfree_skb_any(skb);
 230 }
 231
 232
 233 /* Gigaset Driver Interface */
 234 /* ======================== */
 235
 236 /*
 237  * queue an AT command string for transmission to the Gigaset device
 238  * parameters:
 239  *      cs              controller state structure
 240  *      buf             buffer containing the string to send
 241  *      len             number of characters to send
 242  *      wake_tasklet    tasklet to run when transmission is complete, or NULL
 243  * return value:
 244  *      number of bytes queued, or error code < 0
 245  */
 246 static int gigaset_write_cmd(struct cardstate *cs, const unsigned char *buf,
 247                              int len, struct tasklet_struct *wake_tasklet)
 248 {
 249         struct cmdbuf_t *cb;
 250         unsigned long flags;
 251
 252         gigaset_dbg_buffer(cs->mstate != MS_LOCKED ?
 253                                 DEBUG_TRANSCMD : DEBUG_LOCKCMD,
 254                            "CMD Transmit", len, buf);
 255
 256         if (len <= 0)
 257                 return 0;
 258
 259         cb = kmalloc(sizeof(struct cmdbuf_t) + len, GFP_ATOMIC);
 260         if (!cb) {
 261                 dev_err(cs->dev, "%s: out of memory!\n", __func__);
 262                 return -ENOMEM;
 263         }
 264
 265         memcpy(cb->buf, buf, len);
 266         cb->len = len;
 267         cb->offset = 0;
 268         cb->next = NULL;
 269         cb->wake_tasklet = wake_tasklet;
 270
 271         spin_lock_irqsave(&cs->cmdlock, flags);
 272         cb->prev = cs->lastcmdbuf;
 273         if (cs->lastcmdbuf)
 274                 cs->lastcmdbuf->next = cb;
 275         else {
 276                 cs->cmdbuf = cb;
 277                 cs->curlen = len;
 278         }
 279         cs->cmdbytes += len;
 280         cs->lastcmdbuf = cb;
 281         spin_unlock_irqrestore(&cs->cmdlock, flags);
 282
 283         spin_lock_irqsave(&cs->lock, flags);
 284         if (cs->connected)
 285                 tasklet_schedule(&cs->write_tasklet);
 286         spin_unlock_irqrestore(&cs->lock, flags);
 287         return len;
 288 }
 289
 290 /*
 291  * tty_driver.write_room interface routine
 292  * return number of characters the driver will accept to be written
 293  * parameter:
 294  *      controller state structure
 295  * return value:
 296  *      number of characters
 297  */
 298 static int gigaset_write_room(struct cardstate *cs)
 299 {
 300         unsigned bytes;
 301
 302         bytes = cs->cmdbytes;
 303         return bytes < IF_WRITEBUF ? IF_WRITEBUF - bytes : 0;
 304 }
 305
 306 /*
 307  * tty_driver.chars_in_buffer interface routine
 308  * return number of characters waiting to be sent
 309  * parameter:
 310  *      controller state structure
 311  * return value:
 312  *      number of characters
 313  */
 314 static int gigaset_chars_in_buffer(struct cardstate *cs)
 315 {
 316         return cs->cmdbytes;
 317 }
 318
 319 /*
 320  * implementation of ioctl(GIGASET_BRKCHARS)
 321  * parameter:
 322  *      controller state structure
 323  * return value:
 324  *      -EINVAL (unimplemented function)
 325  */
 326 static int gigaset_brkchars(struct cardstate *cs, const unsigned char buf[6])
 327 {
 328         /* not implemented */
 329         return -EINVAL;
 330 }
 331
 332 /*
 333  * Open B channel
 334  * Called by "do_action" in ev-layer.c
 335  */
 336 static int gigaset_init_bchannel(struct bc_state *bcs)
 337 {
 338         /* nothing to do for M10x */
 339         gigaset_bchannel_up(bcs);
 340         return 0;
 341 }
 342
 343 /*
 344  * Close B channel
 345  * Called by "do_action" in ev-layer.c
 346  */
 347 static int gigaset_close_bchannel(struct bc_state *bcs)
 348 {
 349         /* nothing to do for M10x */
 350         gigaset_bchannel_down(bcs);
 351         return 0;
 352 }
 353
 354 /*
 355  * Set up B channel structure
 356  * This is called by "gigaset_initcs" in common.c
 357  */
 358 static int gigaset_initbcshw(struct bc_state *bcs)
 359 {
 360         /* unused */
 361         bcs->hw.ser = NULL;
 362         return 1;
 363 }
 364
 365 /*
 366  * Free B channel structure
 367  * Called by "gigaset_freebcs" in common.c
 368  */
 369 static int gigaset_freebcshw(struct bc_state *bcs)
 370 {
 371         /* unused */
 372         return 1;
 373 }
 374
 375 /*
 376  * Reinitialize B channel structure
 377  * This is called by "bcs_reinit" in common.c
 378  */
 379 static void gigaset_reinitbcshw(struct bc_state *bcs)
 380 {
 381         /* nothing to do for M10x */
 382 }
 383
 384 /*
 385  * Free hardware specific device data
 386  * This will be called by "gigaset_freecs" in common.c
 387  */
 388 static void gigaset_freecshw(struct cardstate *cs)
 389 {
 390         tasklet_kill(&cs->write_tasklet);
 391         if (!cs->hw.ser)
 392                 return;
 393         dev_set_drvdata(&cs->hw.ser->dev.dev, NULL);
 394         platform_device_unregister(&cs->hw.ser->dev);
 395         kfree(cs->hw.ser);
 396         cs->hw.ser = NULL;
 397 }
 398
 399 static void gigaset_device_release(struct device *dev)
 400 {
 401         struct platform_device *pdev = to_platform_device(dev);
 402
 403         /* adapted from platform_device_release() in drivers/base/platform.c */
 404         kfree(dev->platform_data);
 405         kfree(pdev->resource);
 406 }
 407
 408 /*
 409  * Set up hardware specific device data
 410  * This is called by "gigaset_initcs" in common.c
 411  */
 412 static int gigaset_initcshw(struct cardstate *cs)
 413 {
 414         int rc;
 415         struct ser_cardstate *scs;
 416
 417         scs = kzalloc(sizeof(struct ser_cardstate), GFP_KERNEL);
 418         if (!scs) {
 419                 pr_err("out of memory\n");
 420                 return 0;
 421         }
 422         cs->hw.ser = scs;
 423
 424         cs->hw.ser->dev.name = GIGASET_MODULENAME;
 425         cs->hw.ser->dev.id = cs->minor_index;
 426         cs->hw.ser->dev.dev.release = gigaset_device_release;
 427         rc = platform_device_register(&cs->hw.ser->dev);
 428         if (rc != 0) {
 429                 pr_err("error %d registering platform device\n", rc);
 430                 kfree(cs->hw.ser);
 431                 cs->hw.ser = NULL;
 432                 return 0;
 433         }
 434         dev_set_drvdata(&cs->hw.ser->dev.dev, cs);
 435
 436         tasklet_init(&cs->write_tasklet,
 437                      gigaset_modem_fill, (unsigned long) cs);
 438         return 1;
 439 }
 440
 441 /*
 442  * set modem control lines
 443  * Parameters:
 444  *      card state structure
 445  *      modem control line state ([TIOCM_DTR]|[TIOCM_RTS])
 446  * Called by "gigaset_start" and "gigaset_enterconfigmode" in common.c
 447  * and by "if_lock" and "if_termios" in interface.c
 448  */
 449 static int gigaset_set_modem_ctrl(struct cardstate *cs, unsigned old_state,
 450                                   unsigned new_state)
 451 {
 452         struct tty_struct *tty = cs->hw.ser->tty;
 453         unsigned int set, clear;
 454
 455         if (!tty || !tty->driver || !tty->ops->tiocmset)
 456                 return -EINVAL;
 457         set = new_state & ~old_state;
 458         clear = old_state & ~new_state;
 459         if (!set && !clear)
 460                 return 0;
 461         gig_dbg(DEBUG_IF, "tiocmset set %x clear %x", set, clear);
 462         return tty->ops->tiocmset(tty, NULL, set, clear);
 463 }
 464
 465 static int gigaset_baud_rate(struct cardstate *cs, unsigned cflag)
 466 {
 467         return -EINVAL;
 468 }
 469
 470 static int gigaset_set_line_ctrl(struct cardstate *cs, unsigned cflag)
 471 {
 472         return -EINVAL;
 473 }
 474
 475 static const struct gigaset_ops ops = {
 476         gigaset_write_cmd,
 477         gigaset_write_room,
 478         gigaset_chars_in_buffer,
 479         gigaset_brkchars,
 480         gigaset_init_bchannel,
 481         gigaset_close_bchannel,
 482         gigaset_initbcshw,
 483         gigaset_freebcshw,
 484         gigaset_reinitbcshw,
 485         gigaset_initcshw,
 486         gigaset_freecshw,
 487         gigaset_set_modem_ctrl,
 488         gigaset_baud_rate,
 489         gigaset_set_line_ctrl,
 490         gigaset_m10x_send_skb,  /* asyncdata.c */
 491         gigaset_m10x_input,     /* asyncdata.c */
 492 };
 493
 494
 495 /* Line Discipline Interface */
 496 /* ========================= */
 497
 498 /* helper functions for cardstate refcounting */
 499 static struct cardstate *cs_get(struct tty_struct *tty)
 500 {
 501         struct cardstate *cs = tty->disc_data;
 502
 503         if (!cs || !cs->hw.ser) {
 504                 gig_dbg(DEBUG_ANY, "%s: no cardstate", __func__);
 505                 return NULL;
 506         }
 507         atomic_inc(&cs->hw.ser->refcnt);
 508         return cs;
 509 }
 510
 511 static void cs_put(struct cardstate *cs)
 512 {
 513         if (atomic_dec_and_test(&cs->hw.ser->refcnt))
 514                 complete(&cs->hw.ser->dead_cmp);
 515 }
 516
 517 /*
 518  * Called by the tty driver when the line discipline is pushed onto the tty.
 519  * Called in process context.
 520  */
 521 static int
 522 gigaset_tty_open(struct tty_struct *tty)
 523 {
 524         struct cardstate *cs;
 525
 526         gig_dbg(DEBUG_INIT, "Starting HLL for Gigaset M101");
 527
 528         pr_info(DRIVER_DESC "\n");
 529
 530         if (!driver) {
 531                 pr_err("%s: no driver structure\n", __func__);
 532                 return -ENODEV;
 533         }
 534
 535         /* allocate memory for our device state and intialize it */
 536         cs = gigaset_initcs(driver, 1, 1, 0, cidmode, GIGASET_MODULENAME);
 537         if (!cs)
 538                 goto error;
 539
 540         cs->dev = &cs->hw.ser->dev.dev;
 541         cs->hw.ser->tty = tty;
 542         atomic_set(&cs->hw.ser->refcnt, 1);
 543         init_completion(&cs->hw.ser->dead_cmp);
 544
 545         tty->disc_data = cs;
 546
 547         /* OK.. Initialization of the datastructures and the HW is done.. Now
 548          * startup system and notify the LL that we are ready to run
 549          */
 550         if (startmode == SM_LOCKED)
 551                 cs->mstate = MS_LOCKED;
 552         if (!gigaset_start(cs)) {
 553                 tasklet_kill(&cs->write_tasklet);
 554                 goto error;
 555         }
 556
 557         gig_dbg(DEBUG_INIT, "Startup of HLL done");
 558         return 0;
 559
 560 error:
 561         gig_dbg(DEBUG_INIT, "Startup of HLL failed");
 562         tty->disc_data = NULL;
 563         gigaset_freecs(cs);
 564         return -ENODEV;
 565 }
 566
 567 /*
 568  * Called by the tty driver when the line discipline is removed.
 569  * Called from process context.
 570  */
 571 static void
 572 gigaset_tty_close(struct tty_struct *tty)
 573 {
 574         struct cardstate *cs = tty->disc_data;
 575
 576         gig_dbg(DEBUG_INIT, "Stopping HLL for Gigaset M101");
 577
 578         if (!cs) {
 579                 gig_dbg(DEBUG_INIT, "%s: no cardstate", __func__);
 580                 return;
 581         }
 582
 583         /* prevent other callers from entering ldisc methods */
 584         tty->disc_data = NULL;
 585
 586         if (!cs->hw.ser)
 587                 pr_err("%s: no hw cardstate\n", __func__);
 588         else {
 589                 /* wait for running methods to finish */
 590                 if (!atomic_dec_and_test(&cs->hw.ser->refcnt))
 591                         wait_for_completion(&cs->hw.ser->dead_cmp);
 592         }
 593
 594         /* stop operations */
 595         gigaset_stop(cs);
 596         tasklet_kill(&cs->write_tasklet);
 597         flush_send_queue(cs);
 598         cs->dev = NULL;
 599         gigaset_freecs(cs);
 600
 601         gig_dbg(DEBUG_INIT, "Shutdown of HLL done");
 602 }
 603
 604 /*
 605  * Called by the tty driver when the tty line is hung up.
 606  * Wait for I/O to driver to complete and unregister ISDN device.
 607  * This is already done by the close routine, so just call that.
 608  * Called from process context.
 609  */
 610 static int gigaset_tty_hangup(struct tty_struct *tty)
 611 {
 612         gigaset_tty_close(tty);
 613         return 0;
 614 }
 615
 616 /*
 617  * Read on the tty.
 618  * Unused, received data goes only to the Gigaset driver.
 619  */
 620 static ssize_t
 621 gigaset_tty_read(struct tty_struct *tty, struct file *file,
 622                  unsigned char __user *buf, size_t count)
 623 {
 624         return -EAGAIN;
 625 }
 626
 627 /*
 628  * Write on the tty.
 629  * Unused, transmit data comes only from the Gigaset driver.
 630  */
 631 static ssize_t
 632 gigaset_tty_write(struct tty_struct *tty, struct file *file,
 633                   const unsigned char *buf, size_t count)
 634 {
 635         return -EAGAIN;
 636 }
 637
 638 /*
 639  * Ioctl on the tty.
 640  * Called in process context only.
 641  * May be re-entered by multiple ioctl calling threads.
 642  */
 643 static int
 644 gigaset_tty_ioctl(struct tty_struct *tty, struct file *file,
 645                   unsigned int cmd, unsigned long arg)
 646 {
 647         struct cardstate *cs = cs_get(tty);
 648         int rc, val;
 649         int __user *p = (int __user *)arg;
 650
 651         if (!cs)
 652                 return -ENXIO;
 653
 654         switch (cmd) {
 655
 656         case FIONREAD:
 657                 /* unused, always return zero */
 658                 val = 0;
 659                 rc = put_user(val, p);
 660                 break;
 661
 662         case TCFLSH:
 663                 /* flush our buffers and the serial port's buffer */
 664                 switch (arg) {
 665                 case TCIFLUSH:
 666                         /* no own input buffer to flush */
 667                         break;
 668                 case TCIOFLUSH:
 669                 case TCOFLUSH:
 670                         flush_send_queue(cs);
 671                         break;
 672                 }
 673                 /* Pass through */
 674
 675         default:
 676                 /* pass through to underlying serial device */
 677                 rc = n_tty_ioctl_helper(tty, file, cmd, arg);
 678                 break;
 679         }
 680         cs_put(cs);
 681         return rc;
 682 }
 683
 684 /*
 685  * Called by the tty driver when a block of data has been received.
 686  * Will not be re-entered while running but other ldisc functions
 687  * may be called in parallel.
 688  * Can be called from hard interrupt level as well as soft interrupt
 689  * level or mainline.
 690  * Parameters:
 691  *      tty     tty structure
 692  *      buf     buffer containing received characters
 693  *      cflags  buffer containing error flags for received characters (ignored)
 694  *      count   number of received characters
 695  */
 696 static void
 697 gigaset_tty_receive(struct tty_struct *tty, const unsigned char *buf,
 698                     char *cflags, int count)
 699 {
 700         struct cardstate *cs = cs_get(tty);
 701         unsigned tail, head, n;
 702         struct inbuf_t *inbuf;
 703
 704         if (!cs)
 705                 return;
 706         inbuf = cs->inbuf;
 707         if (!inbuf) {
 708                 dev_err(cs->dev, "%s: no inbuf\n", __func__);
 709                 cs_put(cs);
 710                 return;
 711         }
 712
 713         tail = inbuf->tail;
 714         head = inbuf->head;
 715         gig_dbg(DEBUG_INTR, "buffer state: %u -> %u, receive %u bytes",
 716                 head, tail, count);
 717
 718         if (head <= tail) {
 719                 /* possible buffer wraparound */
 720                 n = min_t(unsigned, count, RBUFSIZE - tail);
 721                 memcpy(inbuf->data + tail, buf, n);
 722                 tail = (tail + n) % RBUFSIZE;
 723                 buf += n;
 724                 count -= n;
 725         }
 726
 727         if (count > 0) {
 728                 /* tail < head and some data left */
 729                 n = head - tail - 1;
 730                 if (count > n) {
 731                         dev_err(cs->dev,
 732                                 "inbuf overflow, discarding %d bytes\n",
 733                                 count - n);
 734                         count = n;
 735                 }
 736                 memcpy(inbuf->data + tail, buf, count);
 737                 tail += count;
 738         }
 739
 740         gig_dbg(DEBUG_INTR, "setting tail to %u", tail);
 741         inbuf->tail = tail;
 742
 743         /* Everything was received .. Push data into handler */
 744         gig_dbg(DEBUG_INTR, "%s-->BH", __func__);
 745         gigaset_schedule_event(cs);
 746         cs_put(cs);
 747 }
 748
 749 /*
 750  * Called by the tty driver when there's room for more data to send.
 751  */
 752 static void
 753 gigaset_tty_wakeup(struct tty_struct *tty)
 754 {
 755         struct cardstate *cs = cs_get(tty);
 756
 757         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 758         if (!cs)
 759                 return;
 760         tasklet_schedule(&cs->write_tasklet);
 761         cs_put(cs);
 762 }
 763
 764 static struct tty_ldisc_ops gigaset_ldisc = {
 765         .owner          = THIS_MODULE,
 766         .magic          = TTY_LDISC_MAGIC,
 767         .name           = "ser_gigaset",
 768         .open           = gigaset_tty_open,
 769         .close          = gigaset_tty_close,
 770         .hangup         = gigaset_tty_hangup,
 771         .read           = gigaset_tty_read,
 772         .write          = gigaset_tty_write,
 773         .ioctl          = gigaset_tty_ioctl,
 774         .receive_buf    = gigaset_tty_receive,
 775         .write_wakeup   = gigaset_tty_wakeup,
 776 };
 777
 778
 779 /* Initialization / Shutdown */
 780 /* ========================= */
 781
 782 static int __init ser_gigaset_init(void)
 783 {
 784         int rc;
 785
 786         gig_dbg(DEBUG_INIT, "%s", __func__);
 787         rc = platform_driver_register(&device_driver);
 788         if (rc != 0) {
 789                 pr_err("error %d registering platform driver\n", rc);
 790                 return rc;
 791         }
 792
 793         /* allocate memory for our driver state and intialize it */
 794         driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
 795                                           GIGASET_MODULENAME, GIGASET_DEVNAME,
 796                                           &ops, THIS_MODULE);
 797         if (!driver)
 798                 goto error;
 799
 800         rc = tty_register_ldisc(N_GIGASET_M101, &gigaset_ldisc);
 801         if (rc != 0) {
 802                 pr_err("error %d registering line discipline\n", rc);
 803                 goto error;
 804         }
 805
 806         return 0;
 807
 808 error:
 809         if (driver) {
 810                 gigaset_freedriver(driver);
 811                 driver = NULL;
 812         }
 813         platform_driver_unregister(&device_driver);
 814         return rc;
 815 }
 816
 817 static void __exit ser_gigaset_exit(void)
 818 {
 819         int rc;
 820
 821         gig_dbg(DEBUG_INIT, "%s", __func__);
 822
 823         if (driver) {
 824                 gigaset_freedriver(driver);
 825                 driver = NULL;
 826         }
 827
 828         rc = tty_unregister_ldisc(N_GIGASET_M101);
 829         if (rc != 0)
 830                 pr_err("error %d unregistering line discipline\n", rc);
 831
 832         platform_driver_unregister(&device_driver);
 833 }
 834
 835 module_init(ser_gigaset_init);
 836 module_exit(ser_gigaset_exit);