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