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