1 /* 2 * nozomi.c -- HSDPA driver Broadband Wireless Data Card - Globe Trotter 3 * 4 * Written by: Ulf Jakobsson, 5 * Jan Åkerfeldt, 6 * Stefan Thomasson, 7 * 8 * Maintained by: Paul Hardwick (p.hardwick@option.com) 9 * 10 * Patches: 11 * Locking code changes for Vodafone by Sphere Systems Ltd, 12 * Andrew Bird (ajb@spheresystems.co.uk ) 13 * & Phil Sanderson 14 * 15 * Source has been ported from an implementation made by Filip Aben @ Option 16 * 17 * -------------------------------------------------------------------------- 18 * 19 * Copyright (c) 2005,2006 Option Wireless Sweden AB 20 * Copyright (c) 2006 Sphere Systems Ltd 21 * Copyright (c) 2006 Option Wireless n/v 22 * All rights Reserved. 23 * 24 * This program is free software; you can redistribute it and/or modify 25 * it under the terms of the GNU General Public License as published by 26 * the Free Software Foundation; either version 2 of the License, or 27 * (at your option) any later version. 28 * 29 * This program is distributed in the hope that it will be useful, 30 * but WITHOUT ANY WARRANTY; without even the implied warranty of 31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 32 * GNU General Public License for more details. 33 * 34 * You should have received a copy of the GNU General Public License 35 * along with this program; if not, write to the Free Software 36 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 37 * 38 * -------------------------------------------------------------------------- 39 */ 40 41 /* Enable this to have a lot of debug printouts */ 42 #define DEBUG 43 44 #include <linux/kernel.h> 45 #include <linux/module.h> 46 #include <linux/pci.h> 47 #include <linux/ioport.h> 48 #include <linux/tty.h> 49 #include <linux/tty_driver.h> 50 #include <linux/tty_flip.h> 51 #include <linux/sched.h> 52 #include <linux/serial.h> 53 #include <linux/interrupt.h> 54 #include <linux/kmod.h> 55 #include <linux/init.h> 56 #include <linux/kfifo.h> 57 #include <linux/uaccess.h> 58 #include <linux/slab.h> 59 #include <asm/byteorder.h> 60 61 #include <linux/delay.h> 62 63 64 #define VERSION_STRING DRIVER_DESC " 2.1d" 65 66 /* Macros definitions */ 67 68 /* Default debug printout level */ 69 #define NOZOMI_DEBUG_LEVEL 0x00 70 71 #define P_BUF_SIZE 128 72 #define NFO(_err_flag_, args...) \ 73 do { \ 74 char tmp[P_BUF_SIZE]; \ 75 snprintf(tmp, sizeof(tmp), ##args); \ 76 printk(_err_flag_ "[%d] %s(): %s\n", __LINE__, \ 77 __func__, tmp); \ 78 } while (0) 79 80 #define DBG1(args...) D_(0x01, ##args) 81 #define DBG2(args...) D_(0x02, ##args) 82 #define DBG3(args...) D_(0x04, ##args) 83 #define DBG4(args...) D_(0x08, ##args) 84 #define DBG5(args...) D_(0x10, ##args) 85 #define DBG6(args...) D_(0x20, ##args) 86 #define DBG7(args...) D_(0x40, ##args) 87 #define DBG8(args...) D_(0x80, ##args) 88 89 #ifdef DEBUG 90 /* Do we need this settable at runtime? */ 91 static int debug = NOZOMI_DEBUG_LEVEL; 92 93 #define D(lvl, args...) do \ 94 {if (lvl & debug) NFO(KERN_DEBUG, ##args); } \ 95 while (0) 96 #define D_(lvl, args...) D(lvl, ##args) 97 98 /* These printouts are always printed */ 99 100 #else 101 static int debug; 102 #define D_(lvl, args...) 103 #endif 104 105 /* TODO: rewrite to optimize macros... */ 106 107 #define TMP_BUF_MAX 256 108 109 #define DUMP(buf__,len__) \ 110 do { \ 111 char tbuf[TMP_BUF_MAX] = {0};\ 112 if (len__ > 1) {\ 113 snprintf(tbuf, len__ > TMP_BUF_MAX ? TMP_BUF_MAX : len__, "%s", buf__);\ 114 if (tbuf[len__-2] == '\r') {\ 115 tbuf[len__-2] = 'r';\ 116 } \ 117 DBG1("SENDING: '%s' (%d+n)", tbuf, len__);\ 118 } else {\ 119 DBG1("SENDING: '%s' (%d)", tbuf, len__);\ 120 } \ 121 } while (0) 122 123 /* Defines */ 124 #define NOZOMI_NAME "nozomi" 125 #define NOZOMI_NAME_TTY "nozomi_tty" 126 #define DRIVER_DESC "Nozomi driver" 127 128 #define NTTY_TTY_MAXMINORS 256 129 #define NTTY_FIFO_BUFFER_SIZE 8192 130 131 /* Must be power of 2 */ 132 #define FIFO_BUFFER_SIZE_UL 8192 133 134 /* Size of tmp send buffer to card */ 135 #define SEND_BUF_MAX 1024 136 #define RECEIVE_BUF_MAX 4 137 138 139 #define R_IIR 0x0000 /* Interrupt Identity Register */ 140 #define R_FCR 0x0000 /* Flow Control Register */ 141 #define R_IER 0x0004 /* Interrupt Enable Register */ 142 143 #define CONFIG_MAGIC 0xEFEFFEFE 144 #define TOGGLE_VALID 0x0000 145 146 /* Definition of interrupt tokens */ 147 #define MDM_DL1 0x0001 148 #define MDM_UL1 0x0002 149 #define MDM_DL2 0x0004 150 #define MDM_UL2 0x0008 151 #define DIAG_DL1 0x0010 152 #define DIAG_DL2 0x0020 153 #define DIAG_UL 0x0040 154 #define APP1_DL 0x0080 155 #define APP1_UL 0x0100 156 #define APP2_DL 0x0200 157 #define APP2_UL 0x0400 158 #define CTRL_DL 0x0800 159 #define CTRL_UL 0x1000 160 #define RESET 0x8000 161 162 #define MDM_DL (MDM_DL1 | MDM_DL2) 163 #define MDM_UL (MDM_UL1 | MDM_UL2) 164 #define DIAG_DL (DIAG_DL1 | DIAG_DL2) 165 166 /* modem signal definition */ 167 #define CTRL_DSR 0x0001 168 #define CTRL_DCD 0x0002 169 #define CTRL_RI 0x0004 170 #define CTRL_CTS 0x0008 171 172 #define CTRL_DTR 0x0001 173 #define CTRL_RTS 0x0002 174 175 #define MAX_PORT 4 176 #define NOZOMI_MAX_PORTS 5 177 #define NOZOMI_MAX_CARDS (NTTY_TTY_MAXMINORS / MAX_PORT) 178 179 /* Type definitions */ 180 181 /* 182 * There are two types of nozomi cards, 183 * one with 2048 memory and with 8192 memory 184 */ 185 enum card_type { 186 F32_2 = 2048, /* 512 bytes downlink + uplink * 2 -> 2048 */ 187 F32_8 = 8192, /* 3072 bytes downl. + 1024 bytes uplink * 2 -> 8192 */ 188 }; 189 190 /* Initialization states a card can be in */ 191 enum card_state { 192 NOZOMI_STATE_UKNOWN = 0, 193 NOZOMI_STATE_ENABLED = 1, /* pci device enabled */ 194 NOZOMI_STATE_ALLOCATED = 2, /* config setup done */ 195 NOZOMI_STATE_READY = 3, /* flowcontrols received */ 196 }; 197 198 /* Two different toggle channels exist */ 199 enum channel_type { 200 CH_A = 0, 201 CH_B = 1, 202 }; 203 204 /* Port definition for the card regarding flow control */ 205 enum ctrl_port_type { 206 CTRL_CMD = 0, 207 CTRL_MDM = 1, 208 CTRL_DIAG = 2, 209 CTRL_APP1 = 3, 210 CTRL_APP2 = 4, 211 CTRL_ERROR = -1, 212 }; 213 214 /* Ports that the nozomi has */ 215 enum port_type { 216 PORT_MDM = 0, 217 PORT_DIAG = 1, 218 PORT_APP1 = 2, 219 PORT_APP2 = 3, 220 PORT_CTRL = 4, 221 PORT_ERROR = -1, 222 }; 223 224 #ifdef __BIG_ENDIAN 225 /* Big endian */ 226 227 struct toggles { 228 unsigned int enabled:5; /* 229 * Toggle fields are valid if enabled is 0, 230 * else A-channels must always be used. 231 */ 232 unsigned int diag_dl:1; 233 unsigned int mdm_dl:1; 234 unsigned int mdm_ul:1; 235 } __attribute__ ((packed)); 236 237 /* Configuration table to read at startup of card */ 238 /* Is for now only needed during initialization phase */ 239 struct config_table { 240 u32 signature; 241 u16 product_information; 242 u16 version; 243 u8 pad3[3]; 244 struct toggles toggle; 245 u8 pad1[4]; 246 u16 dl_mdm_len1; /* 247 * If this is 64, it can hold 248 * 60 bytes + 4 that is length field 249 */ 250 u16 dl_start; 251 252 u16 dl_diag_len1; 253 u16 dl_mdm_len2; /* 254 * If this is 64, it can hold 255 * 60 bytes + 4 that is length field 256 */ 257 u16 dl_app1_len; 258 259 u16 dl_diag_len2; 260 u16 dl_ctrl_len; 261 u16 dl_app2_len; 262 u8 pad2[16]; 263 u16 ul_mdm_len1; 264 u16 ul_start; 265 u16 ul_diag_len; 266 u16 ul_mdm_len2; 267 u16 ul_app1_len; 268 u16 ul_app2_len; 269 u16 ul_ctrl_len; 270 } __attribute__ ((packed)); 271 272 /* This stores all control downlink flags */ 273 struct ctrl_dl { 274 u8 port; 275 unsigned int reserved:4; 276 unsigned int CTS:1; 277 unsigned int RI:1; 278 unsigned int DCD:1; 279 unsigned int DSR:1; 280 } __attribute__ ((packed)); 281 282 /* This stores all control uplink flags */ 283 struct ctrl_ul { 284 u8 port; 285 unsigned int reserved:6; 286 unsigned int RTS:1; 287 unsigned int DTR:1; 288 } __attribute__ ((packed)); 289 290 #else 291 /* Little endian */ 292 293 /* This represents the toggle information */ 294 struct toggles { 295 unsigned int mdm_ul:1; 296 unsigned int mdm_dl:1; 297 unsigned int diag_dl:1; 298 unsigned int enabled:5; /* 299 * Toggle fields are valid if enabled is 0, 300 * else A-channels must always be used. 301 */ 302 } __attribute__ ((packed)); 303 304 /* Configuration table to read at startup of card */ 305 struct config_table { 306 u32 signature; 307 u16 version; 308 u16 product_information; 309 struct toggles toggle; 310 u8 pad1[7]; 311 u16 dl_start; 312 u16 dl_mdm_len1; /* 313 * If this is 64, it can hold 314 * 60 bytes + 4 that is length field 315 */ 316 u16 dl_mdm_len2; 317 u16 dl_diag_len1; 318 u16 dl_diag_len2; 319 u16 dl_app1_len; 320 u16 dl_app2_len; 321 u16 dl_ctrl_len; 322 u8 pad2[16]; 323 u16 ul_start; 324 u16 ul_mdm_len2; 325 u16 ul_mdm_len1; 326 u16 ul_diag_len; 327 u16 ul_app1_len; 328 u16 ul_app2_len; 329 u16 ul_ctrl_len; 330 } __attribute__ ((packed)); 331 332 /* This stores all control downlink flags */ 333 struct ctrl_dl { 334 unsigned int DSR:1; 335 unsigned int DCD:1; 336 unsigned int RI:1; 337 unsigned int CTS:1; 338 unsigned int reserverd:4; 339 u8 port; 340 } __attribute__ ((packed)); 341 342 /* This stores all control uplink flags */ 343 struct ctrl_ul { 344 unsigned int DTR:1; 345 unsigned int RTS:1; 346 unsigned int reserved:6; 347 u8 port; 348 } __attribute__ ((packed)); 349 #endif 350 351 /* This holds all information that is needed regarding a port */ 352 struct port { 353 struct tty_port port; 354 u8 update_flow_control; 355 struct ctrl_ul ctrl_ul; 356 struct ctrl_dl ctrl_dl; 357 struct kfifo fifo_ul; 358 void __iomem *dl_addr[2]; 359 u32 dl_size[2]; 360 u8 toggle_dl; 361 void __iomem *ul_addr[2]; 362 u32 ul_size[2]; 363 u8 toggle_ul; 364 u16 token_dl; 365 366 wait_queue_head_t tty_wait; 367 struct async_icount tty_icount; 368 369 struct nozomi *dc; 370 }; 371 372 /* Private data one for each card in the system */ 373 struct nozomi { 374 void __iomem *base_addr; 375 unsigned long flip; 376 377 /* Pointers to registers */ 378 void __iomem *reg_iir; 379 void __iomem *reg_fcr; 380 void __iomem *reg_ier; 381 382 u16 last_ier; 383 enum card_type card_type; 384 struct config_table config_table; /* Configuration table */ 385 struct pci_dev *pdev; 386 struct port port[NOZOMI_MAX_PORTS]; 387 u8 *send_buf; 388 389 spinlock_t spin_mutex; /* secures access to registers and tty */ 390 391 unsigned int index_start; 392 enum card_state state; 393 u32 open_ttys; 394 }; 395 396 /* This is a data packet that is read or written to/from card */ 397 struct buffer { 398 u32 size; /* size is the length of the data buffer */ 399 u8 *data; 400 } __attribute__ ((packed)); 401 402 /* Global variables */ 403 static const struct pci_device_id nozomi_pci_tbl[] = { 404 {PCI_DEVICE(0x1931, 0x000c)}, /* Nozomi HSDPA */ 405 {}, 406 }; 407 408 MODULE_DEVICE_TABLE(pci, nozomi_pci_tbl); 409 410 static struct nozomi *ndevs[NOZOMI_MAX_CARDS]; 411 static struct tty_driver *ntty_driver; 412 413 static const struct tty_port_operations noz_tty_port_ops; 414 415 /* 416 * find card by tty_index 417 */ 418 static inline struct nozomi *get_dc_by_tty(const struct tty_struct *tty) 419 { 420 return tty ? ndevs[tty->index / MAX_PORT] : NULL; 421 } 422 423 static inline struct port *get_port_by_tty(const struct tty_struct *tty) 424 { 425 struct nozomi *ndev = get_dc_by_tty(tty); 426 return ndev ? &ndev->port[tty->index % MAX_PORT] : NULL; 427 } 428 429 /* 430 * TODO: 431 * -Optimize 432 * -Rewrite cleaner 433 */ 434 435 static void read_mem32(u32 *buf, const void __iomem *mem_addr_start, 436 u32 size_bytes) 437 { 438 u32 i = 0; 439 const u32 __iomem *ptr = mem_addr_start; 440 u16 *buf16; 441 442 if (unlikely(!ptr || !buf)) 443 goto out; 444 445 /* shortcut for extremely often used cases */ 446 switch (size_bytes) { 447 case 2: /* 2 bytes */ 448 buf16 = (u16 *) buf; 449 *buf16 = __le16_to_cpu(readw(ptr)); 450 goto out; 451 break; 452 case 4: /* 4 bytes */ 453 *(buf) = __le32_to_cpu(readl(ptr)); 454 goto out; 455 break; 456 } 457 458 while (i < size_bytes) { 459 if (size_bytes - i == 2) { 460 /* Handle 2 bytes in the end */ 461 buf16 = (u16 *) buf; 462 *(buf16) = __le16_to_cpu(readw(ptr)); 463 i += 2; 464 } else { 465 /* Read 4 bytes */ 466 *(buf) = __le32_to_cpu(readl(ptr)); 467 i += 4; 468 } 469 buf++; 470 ptr++; 471 } 472 out: 473 return; 474 } 475 476 /* 477 * TODO: 478 * -Optimize 479 * -Rewrite cleaner 480 */ 481 static u32 write_mem32(void __iomem *mem_addr_start, const u32 *buf, 482 u32 size_bytes) 483 { 484 u32 i = 0; 485 u32 __iomem *ptr = mem_addr_start; 486 const u16 *buf16; 487 488 if (unlikely(!ptr || !buf)) 489 return 0; 490 491 /* shortcut for extremely often used cases */ 492 switch (size_bytes) { 493 case 2: /* 2 bytes */ 494 buf16 = (const u16 *)buf; 495 writew(__cpu_to_le16(*buf16), ptr); 496 return 2; 497 break; 498 case 1: /* 499 * also needs to write 4 bytes in this case 500 * so falling through.. 501 */ 502 case 4: /* 4 bytes */ 503 writel(__cpu_to_le32(*buf), ptr); 504 return 4; 505 break; 506 } 507 508 while (i < size_bytes) { 509 if (size_bytes - i == 2) { 510 /* 2 bytes */ 511 buf16 = (const u16 *)buf; 512 writew(__cpu_to_le16(*buf16), ptr); 513 i += 2; 514 } else { 515 /* 4 bytes */ 516 writel(__cpu_to_le32(*buf), ptr); 517 i += 4; 518 } 519 buf++; 520 ptr++; 521 } 522 return i; 523 } 524 525 /* Setup pointers to different channels and also setup buffer sizes. */ 526 static void setup_memory(struct nozomi *dc) 527 { 528 void __iomem *offset = dc->base_addr + dc->config_table.dl_start; 529 /* The length reported is including the length field of 4 bytes, 530 * hence subtract with 4. 531 */ 532 const u16 buff_offset = 4; 533 534 /* Modem port dl configuration */ 535 dc->port[PORT_MDM].dl_addr[CH_A] = offset; 536 dc->port[PORT_MDM].dl_addr[CH_B] = 537 (offset += dc->config_table.dl_mdm_len1); 538 dc->port[PORT_MDM].dl_size[CH_A] = 539 dc->config_table.dl_mdm_len1 - buff_offset; 540 dc->port[PORT_MDM].dl_size[CH_B] = 541 dc->config_table.dl_mdm_len2 - buff_offset; 542 543 /* Diag port dl configuration */ 544 dc->port[PORT_DIAG].dl_addr[CH_A] = 545 (offset += dc->config_table.dl_mdm_len2); 546 dc->port[PORT_DIAG].dl_size[CH_A] = 547 dc->config_table.dl_diag_len1 - buff_offset; 548 dc->port[PORT_DIAG].dl_addr[CH_B] = 549 (offset += dc->config_table.dl_diag_len1); 550 dc->port[PORT_DIAG].dl_size[CH_B] = 551 dc->config_table.dl_diag_len2 - buff_offset; 552 553 /* App1 port dl configuration */ 554 dc->port[PORT_APP1].dl_addr[CH_A] = 555 (offset += dc->config_table.dl_diag_len2); 556 dc->port[PORT_APP1].dl_size[CH_A] = 557 dc->config_table.dl_app1_len - buff_offset; 558 559 /* App2 port dl configuration */ 560 dc->port[PORT_APP2].dl_addr[CH_A] = 561 (offset += dc->config_table.dl_app1_len); 562 dc->port[PORT_APP2].dl_size[CH_A] = 563 dc->config_table.dl_app2_len - buff_offset; 564 565 /* Ctrl dl configuration */ 566 dc->port[PORT_CTRL].dl_addr[CH_A] = 567 (offset += dc->config_table.dl_app2_len); 568 dc->port[PORT_CTRL].dl_size[CH_A] = 569 dc->config_table.dl_ctrl_len - buff_offset; 570 571 offset = dc->base_addr + dc->config_table.ul_start; 572 573 /* Modem Port ul configuration */ 574 dc->port[PORT_MDM].ul_addr[CH_A] = offset; 575 dc->port[PORT_MDM].ul_size[CH_A] = 576 dc->config_table.ul_mdm_len1 - buff_offset; 577 dc->port[PORT_MDM].ul_addr[CH_B] = 578 (offset += dc->config_table.ul_mdm_len1); 579 dc->port[PORT_MDM].ul_size[CH_B] = 580 dc->config_table.ul_mdm_len2 - buff_offset; 581 582 /* Diag port ul configuration */ 583 dc->port[PORT_DIAG].ul_addr[CH_A] = 584 (offset += dc->config_table.ul_mdm_len2); 585 dc->port[PORT_DIAG].ul_size[CH_A] = 586 dc->config_table.ul_diag_len - buff_offset; 587 588 /* App1 port ul configuration */ 589 dc->port[PORT_APP1].ul_addr[CH_A] = 590 (offset += dc->config_table.ul_diag_len); 591 dc->port[PORT_APP1].ul_size[CH_A] = 592 dc->config_table.ul_app1_len - buff_offset; 593 594 /* App2 port ul configuration */ 595 dc->port[PORT_APP2].ul_addr[CH_A] = 596 (offset += dc->config_table.ul_app1_len); 597 dc->port[PORT_APP2].ul_size[CH_A] = 598 dc->config_table.ul_app2_len - buff_offset; 599 600 /* Ctrl ul configuration */ 601 dc->port[PORT_CTRL].ul_addr[CH_A] = 602 (offset += dc->config_table.ul_app2_len); 603 dc->port[PORT_CTRL].ul_size[CH_A] = 604 dc->config_table.ul_ctrl_len - buff_offset; 605 } 606 607 /* Dump config table under initalization phase */ 608 #ifdef DEBUG 609 static void dump_table(const struct nozomi *dc) 610 { 611 DBG3("signature: 0x%08X", dc->config_table.signature); 612 DBG3("version: 0x%04X", dc->config_table.version); 613 DBG3("product_information: 0x%04X", \ 614 dc->config_table.product_information); 615 DBG3("toggle enabled: %d", dc->config_table.toggle.enabled); 616 DBG3("toggle up_mdm: %d", dc->config_table.toggle.mdm_ul); 617 DBG3("toggle dl_mdm: %d", dc->config_table.toggle.mdm_dl); 618 DBG3("toggle dl_dbg: %d", dc->config_table.toggle.diag_dl); 619 620 DBG3("dl_start: 0x%04X", dc->config_table.dl_start); 621 DBG3("dl_mdm_len0: 0x%04X, %d", dc->config_table.dl_mdm_len1, 622 dc->config_table.dl_mdm_len1); 623 DBG3("dl_mdm_len1: 0x%04X, %d", dc->config_table.dl_mdm_len2, 624 dc->config_table.dl_mdm_len2); 625 DBG3("dl_diag_len0: 0x%04X, %d", dc->config_table.dl_diag_len1, 626 dc->config_table.dl_diag_len1); 627 DBG3("dl_diag_len1: 0x%04X, %d", dc->config_table.dl_diag_len2, 628 dc->config_table.dl_diag_len2); 629 DBG3("dl_app1_len: 0x%04X, %d", dc->config_table.dl_app1_len, 630 dc->config_table.dl_app1_len); 631 DBG3("dl_app2_len: 0x%04X, %d", dc->config_table.dl_app2_len, 632 dc->config_table.dl_app2_len); 633 DBG3("dl_ctrl_len: 0x%04X, %d", dc->config_table.dl_ctrl_len, 634 dc->config_table.dl_ctrl_len); 635 DBG3("ul_start: 0x%04X, %d", dc->config_table.ul_start, 636 dc->config_table.ul_start); 637 DBG3("ul_mdm_len[0]: 0x%04X, %d", dc->config_table.ul_mdm_len1, 638 dc->config_table.ul_mdm_len1); 639 DBG3("ul_mdm_len[1]: 0x%04X, %d", dc->config_table.ul_mdm_len2, 640 dc->config_table.ul_mdm_len2); 641 DBG3("ul_diag_len: 0x%04X, %d", dc->config_table.ul_diag_len, 642 dc->config_table.ul_diag_len); 643 DBG3("ul_app1_len: 0x%04X, %d", dc->config_table.ul_app1_len, 644 dc->config_table.ul_app1_len); 645 DBG3("ul_app2_len: 0x%04X, %d", dc->config_table.ul_app2_len, 646 dc->config_table.ul_app2_len); 647 DBG3("ul_ctrl_len: 0x%04X, %d", dc->config_table.ul_ctrl_len, 648 dc->config_table.ul_ctrl_len); 649 } 650 #else 651 static inline void dump_table(const struct nozomi *dc) { } 652 #endif 653 654 /* 655 * Read configuration table from card under intalization phase 656 * Returns 1 if ok, else 0 657 */ 658 static int nozomi_read_config_table(struct nozomi *dc) 659 { 660 read_mem32((u32 *) &dc->config_table, dc->base_addr + 0, 661 sizeof(struct config_table)); 662 663 if (dc->config_table.signature != CONFIG_MAGIC) { 664 dev_err(&dc->pdev->dev, "ConfigTable Bad! 0x%08X != 0x%08X\n", 665 dc->config_table.signature, CONFIG_MAGIC); 666 return 0; 667 } 668 669 if ((dc->config_table.version == 0) 670 || (dc->config_table.toggle.enabled == TOGGLE_VALID)) { 671 int i; 672 DBG1("Second phase, configuring card"); 673 674 setup_memory(dc); 675 676 dc->port[PORT_MDM].toggle_ul = dc->config_table.toggle.mdm_ul; 677 dc->port[PORT_MDM].toggle_dl = dc->config_table.toggle.mdm_dl; 678 dc->port[PORT_DIAG].toggle_dl = dc->config_table.toggle.diag_dl; 679 DBG1("toggle ports: MDM UL:%d MDM DL:%d, DIAG DL:%d", 680 dc->port[PORT_MDM].toggle_ul, 681 dc->port[PORT_MDM].toggle_dl, dc->port[PORT_DIAG].toggle_dl); 682 683 dump_table(dc); 684 685 for (i = PORT_MDM; i < MAX_PORT; i++) { 686 memset(&dc->port[i].ctrl_dl, 0, sizeof(struct ctrl_dl)); 687 memset(&dc->port[i].ctrl_ul, 0, sizeof(struct ctrl_ul)); 688 } 689 690 /* Enable control channel */ 691 dc->last_ier = dc->last_ier | CTRL_DL; 692 writew(dc->last_ier, dc->reg_ier); 693 694 dc->state = NOZOMI_STATE_ALLOCATED; 695 dev_info(&dc->pdev->dev, "Initialization OK!\n"); 696 return 1; 697 } 698 699 if ((dc->config_table.version > 0) 700 && (dc->config_table.toggle.enabled != TOGGLE_VALID)) { 701 u32 offset = 0; 702 DBG1("First phase: pushing upload buffers, clearing download"); 703 704 dev_info(&dc->pdev->dev, "Version of card: %d\n", 705 dc->config_table.version); 706 707 /* Here we should disable all I/O over F32. */ 708 setup_memory(dc); 709 710 /* 711 * We should send ALL channel pair tokens back along 712 * with reset token 713 */ 714 715 /* push upload modem buffers */ 716 write_mem32(dc->port[PORT_MDM].ul_addr[CH_A], 717 (u32 *) &offset, 4); 718 write_mem32(dc->port[PORT_MDM].ul_addr[CH_B], 719 (u32 *) &offset, 4); 720 721 writew(MDM_UL | DIAG_DL | MDM_DL, dc->reg_fcr); 722 723 DBG1("First phase done"); 724 } 725 726 return 1; 727 } 728 729 /* Enable uplink interrupts */ 730 static void enable_transmit_ul(enum port_type port, struct nozomi *dc) 731 { 732 static const u16 mask[] = {MDM_UL, DIAG_UL, APP1_UL, APP2_UL, CTRL_UL}; 733 734 if (port < NOZOMI_MAX_PORTS) { 735 dc->last_ier |= mask[port]; 736 writew(dc->last_ier, dc->reg_ier); 737 } else { 738 dev_err(&dc->pdev->dev, "Called with wrong port?\n"); 739 } 740 } 741 742 /* Disable uplink interrupts */ 743 static void disable_transmit_ul(enum port_type port, struct nozomi *dc) 744 { 745 static const u16 mask[] = 746 {~MDM_UL, ~DIAG_UL, ~APP1_UL, ~APP2_UL, ~CTRL_UL}; 747 748 if (port < NOZOMI_MAX_PORTS) { 749 dc->last_ier &= mask[port]; 750 writew(dc->last_ier, dc->reg_ier); 751 } else { 752 dev_err(&dc->pdev->dev, "Called with wrong port?\n"); 753 } 754 } 755 756 /* Enable downlink interrupts */ 757 static void enable_transmit_dl(enum port_type port, struct nozomi *dc) 758 { 759 static const u16 mask[] = {MDM_DL, DIAG_DL, APP1_DL, APP2_DL, CTRL_DL}; 760 761 if (port < NOZOMI_MAX_PORTS) { 762 dc->last_ier |= mask[port]; 763 writew(dc->last_ier, dc->reg_ier); 764 } else { 765 dev_err(&dc->pdev->dev, "Called with wrong port?\n"); 766 } 767 } 768 769 /* Disable downlink interrupts */ 770 static void disable_transmit_dl(enum port_type port, struct nozomi *dc) 771 { 772 static const u16 mask[] = 773 {~MDM_DL, ~DIAG_DL, ~APP1_DL, ~APP2_DL, ~CTRL_DL}; 774 775 if (port < NOZOMI_MAX_PORTS) { 776 dc->last_ier &= mask[port]; 777 writew(dc->last_ier, dc->reg_ier); 778 } else { 779 dev_err(&dc->pdev->dev, "Called with wrong port?\n"); 780 } 781 } 782 783 /* 784 * Return 1 - send buffer to card and ack. 785 * Return 0 - don't ack, don't send buffer to card. 786 */ 787 static int send_data(enum port_type index, struct nozomi *dc) 788 { 789 u32 size = 0; 790 struct port *port = &dc->port[index]; 791 const u8 toggle = port->toggle_ul; 792 void __iomem *addr = port->ul_addr[toggle]; 793 const u32 ul_size = port->ul_size[toggle]; 794 struct tty_struct *tty = tty_port_tty_get(&port->port); 795 796 /* Get data from tty and place in buf for now */ 797 size = kfifo_out(&port->fifo_ul, dc->send_buf, 798 ul_size < SEND_BUF_MAX ? ul_size : SEND_BUF_MAX); 799 800 if (size == 0) { 801 DBG4("No more data to send, disable link:"); 802 tty_kref_put(tty); 803 return 0; 804 } 805 806 /* DUMP(buf, size); */ 807 808 /* Write length + data */ 809 write_mem32(addr, (u32 *) &size, 4); 810 write_mem32(addr + 4, (u32 *) dc->send_buf, size); 811 812 if (tty) 813 tty_wakeup(tty); 814 815 tty_kref_put(tty); 816 return 1; 817 } 818 819 /* If all data has been read, return 1, else 0 */ 820 static int receive_data(enum port_type index, struct nozomi *dc) 821 { 822 u8 buf[RECEIVE_BUF_MAX] = { 0 }; 823 int size; 824 u32 offset = 4; 825 struct port *port = &dc->port[index]; 826 void __iomem *addr = port->dl_addr[port->toggle_dl]; 827 struct tty_struct *tty = tty_port_tty_get(&port->port); 828 int i, ret; 829 830 read_mem32((u32 *) &size, addr, 4); 831 /* DBG1( "%d bytes port: %d", size, index); */ 832 833 if (tty && test_bit(TTY_THROTTLED, &tty->flags)) { 834 DBG1("No room in tty, don't read data, don't ack interrupt, " 835 "disable interrupt"); 836 837 /* disable interrupt in downlink... */ 838 disable_transmit_dl(index, dc); 839 ret = 0; 840 goto put; 841 } 842 843 if (unlikely(size == 0)) { 844 dev_err(&dc->pdev->dev, "size == 0?\n"); 845 ret = 1; 846 goto put; 847 } 848 849 while (size > 0) { 850 read_mem32((u32 *) buf, addr + offset, RECEIVE_BUF_MAX); 851 852 if (size == 1) { 853 tty_insert_flip_char(&port->port, buf[0], TTY_NORMAL); 854 size = 0; 855 } else if (size < RECEIVE_BUF_MAX) { 856 size -= tty_insert_flip_string(&port->port, 857 (char *)buf, size); 858 } else { 859 i = tty_insert_flip_string(&port->port, 860 (char *)buf, RECEIVE_BUF_MAX); 861 size -= i; 862 offset += i; 863 } 864 } 865 866 set_bit(index, &dc->flip); 867 ret = 1; 868 put: 869 tty_kref_put(tty); 870 return ret; 871 } 872 873 /* Debug for interrupts */ 874 #ifdef DEBUG 875 static char *interrupt2str(u16 interrupt) 876 { 877 static char buf[TMP_BUF_MAX]; 878 char *p = buf; 879 880 interrupt & MDM_DL1 ? p += snprintf(p, TMP_BUF_MAX, "MDM_DL1 ") : NULL; 881 interrupt & MDM_DL2 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 882 "MDM_DL2 ") : NULL; 883 884 interrupt & MDM_UL1 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 885 "MDM_UL1 ") : NULL; 886 interrupt & MDM_UL2 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 887 "MDM_UL2 ") : NULL; 888 889 interrupt & DIAG_DL1 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 890 "DIAG_DL1 ") : NULL; 891 interrupt & DIAG_DL2 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 892 "DIAG_DL2 ") : NULL; 893 894 interrupt & DIAG_UL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 895 "DIAG_UL ") : NULL; 896 897 interrupt & APP1_DL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 898 "APP1_DL ") : NULL; 899 interrupt & APP2_DL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 900 "APP2_DL ") : NULL; 901 902 interrupt & APP1_UL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 903 "APP1_UL ") : NULL; 904 interrupt & APP2_UL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 905 "APP2_UL ") : NULL; 906 907 interrupt & CTRL_DL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 908 "CTRL_DL ") : NULL; 909 interrupt & CTRL_UL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 910 "CTRL_UL ") : NULL; 911 912 interrupt & RESET ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 913 "RESET ") : NULL; 914 915 return buf; 916 } 917 #endif 918 919 /* 920 * Receive flow control 921 * Return 1 - If ok, else 0 922 */ 923 static int receive_flow_control(struct nozomi *dc) 924 { 925 enum port_type port = PORT_MDM; 926 struct ctrl_dl ctrl_dl; 927 struct ctrl_dl old_ctrl; 928 u16 enable_ier = 0; 929 930 read_mem32((u32 *) &ctrl_dl, dc->port[PORT_CTRL].dl_addr[CH_A], 2); 931 932 switch (ctrl_dl.port) { 933 case CTRL_CMD: 934 DBG1("The Base Band sends this value as a response to a " 935 "request for IMSI detach sent over the control " 936 "channel uplink (see section 7.6.1)."); 937 break; 938 case CTRL_MDM: 939 port = PORT_MDM; 940 enable_ier = MDM_DL; 941 break; 942 case CTRL_DIAG: 943 port = PORT_DIAG; 944 enable_ier = DIAG_DL; 945 break; 946 case CTRL_APP1: 947 port = PORT_APP1; 948 enable_ier = APP1_DL; 949 break; 950 case CTRL_APP2: 951 port = PORT_APP2; 952 enable_ier = APP2_DL; 953 if (dc->state == NOZOMI_STATE_ALLOCATED) { 954 /* 955 * After card initialization the flow control 956 * received for APP2 is always the last 957 */ 958 dc->state = NOZOMI_STATE_READY; 959 dev_info(&dc->pdev->dev, "Device READY!\n"); 960 } 961 break; 962 default: 963 dev_err(&dc->pdev->dev, 964 "ERROR: flow control received for non-existing port\n"); 965 return 0; 966 }; 967 968 DBG1("0x%04X->0x%04X", *((u16 *)&dc->port[port].ctrl_dl), 969 *((u16 *)&ctrl_dl)); 970 971 old_ctrl = dc->port[port].ctrl_dl; 972 dc->port[port].ctrl_dl = ctrl_dl; 973 974 if (old_ctrl.CTS == 1 && ctrl_dl.CTS == 0) { 975 DBG1("Disable interrupt (0x%04X) on port: %d", 976 enable_ier, port); 977 disable_transmit_ul(port, dc); 978 979 } else if (old_ctrl.CTS == 0 && ctrl_dl.CTS == 1) { 980 981 if (kfifo_len(&dc->port[port].fifo_ul)) { 982 DBG1("Enable interrupt (0x%04X) on port: %d", 983 enable_ier, port); 984 DBG1("Data in buffer [%d], enable transmit! ", 985 kfifo_len(&dc->port[port].fifo_ul)); 986 enable_transmit_ul(port, dc); 987 } else { 988 DBG1("No data in buffer..."); 989 } 990 } 991 992 if (*(u16 *)&old_ctrl == *(u16 *)&ctrl_dl) { 993 DBG1(" No change in mctrl"); 994 return 1; 995 } 996 /* Update statistics */ 997 if (old_ctrl.CTS != ctrl_dl.CTS) 998 dc->port[port].tty_icount.cts++; 999 if (old_ctrl.DSR != ctrl_dl.DSR) 1000 dc->port[port].tty_icount.dsr++; 1001 if (old_ctrl.RI != ctrl_dl.RI) 1002 dc->port[port].tty_icount.rng++; 1003 if (old_ctrl.DCD != ctrl_dl.DCD) 1004 dc->port[port].tty_icount.dcd++; 1005 1006 wake_up_interruptible(&dc->port[port].tty_wait); 1007 1008 DBG1("port: %d DCD(%d), CTS(%d), RI(%d), DSR(%d)", 1009 port, 1010 dc->port[port].tty_icount.dcd, dc->port[port].tty_icount.cts, 1011 dc->port[port].tty_icount.rng, dc->port[port].tty_icount.dsr); 1012 1013 return 1; 1014 } 1015 1016 static enum ctrl_port_type port2ctrl(enum port_type port, 1017 const struct nozomi *dc) 1018 { 1019 switch (port) { 1020 case PORT_MDM: 1021 return CTRL_MDM; 1022 case PORT_DIAG: 1023 return CTRL_DIAG; 1024 case PORT_APP1: 1025 return CTRL_APP1; 1026 case PORT_APP2: 1027 return CTRL_APP2; 1028 default: 1029 dev_err(&dc->pdev->dev, 1030 "ERROR: send flow control " \ 1031 "received for non-existing port\n"); 1032 }; 1033 return CTRL_ERROR; 1034 } 1035 1036 /* 1037 * Send flow control, can only update one channel at a time 1038 * Return 0 - If we have updated all flow control 1039 * Return 1 - If we need to update more flow control, ack current enable more 1040 */ 1041 static int send_flow_control(struct nozomi *dc) 1042 { 1043 u32 i, more_flow_control_to_be_updated = 0; 1044 u16 *ctrl; 1045 1046 for (i = PORT_MDM; i < MAX_PORT; i++) { 1047 if (dc->port[i].update_flow_control) { 1048 if (more_flow_control_to_be_updated) { 1049 /* We have more flow control to be updated */ 1050 return 1; 1051 } 1052 dc->port[i].ctrl_ul.port = port2ctrl(i, dc); 1053 ctrl = (u16 *)&dc->port[i].ctrl_ul; 1054 write_mem32(dc->port[PORT_CTRL].ul_addr[0], \ 1055 (u32 *) ctrl, 2); 1056 dc->port[i].update_flow_control = 0; 1057 more_flow_control_to_be_updated = 1; 1058 } 1059 } 1060 return 0; 1061 } 1062 1063 /* 1064 * Handle downlink data, ports that are handled are modem and diagnostics 1065 * Return 1 - ok 1066 * Return 0 - toggle fields are out of sync 1067 */ 1068 static int handle_data_dl(struct nozomi *dc, enum port_type port, u8 *toggle, 1069 u16 read_iir, u16 mask1, u16 mask2) 1070 { 1071 if (*toggle == 0 && read_iir & mask1) { 1072 if (receive_data(port, dc)) { 1073 writew(mask1, dc->reg_fcr); 1074 *toggle = !(*toggle); 1075 } 1076 1077 if (read_iir & mask2) { 1078 if (receive_data(port, dc)) { 1079 writew(mask2, dc->reg_fcr); 1080 *toggle = !(*toggle); 1081 } 1082 } 1083 } else if (*toggle == 1 && read_iir & mask2) { 1084 if (receive_data(port, dc)) { 1085 writew(mask2, dc->reg_fcr); 1086 *toggle = !(*toggle); 1087 } 1088 1089 if (read_iir & mask1) { 1090 if (receive_data(port, dc)) { 1091 writew(mask1, dc->reg_fcr); 1092 *toggle = !(*toggle); 1093 } 1094 } 1095 } else { 1096 dev_err(&dc->pdev->dev, "port out of sync!, toggle:%d\n", 1097 *toggle); 1098 return 0; 1099 } 1100 return 1; 1101 } 1102 1103 /* 1104 * Handle uplink data, this is currently for the modem port 1105 * Return 1 - ok 1106 * Return 0 - toggle field are out of sync 1107 */ 1108 static int handle_data_ul(struct nozomi *dc, enum port_type port, u16 read_iir) 1109 { 1110 u8 *toggle = &(dc->port[port].toggle_ul); 1111 1112 if (*toggle == 0 && read_iir & MDM_UL1) { 1113 dc->last_ier &= ~MDM_UL; 1114 writew(dc->last_ier, dc->reg_ier); 1115 if (send_data(port, dc)) { 1116 writew(MDM_UL1, dc->reg_fcr); 1117 dc->last_ier = dc->last_ier | MDM_UL; 1118 writew(dc->last_ier, dc->reg_ier); 1119 *toggle = !*toggle; 1120 } 1121 1122 if (read_iir & MDM_UL2) { 1123 dc->last_ier &= ~MDM_UL; 1124 writew(dc->last_ier, dc->reg_ier); 1125 if (send_data(port, dc)) { 1126 writew(MDM_UL2, dc->reg_fcr); 1127 dc->last_ier = dc->last_ier | MDM_UL; 1128 writew(dc->last_ier, dc->reg_ier); 1129 *toggle = !*toggle; 1130 } 1131 } 1132 1133 } else if (*toggle == 1 && read_iir & MDM_UL2) { 1134 dc->last_ier &= ~MDM_UL; 1135 writew(dc->last_ier, dc->reg_ier); 1136 if (send_data(port, dc)) { 1137 writew(MDM_UL2, dc->reg_fcr); 1138 dc->last_ier = dc->last_ier | MDM_UL; 1139 writew(dc->last_ier, dc->reg_ier); 1140 *toggle = !*toggle; 1141 } 1142 1143 if (read_iir & MDM_UL1) { 1144 dc->last_ier &= ~MDM_UL; 1145 writew(dc->last_ier, dc->reg_ier); 1146 if (send_data(port, dc)) { 1147 writew(MDM_UL1, dc->reg_fcr); 1148 dc->last_ier = dc->last_ier | MDM_UL; 1149 writew(dc->last_ier, dc->reg_ier); 1150 *toggle = !*toggle; 1151 } 1152 } 1153 } else { 1154 writew(read_iir & MDM_UL, dc->reg_fcr); 1155 dev_err(&dc->pdev->dev, "port out of sync!\n"); 1156 return 0; 1157 } 1158 return 1; 1159 } 1160 1161 static irqreturn_t interrupt_handler(int irq, void *dev_id) 1162 { 1163 struct nozomi *dc = dev_id; 1164 unsigned int a; 1165 u16 read_iir; 1166 1167 if (!dc) 1168 return IRQ_NONE; 1169 1170 spin_lock(&dc->spin_mutex); 1171 read_iir = readw(dc->reg_iir); 1172 1173 /* Card removed */ 1174 if (read_iir == (u16)-1) 1175 goto none; 1176 /* 1177 * Just handle interrupt enabled in IER 1178 * (by masking with dc->last_ier) 1179 */ 1180 read_iir &= dc->last_ier; 1181 1182 if (read_iir == 0) 1183 goto none; 1184 1185 1186 DBG4("%s irq:0x%04X, prev:0x%04X", interrupt2str(read_iir), read_iir, 1187 dc->last_ier); 1188 1189 if (read_iir & RESET) { 1190 if (unlikely(!nozomi_read_config_table(dc))) { 1191 dc->last_ier = 0x0; 1192 writew(dc->last_ier, dc->reg_ier); 1193 dev_err(&dc->pdev->dev, "Could not read status from " 1194 "card, we should disable interface\n"); 1195 } else { 1196 writew(RESET, dc->reg_fcr); 1197 } 1198 /* No more useful info if this was the reset interrupt. */ 1199 goto exit_handler; 1200 } 1201 if (read_iir & CTRL_UL) { 1202 DBG1("CTRL_UL"); 1203 dc->last_ier &= ~CTRL_UL; 1204 writew(dc->last_ier, dc->reg_ier); 1205 if (send_flow_control(dc)) { 1206 writew(CTRL_UL, dc->reg_fcr); 1207 dc->last_ier = dc->last_ier | CTRL_UL; 1208 writew(dc->last_ier, dc->reg_ier); 1209 } 1210 } 1211 if (read_iir & CTRL_DL) { 1212 receive_flow_control(dc); 1213 writew(CTRL_DL, dc->reg_fcr); 1214 } 1215 if (read_iir & MDM_DL) { 1216 if (!handle_data_dl(dc, PORT_MDM, 1217 &(dc->port[PORT_MDM].toggle_dl), read_iir, 1218 MDM_DL1, MDM_DL2)) { 1219 dev_err(&dc->pdev->dev, "MDM_DL out of sync!\n"); 1220 goto exit_handler; 1221 } 1222 } 1223 if (read_iir & MDM_UL) { 1224 if (!handle_data_ul(dc, PORT_MDM, read_iir)) { 1225 dev_err(&dc->pdev->dev, "MDM_UL out of sync!\n"); 1226 goto exit_handler; 1227 } 1228 } 1229 if (read_iir & DIAG_DL) { 1230 if (!handle_data_dl(dc, PORT_DIAG, 1231 &(dc->port[PORT_DIAG].toggle_dl), read_iir, 1232 DIAG_DL1, DIAG_DL2)) { 1233 dev_err(&dc->pdev->dev, "DIAG_DL out of sync!\n"); 1234 goto exit_handler; 1235 } 1236 } 1237 if (read_iir & DIAG_UL) { 1238 dc->last_ier &= ~DIAG_UL; 1239 writew(dc->last_ier, dc->reg_ier); 1240 if (send_data(PORT_DIAG, dc)) { 1241 writew(DIAG_UL, dc->reg_fcr); 1242 dc->last_ier = dc->last_ier | DIAG_UL; 1243 writew(dc->last_ier, dc->reg_ier); 1244 } 1245 } 1246 if (read_iir & APP1_DL) { 1247 if (receive_data(PORT_APP1, dc)) 1248 writew(APP1_DL, dc->reg_fcr); 1249 } 1250 if (read_iir & APP1_UL) { 1251 dc->last_ier &= ~APP1_UL; 1252 writew(dc->last_ier, dc->reg_ier); 1253 if (send_data(PORT_APP1, dc)) { 1254 writew(APP1_UL, dc->reg_fcr); 1255 dc->last_ier = dc->last_ier | APP1_UL; 1256 writew(dc->last_ier, dc->reg_ier); 1257 } 1258 } 1259 if (read_iir & APP2_DL) { 1260 if (receive_data(PORT_APP2, dc)) 1261 writew(APP2_DL, dc->reg_fcr); 1262 } 1263 if (read_iir & APP2_UL) { 1264 dc->last_ier &= ~APP2_UL; 1265 writew(dc->last_ier, dc->reg_ier); 1266 if (send_data(PORT_APP2, dc)) { 1267 writew(APP2_UL, dc->reg_fcr); 1268 dc->last_ier = dc->last_ier | APP2_UL; 1269 writew(dc->last_ier, dc->reg_ier); 1270 } 1271 } 1272 1273 exit_handler: 1274 spin_unlock(&dc->spin_mutex); 1275 1276 for (a = 0; a < NOZOMI_MAX_PORTS; a++) 1277 if (test_and_clear_bit(a, &dc->flip)) 1278 tty_flip_buffer_push(&dc->port[a].port); 1279 1280 return IRQ_HANDLED; 1281 none: 1282 spin_unlock(&dc->spin_mutex); 1283 return IRQ_NONE; 1284 } 1285 1286 static void nozomi_get_card_type(struct nozomi *dc) 1287 { 1288 int i; 1289 u32 size = 0; 1290 1291 for (i = 0; i < 6; i++) 1292 size += pci_resource_len(dc->pdev, i); 1293 1294 /* Assume card type F32_8 if no match */ 1295 dc->card_type = size == 2048 ? F32_2 : F32_8; 1296 1297 dev_info(&dc->pdev->dev, "Card type is: %d\n", dc->card_type); 1298 } 1299 1300 static void nozomi_setup_private_data(struct nozomi *dc) 1301 { 1302 void __iomem *offset = dc->base_addr + dc->card_type / 2; 1303 unsigned int i; 1304 1305 dc->reg_fcr = (void __iomem *)(offset + R_FCR); 1306 dc->reg_iir = (void __iomem *)(offset + R_IIR); 1307 dc->reg_ier = (void __iomem *)(offset + R_IER); 1308 dc->last_ier = 0; 1309 dc->flip = 0; 1310 1311 dc->port[PORT_MDM].token_dl = MDM_DL; 1312 dc->port[PORT_DIAG].token_dl = DIAG_DL; 1313 dc->port[PORT_APP1].token_dl = APP1_DL; 1314 dc->port[PORT_APP2].token_dl = APP2_DL; 1315 1316 for (i = 0; i < MAX_PORT; i++) 1317 init_waitqueue_head(&dc->port[i].tty_wait); 1318 } 1319 1320 static ssize_t card_type_show(struct device *dev, struct device_attribute *attr, 1321 char *buf) 1322 { 1323 const struct nozomi *dc = pci_get_drvdata(to_pci_dev(dev)); 1324 1325 return sprintf(buf, "%d\n", dc->card_type); 1326 } 1327 static DEVICE_ATTR(card_type, S_IRUGO, card_type_show, NULL); 1328 1329 static ssize_t open_ttys_show(struct device *dev, struct device_attribute *attr, 1330 char *buf) 1331 { 1332 const struct nozomi *dc = pci_get_drvdata(to_pci_dev(dev)); 1333 1334 return sprintf(buf, "%u\n", dc->open_ttys); 1335 } 1336 static DEVICE_ATTR(open_ttys, S_IRUGO, open_ttys_show, NULL); 1337 1338 static void make_sysfs_files(struct nozomi *dc) 1339 { 1340 if (device_create_file(&dc->pdev->dev, &dev_attr_card_type)) 1341 dev_err(&dc->pdev->dev, 1342 "Could not create sysfs file for card_type\n"); 1343 if (device_create_file(&dc->pdev->dev, &dev_attr_open_ttys)) 1344 dev_err(&dc->pdev->dev, 1345 "Could not create sysfs file for open_ttys\n"); 1346 } 1347 1348 static void remove_sysfs_files(struct nozomi *dc) 1349 { 1350 device_remove_file(&dc->pdev->dev, &dev_attr_card_type); 1351 device_remove_file(&dc->pdev->dev, &dev_attr_open_ttys); 1352 } 1353 1354 /* Allocate memory for one device */ 1355 static int nozomi_card_init(struct pci_dev *pdev, 1356 const struct pci_device_id *ent) 1357 { 1358 resource_size_t start; 1359 int ret; 1360 struct nozomi *dc = NULL; 1361 int ndev_idx; 1362 int i; 1363 1364 dev_dbg(&pdev->dev, "Init, new card found\n"); 1365 1366 for (ndev_idx = 0; ndev_idx < ARRAY_SIZE(ndevs); ndev_idx++) 1367 if (!ndevs[ndev_idx]) 1368 break; 1369 1370 if (ndev_idx >= ARRAY_SIZE(ndevs)) { 1371 dev_err(&pdev->dev, "no free tty range for this card left\n"); 1372 ret = -EIO; 1373 goto err; 1374 } 1375 1376 dc = kzalloc(sizeof(struct nozomi), GFP_KERNEL); 1377 if (unlikely(!dc)) { 1378 dev_err(&pdev->dev, "Could not allocate memory\n"); 1379 ret = -ENOMEM; 1380 goto err_free; 1381 } 1382 1383 dc->pdev = pdev; 1384 1385 ret = pci_enable_device(dc->pdev); 1386 if (ret) { 1387 dev_err(&pdev->dev, "Failed to enable PCI Device\n"); 1388 goto err_free; 1389 } 1390 1391 ret = pci_request_regions(dc->pdev, NOZOMI_NAME); 1392 if (ret) { 1393 dev_err(&pdev->dev, "I/O address 0x%04x already in use\n", 1394 (int) /* nozomi_private.io_addr */ 0); 1395 goto err_disable_device; 1396 } 1397 1398 start = pci_resource_start(dc->pdev, 0); 1399 if (start == 0) { 1400 dev_err(&pdev->dev, "No I/O address for card detected\n"); 1401 ret = -ENODEV; 1402 goto err_rel_regs; 1403 } 1404 1405 /* Find out what card type it is */ 1406 nozomi_get_card_type(dc); 1407 1408 dc->base_addr = ioremap_nocache(start, dc->card_type); 1409 if (!dc->base_addr) { 1410 dev_err(&pdev->dev, "Unable to map card MMIO\n"); 1411 ret = -ENODEV; 1412 goto err_rel_regs; 1413 } 1414 1415 dc->send_buf = kmalloc(SEND_BUF_MAX, GFP_KERNEL); 1416 if (!dc->send_buf) { 1417 dev_err(&pdev->dev, "Could not allocate send buffer?\n"); 1418 ret = -ENOMEM; 1419 goto err_free_sbuf; 1420 } 1421 1422 for (i = PORT_MDM; i < MAX_PORT; i++) { 1423 if (kfifo_alloc(&dc->port[i].fifo_ul, FIFO_BUFFER_SIZE_UL, 1424 GFP_KERNEL)) { 1425 dev_err(&pdev->dev, 1426 "Could not allocate kfifo buffer\n"); 1427 ret = -ENOMEM; 1428 goto err_free_kfifo; 1429 } 1430 } 1431 1432 spin_lock_init(&dc->spin_mutex); 1433 1434 nozomi_setup_private_data(dc); 1435 1436 /* Disable all interrupts */ 1437 dc->last_ier = 0; 1438 writew(dc->last_ier, dc->reg_ier); 1439 1440 ret = request_irq(pdev->irq, &interrupt_handler, IRQF_SHARED, 1441 NOZOMI_NAME, dc); 1442 if (unlikely(ret)) { 1443 dev_err(&pdev->dev, "can't request irq %d\n", pdev->irq); 1444 goto err_free_kfifo; 1445 } 1446 1447 DBG1("base_addr: %p", dc->base_addr); 1448 1449 make_sysfs_files(dc); 1450 1451 dc->index_start = ndev_idx * MAX_PORT; 1452 ndevs[ndev_idx] = dc; 1453 1454 pci_set_drvdata(pdev, dc); 1455 1456 /* Enable RESET interrupt */ 1457 dc->last_ier = RESET; 1458 iowrite16(dc->last_ier, dc->reg_ier); 1459 1460 dc->state = NOZOMI_STATE_ENABLED; 1461 1462 for (i = 0; i < MAX_PORT; i++) { 1463 struct device *tty_dev; 1464 struct port *port = &dc->port[i]; 1465 port->dc = dc; 1466 tty_port_init(&port->port); 1467 port->port.ops = &noz_tty_port_ops; 1468 tty_dev = tty_port_register_device(&port->port, ntty_driver, 1469 dc->index_start + i, &pdev->dev); 1470 1471 if (IS_ERR(tty_dev)) { 1472 ret = PTR_ERR(tty_dev); 1473 dev_err(&pdev->dev, "Could not allocate tty?\n"); 1474 tty_port_destroy(&port->port); 1475 goto err_free_tty; 1476 } 1477 } 1478 1479 return 0; 1480 1481 err_free_tty: 1482 for (i = 0; i < MAX_PORT; ++i) { 1483 tty_unregister_device(ntty_driver, dc->index_start + i); 1484 tty_port_destroy(&dc->port[i].port); 1485 } 1486 err_free_kfifo: 1487 for (i = 0; i < MAX_PORT; i++) 1488 kfifo_free(&dc->port[i].fifo_ul); 1489 err_free_sbuf: 1490 kfree(dc->send_buf); 1491 iounmap(dc->base_addr); 1492 err_rel_regs: 1493 pci_release_regions(pdev); 1494 err_disable_device: 1495 pci_disable_device(pdev); 1496 err_free: 1497 kfree(dc); 1498 err: 1499 return ret; 1500 } 1501 1502 static void tty_exit(struct nozomi *dc) 1503 { 1504 unsigned int i; 1505 1506 DBG1(" "); 1507 1508 for (i = 0; i < MAX_PORT; ++i) { 1509 struct tty_struct *tty = tty_port_tty_get(&dc->port[i].port); 1510 if (tty && list_empty(&tty->hangup_work.entry)) 1511 tty_hangup(tty); 1512 tty_kref_put(tty); 1513 } 1514 /* Racy below - surely should wait for scheduled work to be done or 1515 complete off a hangup method ? */ 1516 while (dc->open_ttys) 1517 msleep(1); 1518 for (i = 0; i < MAX_PORT; ++i) { 1519 tty_unregister_device(ntty_driver, dc->index_start + i); 1520 tty_port_destroy(&dc->port[i].port); 1521 } 1522 } 1523 1524 /* Deallocate memory for one device */ 1525 static void nozomi_card_exit(struct pci_dev *pdev) 1526 { 1527 int i; 1528 struct ctrl_ul ctrl; 1529 struct nozomi *dc = pci_get_drvdata(pdev); 1530 1531 /* Disable all interrupts */ 1532 dc->last_ier = 0; 1533 writew(dc->last_ier, dc->reg_ier); 1534 1535 tty_exit(dc); 1536 1537 /* Send 0x0001, command card to resend the reset token. */ 1538 /* This is to get the reset when the module is reloaded. */ 1539 ctrl.port = 0x00; 1540 ctrl.reserved = 0; 1541 ctrl.RTS = 0; 1542 ctrl.DTR = 1; 1543 DBG1("sending flow control 0x%04X", *((u16 *)&ctrl)); 1544 1545 /* Setup dc->reg addresses to we can use defines here */ 1546 write_mem32(dc->port[PORT_CTRL].ul_addr[0], (u32 *)&ctrl, 2); 1547 writew(CTRL_UL, dc->reg_fcr); /* push the token to the card. */ 1548 1549 remove_sysfs_files(dc); 1550 1551 free_irq(pdev->irq, dc); 1552 1553 for (i = 0; i < MAX_PORT; i++) 1554 kfifo_free(&dc->port[i].fifo_ul); 1555 1556 kfree(dc->send_buf); 1557 1558 iounmap(dc->base_addr); 1559 1560 pci_release_regions(pdev); 1561 1562 pci_disable_device(pdev); 1563 1564 ndevs[dc->index_start / MAX_PORT] = NULL; 1565 1566 kfree(dc); 1567 } 1568 1569 static void set_rts(const struct tty_struct *tty, int rts) 1570 { 1571 struct port *port = get_port_by_tty(tty); 1572 1573 port->ctrl_ul.RTS = rts; 1574 port->update_flow_control = 1; 1575 enable_transmit_ul(PORT_CTRL, get_dc_by_tty(tty)); 1576 } 1577 1578 static void set_dtr(const struct tty_struct *tty, int dtr) 1579 { 1580 struct port *port = get_port_by_tty(tty); 1581 1582 DBG1("SETTING DTR index: %d, dtr: %d", tty->index, dtr); 1583 1584 port->ctrl_ul.DTR = dtr; 1585 port->update_flow_control = 1; 1586 enable_transmit_ul(PORT_CTRL, get_dc_by_tty(tty)); 1587 } 1588 1589 /* 1590 * ---------------------------------------------------------------------------- 1591 * TTY code 1592 * ---------------------------------------------------------------------------- 1593 */ 1594 1595 static int ntty_install(struct tty_driver *driver, struct tty_struct *tty) 1596 { 1597 struct port *port = get_port_by_tty(tty); 1598 struct nozomi *dc = get_dc_by_tty(tty); 1599 int ret; 1600 if (!port || !dc || dc->state != NOZOMI_STATE_READY) 1601 return -ENODEV; 1602 ret = tty_standard_install(driver, tty); 1603 if (ret == 0) 1604 tty->driver_data = port; 1605 return ret; 1606 } 1607 1608 static void ntty_cleanup(struct tty_struct *tty) 1609 { 1610 tty->driver_data = NULL; 1611 } 1612 1613 static int ntty_activate(struct tty_port *tport, struct tty_struct *tty) 1614 { 1615 struct port *port = container_of(tport, struct port, port); 1616 struct nozomi *dc = port->dc; 1617 unsigned long flags; 1618 1619 DBG1("open: %d", port->token_dl); 1620 spin_lock_irqsave(&dc->spin_mutex, flags); 1621 dc->last_ier = dc->last_ier | port->token_dl; 1622 writew(dc->last_ier, dc->reg_ier); 1623 dc->open_ttys++; 1624 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1625 printk("noz: activated %d: %p\n", tty->index, tport); 1626 return 0; 1627 } 1628 1629 static int ntty_open(struct tty_struct *tty, struct file *filp) 1630 { 1631 struct port *port = tty->driver_data; 1632 return tty_port_open(&port->port, tty, filp); 1633 } 1634 1635 static void ntty_shutdown(struct tty_port *tport) 1636 { 1637 struct port *port = container_of(tport, struct port, port); 1638 struct nozomi *dc = port->dc; 1639 unsigned long flags; 1640 1641 DBG1("close: %d", port->token_dl); 1642 spin_lock_irqsave(&dc->spin_mutex, flags); 1643 dc->last_ier &= ~(port->token_dl); 1644 writew(dc->last_ier, dc->reg_ier); 1645 dc->open_ttys--; 1646 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1647 printk("noz: shutdown %p\n", tport); 1648 } 1649 1650 static void ntty_close(struct tty_struct *tty, struct file *filp) 1651 { 1652 struct port *port = tty->driver_data; 1653 if (port) 1654 tty_port_close(&port->port, tty, filp); 1655 } 1656 1657 static void ntty_hangup(struct tty_struct *tty) 1658 { 1659 struct port *port = tty->driver_data; 1660 tty_port_hangup(&port->port); 1661 } 1662 1663 /* 1664 * called when the userspace process writes to the tty (/dev/noz*). 1665 * Data is inserted into a fifo, which is then read and transferred to the modem. 1666 */ 1667 static int ntty_write(struct tty_struct *tty, const unsigned char *buffer, 1668 int count) 1669 { 1670 int rval = -EINVAL; 1671 struct nozomi *dc = get_dc_by_tty(tty); 1672 struct port *port = tty->driver_data; 1673 unsigned long flags; 1674 1675 /* DBG1( "WRITEx: %d, index = %d", count, index); */ 1676 1677 if (!dc || !port) 1678 return -ENODEV; 1679 1680 rval = kfifo_in(&port->fifo_ul, (unsigned char *)buffer, count); 1681 1682 spin_lock_irqsave(&dc->spin_mutex, flags); 1683 /* CTS is only valid on the modem channel */ 1684 if (port == &(dc->port[PORT_MDM])) { 1685 if (port->ctrl_dl.CTS) { 1686 DBG4("Enable interrupt"); 1687 enable_transmit_ul(tty->index % MAX_PORT, dc); 1688 } else { 1689 dev_err(&dc->pdev->dev, 1690 "CTS not active on modem port?\n"); 1691 } 1692 } else { 1693 enable_transmit_ul(tty->index % MAX_PORT, dc); 1694 } 1695 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1696 1697 return rval; 1698 } 1699 1700 /* 1701 * Calculate how much is left in device 1702 * This method is called by the upper tty layer. 1703 * #according to sources N_TTY.c it expects a value >= 0 and 1704 * does not check for negative values. 1705 * 1706 * If the port is unplugged report lots of room and let the bits 1707 * dribble away so we don't block anything. 1708 */ 1709 static int ntty_write_room(struct tty_struct *tty) 1710 { 1711 struct port *port = tty->driver_data; 1712 int room = 4096; 1713 const struct nozomi *dc = get_dc_by_tty(tty); 1714 1715 if (dc) 1716 room = kfifo_avail(&port->fifo_ul); 1717 1718 return room; 1719 } 1720 1721 /* Gets io control parameters */ 1722 static int ntty_tiocmget(struct tty_struct *tty) 1723 { 1724 const struct port *port = tty->driver_data; 1725 const struct ctrl_dl *ctrl_dl = &port->ctrl_dl; 1726 const struct ctrl_ul *ctrl_ul = &port->ctrl_ul; 1727 1728 /* Note: these could change under us but it is not clear this 1729 matters if so */ 1730 return (ctrl_ul->RTS ? TIOCM_RTS : 0) | 1731 (ctrl_ul->DTR ? TIOCM_DTR : 0) | 1732 (ctrl_dl->DCD ? TIOCM_CAR : 0) | 1733 (ctrl_dl->RI ? TIOCM_RNG : 0) | 1734 (ctrl_dl->DSR ? TIOCM_DSR : 0) | 1735 (ctrl_dl->CTS ? TIOCM_CTS : 0); 1736 } 1737 1738 /* Sets io controls parameters */ 1739 static int ntty_tiocmset(struct tty_struct *tty, 1740 unsigned int set, unsigned int clear) 1741 { 1742 struct nozomi *dc = get_dc_by_tty(tty); 1743 unsigned long flags; 1744 1745 spin_lock_irqsave(&dc->spin_mutex, flags); 1746 if (set & TIOCM_RTS) 1747 set_rts(tty, 1); 1748 else if (clear & TIOCM_RTS) 1749 set_rts(tty, 0); 1750 1751 if (set & TIOCM_DTR) 1752 set_dtr(tty, 1); 1753 else if (clear & TIOCM_DTR) 1754 set_dtr(tty, 0); 1755 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1756 1757 return 0; 1758 } 1759 1760 static int ntty_cflags_changed(struct port *port, unsigned long flags, 1761 struct async_icount *cprev) 1762 { 1763 const struct async_icount cnow = port->tty_icount; 1764 int ret; 1765 1766 ret = ((flags & TIOCM_RNG) && (cnow.rng != cprev->rng)) || 1767 ((flags & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) || 1768 ((flags & TIOCM_CD) && (cnow.dcd != cprev->dcd)) || 1769 ((flags & TIOCM_CTS) && (cnow.cts != cprev->cts)); 1770 1771 *cprev = cnow; 1772 1773 return ret; 1774 } 1775 1776 static int ntty_tiocgicount(struct tty_struct *tty, 1777 struct serial_icounter_struct *icount) 1778 { 1779 struct port *port = tty->driver_data; 1780 const struct async_icount cnow = port->tty_icount; 1781 1782 icount->cts = cnow.cts; 1783 icount->dsr = cnow.dsr; 1784 icount->rng = cnow.rng; 1785 icount->dcd = cnow.dcd; 1786 icount->rx = cnow.rx; 1787 icount->tx = cnow.tx; 1788 icount->frame = cnow.frame; 1789 icount->overrun = cnow.overrun; 1790 icount->parity = cnow.parity; 1791 icount->brk = cnow.brk; 1792 icount->buf_overrun = cnow.buf_overrun; 1793 return 0; 1794 } 1795 1796 static int ntty_ioctl(struct tty_struct *tty, 1797 unsigned int cmd, unsigned long arg) 1798 { 1799 struct port *port = tty->driver_data; 1800 int rval = -ENOIOCTLCMD; 1801 1802 DBG1("******** IOCTL, cmd: %d", cmd); 1803 1804 switch (cmd) { 1805 case TIOCMIWAIT: { 1806 struct async_icount cprev = port->tty_icount; 1807 1808 rval = wait_event_interruptible(port->tty_wait, 1809 ntty_cflags_changed(port, arg, &cprev)); 1810 break; 1811 } 1812 default: 1813 DBG1("ERR: 0x%08X, %d", cmd, cmd); 1814 break; 1815 }; 1816 1817 return rval; 1818 } 1819 1820 /* 1821 * Called by the upper tty layer when tty buffers are ready 1822 * to receive data again after a call to throttle. 1823 */ 1824 static void ntty_unthrottle(struct tty_struct *tty) 1825 { 1826 struct nozomi *dc = get_dc_by_tty(tty); 1827 unsigned long flags; 1828 1829 DBG1("UNTHROTTLE"); 1830 spin_lock_irqsave(&dc->spin_mutex, flags); 1831 enable_transmit_dl(tty->index % MAX_PORT, dc); 1832 set_rts(tty, 1); 1833 1834 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1835 } 1836 1837 /* 1838 * Called by the upper tty layer when the tty buffers are almost full. 1839 * The driver should stop send more data. 1840 */ 1841 static void ntty_throttle(struct tty_struct *tty) 1842 { 1843 struct nozomi *dc = get_dc_by_tty(tty); 1844 unsigned long flags; 1845 1846 DBG1("THROTTLE"); 1847 spin_lock_irqsave(&dc->spin_mutex, flags); 1848 set_rts(tty, 0); 1849 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1850 } 1851 1852 /* Returns number of chars in buffer, called by tty layer */ 1853 static s32 ntty_chars_in_buffer(struct tty_struct *tty) 1854 { 1855 struct port *port = tty->driver_data; 1856 struct nozomi *dc = get_dc_by_tty(tty); 1857 s32 rval = 0; 1858 1859 if (unlikely(!dc || !port)) { 1860 goto exit_in_buffer; 1861 } 1862 1863 rval = kfifo_len(&port->fifo_ul); 1864 1865 exit_in_buffer: 1866 return rval; 1867 } 1868 1869 static const struct tty_port_operations noz_tty_port_ops = { 1870 .activate = ntty_activate, 1871 .shutdown = ntty_shutdown, 1872 }; 1873 1874 static const struct tty_operations tty_ops = { 1875 .ioctl = ntty_ioctl, 1876 .open = ntty_open, 1877 .close = ntty_close, 1878 .hangup = ntty_hangup, 1879 .write = ntty_write, 1880 .write_room = ntty_write_room, 1881 .unthrottle = ntty_unthrottle, 1882 .throttle = ntty_throttle, 1883 .chars_in_buffer = ntty_chars_in_buffer, 1884 .tiocmget = ntty_tiocmget, 1885 .tiocmset = ntty_tiocmset, 1886 .get_icount = ntty_tiocgicount, 1887 .install = ntty_install, 1888 .cleanup = ntty_cleanup, 1889 }; 1890 1891 /* Module initialization */ 1892 static struct pci_driver nozomi_driver = { 1893 .name = NOZOMI_NAME, 1894 .id_table = nozomi_pci_tbl, 1895 .probe = nozomi_card_init, 1896 .remove = nozomi_card_exit, 1897 }; 1898 1899 static __init int nozomi_init(void) 1900 { 1901 int ret; 1902 1903 printk(KERN_INFO "Initializing %s\n", VERSION_STRING); 1904 1905 ntty_driver = alloc_tty_driver(NTTY_TTY_MAXMINORS); 1906 if (!ntty_driver) 1907 return -ENOMEM; 1908 1909 ntty_driver->driver_name = NOZOMI_NAME_TTY; 1910 ntty_driver->name = "noz"; 1911 ntty_driver->major = 0; 1912 ntty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1913 ntty_driver->subtype = SERIAL_TYPE_NORMAL; 1914 ntty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1915 ntty_driver->init_termios = tty_std_termios; 1916 ntty_driver->init_termios.c_cflag = B115200 | CS8 | CREAD | \ 1917 HUPCL | CLOCAL; 1918 ntty_driver->init_termios.c_ispeed = 115200; 1919 ntty_driver->init_termios.c_ospeed = 115200; 1920 tty_set_operations(ntty_driver, &tty_ops); 1921 1922 ret = tty_register_driver(ntty_driver); 1923 if (ret) { 1924 printk(KERN_ERR "Nozomi: failed to register ntty driver\n"); 1925 goto free_tty; 1926 } 1927 1928 ret = pci_register_driver(&nozomi_driver); 1929 if (ret) { 1930 printk(KERN_ERR "Nozomi: can't register pci driver\n"); 1931 goto unr_tty; 1932 } 1933 1934 return 0; 1935 unr_tty: 1936 tty_unregister_driver(ntty_driver); 1937 free_tty: 1938 put_tty_driver(ntty_driver); 1939 return ret; 1940 } 1941 1942 static __exit void nozomi_exit(void) 1943 { 1944 printk(KERN_INFO "Unloading %s\n", DRIVER_DESC); 1945 pci_unregister_driver(&nozomi_driver); 1946 tty_unregister_driver(ntty_driver); 1947 put_tty_driver(ntty_driver); 1948 } 1949 1950 module_init(nozomi_init); 1951 module_exit(nozomi_exit); 1952 1953 module_param(debug, int, S_IRUGO | S_IWUSR); 1954 1955 MODULE_LICENSE("Dual BSD/GPL"); 1956 MODULE_DESCRIPTION(DRIVER_DESC); 1957