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