drivers/char/pcmcia/ipwireless/tty.c

   1 /*
   2  * IPWireless 3G PCMCIA Network Driver
   3  *
   4  * Original code
   5  *   by Stephen Blackheath <stephen@blacksapphire.com>,
   6  *      Ben Martel <benm@symmetric.co.nz>
   7  *
   8  * Copyrighted as follows:
   9  *   Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
  10  *
  11  * Various driver changes and rewrites, port to new kernels
  12  *   Copyright (C) 2006-2007 Jiri Kosina
  13  *
  14  * Misc code cleanups and updates
  15  *   Copyright (C) 2007 David Sterba
  16  */
  17
  18 #include <linux/init.h>
  19 #include <linux/kernel.h>
  20 #include <linux/module.h>
  21 #include <linux/mutex.h>
  22 #include <linux/ppp_defs.h>
  23 #include <linux/if.h>
  24 #include <linux/if_ppp.h>
  25 #include <linux/sched.h>
  26 #include <linux/serial.h>
  27 #include <linux/slab.h>
  28 #include <linux/tty.h>
  29 #include <linux/tty_driver.h>
  30 #include <linux/tty_flip.h>
  31 #include <linux/uaccess.h>
  32 #include <linux/version.h>
  33
  34 #include "tty.h"
  35 #include "network.h"
  36 #include "hardware.h"
  37 #include "main.h"
  38
  39 #define IPWIRELESS_PCMCIA_START         (0)
  40 #define IPWIRELESS_PCMCIA_MINORS        (24)
  41 #define IPWIRELESS_PCMCIA_MINOR_RANGE   (8)
  42
  43 #define TTYTYPE_MODEM    (0)
  44 #define TTYTYPE_MONITOR  (1)
  45 #define TTYTYPE_RAS_RAW  (2)
  46
  47 struct ipw_tty {
  48         int index;
  49         struct ipw_hardware *hardware;
  50         unsigned int channel_idx;
  51         unsigned int secondary_channel_idx;
  52         int tty_type;
  53         struct ipw_network *network;
  54         struct tty_struct *linux_tty;
  55         int open_count;
  56         unsigned int control_lines;
  57         struct mutex ipw_tty_mutex;
  58         int tx_bytes_queued;
  59         int closing;
  60 };
  61
  62 static struct ipw_tty *ttys[IPWIRELESS_PCMCIA_MINORS];
  63
  64 static struct tty_driver *ipw_tty_driver;
  65
  66 static char *tty_type_name(int tty_type)
  67 {
  68         static char *channel_names[] = {
  69                 "modem",
  70                 "monitor",
  71                 "RAS-raw"
  72         };
  73
  74         return channel_names[tty_type];
  75 }
  76
  77 static void report_registering(struct ipw_tty *tty)
  78 {
  79         char *iftype = tty_type_name(tty->tty_type);
  80
  81         printk(KERN_INFO IPWIRELESS_PCCARD_NAME
  82                ": registering %s device ttyIPWp%d\n", iftype, tty->index);
  83 }
  84
  85 static void report_deregistering(struct ipw_tty *tty)
  86 {
  87         char *iftype = tty_type_name(tty->tty_type);
  88
  89         printk(KERN_INFO IPWIRELESS_PCCARD_NAME
  90                ": deregistering %s device ttyIPWp%d\n", iftype,
  91                tty->index);
  92 }
  93
  94 static struct ipw_tty *get_tty(int minor)
  95 {
  96         if (minor < ipw_tty_driver->minor_start
  97                         || minor >= ipw_tty_driver->minor_start +
  98                         IPWIRELESS_PCMCIA_MINORS)
  99                 return NULL;
 100         else {
 101                 int minor_offset = minor - ipw_tty_driver->minor_start;
 102
 103                 /*
 104                  * The 'ras_raw' channel is only available when 'loopback' mode
 105                  * is enabled.
 106                  * Number of minor starts with 16 (_RANGE * _RAS_RAW).
 107                  */
 108                 if (!ipwireless_loopback &&
 109                                 minor_offset >=
 110                                  IPWIRELESS_PCMCIA_MINOR_RANGE * TTYTYPE_RAS_RAW)
 111                         return NULL;
 112
 113                 return ttys[minor_offset];
 114         }
 115 }
 116
 117 static int ipw_open(struct tty_struct *linux_tty, struct file *filp)
 118 {
 119         int minor = linux_tty->index;
 120         struct ipw_tty *tty = get_tty(minor);
 121
 122         if (!tty)
 123                 return -ENODEV;
 124
 125         mutex_lock(&tty->ipw_tty_mutex);
 126
 127         if (tty->closing) {
 128                 mutex_unlock(&tty->ipw_tty_mutex);
 129                 return -ENODEV;
 130         }
 131         if (tty->open_count == 0)
 132                 tty->tx_bytes_queued = 0;
 133
 134         tty->open_count++;
 135
 136         tty->linux_tty = linux_tty;
 137         linux_tty->driver_data = tty;
 138         linux_tty->low_latency = 1;
 139
 140         if (tty->tty_type == TTYTYPE_MODEM)
 141                 ipwireless_ppp_open(tty->network);
 142
 143         mutex_unlock(&tty->ipw_tty_mutex);
 144
 145         return 0;
 146 }
 147
 148 static void do_ipw_close(struct ipw_tty *tty)
 149 {
 150         tty->open_count--;
 151
 152         if (tty->open_count == 0) {
 153                 struct tty_struct *linux_tty = tty->linux_tty;
 154
 155                 if (linux_tty != NULL) {
 156                         tty->linux_tty = NULL;
 157                         linux_tty->driver_data = NULL;
 158
 159                         if (tty->tty_type == TTYTYPE_MODEM)
 160                                 ipwireless_ppp_close(tty->network);
 161                 }
 162         }
 163 }
 164
 165 static void ipw_hangup(struct tty_struct *linux_tty)
 166 {
 167         struct ipw_tty *tty = linux_tty->driver_data;
 168
 169         if (!tty)
 170                 return;
 171
 172         mutex_lock(&tty->ipw_tty_mutex);
 173         if (tty->open_count == 0) {
 174                 mutex_unlock(&tty->ipw_tty_mutex);
 175                 return;
 176         }
 177
 178         do_ipw_close(tty);
 179
 180         mutex_unlock(&tty->ipw_tty_mutex);
 181 }
 182
 183 static void ipw_close(struct tty_struct *linux_tty, struct file *filp)
 184 {
 185         ipw_hangup(linux_tty);
 186 }
 187
 188 /* Take data received from hardware, and send it out the tty */
 189 void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
 190                         unsigned int length)
 191 {
 192         struct tty_struct *linux_tty;
 193         int work = 0;
 194
 195         mutex_lock(&tty->ipw_tty_mutex);
 196         linux_tty = tty->linux_tty;
 197         if (linux_tty == NULL) {
 198                 mutex_unlock(&tty->ipw_tty_mutex);
 199                 return;
 200         }
 201
 202         if (!tty->open_count) {
 203                 mutex_unlock(&tty->ipw_tty_mutex);
 204                 return;
 205         }
 206         mutex_unlock(&tty->ipw_tty_mutex);
 207
 208         work = tty_insert_flip_string(linux_tty, data, length);
 209
 210         if (work != length)
 211                 printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
 212                                 ": %d chars not inserted to flip buffer!\n",
 213                                 length - work);
 214
 215         /*
 216          * This may sleep if ->low_latency is set
 217          */
 218         if (work)
 219                 tty_flip_buffer_push(linux_tty);
 220 }
 221
 222 static void ipw_write_packet_sent_callback(void *callback_data,
 223                                            unsigned int packet_length)
 224 {
 225         struct ipw_tty *tty = callback_data;
 226
 227         /*
 228          * Packet has been sent, so we subtract the number of bytes from our
 229          * tally of outstanding TX bytes.
 230          */
 231         tty->tx_bytes_queued -= packet_length;
 232 }
 233
 234 static int ipw_write(struct tty_struct *linux_tty,
 235                      const unsigned char *buf, int count)
 236 {
 237         struct ipw_tty *tty = linux_tty->driver_data;
 238         int room, ret;
 239
 240         if (!tty)
 241                 return -ENODEV;
 242
 243         mutex_lock(&tty->ipw_tty_mutex);
 244         if (!tty->open_count) {
 245                 mutex_unlock(&tty->ipw_tty_mutex);
 246                 return -EINVAL;
 247         }
 248
 249         room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
 250         if (room < 0)
 251                 room = 0;
 252         /* Don't allow caller to write any more than we have room for */
 253         if (count > room)
 254                 count = room;
 255
 256         if (count == 0) {
 257                 mutex_unlock(&tty->ipw_tty_mutex);
 258                 return 0;
 259         }
 260
 261         ret = ipwireless_send_packet(tty->hardware, IPW_CHANNEL_RAS,
 262                                (unsigned char *) buf, count,
 263                                ipw_write_packet_sent_callback, tty);
 264         if (ret == -1) {
 265                 mutex_unlock(&tty->ipw_tty_mutex);
 266                 return 0;
 267         }
 268
 269         tty->tx_bytes_queued += count;
 270         mutex_unlock(&tty->ipw_tty_mutex);
 271
 272         return count;
 273 }
 274
 275 static int ipw_write_room(struct tty_struct *linux_tty)
 276 {
 277         struct ipw_tty *tty = linux_tty->driver_data;
 278         int room;
 279
 280         if (!tty)
 281                 return -ENODEV;
 282
 283         if (!tty->open_count)
 284                 return -EINVAL;
 285
 286         room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
 287         if (room < 0)
 288                 room = 0;
 289
 290         return room;
 291 }
 292
 293 static int ipwireless_get_serial_info(struct ipw_tty *tty,
 294                                       struct serial_struct __user *retinfo)
 295 {
 296         struct serial_struct tmp;
 297
 298         if (!retinfo)
 299                 return (-EFAULT);
 300
 301         memset(&tmp, 0, sizeof(tmp));
 302         tmp.type = PORT_UNKNOWN;
 303         tmp.line = tty->index;
 304         tmp.port = 0;
 305         tmp.irq = 0;
 306         tmp.flags = 0;
 307         tmp.baud_base = 115200;
 308         tmp.close_delay = 0;
 309         tmp.closing_wait = 0;
 310         tmp.custom_divisor = 0;
 311         tmp.hub6 = 0;
 312         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
 313                 return -EFAULT;
 314
 315         return 0;
 316 }
 317
 318 static int ipw_chars_in_buffer(struct tty_struct *linux_tty)
 319 {
 320         struct ipw_tty *tty = linux_tty->driver_data;
 321
 322         if (!tty)
 323                 return -ENODEV;
 324
 325         if (!tty->open_count)
 326                 return -EINVAL;
 327
 328         return tty->tx_bytes_queued;
 329 }
 330
 331 static int get_control_lines(struct ipw_tty *tty)
 332 {
 333         unsigned int my = tty->control_lines;
 334         unsigned int out = 0;
 335
 336         if (my & IPW_CONTROL_LINE_RTS)
 337                 out |= TIOCM_RTS;
 338         if (my & IPW_CONTROL_LINE_DTR)
 339                 out |= TIOCM_DTR;
 340         if (my & IPW_CONTROL_LINE_CTS)
 341                 out |= TIOCM_CTS;
 342         if (my & IPW_CONTROL_LINE_DSR)
 343                 out |= TIOCM_DSR;
 344         if (my & IPW_CONTROL_LINE_DCD)
 345                 out |= TIOCM_CD;
 346
 347         return out;
 348 }
 349
 350 static int set_control_lines(struct ipw_tty *tty, unsigned int set,
 351                              unsigned int clear)
 352 {
 353         int ret;
 354
 355         if (set & TIOCM_RTS) {
 356                 ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 1);
 357                 if (ret)
 358                         return ret;
 359                 if (tty->secondary_channel_idx != -1) {
 360                         ret = ipwireless_set_RTS(tty->hardware,
 361                                           tty->secondary_channel_idx, 1);
 362                         if (ret)
 363                                 return ret;
 364                 }
 365         }
 366         if (set & TIOCM_DTR) {
 367                 ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 1);
 368                 if (ret)
 369                         return ret;
 370                 if (tty->secondary_channel_idx != -1) {
 371                         ret = ipwireless_set_DTR(tty->hardware,
 372                                           tty->secondary_channel_idx, 1);
 373                         if (ret)
 374                                 return ret;
 375                 }
 376         }
 377         if (clear & TIOCM_RTS) {
 378                 ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 0);
 379                 if (tty->secondary_channel_idx != -1) {
 380                         ret = ipwireless_set_RTS(tty->hardware,
 381                                           tty->secondary_channel_idx, 0);
 382                         if (ret)
 383                                 return ret;
 384                 }
 385         }
 386         if (clear & TIOCM_DTR) {
 387                 ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 0);
 388                 if (tty->secondary_channel_idx != -1) {
 389                         ret = ipwireless_set_DTR(tty->hardware,
 390                                           tty->secondary_channel_idx, 0);
 391                         if (ret)
 392                                 return ret;
 393                 }
 394         }
 395         return 0;
 396 }
 397
 398 static int ipw_tiocmget(struct tty_struct *linux_tty, struct file *file)
 399 {
 400         struct ipw_tty *tty = linux_tty->driver_data;
 401
 402         if (!tty)
 403                 return -ENODEV;
 404
 405         if (!tty->open_count)
 406                 return -EINVAL;
 407
 408         return get_control_lines(tty);
 409 }
 410
 411 static int
 412 ipw_tiocmset(struct tty_struct *linux_tty, struct file *file,
 413              unsigned int set, unsigned int clear)
 414 {
 415         struct ipw_tty *tty = linux_tty->driver_data;
 416
 417         if (!tty)
 418                 return -ENODEV;
 419
 420         if (!tty->open_count)
 421                 return -EINVAL;
 422
 423         return set_control_lines(tty, set, clear);
 424 }
 425
 426 static int ipw_ioctl(struct tty_struct *linux_tty, struct file *file,
 427                      unsigned int cmd, unsigned long arg)
 428 {
 429         struct ipw_tty *tty = linux_tty->driver_data;
 430
 431         if (!tty)
 432                 return -ENODEV;
 433
 434         if (!tty->open_count)
 435                 return -EINVAL;
 436
 437         switch (cmd) {
 438         case TIOCGSERIAL:
 439                 return ipwireless_get_serial_info(tty, (void __user *) arg);
 440
 441         case TIOCSSERIAL:
 442                 return 0;       /* Keeps the PCMCIA scripts happy. */
 443         }
 444
 445         if (tty->tty_type == TTYTYPE_MODEM) {
 446                 switch (cmd) {
 447                 case PPPIOCGCHAN:
 448                         {
 449                                 int chan = ipwireless_ppp_channel_index(
 450                                                         tty->network);
 451
 452                                 if (chan < 0)
 453                                         return -ENODEV;
 454                                 if (put_user(chan, (int __user *) arg))
 455                                         return -EFAULT;
 456                         }
 457                         return 0;
 458
 459                 case PPPIOCGUNIT:
 460                         {
 461                                 int unit = ipwireless_ppp_unit_number(
 462                                                 tty->network);
 463
 464                                 if (unit < 0)
 465                                         return -ENODEV;
 466                                 if (put_user(unit, (int __user *) arg))
 467                                         return -EFAULT;
 468                         }
 469                         return 0;
 470
 471                 case TCGETS:
 472                 case TCGETA:
 473                         return n_tty_ioctl(linux_tty, file, cmd, arg);
 474
 475                 case TCFLSH:
 476                         return n_tty_ioctl(linux_tty, file, cmd, arg);
 477
 478                 case FIONREAD:
 479                         {
 480                                 int val = 0;
 481
 482                                 if (put_user(val, (int __user *) arg))
 483                                         return -EFAULT;
 484                         }
 485                         return 0;
 486                 }
 487         }
 488
 489         return -ENOIOCTLCMD;
 490 }
 491
 492 static int add_tty(dev_node_t *nodesp, int j,
 493                     struct ipw_hardware *hardware,
 494                     struct ipw_network *network, int channel_idx,
 495                     int secondary_channel_idx, int tty_type)
 496 {
 497         ttys[j] = kzalloc(sizeof(struct ipw_tty), GFP_KERNEL);
 498         if (!ttys[j])
 499                 return -ENOMEM;
 500         ttys[j]->index = j;
 501         ttys[j]->hardware = hardware;
 502         ttys[j]->channel_idx = channel_idx;
 503         ttys[j]->secondary_channel_idx = secondary_channel_idx;
 504         ttys[j]->network = network;
 505         ttys[j]->tty_type = tty_type;
 506         mutex_init(&ttys[j]->ipw_tty_mutex);
 507
 508         tty_register_device(ipw_tty_driver, j, NULL);
 509         ipwireless_associate_network_tty(network, channel_idx, ttys[j]);
 510
 511         if (secondary_channel_idx != -1)
 512                 ipwireless_associate_network_tty(network,
 513                                                  secondary_channel_idx,
 514                                                  ttys[j]);
 515         if (nodesp != NULL) {
 516                 sprintf(nodesp->dev_name, "ttyIPWp%d", j);
 517                 nodesp->major = ipw_tty_driver->major;
 518                 nodesp->minor = j + ipw_tty_driver->minor_start;
 519         }
 520         if (get_tty(j + ipw_tty_driver->minor_start) == ttys[j])
 521                 report_registering(ttys[j]);
 522         return 0;
 523 }
 524
 525 struct ipw_tty *ipwireless_tty_create(struct ipw_hardware *hardware,
 526                                       struct ipw_network *network,
 527                                       dev_node_t *nodes)
 528 {
 529         int i, j;
 530
 531         for (i = 0; i < IPWIRELESS_PCMCIA_MINOR_RANGE; i++) {
 532                 int allfree = 1;
 533
 534                 for (j = i; j < IPWIRELESS_PCMCIA_MINORS;
 535                                 j += IPWIRELESS_PCMCIA_MINOR_RANGE)
 536                         if (ttys[j] != NULL) {
 537                                 allfree = 0;
 538                                 break;
 539                         }
 540
 541                 if (allfree) {
 542                         j = i;
 543
 544                         if (add_tty(&nodes[0], j, hardware, network,
 545                                         IPW_CHANNEL_DIALLER, IPW_CHANNEL_RAS,
 546                                         TTYTYPE_MODEM))
 547                                 return NULL;
 548
 549                         j += IPWIRELESS_PCMCIA_MINOR_RANGE;
 550                         if (add_tty(&nodes[1], j, hardware, network,
 551                                         IPW_CHANNEL_DIALLER, -1,
 552                                         TTYTYPE_MONITOR))
 553                                 return NULL;
 554
 555                         j += IPWIRELESS_PCMCIA_MINOR_RANGE;
 556                         if (add_tty(NULL, j, hardware, network,
 557                                         IPW_CHANNEL_RAS, -1,
 558                                         TTYTYPE_RAS_RAW))
 559                                 return NULL;
 560
 561                         nodes[0].next = &nodes[1];
 562                         nodes[1].next = NULL;
 563
 564                         return ttys[i];
 565                 }
 566         }
 567         return NULL;
 568 }
 569
 570 /*
 571  * Must be called before ipwireless_network_free().
 572  */
 573 void ipwireless_tty_free(struct ipw_tty *tty)
 574 {
 575         int j;
 576         struct ipw_network *network = ttys[tty->index]->network;
 577
 578         for (j = tty->index; j < IPWIRELESS_PCMCIA_MINORS;
 579                         j += IPWIRELESS_PCMCIA_MINOR_RANGE) {
 580                 struct ipw_tty *ttyj = ttys[j];
 581
 582                 if (ttyj) {
 583                         mutex_lock(&ttyj->ipw_tty_mutex);
 584                         if (get_tty(j + ipw_tty_driver->minor_start) == ttyj)
 585                                 report_deregistering(ttyj);
 586                         ttyj->closing = 1;
 587                         if (ttyj->linux_tty != NULL) {
 588                                 mutex_unlock(&ttyj->ipw_tty_mutex);
 589                                 tty_hangup(ttyj->linux_tty);
 590                                 /* Wait till the tty_hangup has completed */
 591                                 flush_scheduled_work();
 592                                 mutex_lock(&ttyj->ipw_tty_mutex);
 593                         }
 594                         while (ttyj->open_count)
 595                                 do_ipw_close(ttyj);
 596                         ipwireless_disassociate_network_ttys(network,
 597                                                              ttyj->channel_idx);
 598                         tty_unregister_device(ipw_tty_driver, j);
 599                         ttys[j] = NULL;
 600                         mutex_unlock(&ttyj->ipw_tty_mutex);
 601                         kfree(ttyj);
 602                 }
 603         }
 604 }
 605
 606 static struct tty_operations tty_ops = {
 607         .open = ipw_open,
 608         .close = ipw_close,
 609         .hangup = ipw_hangup,
 610         .write = ipw_write,
 611         .write_room = ipw_write_room,
 612         .ioctl = ipw_ioctl,
 613         .chars_in_buffer = ipw_chars_in_buffer,
 614         .tiocmget = ipw_tiocmget,
 615         .tiocmset = ipw_tiocmset,
 616 };
 617
 618 int ipwireless_tty_init(void)
 619 {
 620         int result;
 621
 622         ipw_tty_driver = alloc_tty_driver(IPWIRELESS_PCMCIA_MINORS);
 623         if (!ipw_tty_driver)
 624                 return -ENOMEM;
 625
 626         ipw_tty_driver->owner = THIS_MODULE;
 627         ipw_tty_driver->driver_name = IPWIRELESS_PCCARD_NAME;
 628         ipw_tty_driver->name = "ttyIPWp";
 629         ipw_tty_driver->major = 0;
 630         ipw_tty_driver->minor_start = IPWIRELESS_PCMCIA_START;
 631         ipw_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
 632         ipw_tty_driver->subtype = SERIAL_TYPE_NORMAL;
 633         ipw_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
 634         ipw_tty_driver->init_termios = tty_std_termios;
 635         ipw_tty_driver->init_termios.c_cflag =
 636             B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 637         ipw_tty_driver->init_termios.c_ispeed = 9600;
 638         ipw_tty_driver->init_termios.c_ospeed = 9600;
 639         tty_set_operations(ipw_tty_driver, &tty_ops);
 640         result = tty_register_driver(ipw_tty_driver);
 641         if (result) {
 642                 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
 643                        ": failed to register tty driver\n");
 644                 put_tty_driver(ipw_tty_driver);
 645                 return result;
 646         }
 647
 648         return 0;
 649 }
 650
 651 void ipwireless_tty_release(void)
 652 {
 653         int ret;
 654
 655         ret = tty_unregister_driver(ipw_tty_driver);
 656         put_tty_driver(ipw_tty_driver);
 657         if (ret != 0)
 658                 printk(KERN_ERR IPWIRELESS_PCCARD_NAME
 659                         ": tty_unregister_driver failed with code %d\n", ret);
 660 }
 661
 662 int ipwireless_tty_is_modem(struct ipw_tty *tty)
 663 {
 664         return tty->tty_type == TTYTYPE_MODEM;
 665 }
 666
 667 void
 668 ipwireless_tty_notify_control_line_change(struct ipw_tty *tty,
 669                                           unsigned int channel_idx,
 670                                           unsigned int control_lines,
 671                                           unsigned int changed_mask)
 672 {
 673         unsigned int old_control_lines = tty->control_lines;
 674
 675         tty->control_lines = (tty->control_lines & ~changed_mask)
 676                 | (control_lines & changed_mask);
 677
 678         /*
 679          * If DCD is de-asserted, we close the tty so pppd can tell that we
 680          * have gone offline.
 681          */
 682         if ((old_control_lines & IPW_CONTROL_LINE_DCD)
 683                         && !(tty->control_lines & IPW_CONTROL_LINE_DCD)
 684                         && tty->linux_tty) {
 685                 tty_hangup(tty->linux_tty);
 686         }
 687 }
 688