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 if (unlikely(!tty)) { 831 DBG1("tty not open for port: %d?", index); 832 return 1; 833 } 834 835 read_mem32((u32 *) &size, addr, 4); 836 /* DBG1( "%d bytes port: %d", size, index); */ 837 838 if (test_bit(TTY_THROTTLED, &tty->flags)) { 839 DBG1("No room in tty, don't read data, don't ack interrupt, " 840 "disable interrupt"); 841 842 /* disable interrupt in downlink... */ 843 disable_transmit_dl(index, dc); 844 ret = 0; 845 goto put; 846 } 847 848 if (unlikely(size == 0)) { 849 dev_err(&dc->pdev->dev, "size == 0?\n"); 850 ret = 1; 851 goto put; 852 } 853 854 while (size > 0) { 855 read_mem32((u32 *) buf, addr + offset, RECEIVE_BUF_MAX); 856 857 if (size == 1) { 858 tty_insert_flip_char(tty, buf[0], TTY_NORMAL); 859 size = 0; 860 } else if (size < RECEIVE_BUF_MAX) { 861 size -= tty_insert_flip_string(tty, (char *) buf, size); 862 } else { 863 i = tty_insert_flip_string(tty, \ 864 (char *) buf, RECEIVE_BUF_MAX); 865 size -= i; 866 offset += i; 867 } 868 } 869 870 set_bit(index, &dc->flip); 871 ret = 1; 872 put: 873 tty_kref_put(tty); 874 return ret; 875 } 876 877 /* Debug for interrupts */ 878 #ifdef DEBUG 879 static char *interrupt2str(u16 interrupt) 880 { 881 static char buf[TMP_BUF_MAX]; 882 char *p = buf; 883 884 interrupt & MDM_DL1 ? p += snprintf(p, TMP_BUF_MAX, "MDM_DL1 ") : NULL; 885 interrupt & MDM_DL2 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 886 "MDM_DL2 ") : NULL; 887 888 interrupt & MDM_UL1 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 889 "MDM_UL1 ") : NULL; 890 interrupt & MDM_UL2 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 891 "MDM_UL2 ") : NULL; 892 893 interrupt & DIAG_DL1 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 894 "DIAG_DL1 ") : NULL; 895 interrupt & DIAG_DL2 ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 896 "DIAG_DL2 ") : NULL; 897 898 interrupt & DIAG_UL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 899 "DIAG_UL ") : NULL; 900 901 interrupt & APP1_DL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 902 "APP1_DL ") : NULL; 903 interrupt & APP2_DL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 904 "APP2_DL ") : NULL; 905 906 interrupt & APP1_UL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 907 "APP1_UL ") : NULL; 908 interrupt & APP2_UL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 909 "APP2_UL ") : NULL; 910 911 interrupt & CTRL_DL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 912 "CTRL_DL ") : NULL; 913 interrupt & CTRL_UL ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 914 "CTRL_UL ") : NULL; 915 916 interrupt & RESET ? p += snprintf(p, TMP_BUF_MAX - (p - buf), 917 "RESET ") : NULL; 918 919 return buf; 920 } 921 #endif 922 923 /* 924 * Receive flow control 925 * Return 1 - If ok, else 0 926 */ 927 static int receive_flow_control(struct nozomi *dc) 928 { 929 enum port_type port = PORT_MDM; 930 struct ctrl_dl ctrl_dl; 931 struct ctrl_dl old_ctrl; 932 u16 enable_ier = 0; 933 934 read_mem32((u32 *) &ctrl_dl, dc->port[PORT_CTRL].dl_addr[CH_A], 2); 935 936 switch (ctrl_dl.port) { 937 case CTRL_CMD: 938 DBG1("The Base Band sends this value as a response to a " 939 "request for IMSI detach sent over the control " 940 "channel uplink (see section 7.6.1)."); 941 break; 942 case CTRL_MDM: 943 port = PORT_MDM; 944 enable_ier = MDM_DL; 945 break; 946 case CTRL_DIAG: 947 port = PORT_DIAG; 948 enable_ier = DIAG_DL; 949 break; 950 case CTRL_APP1: 951 port = PORT_APP1; 952 enable_ier = APP1_DL; 953 break; 954 case CTRL_APP2: 955 port = PORT_APP2; 956 enable_ier = APP2_DL; 957 if (dc->state == NOZOMI_STATE_ALLOCATED) { 958 /* 959 * After card initialization the flow control 960 * received for APP2 is always the last 961 */ 962 dc->state = NOZOMI_STATE_READY; 963 dev_info(&dc->pdev->dev, "Device READY!\n"); 964 } 965 break; 966 default: 967 dev_err(&dc->pdev->dev, 968 "ERROR: flow control received for non-existing port\n"); 969 return 0; 970 }; 971 972 DBG1("0x%04X->0x%04X", *((u16 *)&dc->port[port].ctrl_dl), 973 *((u16 *)&ctrl_dl)); 974 975 old_ctrl = dc->port[port].ctrl_dl; 976 dc->port[port].ctrl_dl = ctrl_dl; 977 978 if (old_ctrl.CTS == 1 && ctrl_dl.CTS == 0) { 979 DBG1("Disable interrupt (0x%04X) on port: %d", 980 enable_ier, port); 981 disable_transmit_ul(port, dc); 982 983 } else if (old_ctrl.CTS == 0 && ctrl_dl.CTS == 1) { 984 985 if (kfifo_len(&dc->port[port].fifo_ul)) { 986 DBG1("Enable interrupt (0x%04X) on port: %d", 987 enable_ier, port); 988 DBG1("Data in buffer [%d], enable transmit! ", 989 kfifo_len(&dc->port[port].fifo_ul)); 990 enable_transmit_ul(port, dc); 991 } else { 992 DBG1("No data in buffer..."); 993 } 994 } 995 996 if (*(u16 *)&old_ctrl == *(u16 *)&ctrl_dl) { 997 DBG1(" No change in mctrl"); 998 return 1; 999 } 1000 /* Update statistics */ 1001 if (old_ctrl.CTS != ctrl_dl.CTS) 1002 dc->port[port].tty_icount.cts++; 1003 if (old_ctrl.DSR != ctrl_dl.DSR) 1004 dc->port[port].tty_icount.dsr++; 1005 if (old_ctrl.RI != ctrl_dl.RI) 1006 dc->port[port].tty_icount.rng++; 1007 if (old_ctrl.DCD != ctrl_dl.DCD) 1008 dc->port[port].tty_icount.dcd++; 1009 1010 wake_up_interruptible(&dc->port[port].tty_wait); 1011 1012 DBG1("port: %d DCD(%d), CTS(%d), RI(%d), DSR(%d)", 1013 port, 1014 dc->port[port].tty_icount.dcd, dc->port[port].tty_icount.cts, 1015 dc->port[port].tty_icount.rng, dc->port[port].tty_icount.dsr); 1016 1017 return 1; 1018 } 1019 1020 static enum ctrl_port_type port2ctrl(enum port_type port, 1021 const struct nozomi *dc) 1022 { 1023 switch (port) { 1024 case PORT_MDM: 1025 return CTRL_MDM; 1026 case PORT_DIAG: 1027 return CTRL_DIAG; 1028 case PORT_APP1: 1029 return CTRL_APP1; 1030 case PORT_APP2: 1031 return CTRL_APP2; 1032 default: 1033 dev_err(&dc->pdev->dev, 1034 "ERROR: send flow control " \ 1035 "received for non-existing port\n"); 1036 }; 1037 return CTRL_ERROR; 1038 } 1039 1040 /* 1041 * Send flow control, can only update one channel at a time 1042 * Return 0 - If we have updated all flow control 1043 * Return 1 - If we need to update more flow control, ack current enable more 1044 */ 1045 static int send_flow_control(struct nozomi *dc) 1046 { 1047 u32 i, more_flow_control_to_be_updated = 0; 1048 u16 *ctrl; 1049 1050 for (i = PORT_MDM; i < MAX_PORT; i++) { 1051 if (dc->port[i].update_flow_control) { 1052 if (more_flow_control_to_be_updated) { 1053 /* We have more flow control to be updated */ 1054 return 1; 1055 } 1056 dc->port[i].ctrl_ul.port = port2ctrl(i, dc); 1057 ctrl = (u16 *)&dc->port[i].ctrl_ul; 1058 write_mem32(dc->port[PORT_CTRL].ul_addr[0], \ 1059 (u32 *) ctrl, 2); 1060 dc->port[i].update_flow_control = 0; 1061 more_flow_control_to_be_updated = 1; 1062 } 1063 } 1064 return 0; 1065 } 1066 1067 /* 1068 * Handle downlink data, ports that are handled are modem and diagnostics 1069 * Return 1 - ok 1070 * Return 0 - toggle fields are out of sync 1071 */ 1072 static int handle_data_dl(struct nozomi *dc, enum port_type port, u8 *toggle, 1073 u16 read_iir, u16 mask1, u16 mask2) 1074 { 1075 if (*toggle == 0 && read_iir & mask1) { 1076 if (receive_data(port, dc)) { 1077 writew(mask1, dc->reg_fcr); 1078 *toggle = !(*toggle); 1079 } 1080 1081 if (read_iir & mask2) { 1082 if (receive_data(port, dc)) { 1083 writew(mask2, dc->reg_fcr); 1084 *toggle = !(*toggle); 1085 } 1086 } 1087 } else if (*toggle == 1 && read_iir & mask2) { 1088 if (receive_data(port, dc)) { 1089 writew(mask2, dc->reg_fcr); 1090 *toggle = !(*toggle); 1091 } 1092 1093 if (read_iir & mask1) { 1094 if (receive_data(port, dc)) { 1095 writew(mask1, dc->reg_fcr); 1096 *toggle = !(*toggle); 1097 } 1098 } 1099 } else { 1100 dev_err(&dc->pdev->dev, "port out of sync!, toggle:%d\n", 1101 *toggle); 1102 return 0; 1103 } 1104 return 1; 1105 } 1106 1107 /* 1108 * Handle uplink data, this is currently for the modem port 1109 * Return 1 - ok 1110 * Return 0 - toggle field are out of sync 1111 */ 1112 static int handle_data_ul(struct nozomi *dc, enum port_type port, u16 read_iir) 1113 { 1114 u8 *toggle = &(dc->port[port].toggle_ul); 1115 1116 if (*toggle == 0 && read_iir & MDM_UL1) { 1117 dc->last_ier &= ~MDM_UL; 1118 writew(dc->last_ier, dc->reg_ier); 1119 if (send_data(port, dc)) { 1120 writew(MDM_UL1, dc->reg_fcr); 1121 dc->last_ier = dc->last_ier | MDM_UL; 1122 writew(dc->last_ier, dc->reg_ier); 1123 *toggle = !*toggle; 1124 } 1125 1126 if (read_iir & MDM_UL2) { 1127 dc->last_ier &= ~MDM_UL; 1128 writew(dc->last_ier, dc->reg_ier); 1129 if (send_data(port, dc)) { 1130 writew(MDM_UL2, dc->reg_fcr); 1131 dc->last_ier = dc->last_ier | MDM_UL; 1132 writew(dc->last_ier, dc->reg_ier); 1133 *toggle = !*toggle; 1134 } 1135 } 1136 1137 } else if (*toggle == 1 && read_iir & MDM_UL2) { 1138 dc->last_ier &= ~MDM_UL; 1139 writew(dc->last_ier, dc->reg_ier); 1140 if (send_data(port, dc)) { 1141 writew(MDM_UL2, dc->reg_fcr); 1142 dc->last_ier = dc->last_ier | MDM_UL; 1143 writew(dc->last_ier, dc->reg_ier); 1144 *toggle = !*toggle; 1145 } 1146 1147 if (read_iir & MDM_UL1) { 1148 dc->last_ier &= ~MDM_UL; 1149 writew(dc->last_ier, dc->reg_ier); 1150 if (send_data(port, dc)) { 1151 writew(MDM_UL1, dc->reg_fcr); 1152 dc->last_ier = dc->last_ier | MDM_UL; 1153 writew(dc->last_ier, dc->reg_ier); 1154 *toggle = !*toggle; 1155 } 1156 } 1157 } else { 1158 writew(read_iir & MDM_UL, dc->reg_fcr); 1159 dev_err(&dc->pdev->dev, "port out of sync!\n"); 1160 return 0; 1161 } 1162 return 1; 1163 } 1164 1165 static irqreturn_t interrupt_handler(int irq, void *dev_id) 1166 { 1167 struct nozomi *dc = dev_id; 1168 unsigned int a; 1169 u16 read_iir; 1170 1171 if (!dc) 1172 return IRQ_NONE; 1173 1174 spin_lock(&dc->spin_mutex); 1175 read_iir = readw(dc->reg_iir); 1176 1177 /* Card removed */ 1178 if (read_iir == (u16)-1) 1179 goto none; 1180 /* 1181 * Just handle interrupt enabled in IER 1182 * (by masking with dc->last_ier) 1183 */ 1184 read_iir &= dc->last_ier; 1185 1186 if (read_iir == 0) 1187 goto none; 1188 1189 1190 DBG4("%s irq:0x%04X, prev:0x%04X", interrupt2str(read_iir), read_iir, 1191 dc->last_ier); 1192 1193 if (read_iir & RESET) { 1194 if (unlikely(!nozomi_read_config_table(dc))) { 1195 dc->last_ier = 0x0; 1196 writew(dc->last_ier, dc->reg_ier); 1197 dev_err(&dc->pdev->dev, "Could not read status from " 1198 "card, we should disable interface\n"); 1199 } else { 1200 writew(RESET, dc->reg_fcr); 1201 } 1202 /* No more useful info if this was the reset interrupt. */ 1203 goto exit_handler; 1204 } 1205 if (read_iir & CTRL_UL) { 1206 DBG1("CTRL_UL"); 1207 dc->last_ier &= ~CTRL_UL; 1208 writew(dc->last_ier, dc->reg_ier); 1209 if (send_flow_control(dc)) { 1210 writew(CTRL_UL, dc->reg_fcr); 1211 dc->last_ier = dc->last_ier | CTRL_UL; 1212 writew(dc->last_ier, dc->reg_ier); 1213 } 1214 } 1215 if (read_iir & CTRL_DL) { 1216 receive_flow_control(dc); 1217 writew(CTRL_DL, dc->reg_fcr); 1218 } 1219 if (read_iir & MDM_DL) { 1220 if (!handle_data_dl(dc, PORT_MDM, 1221 &(dc->port[PORT_MDM].toggle_dl), read_iir, 1222 MDM_DL1, MDM_DL2)) { 1223 dev_err(&dc->pdev->dev, "MDM_DL out of sync!\n"); 1224 goto exit_handler; 1225 } 1226 } 1227 if (read_iir & MDM_UL) { 1228 if (!handle_data_ul(dc, PORT_MDM, read_iir)) { 1229 dev_err(&dc->pdev->dev, "MDM_UL out of sync!\n"); 1230 goto exit_handler; 1231 } 1232 } 1233 if (read_iir & DIAG_DL) { 1234 if (!handle_data_dl(dc, PORT_DIAG, 1235 &(dc->port[PORT_DIAG].toggle_dl), read_iir, 1236 DIAG_DL1, DIAG_DL2)) { 1237 dev_err(&dc->pdev->dev, "DIAG_DL out of sync!\n"); 1238 goto exit_handler; 1239 } 1240 } 1241 if (read_iir & DIAG_UL) { 1242 dc->last_ier &= ~DIAG_UL; 1243 writew(dc->last_ier, dc->reg_ier); 1244 if (send_data(PORT_DIAG, dc)) { 1245 writew(DIAG_UL, dc->reg_fcr); 1246 dc->last_ier = dc->last_ier | DIAG_UL; 1247 writew(dc->last_ier, dc->reg_ier); 1248 } 1249 } 1250 if (read_iir & APP1_DL) { 1251 if (receive_data(PORT_APP1, dc)) 1252 writew(APP1_DL, dc->reg_fcr); 1253 } 1254 if (read_iir & APP1_UL) { 1255 dc->last_ier &= ~APP1_UL; 1256 writew(dc->last_ier, dc->reg_ier); 1257 if (send_data(PORT_APP1, dc)) { 1258 writew(APP1_UL, dc->reg_fcr); 1259 dc->last_ier = dc->last_ier | APP1_UL; 1260 writew(dc->last_ier, dc->reg_ier); 1261 } 1262 } 1263 if (read_iir & APP2_DL) { 1264 if (receive_data(PORT_APP2, dc)) 1265 writew(APP2_DL, dc->reg_fcr); 1266 } 1267 if (read_iir & APP2_UL) { 1268 dc->last_ier &= ~APP2_UL; 1269 writew(dc->last_ier, dc->reg_ier); 1270 if (send_data(PORT_APP2, dc)) { 1271 writew(APP2_UL, dc->reg_fcr); 1272 dc->last_ier = dc->last_ier | APP2_UL; 1273 writew(dc->last_ier, dc->reg_ier); 1274 } 1275 } 1276 1277 exit_handler: 1278 spin_unlock(&dc->spin_mutex); 1279 for (a = 0; a < NOZOMI_MAX_PORTS; a++) { 1280 struct tty_struct *tty; 1281 if (test_and_clear_bit(a, &dc->flip)) { 1282 tty = tty_port_tty_get(&dc->port[a].port); 1283 if (tty) 1284 tty_flip_buffer_push(tty); 1285 tty_kref_put(tty); 1286 } 1287 } 1288 return IRQ_HANDLED; 1289 none: 1290 spin_unlock(&dc->spin_mutex); 1291 return IRQ_NONE; 1292 } 1293 1294 static void nozomi_get_card_type(struct nozomi *dc) 1295 { 1296 int i; 1297 u32 size = 0; 1298 1299 for (i = 0; i < 6; i++) 1300 size += pci_resource_len(dc->pdev, i); 1301 1302 /* Assume card type F32_8 if no match */ 1303 dc->card_type = size == 2048 ? F32_2 : F32_8; 1304 1305 dev_info(&dc->pdev->dev, "Card type is: %d\n", dc->card_type); 1306 } 1307 1308 static void nozomi_setup_private_data(struct nozomi *dc) 1309 { 1310 void __iomem *offset = dc->base_addr + dc->card_type / 2; 1311 unsigned int i; 1312 1313 dc->reg_fcr = (void __iomem *)(offset + R_FCR); 1314 dc->reg_iir = (void __iomem *)(offset + R_IIR); 1315 dc->reg_ier = (void __iomem *)(offset + R_IER); 1316 dc->last_ier = 0; 1317 dc->flip = 0; 1318 1319 dc->port[PORT_MDM].token_dl = MDM_DL; 1320 dc->port[PORT_DIAG].token_dl = DIAG_DL; 1321 dc->port[PORT_APP1].token_dl = APP1_DL; 1322 dc->port[PORT_APP2].token_dl = APP2_DL; 1323 1324 for (i = 0; i < MAX_PORT; i++) 1325 init_waitqueue_head(&dc->port[i].tty_wait); 1326 } 1327 1328 static ssize_t card_type_show(struct device *dev, struct device_attribute *attr, 1329 char *buf) 1330 { 1331 const struct nozomi *dc = pci_get_drvdata(to_pci_dev(dev)); 1332 1333 return sprintf(buf, "%d\n", dc->card_type); 1334 } 1335 static DEVICE_ATTR(card_type, S_IRUGO, card_type_show, NULL); 1336 1337 static ssize_t open_ttys_show(struct device *dev, struct device_attribute *attr, 1338 char *buf) 1339 { 1340 const struct nozomi *dc = pci_get_drvdata(to_pci_dev(dev)); 1341 1342 return sprintf(buf, "%u\n", dc->open_ttys); 1343 } 1344 static DEVICE_ATTR(open_ttys, S_IRUGO, open_ttys_show, NULL); 1345 1346 static void make_sysfs_files(struct nozomi *dc) 1347 { 1348 if (device_create_file(&dc->pdev->dev, &dev_attr_card_type)) 1349 dev_err(&dc->pdev->dev, 1350 "Could not create sysfs file for card_type\n"); 1351 if (device_create_file(&dc->pdev->dev, &dev_attr_open_ttys)) 1352 dev_err(&dc->pdev->dev, 1353 "Could not create sysfs file for open_ttys\n"); 1354 } 1355 1356 static void remove_sysfs_files(struct nozomi *dc) 1357 { 1358 device_remove_file(&dc->pdev->dev, &dev_attr_card_type); 1359 device_remove_file(&dc->pdev->dev, &dev_attr_open_ttys); 1360 } 1361 1362 /* Allocate memory for one device */ 1363 static int nozomi_card_init(struct pci_dev *pdev, 1364 const struct pci_device_id *ent) 1365 { 1366 resource_size_t start; 1367 int ret; 1368 struct nozomi *dc = NULL; 1369 int ndev_idx; 1370 int i; 1371 1372 dev_dbg(&pdev->dev, "Init, new card found\n"); 1373 1374 for (ndev_idx = 0; ndev_idx < ARRAY_SIZE(ndevs); ndev_idx++) 1375 if (!ndevs[ndev_idx]) 1376 break; 1377 1378 if (ndev_idx >= ARRAY_SIZE(ndevs)) { 1379 dev_err(&pdev->dev, "no free tty range for this card left\n"); 1380 ret = -EIO; 1381 goto err; 1382 } 1383 1384 dc = kzalloc(sizeof(struct nozomi), GFP_KERNEL); 1385 if (unlikely(!dc)) { 1386 dev_err(&pdev->dev, "Could not allocate memory\n"); 1387 ret = -ENOMEM; 1388 goto err_free; 1389 } 1390 1391 dc->pdev = pdev; 1392 1393 ret = pci_enable_device(dc->pdev); 1394 if (ret) { 1395 dev_err(&pdev->dev, "Failed to enable PCI Device\n"); 1396 goto err_free; 1397 } 1398 1399 ret = pci_request_regions(dc->pdev, NOZOMI_NAME); 1400 if (ret) { 1401 dev_err(&pdev->dev, "I/O address 0x%04x already in use\n", 1402 (int) /* nozomi_private.io_addr */ 0); 1403 goto err_disable_device; 1404 } 1405 1406 start = pci_resource_start(dc->pdev, 0); 1407 if (start == 0) { 1408 dev_err(&pdev->dev, "No I/O address for card detected\n"); 1409 ret = -ENODEV; 1410 goto err_rel_regs; 1411 } 1412 1413 /* Find out what card type it is */ 1414 nozomi_get_card_type(dc); 1415 1416 dc->base_addr = ioremap_nocache(start, dc->card_type); 1417 if (!dc->base_addr) { 1418 dev_err(&pdev->dev, "Unable to map card MMIO\n"); 1419 ret = -ENODEV; 1420 goto err_rel_regs; 1421 } 1422 1423 dc->send_buf = kmalloc(SEND_BUF_MAX, GFP_KERNEL); 1424 if (!dc->send_buf) { 1425 dev_err(&pdev->dev, "Could not allocate send buffer?\n"); 1426 ret = -ENOMEM; 1427 goto err_free_sbuf; 1428 } 1429 1430 for (i = PORT_MDM; i < MAX_PORT; i++) { 1431 if (kfifo_alloc(&dc->port[i].fifo_ul, FIFO_BUFFER_SIZE_UL, 1432 GFP_KERNEL)) { 1433 dev_err(&pdev->dev, 1434 "Could not allocate kfifo buffer\n"); 1435 ret = -ENOMEM; 1436 goto err_free_kfifo; 1437 } 1438 } 1439 1440 spin_lock_init(&dc->spin_mutex); 1441 1442 nozomi_setup_private_data(dc); 1443 1444 /* Disable all interrupts */ 1445 dc->last_ier = 0; 1446 writew(dc->last_ier, dc->reg_ier); 1447 1448 ret = request_irq(pdev->irq, &interrupt_handler, IRQF_SHARED, 1449 NOZOMI_NAME, dc); 1450 if (unlikely(ret)) { 1451 dev_err(&pdev->dev, "can't request irq %d\n", pdev->irq); 1452 goto err_free_kfifo; 1453 } 1454 1455 DBG1("base_addr: %p", dc->base_addr); 1456 1457 make_sysfs_files(dc); 1458 1459 dc->index_start = ndev_idx * MAX_PORT; 1460 ndevs[ndev_idx] = dc; 1461 1462 pci_set_drvdata(pdev, dc); 1463 1464 /* Enable RESET interrupt */ 1465 dc->last_ier = RESET; 1466 iowrite16(dc->last_ier, dc->reg_ier); 1467 1468 dc->state = NOZOMI_STATE_ENABLED; 1469 1470 for (i = 0; i < MAX_PORT; i++) { 1471 struct device *tty_dev; 1472 struct port *port = &dc->port[i]; 1473 port->dc = dc; 1474 tty_port_init(&port->port); 1475 port->port.ops = &noz_tty_port_ops; 1476 tty_dev = tty_port_register_device(&port->port, ntty_driver, 1477 dc->index_start + i, &pdev->dev); 1478 1479 if (IS_ERR(tty_dev)) { 1480 ret = PTR_ERR(tty_dev); 1481 dev_err(&pdev->dev, "Could not allocate tty?\n"); 1482 tty_port_destroy(&port->port); 1483 goto err_free_tty; 1484 } 1485 } 1486 1487 return 0; 1488 1489 err_free_tty: 1490 for (i = 0; i < MAX_PORT; ++i) { 1491 tty_unregister_device(ntty_driver, dc->index_start + i); 1492 tty_port_destroy(&dc->port[i].port); 1493 } 1494 err_free_kfifo: 1495 for (i = 0; i < MAX_PORT; i++) 1496 kfifo_free(&dc->port[i].fifo_ul); 1497 err_free_sbuf: 1498 kfree(dc->send_buf); 1499 iounmap(dc->base_addr); 1500 err_rel_regs: 1501 pci_release_regions(pdev); 1502 err_disable_device: 1503 pci_disable_device(pdev); 1504 err_free: 1505 kfree(dc); 1506 err: 1507 return ret; 1508 } 1509 1510 static void tty_exit(struct nozomi *dc) 1511 { 1512 unsigned int i; 1513 1514 DBG1(" "); 1515 1516 for (i = 0; i < MAX_PORT; ++i) { 1517 struct tty_struct *tty = tty_port_tty_get(&dc->port[i].port); 1518 if (tty && list_empty(&tty->hangup_work.entry)) 1519 tty_hangup(tty); 1520 tty_kref_put(tty); 1521 } 1522 /* Racy below - surely should wait for scheduled work to be done or 1523 complete off a hangup method ? */ 1524 while (dc->open_ttys) 1525 msleep(1); 1526 for (i = 0; i < MAX_PORT; ++i) { 1527 tty_unregister_device(ntty_driver, dc->index_start + i); 1528 tty_port_destroy(&dc->port[i].port); 1529 } 1530 } 1531 1532 /* Deallocate memory for one device */ 1533 static void nozomi_card_exit(struct pci_dev *pdev) 1534 { 1535 int i; 1536 struct ctrl_ul ctrl; 1537 struct nozomi *dc = pci_get_drvdata(pdev); 1538 1539 /* Disable all interrupts */ 1540 dc->last_ier = 0; 1541 writew(dc->last_ier, dc->reg_ier); 1542 1543 tty_exit(dc); 1544 1545 /* Send 0x0001, command card to resend the reset token. */ 1546 /* This is to get the reset when the module is reloaded. */ 1547 ctrl.port = 0x00; 1548 ctrl.reserved = 0; 1549 ctrl.RTS = 0; 1550 ctrl.DTR = 1; 1551 DBG1("sending flow control 0x%04X", *((u16 *)&ctrl)); 1552 1553 /* Setup dc->reg addresses to we can use defines here */ 1554 write_mem32(dc->port[PORT_CTRL].ul_addr[0], (u32 *)&ctrl, 2); 1555 writew(CTRL_UL, dc->reg_fcr); /* push the token to the card. */ 1556 1557 remove_sysfs_files(dc); 1558 1559 free_irq(pdev->irq, dc); 1560 1561 for (i = 0; i < MAX_PORT; i++) 1562 kfifo_free(&dc->port[i].fifo_ul); 1563 1564 kfree(dc->send_buf); 1565 1566 iounmap(dc->base_addr); 1567 1568 pci_release_regions(pdev); 1569 1570 pci_disable_device(pdev); 1571 1572 ndevs[dc->index_start / MAX_PORT] = NULL; 1573 1574 kfree(dc); 1575 } 1576 1577 static void set_rts(const struct tty_struct *tty, int rts) 1578 { 1579 struct port *port = get_port_by_tty(tty); 1580 1581 port->ctrl_ul.RTS = rts; 1582 port->update_flow_control = 1; 1583 enable_transmit_ul(PORT_CTRL, get_dc_by_tty(tty)); 1584 } 1585 1586 static void set_dtr(const struct tty_struct *tty, int dtr) 1587 { 1588 struct port *port = get_port_by_tty(tty); 1589 1590 DBG1("SETTING DTR index: %d, dtr: %d", tty->index, dtr); 1591 1592 port->ctrl_ul.DTR = dtr; 1593 port->update_flow_control = 1; 1594 enable_transmit_ul(PORT_CTRL, get_dc_by_tty(tty)); 1595 } 1596 1597 /* 1598 * ---------------------------------------------------------------------------- 1599 * TTY code 1600 * ---------------------------------------------------------------------------- 1601 */ 1602 1603 static int ntty_install(struct tty_driver *driver, struct tty_struct *tty) 1604 { 1605 struct port *port = get_port_by_tty(tty); 1606 struct nozomi *dc = get_dc_by_tty(tty); 1607 int ret; 1608 if (!port || !dc || dc->state != NOZOMI_STATE_READY) 1609 return -ENODEV; 1610 ret = tty_standard_install(driver, tty); 1611 if (ret == 0) 1612 tty->driver_data = port; 1613 return ret; 1614 } 1615 1616 static void ntty_cleanup(struct tty_struct *tty) 1617 { 1618 tty->driver_data = NULL; 1619 } 1620 1621 static int ntty_activate(struct tty_port *tport, struct tty_struct *tty) 1622 { 1623 struct port *port = container_of(tport, struct port, port); 1624 struct nozomi *dc = port->dc; 1625 unsigned long flags; 1626 1627 DBG1("open: %d", port->token_dl); 1628 spin_lock_irqsave(&dc->spin_mutex, flags); 1629 dc->last_ier = dc->last_ier | port->token_dl; 1630 writew(dc->last_ier, dc->reg_ier); 1631 dc->open_ttys++; 1632 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1633 printk("noz: activated %d: %p\n", tty->index, tport); 1634 return 0; 1635 } 1636 1637 static int ntty_open(struct tty_struct *tty, struct file *filp) 1638 { 1639 struct port *port = tty->driver_data; 1640 return tty_port_open(&port->port, tty, filp); 1641 } 1642 1643 static void ntty_shutdown(struct tty_port *tport) 1644 { 1645 struct port *port = container_of(tport, struct port, port); 1646 struct nozomi *dc = port->dc; 1647 unsigned long flags; 1648 1649 DBG1("close: %d", port->token_dl); 1650 spin_lock_irqsave(&dc->spin_mutex, flags); 1651 dc->last_ier &= ~(port->token_dl); 1652 writew(dc->last_ier, dc->reg_ier); 1653 dc->open_ttys--; 1654 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1655 printk("noz: shutdown %p\n", tport); 1656 } 1657 1658 static void ntty_close(struct tty_struct *tty, struct file *filp) 1659 { 1660 struct port *port = tty->driver_data; 1661 if (port) 1662 tty_port_close(&port->port, tty, filp); 1663 } 1664 1665 static void ntty_hangup(struct tty_struct *tty) 1666 { 1667 struct port *port = tty->driver_data; 1668 tty_port_hangup(&port->port); 1669 } 1670 1671 /* 1672 * called when the userspace process writes to the tty (/dev/noz*). 1673 * Data is inserted into a fifo, which is then read and transferred to the modem. 1674 */ 1675 static int ntty_write(struct tty_struct *tty, const unsigned char *buffer, 1676 int count) 1677 { 1678 int rval = -EINVAL; 1679 struct nozomi *dc = get_dc_by_tty(tty); 1680 struct port *port = tty->driver_data; 1681 unsigned long flags; 1682 1683 /* DBG1( "WRITEx: %d, index = %d", count, index); */ 1684 1685 if (!dc || !port) 1686 return -ENODEV; 1687 1688 rval = kfifo_in(&port->fifo_ul, (unsigned char *)buffer, count); 1689 1690 /* notify card */ 1691 if (unlikely(dc == NULL)) { 1692 DBG1("No device context?"); 1693 goto exit; 1694 } 1695 1696 spin_lock_irqsave(&dc->spin_mutex, flags); 1697 /* CTS is only valid on the modem channel */ 1698 if (port == &(dc->port[PORT_MDM])) { 1699 if (port->ctrl_dl.CTS) { 1700 DBG4("Enable interrupt"); 1701 enable_transmit_ul(tty->index % MAX_PORT, dc); 1702 } else { 1703 dev_err(&dc->pdev->dev, 1704 "CTS not active on modem port?\n"); 1705 } 1706 } else { 1707 enable_transmit_ul(tty->index % MAX_PORT, dc); 1708 } 1709 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1710 1711 exit: 1712 return rval; 1713 } 1714 1715 /* 1716 * Calculate how much is left in device 1717 * This method is called by the upper tty layer. 1718 * #according to sources N_TTY.c it expects a value >= 0 and 1719 * does not check for negative values. 1720 * 1721 * If the port is unplugged report lots of room and let the bits 1722 * dribble away so we don't block anything. 1723 */ 1724 static int ntty_write_room(struct tty_struct *tty) 1725 { 1726 struct port *port = tty->driver_data; 1727 int room = 4096; 1728 const struct nozomi *dc = get_dc_by_tty(tty); 1729 1730 if (dc) 1731 room = kfifo_avail(&port->fifo_ul); 1732 1733 return room; 1734 } 1735 1736 /* Gets io control parameters */ 1737 static int ntty_tiocmget(struct tty_struct *tty) 1738 { 1739 const struct port *port = tty->driver_data; 1740 const struct ctrl_dl *ctrl_dl = &port->ctrl_dl; 1741 const struct ctrl_ul *ctrl_ul = &port->ctrl_ul; 1742 1743 /* Note: these could change under us but it is not clear this 1744 matters if so */ 1745 return (ctrl_ul->RTS ? TIOCM_RTS : 0) | 1746 (ctrl_ul->DTR ? TIOCM_DTR : 0) | 1747 (ctrl_dl->DCD ? TIOCM_CAR : 0) | 1748 (ctrl_dl->RI ? TIOCM_RNG : 0) | 1749 (ctrl_dl->DSR ? TIOCM_DSR : 0) | 1750 (ctrl_dl->CTS ? TIOCM_CTS : 0); 1751 } 1752 1753 /* Sets io controls parameters */ 1754 static int ntty_tiocmset(struct tty_struct *tty, 1755 unsigned int set, unsigned int clear) 1756 { 1757 struct nozomi *dc = get_dc_by_tty(tty); 1758 unsigned long flags; 1759 1760 spin_lock_irqsave(&dc->spin_mutex, flags); 1761 if (set & TIOCM_RTS) 1762 set_rts(tty, 1); 1763 else if (clear & TIOCM_RTS) 1764 set_rts(tty, 0); 1765 1766 if (set & TIOCM_DTR) 1767 set_dtr(tty, 1); 1768 else if (clear & TIOCM_DTR) 1769 set_dtr(tty, 0); 1770 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1771 1772 return 0; 1773 } 1774 1775 static int ntty_cflags_changed(struct port *port, unsigned long flags, 1776 struct async_icount *cprev) 1777 { 1778 const struct async_icount cnow = port->tty_icount; 1779 int ret; 1780 1781 ret = ((flags & TIOCM_RNG) && (cnow.rng != cprev->rng)) || 1782 ((flags & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) || 1783 ((flags & TIOCM_CD) && (cnow.dcd != cprev->dcd)) || 1784 ((flags & TIOCM_CTS) && (cnow.cts != cprev->cts)); 1785 1786 *cprev = cnow; 1787 1788 return ret; 1789 } 1790 1791 static int ntty_tiocgicount(struct tty_struct *tty, 1792 struct serial_icounter_struct *icount) 1793 { 1794 struct port *port = tty->driver_data; 1795 const struct async_icount cnow = port->tty_icount; 1796 1797 icount->cts = cnow.cts; 1798 icount->dsr = cnow.dsr; 1799 icount->rng = cnow.rng; 1800 icount->dcd = cnow.dcd; 1801 icount->rx = cnow.rx; 1802 icount->tx = cnow.tx; 1803 icount->frame = cnow.frame; 1804 icount->overrun = cnow.overrun; 1805 icount->parity = cnow.parity; 1806 icount->brk = cnow.brk; 1807 icount->buf_overrun = cnow.buf_overrun; 1808 return 0; 1809 } 1810 1811 static int ntty_ioctl(struct tty_struct *tty, 1812 unsigned int cmd, unsigned long arg) 1813 { 1814 struct port *port = tty->driver_data; 1815 int rval = -ENOIOCTLCMD; 1816 1817 DBG1("******** IOCTL, cmd: %d", cmd); 1818 1819 switch (cmd) { 1820 case TIOCMIWAIT: { 1821 struct async_icount cprev = port->tty_icount; 1822 1823 rval = wait_event_interruptible(port->tty_wait, 1824 ntty_cflags_changed(port, arg, &cprev)); 1825 break; 1826 } 1827 default: 1828 DBG1("ERR: 0x%08X, %d", cmd, cmd); 1829 break; 1830 }; 1831 1832 return rval; 1833 } 1834 1835 /* 1836 * Called by the upper tty layer when tty buffers are ready 1837 * to receive data again after a call to throttle. 1838 */ 1839 static void ntty_unthrottle(struct tty_struct *tty) 1840 { 1841 struct nozomi *dc = get_dc_by_tty(tty); 1842 unsigned long flags; 1843 1844 DBG1("UNTHROTTLE"); 1845 spin_lock_irqsave(&dc->spin_mutex, flags); 1846 enable_transmit_dl(tty->index % MAX_PORT, dc); 1847 set_rts(tty, 1); 1848 1849 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1850 } 1851 1852 /* 1853 * Called by the upper tty layer when the tty buffers are almost full. 1854 * The driver should stop send more data. 1855 */ 1856 static void ntty_throttle(struct tty_struct *tty) 1857 { 1858 struct nozomi *dc = get_dc_by_tty(tty); 1859 unsigned long flags; 1860 1861 DBG1("THROTTLE"); 1862 spin_lock_irqsave(&dc->spin_mutex, flags); 1863 set_rts(tty, 0); 1864 spin_unlock_irqrestore(&dc->spin_mutex, flags); 1865 } 1866 1867 /* Returns number of chars in buffer, called by tty layer */ 1868 static s32 ntty_chars_in_buffer(struct tty_struct *tty) 1869 { 1870 struct port *port = tty->driver_data; 1871 struct nozomi *dc = get_dc_by_tty(tty); 1872 s32 rval = 0; 1873 1874 if (unlikely(!dc || !port)) { 1875 goto exit_in_buffer; 1876 } 1877 1878 rval = kfifo_len(&port->fifo_ul); 1879 1880 exit_in_buffer: 1881 return rval; 1882 } 1883 1884 static const struct tty_port_operations noz_tty_port_ops = { 1885 .activate = ntty_activate, 1886 .shutdown = ntty_shutdown, 1887 }; 1888 1889 static const struct tty_operations tty_ops = { 1890 .ioctl = ntty_ioctl, 1891 .open = ntty_open, 1892 .close = ntty_close, 1893 .hangup = ntty_hangup, 1894 .write = ntty_write, 1895 .write_room = ntty_write_room, 1896 .unthrottle = ntty_unthrottle, 1897 .throttle = ntty_throttle, 1898 .chars_in_buffer = ntty_chars_in_buffer, 1899 .tiocmget = ntty_tiocmget, 1900 .tiocmset = ntty_tiocmset, 1901 .get_icount = ntty_tiocgicount, 1902 .install = ntty_install, 1903 .cleanup = ntty_cleanup, 1904 }; 1905 1906 /* Module initialization */ 1907 static struct pci_driver nozomi_driver = { 1908 .name = NOZOMI_NAME, 1909 .id_table = nozomi_pci_tbl, 1910 .probe = nozomi_card_init, 1911 .remove = nozomi_card_exit, 1912 }; 1913 1914 static __init int nozomi_init(void) 1915 { 1916 int ret; 1917 1918 printk(KERN_INFO "Initializing %s\n", VERSION_STRING); 1919 1920 ntty_driver = alloc_tty_driver(NTTY_TTY_MAXMINORS); 1921 if (!ntty_driver) 1922 return -ENOMEM; 1923 1924 ntty_driver->driver_name = NOZOMI_NAME_TTY; 1925 ntty_driver->name = "noz"; 1926 ntty_driver->major = 0; 1927 ntty_driver->type = TTY_DRIVER_TYPE_SERIAL; 1928 ntty_driver->subtype = SERIAL_TYPE_NORMAL; 1929 ntty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV; 1930 ntty_driver->init_termios = tty_std_termios; 1931 ntty_driver->init_termios.c_cflag = B115200 | CS8 | CREAD | \ 1932 HUPCL | CLOCAL; 1933 ntty_driver->init_termios.c_ispeed = 115200; 1934 ntty_driver->init_termios.c_ospeed = 115200; 1935 tty_set_operations(ntty_driver, &tty_ops); 1936 1937 ret = tty_register_driver(ntty_driver); 1938 if (ret) { 1939 printk(KERN_ERR "Nozomi: failed to register ntty driver\n"); 1940 goto free_tty; 1941 } 1942 1943 ret = pci_register_driver(&nozomi_driver); 1944 if (ret) { 1945 printk(KERN_ERR "Nozomi: can't register pci driver\n"); 1946 goto unr_tty; 1947 } 1948 1949 return 0; 1950 unr_tty: 1951 tty_unregister_driver(ntty_driver); 1952 free_tty: 1953 put_tty_driver(ntty_driver); 1954 return ret; 1955 } 1956 1957 static __exit void nozomi_exit(void) 1958 { 1959 printk(KERN_INFO "Unloading %s\n", DRIVER_DESC); 1960 pci_unregister_driver(&nozomi_driver); 1961 tty_unregister_driver(ntty_driver); 1962 put_tty_driver(ntty_driver); 1963 } 1964 1965 module_init(nozomi_init); 1966 module_exit(nozomi_exit); 1967 1968 module_param(debug, int, S_IRUGO | S_IWUSR); 1969 1970 MODULE_LICENSE("Dual BSD/GPL"); 1971 MODULE_DESCRIPTION(DRIVER_DESC); 1972