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