1 /* 2 * TI FlashMedia driver 3 * 4 * Copyright (C) 2007 Alex Dubov <oakad@yahoo.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 * 10 * Special thanks to Carlos Corbacho for providing various MemoryStick cards 11 * that made this driver possible. 12 * 13 */ 14 15 #include <linux/tifm.h> 16 #include <linux/memstick.h> 17 #include <linux/highmem.h> 18 #include <linux/scatterlist.h> 19 #include <linux/log2.h> 20 #include <linux/module.h> 21 #include <asm/io.h> 22 23 #define DRIVER_NAME "tifm_ms" 24 25 static bool no_dma; 26 module_param(no_dma, bool, 0644); 27 28 /* 29 * Some control bits of TIFM appear to conform to Sony's reference design, 30 * so I'm just assuming they all are. 31 */ 32 33 #define TIFM_MS_STAT_DRQ 0x04000 34 #define TIFM_MS_STAT_MSINT 0x02000 35 #define TIFM_MS_STAT_RDY 0x01000 36 #define TIFM_MS_STAT_CRC 0x00200 37 #define TIFM_MS_STAT_TOE 0x00100 38 #define TIFM_MS_STAT_EMP 0x00020 39 #define TIFM_MS_STAT_FUL 0x00010 40 #define TIFM_MS_STAT_CED 0x00008 41 #define TIFM_MS_STAT_ERR 0x00004 42 #define TIFM_MS_STAT_BRQ 0x00002 43 #define TIFM_MS_STAT_CNK 0x00001 44 45 #define TIFM_MS_SYS_DMA 0x10000 46 #define TIFM_MS_SYS_RESET 0x08000 47 #define TIFM_MS_SYS_SRAC 0x04000 48 #define TIFM_MS_SYS_INTEN 0x02000 49 #define TIFM_MS_SYS_NOCRC 0x01000 50 #define TIFM_MS_SYS_INTCLR 0x00800 51 #define TIFM_MS_SYS_MSIEN 0x00400 52 #define TIFM_MS_SYS_FCLR 0x00200 53 #define TIFM_MS_SYS_FDIR 0x00100 54 #define TIFM_MS_SYS_DAM 0x00080 55 #define TIFM_MS_SYS_DRM 0x00040 56 #define TIFM_MS_SYS_DRQSL 0x00020 57 #define TIFM_MS_SYS_REI 0x00010 58 #define TIFM_MS_SYS_REO 0x00008 59 #define TIFM_MS_SYS_BSY_MASK 0x00007 60 61 #define TIFM_MS_SYS_FIFO (TIFM_MS_SYS_INTEN | TIFM_MS_SYS_MSIEN \ 62 | TIFM_MS_SYS_FCLR | TIFM_MS_SYS_BSY_MASK) 63 64 /* Hardware flags */ 65 enum { 66 CMD_READY = 0x01, 67 FIFO_READY = 0x02, 68 CARD_INT = 0x04 69 }; 70 71 struct tifm_ms { 72 struct tifm_dev *dev; 73 struct timer_list timer; 74 struct memstick_request *req; 75 struct tasklet_struct notify; 76 unsigned int mode_mask; 77 unsigned int block_pos; 78 unsigned long timeout_jiffies; 79 unsigned char eject:1, 80 use_dma:1; 81 unsigned char cmd_flags; 82 unsigned char io_pos; 83 unsigned int io_word; 84 }; 85 86 static unsigned int tifm_ms_read_data(struct tifm_ms *host, 87 unsigned char *buf, unsigned int length) 88 { 89 struct tifm_dev *sock = host->dev; 90 unsigned int off = 0; 91 92 while (host->io_pos && length) { 93 buf[off++] = host->io_word & 0xff; 94 host->io_word >>= 8; 95 length--; 96 host->io_pos--; 97 } 98 99 if (!length) 100 return off; 101 102 while (!(TIFM_MS_STAT_EMP & readl(sock->addr + SOCK_MS_STATUS))) { 103 if (length < 4) 104 break; 105 *(unsigned int *)(buf + off) = __raw_readl(sock->addr 106 + SOCK_MS_DATA); 107 length -= 4; 108 off += 4; 109 } 110 111 if (length 112 && !(TIFM_MS_STAT_EMP & readl(sock->addr + SOCK_MS_STATUS))) { 113 host->io_word = readl(sock->addr + SOCK_MS_DATA); 114 for (host->io_pos = 4; host->io_pos; --host->io_pos) { 115 buf[off++] = host->io_word & 0xff; 116 host->io_word >>= 8; 117 length--; 118 if (!length) 119 break; 120 } 121 } 122 123 return off; 124 } 125 126 static unsigned int tifm_ms_write_data(struct tifm_ms *host, 127 unsigned char *buf, unsigned int length) 128 { 129 struct tifm_dev *sock = host->dev; 130 unsigned int off = 0; 131 132 if (host->io_pos) { 133 while (host->io_pos < 4 && length) { 134 host->io_word |= buf[off++] << (host->io_pos * 8); 135 host->io_pos++; 136 length--; 137 } 138 } 139 140 if (host->io_pos == 4 141 && !(TIFM_MS_STAT_FUL & readl(sock->addr + SOCK_MS_STATUS))) { 142 writel(TIFM_MS_SYS_FDIR | readl(sock->addr + SOCK_MS_SYSTEM), 143 sock->addr + SOCK_MS_SYSTEM); 144 writel(host->io_word, sock->addr + SOCK_MS_DATA); 145 host->io_pos = 0; 146 host->io_word = 0; 147 } else if (host->io_pos) { 148 return off; 149 } 150 151 if (!length) 152 return off; 153 154 while (!(TIFM_MS_STAT_FUL & readl(sock->addr + SOCK_MS_STATUS))) { 155 if (length < 4) 156 break; 157 writel(TIFM_MS_SYS_FDIR | readl(sock->addr + SOCK_MS_SYSTEM), 158 sock->addr + SOCK_MS_SYSTEM); 159 __raw_writel(*(unsigned int *)(buf + off), 160 sock->addr + SOCK_MS_DATA); 161 length -= 4; 162 off += 4; 163 } 164 165 switch (length) { 166 case 3: 167 host->io_word |= buf[off + 2] << 16; 168 host->io_pos++; 169 /* fall through */ 170 case 2: 171 host->io_word |= buf[off + 1] << 8; 172 host->io_pos++; 173 /* fall through */ 174 case 1: 175 host->io_word |= buf[off]; 176 host->io_pos++; 177 } 178 179 off += host->io_pos; 180 181 return off; 182 } 183 184 static unsigned int tifm_ms_transfer_data(struct tifm_ms *host) 185 { 186 struct tifm_dev *sock = host->dev; 187 unsigned int length; 188 unsigned int off; 189 unsigned int t_size, p_cnt; 190 unsigned char *buf; 191 struct page *pg; 192 unsigned long flags = 0; 193 194 if (host->req->long_data) { 195 length = host->req->sg.length - host->block_pos; 196 off = host->req->sg.offset + host->block_pos; 197 } else { 198 length = host->req->data_len - host->block_pos; 199 off = 0; 200 } 201 dev_dbg(&sock->dev, "fifo data transfer, %d, %d\n", length, 202 host->block_pos); 203 204 while (length) { 205 unsigned int uninitialized_var(p_off); 206 207 if (host->req->long_data) { 208 pg = nth_page(sg_page(&host->req->sg), 209 off >> PAGE_SHIFT); 210 p_off = offset_in_page(off); 211 p_cnt = PAGE_SIZE - p_off; 212 p_cnt = min(p_cnt, length); 213 214 local_irq_save(flags); 215 buf = kmap_atomic(pg) + p_off; 216 } else { 217 buf = host->req->data + host->block_pos; 218 p_cnt = host->req->data_len - host->block_pos; 219 } 220 221 t_size = host->req->data_dir == WRITE 222 ? tifm_ms_write_data(host, buf, p_cnt) 223 : tifm_ms_read_data(host, buf, p_cnt); 224 225 if (host->req->long_data) { 226 kunmap_atomic(buf - p_off); 227 local_irq_restore(flags); 228 } 229 230 if (!t_size) 231 break; 232 host->block_pos += t_size; 233 length -= t_size; 234 off += t_size; 235 } 236 237 dev_dbg(&sock->dev, "fifo data transfer, %d remaining\n", length); 238 if (!length && (host->req->data_dir == WRITE)) { 239 if (host->io_pos) { 240 writel(TIFM_MS_SYS_FDIR 241 | readl(sock->addr + SOCK_MS_SYSTEM), 242 sock->addr + SOCK_MS_SYSTEM); 243 writel(host->io_word, sock->addr + SOCK_MS_DATA); 244 } 245 writel(TIFM_MS_SYS_FDIR 246 | readl(sock->addr + SOCK_MS_SYSTEM), 247 sock->addr + SOCK_MS_SYSTEM); 248 writel(0, sock->addr + SOCK_MS_DATA); 249 } else { 250 readl(sock->addr + SOCK_MS_DATA); 251 } 252 253 return length; 254 } 255 256 static int tifm_ms_issue_cmd(struct tifm_ms *host) 257 { 258 struct tifm_dev *sock = host->dev; 259 unsigned int data_len, cmd, sys_param; 260 261 host->cmd_flags = 0; 262 host->block_pos = 0; 263 host->io_pos = 0; 264 host->io_word = 0; 265 host->cmd_flags = 0; 266 267 host->use_dma = !no_dma; 268 269 if (host->req->long_data) { 270 data_len = host->req->sg.length; 271 if (!is_power_of_2(data_len)) 272 host->use_dma = 0; 273 } else { 274 data_len = host->req->data_len; 275 host->use_dma = 0; 276 } 277 278 writel(TIFM_FIFO_INT_SETALL, 279 sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR); 280 writel(TIFM_FIFO_ENABLE, 281 sock->addr + SOCK_FIFO_CONTROL); 282 283 if (host->use_dma) { 284 if (1 != tifm_map_sg(sock, &host->req->sg, 1, 285 host->req->data_dir == READ 286 ? PCI_DMA_FROMDEVICE 287 : PCI_DMA_TODEVICE)) { 288 host->req->error = -ENOMEM; 289 return host->req->error; 290 } 291 data_len = sg_dma_len(&host->req->sg); 292 293 writel(ilog2(data_len) - 2, 294 sock->addr + SOCK_FIFO_PAGE_SIZE); 295 writel(TIFM_FIFO_INTMASK, 296 sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET); 297 sys_param = TIFM_DMA_EN | (1 << 8); 298 if (host->req->data_dir == WRITE) 299 sys_param |= TIFM_DMA_TX; 300 301 writel(TIFM_FIFO_INTMASK, 302 sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET); 303 304 writel(sg_dma_address(&host->req->sg), 305 sock->addr + SOCK_DMA_ADDRESS); 306 writel(sys_param, sock->addr + SOCK_DMA_CONTROL); 307 } else { 308 writel(host->mode_mask | TIFM_MS_SYS_FIFO, 309 sock->addr + SOCK_MS_SYSTEM); 310 311 writel(TIFM_FIFO_MORE, 312 sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET); 313 } 314 315 mod_timer(&host->timer, jiffies + host->timeout_jiffies); 316 writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL), 317 sock->addr + SOCK_CONTROL); 318 host->req->error = 0; 319 320 sys_param = readl(sock->addr + SOCK_MS_SYSTEM); 321 sys_param |= TIFM_MS_SYS_INTCLR; 322 323 if (host->use_dma) 324 sys_param |= TIFM_MS_SYS_DMA; 325 else 326 sys_param &= ~TIFM_MS_SYS_DMA; 327 328 writel(sys_param, sock->addr + SOCK_MS_SYSTEM); 329 330 cmd = (host->req->tpc & 0xf) << 12; 331 cmd |= data_len; 332 writel(cmd, sock->addr + SOCK_MS_COMMAND); 333 334 dev_dbg(&sock->dev, "executing TPC %x, %x\n", cmd, sys_param); 335 return 0; 336 } 337 338 static void tifm_ms_complete_cmd(struct tifm_ms *host) 339 { 340 struct tifm_dev *sock = host->dev; 341 struct memstick_host *msh = tifm_get_drvdata(sock); 342 int rc; 343 344 del_timer(&host->timer); 345 346 host->req->int_reg = readl(sock->addr + SOCK_MS_STATUS) & 0xff; 347 host->req->int_reg = (host->req->int_reg & 1) 348 | ((host->req->int_reg << 4) & 0xe0); 349 350 writel(TIFM_FIFO_INT_SETALL, 351 sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR); 352 writel(TIFM_DMA_RESET, sock->addr + SOCK_DMA_CONTROL); 353 354 if (host->use_dma) { 355 tifm_unmap_sg(sock, &host->req->sg, 1, 356 host->req->data_dir == READ 357 ? PCI_DMA_FROMDEVICE 358 : PCI_DMA_TODEVICE); 359 } 360 361 writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL), 362 sock->addr + SOCK_CONTROL); 363 364 dev_dbg(&sock->dev, "TPC complete\n"); 365 do { 366 rc = memstick_next_req(msh, &host->req); 367 } while (!rc && tifm_ms_issue_cmd(host)); 368 } 369 370 static int tifm_ms_check_status(struct tifm_ms *host) 371 { 372 if (!host->req->error) { 373 if (!(host->cmd_flags & CMD_READY)) 374 return 1; 375 if (!(host->cmd_flags & FIFO_READY)) 376 return 1; 377 if (host->req->need_card_int 378 && !(host->cmd_flags & CARD_INT)) 379 return 1; 380 } 381 return 0; 382 } 383 384 /* Called from interrupt handler */ 385 static void tifm_ms_data_event(struct tifm_dev *sock) 386 { 387 struct tifm_ms *host; 388 unsigned int fifo_status = 0, host_status = 0; 389 int rc = 1; 390 391 spin_lock(&sock->lock); 392 host = memstick_priv((struct memstick_host *)tifm_get_drvdata(sock)); 393 fifo_status = readl(sock->addr + SOCK_DMA_FIFO_STATUS); 394 host_status = readl(sock->addr + SOCK_MS_STATUS); 395 dev_dbg(&sock->dev, 396 "data event: fifo_status %x, host_status %x, flags %x\n", 397 fifo_status, host_status, host->cmd_flags); 398 399 if (host->req) { 400 if (host->use_dma && (fifo_status & 1)) { 401 host->cmd_flags |= FIFO_READY; 402 rc = tifm_ms_check_status(host); 403 } 404 if (!host->use_dma && (fifo_status & TIFM_FIFO_MORE)) { 405 if (!tifm_ms_transfer_data(host)) { 406 host->cmd_flags |= FIFO_READY; 407 rc = tifm_ms_check_status(host); 408 } 409 } 410 } 411 412 writel(fifo_status, sock->addr + SOCK_DMA_FIFO_STATUS); 413 if (!rc) 414 tifm_ms_complete_cmd(host); 415 416 spin_unlock(&sock->lock); 417 } 418 419 420 /* Called from interrupt handler */ 421 static void tifm_ms_card_event(struct tifm_dev *sock) 422 { 423 struct tifm_ms *host; 424 unsigned int host_status = 0; 425 int rc = 1; 426 427 spin_lock(&sock->lock); 428 host = memstick_priv((struct memstick_host *)tifm_get_drvdata(sock)); 429 host_status = readl(sock->addr + SOCK_MS_STATUS); 430 dev_dbg(&sock->dev, "host event: host_status %x, flags %x\n", 431 host_status, host->cmd_flags); 432 433 if (host->req) { 434 if (host_status & TIFM_MS_STAT_TOE) 435 host->req->error = -ETIME; 436 else if (host_status & TIFM_MS_STAT_CRC) 437 host->req->error = -EILSEQ; 438 439 if (host_status & TIFM_MS_STAT_RDY) 440 host->cmd_flags |= CMD_READY; 441 442 if (host_status & TIFM_MS_STAT_MSINT) 443 host->cmd_flags |= CARD_INT; 444 445 rc = tifm_ms_check_status(host); 446 447 } 448 449 writel(TIFM_MS_SYS_INTCLR | readl(sock->addr + SOCK_MS_SYSTEM), 450 sock->addr + SOCK_MS_SYSTEM); 451 452 if (!rc) 453 tifm_ms_complete_cmd(host); 454 455 spin_unlock(&sock->lock); 456 return; 457 } 458 459 static void tifm_ms_req_tasklet(unsigned long data) 460 { 461 struct memstick_host *msh = (struct memstick_host *)data; 462 struct tifm_ms *host = memstick_priv(msh); 463 struct tifm_dev *sock = host->dev; 464 unsigned long flags; 465 int rc; 466 467 spin_lock_irqsave(&sock->lock, flags); 468 if (!host->req) { 469 if (host->eject) { 470 do { 471 rc = memstick_next_req(msh, &host->req); 472 if (!rc) 473 host->req->error = -ETIME; 474 } while (!rc); 475 spin_unlock_irqrestore(&sock->lock, flags); 476 return; 477 } 478 479 do { 480 rc = memstick_next_req(msh, &host->req); 481 } while (!rc && tifm_ms_issue_cmd(host)); 482 } 483 spin_unlock_irqrestore(&sock->lock, flags); 484 } 485 486 static void tifm_ms_dummy_submit(struct memstick_host *msh) 487 { 488 return; 489 } 490 491 static void tifm_ms_submit_req(struct memstick_host *msh) 492 { 493 struct tifm_ms *host = memstick_priv(msh); 494 495 tasklet_schedule(&host->notify); 496 } 497 498 static int tifm_ms_set_param(struct memstick_host *msh, 499 enum memstick_param param, 500 int value) 501 { 502 struct tifm_ms *host = memstick_priv(msh); 503 struct tifm_dev *sock = host->dev; 504 505 switch (param) { 506 case MEMSTICK_POWER: 507 /* also affected by media detection mechanism */ 508 if (value == MEMSTICK_POWER_ON) { 509 host->mode_mask = TIFM_MS_SYS_SRAC | TIFM_MS_SYS_REI; 510 writel(TIFM_MS_SYS_RESET, sock->addr + SOCK_MS_SYSTEM); 511 writel(TIFM_MS_SYS_FCLR | TIFM_MS_SYS_INTCLR, 512 sock->addr + SOCK_MS_SYSTEM); 513 writel(0xffffffff, sock->addr + SOCK_MS_STATUS); 514 } else if (value == MEMSTICK_POWER_OFF) { 515 writel(TIFM_MS_SYS_FCLR | TIFM_MS_SYS_INTCLR, 516 sock->addr + SOCK_MS_SYSTEM); 517 writel(0xffffffff, sock->addr + SOCK_MS_STATUS); 518 } else 519 return -EINVAL; 520 break; 521 case MEMSTICK_INTERFACE: 522 if (value == MEMSTICK_SERIAL) { 523 host->mode_mask = TIFM_MS_SYS_SRAC | TIFM_MS_SYS_REI; 524 writel((~TIFM_CTRL_FAST_CLK) 525 & readl(sock->addr + SOCK_CONTROL), 526 sock->addr + SOCK_CONTROL); 527 } else if (value == MEMSTICK_PAR4) { 528 host->mode_mask = 0; 529 writel(TIFM_CTRL_FAST_CLK 530 | readl(sock->addr + SOCK_CONTROL), 531 sock->addr + SOCK_CONTROL); 532 } else 533 return -EINVAL; 534 break; 535 }; 536 537 return 0; 538 } 539 540 static void tifm_ms_abort(struct timer_list *t) 541 { 542 struct tifm_ms *host = from_timer(host, t, timer); 543 544 dev_dbg(&host->dev->dev, "status %x\n", 545 readl(host->dev->addr + SOCK_MS_STATUS)); 546 printk(KERN_ERR 547 "%s : card failed to respond for a long period of time " 548 "(%x, %x)\n", 549 dev_name(&host->dev->dev), host->req ? host->req->tpc : 0, 550 host->cmd_flags); 551 552 tifm_eject(host->dev); 553 } 554 555 static int tifm_ms_probe(struct tifm_dev *sock) 556 { 557 struct memstick_host *msh; 558 struct tifm_ms *host; 559 int rc = -EIO; 560 561 if (!(TIFM_SOCK_STATE_OCCUPIED 562 & readl(sock->addr + SOCK_PRESENT_STATE))) { 563 printk(KERN_WARNING "%s : card gone, unexpectedly\n", 564 dev_name(&sock->dev)); 565 return rc; 566 } 567 568 msh = memstick_alloc_host(sizeof(struct tifm_ms), &sock->dev); 569 if (!msh) 570 return -ENOMEM; 571 572 host = memstick_priv(msh); 573 tifm_set_drvdata(sock, msh); 574 host->dev = sock; 575 host->timeout_jiffies = msecs_to_jiffies(1000); 576 577 timer_setup(&host->timer, tifm_ms_abort, 0); 578 tasklet_init(&host->notify, tifm_ms_req_tasklet, (unsigned long)msh); 579 580 msh->request = tifm_ms_submit_req; 581 msh->set_param = tifm_ms_set_param; 582 sock->card_event = tifm_ms_card_event; 583 sock->data_event = tifm_ms_data_event; 584 if (tifm_has_ms_pif(sock)) 585 msh->caps |= MEMSTICK_CAP_PAR4; 586 587 rc = memstick_add_host(msh); 588 if (!rc) 589 return 0; 590 591 memstick_free_host(msh); 592 return rc; 593 } 594 595 static void tifm_ms_remove(struct tifm_dev *sock) 596 { 597 struct memstick_host *msh = tifm_get_drvdata(sock); 598 struct tifm_ms *host = memstick_priv(msh); 599 int rc = 0; 600 unsigned long flags; 601 602 msh->request = tifm_ms_dummy_submit; 603 tasklet_kill(&host->notify); 604 spin_lock_irqsave(&sock->lock, flags); 605 host->eject = 1; 606 if (host->req) { 607 del_timer(&host->timer); 608 writel(TIFM_FIFO_INT_SETALL, 609 sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR); 610 writel(TIFM_DMA_RESET, sock->addr + SOCK_DMA_CONTROL); 611 if (host->use_dma) 612 tifm_unmap_sg(sock, &host->req->sg, 1, 613 host->req->data_dir == READ 614 ? PCI_DMA_TODEVICE 615 : PCI_DMA_FROMDEVICE); 616 host->req->error = -ETIME; 617 618 do { 619 rc = memstick_next_req(msh, &host->req); 620 if (!rc) 621 host->req->error = -ETIME; 622 } while (!rc); 623 } 624 spin_unlock_irqrestore(&sock->lock, flags); 625 626 memstick_remove_host(msh); 627 memstick_free_host(msh); 628 } 629 630 #ifdef CONFIG_PM 631 632 static int tifm_ms_suspend(struct tifm_dev *sock, pm_message_t state) 633 { 634 struct memstick_host *msh = tifm_get_drvdata(sock); 635 636 memstick_suspend_host(msh); 637 return 0; 638 } 639 640 static int tifm_ms_resume(struct tifm_dev *sock) 641 { 642 struct memstick_host *msh = tifm_get_drvdata(sock); 643 644 memstick_resume_host(msh); 645 return 0; 646 } 647 648 #else 649 650 #define tifm_ms_suspend NULL 651 #define tifm_ms_resume NULL 652 653 #endif /* CONFIG_PM */ 654 655 static struct tifm_device_id tifm_ms_id_tbl[] = { 656 { TIFM_TYPE_MS }, { 0 } 657 }; 658 659 static struct tifm_driver tifm_ms_driver = { 660 .driver = { 661 .name = DRIVER_NAME, 662 .owner = THIS_MODULE 663 }, 664 .id_table = tifm_ms_id_tbl, 665 .probe = tifm_ms_probe, 666 .remove = tifm_ms_remove, 667 .suspend = tifm_ms_suspend, 668 .resume = tifm_ms_resume 669 }; 670 671 static int __init tifm_ms_init(void) 672 { 673 return tifm_register_driver(&tifm_ms_driver); 674 } 675 676 static void __exit tifm_ms_exit(void) 677 { 678 tifm_unregister_driver(&tifm_ms_driver); 679 } 680 681 MODULE_AUTHOR("Alex Dubov"); 682 MODULE_DESCRIPTION("TI FlashMedia MemoryStick driver"); 683 MODULE_LICENSE("GPL"); 684 MODULE_DEVICE_TABLE(tifm, tifm_ms_id_tbl); 685 686 module_init(tifm_ms_init); 687 module_exit(tifm_ms_exit); 688