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