Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tifm_ms.c
Go to the documentation of this file.
1 /*
2  * TI FlashMedia driver
3  *
4  * Copyright (C) 2007 Alex Dubov <[email protected]>
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  case 2:
170  host->io_word |= buf[off + 1] << 8;
171  host->io_pos++;
172  case 1:
173  host->io_word |= buf[off];
174  host->io_pos++;
175  }
176 
177  off += host->io_pos;
178 
179  return off;
180 }
181 
182 static unsigned int tifm_ms_transfer_data(struct tifm_ms *host)
183 {
184  struct tifm_dev *sock = host->dev;
185  unsigned int length;
186  unsigned int off;
187  unsigned int t_size, p_cnt;
188  unsigned char *buf;
189  struct page *pg;
190  unsigned long flags = 0;
191 
192  if (host->req->long_data) {
193  length = host->req->sg.length - host->block_pos;
194  off = host->req->sg.offset + host->block_pos;
195  } else {
196  length = host->req->data_len - host->block_pos;
197  off = 0;
198  }
199  dev_dbg(&sock->dev, "fifo data transfer, %d, %d\n", length,
200  host->block_pos);
201 
202  while (length) {
203  unsigned int uninitialized_var(p_off);
204 
205  if (host->req->long_data) {
206  pg = nth_page(sg_page(&host->req->sg),
207  off >> PAGE_SHIFT);
208  p_off = offset_in_page(off);
209  p_cnt = PAGE_SIZE - p_off;
210  p_cnt = min(p_cnt, length);
211 
212  local_irq_save(flags);
213  buf = kmap_atomic(pg) + p_off;
214  } else {
215  buf = host->req->data + host->block_pos;
216  p_cnt = host->req->data_len - host->block_pos;
217  }
218 
219  t_size = host->req->data_dir == WRITE
220  ? tifm_ms_write_data(host, buf, p_cnt)
221  : tifm_ms_read_data(host, buf, p_cnt);
222 
223  if (host->req->long_data) {
224  kunmap_atomic(buf - p_off);
225  local_irq_restore(flags);
226  }
227 
228  if (!t_size)
229  break;
230  host->block_pos += t_size;
231  length -= t_size;
232  off += t_size;
233  }
234 
235  dev_dbg(&sock->dev, "fifo data transfer, %d remaining\n", length);
236  if (!length && (host->req->data_dir == WRITE)) {
237  if (host->io_pos) {
238  writel(TIFM_MS_SYS_FDIR
239  | readl(sock->addr + SOCK_MS_SYSTEM),
240  sock->addr + SOCK_MS_SYSTEM);
241  writel(host->io_word, sock->addr + SOCK_MS_DATA);
242  }
243  writel(TIFM_MS_SYS_FDIR
244  | readl(sock->addr + SOCK_MS_SYSTEM),
245  sock->addr + SOCK_MS_SYSTEM);
246  writel(0, sock->addr + SOCK_MS_DATA);
247  } else {
248  readl(sock->addr + SOCK_MS_DATA);
249  }
250 
251  return length;
252 }
253 
254 static int tifm_ms_issue_cmd(struct tifm_ms *host)
255 {
256  struct tifm_dev *sock = host->dev;
257  unsigned char *data;
258  unsigned int data_len, cmd, sys_param;
259 
260  host->cmd_flags = 0;
261  host->block_pos = 0;
262  host->io_pos = 0;
263  host->io_word = 0;
264  host->cmd_flags = 0;
265 
266  data = host->req->data;
267 
268  host->use_dma = !no_dma;
269 
270  if (host->req->long_data) {
271  data_len = host->req->sg.length;
272  if (!is_power_of_2(data_len))
273  host->use_dma = 0;
274  } else {
275  data_len = host->req->data_len;
276  host->use_dma = 0;
277  }
278 
279  writel(TIFM_FIFO_INT_SETALL,
280  sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
281  writel(TIFM_FIFO_ENABLE,
282  sock->addr + SOCK_FIFO_CONTROL);
283 
284  if (host->use_dma) {
285  if (1 != tifm_map_sg(sock, &host->req->sg, 1,
286  host->req->data_dir == READ
287  ? PCI_DMA_FROMDEVICE
288  : PCI_DMA_TODEVICE)) {
289  host->req->error = -ENOMEM;
290  return host->req->error;
291  }
292  data_len = sg_dma_len(&host->req->sg);
293 
294  writel(ilog2(data_len) - 2,
295  sock->addr + SOCK_FIFO_PAGE_SIZE);
296  writel(TIFM_FIFO_INTMASK,
297  sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
298  sys_param = TIFM_DMA_EN | (1 << 8);
299  if (host->req->data_dir == WRITE)
300  sys_param |= TIFM_DMA_TX;
301 
302  writel(TIFM_FIFO_INTMASK,
303  sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
304 
305  writel(sg_dma_address(&host->req->sg),
306  sock->addr + SOCK_DMA_ADDRESS);
307  writel(sys_param, sock->addr + SOCK_DMA_CONTROL);
308  } else {
309  writel(host->mode_mask | TIFM_MS_SYS_FIFO,
310  sock->addr + SOCK_MS_SYSTEM);
311 
312  writel(TIFM_FIFO_MORE,
313  sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
314  }
315 
316  mod_timer(&host->timer, jiffies + host->timeout_jiffies);
317  writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
318  sock->addr + SOCK_CONTROL);
319  host->req->error = 0;
320 
321  sys_param = readl(sock->addr + SOCK_MS_SYSTEM);
322  sys_param |= TIFM_MS_SYS_INTCLR;
323 
324  if (host->use_dma)
325  sys_param |= TIFM_MS_SYS_DMA;
326  else
327  sys_param &= ~TIFM_MS_SYS_DMA;
328 
329  writel(sys_param, sock->addr + SOCK_MS_SYSTEM);
330 
331  cmd = (host->req->tpc & 0xf) << 12;
332  cmd |= data_len;
333  writel(cmd, sock->addr + SOCK_MS_COMMAND);
334 
335  dev_dbg(&sock->dev, "executing TPC %x, %x\n", cmd, sys_param);
336  return 0;
337 }
338 
339 static void tifm_ms_complete_cmd(struct tifm_ms *host)
340 {
341  struct tifm_dev *sock = host->dev;
342  struct memstick_host *msh = tifm_get_drvdata(sock);
343  int rc;
344 
345  del_timer(&host->timer);
346 
347  host->req->int_reg = readl(sock->addr + SOCK_MS_STATUS) & 0xff;
348  host->req->int_reg = (host->req->int_reg & 1)
349  | ((host->req->int_reg << 4) & 0xe0);
350 
351  writel(TIFM_FIFO_INT_SETALL,
352  sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
353  writel(TIFM_DMA_RESET, sock->addr + SOCK_DMA_CONTROL);
354 
355  if (host->use_dma) {
356  tifm_unmap_sg(sock, &host->req->sg, 1,
357  host->req->data_dir == READ
358  ? PCI_DMA_FROMDEVICE
359  : PCI_DMA_TODEVICE);
360  }
361 
362  writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL),
363  sock->addr + SOCK_CONTROL);
364 
365  dev_dbg(&sock->dev, "TPC complete\n");
366  do {
367  rc = memstick_next_req(msh, &host->req);
368  } while (!rc && tifm_ms_issue_cmd(host));
369 }
370 
371 static int tifm_ms_check_status(struct tifm_ms *host)
372 {
373  if (!host->req->error) {
374  if (!(host->cmd_flags & CMD_READY))
375  return 1;
376  if (!(host->cmd_flags & FIFO_READY))
377  return 1;
378  if (host->req->need_card_int
379  && !(host->cmd_flags & CARD_INT))
380  return 1;
381  }
382  return 0;
383 }
384 
385 /* Called from interrupt handler */
386 static void tifm_ms_data_event(struct tifm_dev *sock)
387 {
388  struct tifm_ms *host;
389  unsigned int fifo_status = 0, host_status = 0;
390  int rc = 1;
391 
392  spin_lock(&sock->lock);
393  host = memstick_priv((struct memstick_host *)tifm_get_drvdata(sock));
394  fifo_status = readl(sock->addr + SOCK_DMA_FIFO_STATUS);
395  host_status = readl(sock->addr + SOCK_MS_STATUS);
396  dev_dbg(&sock->dev,
397  "data event: fifo_status %x, host_status %x, flags %x\n",
398  fifo_status, host_status, host->cmd_flags);
399 
400  if (host->req) {
401  if (host->use_dma && (fifo_status & 1)) {
402  host->cmd_flags |= FIFO_READY;
403  rc = tifm_ms_check_status(host);
404  }
405  if (!host->use_dma && (fifo_status & TIFM_FIFO_MORE)) {
406  if (!tifm_ms_transfer_data(host)) {
407  host->cmd_flags |= FIFO_READY;
408  rc = tifm_ms_check_status(host);
409  }
410  }
411  }
412 
413  writel(fifo_status, sock->addr + SOCK_DMA_FIFO_STATUS);
414  if (!rc)
415  tifm_ms_complete_cmd(host);
416 
417  spin_unlock(&sock->lock);
418 }
419 
420 
421 /* Called from interrupt handler */
422 static void tifm_ms_card_event(struct tifm_dev *sock)
423 {
424  struct tifm_ms *host;
425  unsigned int host_status = 0;
426  int rc = 1;
427 
428  spin_lock(&sock->lock);
429  host = memstick_priv((struct memstick_host *)tifm_get_drvdata(sock));
430  host_status = readl(sock->addr + SOCK_MS_STATUS);
431  dev_dbg(&sock->dev, "host event: host_status %x, flags %x\n",
432  host_status, host->cmd_flags);
433 
434  if (host->req) {
435  if (host_status & TIFM_MS_STAT_TOE)
436  host->req->error = -ETIME;
437  else if (host_status & TIFM_MS_STAT_CRC)
438  host->req->error = -EILSEQ;
439 
440  if (host_status & TIFM_MS_STAT_RDY)
441  host->cmd_flags |= CMD_READY;
442 
443  if (host_status & TIFM_MS_STAT_MSINT)
444  host->cmd_flags |= CARD_INT;
445 
446  rc = tifm_ms_check_status(host);
447 
448  }
449 
450  writel(TIFM_MS_SYS_INTCLR | readl(sock->addr + SOCK_MS_SYSTEM),
451  sock->addr + SOCK_MS_SYSTEM);
452 
453  if (!rc)
454  tifm_ms_complete_cmd(host);
455 
456  spin_unlock(&sock->lock);
457  return;
458 }
459 
460 static void tifm_ms_req_tasklet(unsigned long data)
461 {
462  struct memstick_host *msh = (struct memstick_host *)data;
463  struct tifm_ms *host = memstick_priv(msh);
464  struct tifm_dev *sock = host->dev;
465  unsigned long flags;
466  int rc;
467 
468  spin_lock_irqsave(&sock->lock, flags);
469  if (!host->req) {
470  if (host->eject) {
471  do {
472  rc = memstick_next_req(msh, &host->req);
473  if (!rc)
474  host->req->error = -ETIME;
475  } while (!rc);
476  spin_unlock_irqrestore(&sock->lock, flags);
477  return;
478  }
479 
480  do {
481  rc = memstick_next_req(msh, &host->req);
482  } while (!rc && tifm_ms_issue_cmd(host));
483  }
484  spin_unlock_irqrestore(&sock->lock, flags);
485 }
486 
487 static void tifm_ms_dummy_submit(struct memstick_host *msh)
488 {
489  return;
490 }
491 
492 static void tifm_ms_submit_req(struct memstick_host *msh)
493 {
494  struct tifm_ms *host = memstick_priv(msh);
495 
496  tasklet_schedule(&host->notify);
497 }
498 
499 static int tifm_ms_set_param(struct memstick_host *msh,
500  enum memstick_param param,
501  int value)
502 {
503  struct tifm_ms *host = memstick_priv(msh);
504  struct tifm_dev *sock = host->dev;
505 
506  switch (param) {
507  case MEMSTICK_POWER:
508  /* also affected by media detection mechanism */
509  if (value == MEMSTICK_POWER_ON) {
510  host->mode_mask = TIFM_MS_SYS_SRAC | TIFM_MS_SYS_REI;
511  writel(TIFM_MS_SYS_RESET, sock->addr + SOCK_MS_SYSTEM);
512  writel(TIFM_MS_SYS_FCLR | TIFM_MS_SYS_INTCLR,
513  sock->addr + SOCK_MS_SYSTEM);
514  writel(0xffffffff, sock->addr + SOCK_MS_STATUS);
515  } else if (value == MEMSTICK_POWER_OFF) {
516  writel(TIFM_MS_SYS_FCLR | TIFM_MS_SYS_INTCLR,
517  sock->addr + SOCK_MS_SYSTEM);
518  writel(0xffffffff, sock->addr + SOCK_MS_STATUS);
519  } else
520  return -EINVAL;
521  break;
522  case MEMSTICK_INTERFACE:
523  if (value == MEMSTICK_SERIAL) {
524  host->mode_mask = TIFM_MS_SYS_SRAC | TIFM_MS_SYS_REI;
525  writel((~TIFM_CTRL_FAST_CLK)
526  & readl(sock->addr + SOCK_CONTROL),
527  sock->addr + SOCK_CONTROL);
528  } else if (value == MEMSTICK_PAR4) {
529  host->mode_mask = 0;
530  writel(TIFM_CTRL_FAST_CLK
531  | readl(sock->addr + SOCK_CONTROL),
532  sock->addr + SOCK_CONTROL);
533  } else
534  return -EINVAL;
535  break;
536  };
537 
538  return 0;
539 }
540 
541 static void tifm_ms_abort(unsigned long data)
542 {
543  struct tifm_ms *host = (struct tifm_ms *)data;
544 
545  dev_dbg(&host->dev->dev, "status %x\n",
546  readl(host->dev->addr + SOCK_MS_STATUS));
547  printk(KERN_ERR
548  "%s : card failed to respond for a long period of time "
549  "(%x, %x)\n",
550  dev_name(&host->dev->dev), host->req ? host->req->tpc : 0,
551  host->cmd_flags);
552 
553  tifm_eject(host->dev);
554 }
555 
556 static int tifm_ms_probe(struct tifm_dev *sock)
557 {
558  struct memstick_host *msh;
559  struct tifm_ms *host;
560  int rc = -EIO;
561 
562  if (!(TIFM_SOCK_STATE_OCCUPIED
563  & readl(sock->addr + SOCK_PRESENT_STATE))) {
564  printk(KERN_WARNING "%s : card gone, unexpectedly\n",
565  dev_name(&sock->dev));
566  return rc;
567  }
568 
569  msh = memstick_alloc_host(sizeof(struct tifm_ms), &sock->dev);
570  if (!msh)
571  return -ENOMEM;
572 
573  host = memstick_priv(msh);
574  tifm_set_drvdata(sock, msh);
575  host->dev = sock;
576  host->timeout_jiffies = msecs_to_jiffies(1000);
577 
578  setup_timer(&host->timer, tifm_ms_abort, (unsigned long)host);
579  tasklet_init(&host->notify, tifm_ms_req_tasklet, (unsigned long)msh);
580 
581  msh->request = tifm_ms_submit_req;
582  msh->set_param = tifm_ms_set_param;
583  sock->card_event = tifm_ms_card_event;
584  sock->data_event = tifm_ms_data_event;
585  if (tifm_has_ms_pif(sock))
586  msh->caps |= MEMSTICK_CAP_PAR4;
587 
588  rc = memstick_add_host(msh);
589  if (!rc)
590  return 0;
591 
592  memstick_free_host(msh);
593  return rc;
594 }
595 
596 static void tifm_ms_remove(struct tifm_dev *sock)
597 {
598  struct memstick_host *msh = tifm_get_drvdata(sock);
599  struct tifm_ms *host = memstick_priv(msh);
600  int rc = 0;
601  unsigned long flags;
602 
603  msh->request = tifm_ms_dummy_submit;
604  tasklet_kill(&host->notify);
605  spin_lock_irqsave(&sock->lock, flags);
606  host->eject = 1;
607  if (host->req) {
608  del_timer(&host->timer);
609  writel(TIFM_FIFO_INT_SETALL,
610  sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
611  writel(TIFM_DMA_RESET, sock->addr + SOCK_DMA_CONTROL);
612  if (host->use_dma)
613  tifm_unmap_sg(sock, &host->req->sg, 1,
614  host->req->data_dir == READ
615  ? PCI_DMA_TODEVICE
616  : PCI_DMA_FROMDEVICE);
617  host->req->error = -ETIME;
618 
619  do {
620  rc = memstick_next_req(msh, &host->req);
621  if (!rc)
622  host->req->error = -ETIME;
623  } while (!rc);
624  }
625  spin_unlock_irqrestore(&sock->lock, flags);
626 
627  memstick_remove_host(msh);
628  memstick_free_host(msh);
629 }
630 
631 #ifdef CONFIG_PM
632 
633 static int tifm_ms_suspend(struct tifm_dev *sock, pm_message_t state)
634 {
635  struct memstick_host *msh = tifm_get_drvdata(sock);
636 
637  memstick_suspend_host(msh);
638  return 0;
639 }
640 
641 static int tifm_ms_resume(struct tifm_dev *sock)
642 {
643  struct memstick_host *msh = tifm_get_drvdata(sock);
644 
645  memstick_resume_host(msh);
646  return 0;
647 }
648 
649 #else
650 
651 #define tifm_ms_suspend NULL
652 #define tifm_ms_resume NULL
653 
654 #endif /* CONFIG_PM */
655 
656 static struct tifm_device_id tifm_ms_id_tbl[] = {
657  { TIFM_TYPE_MS }, { 0 }
658 };
659 
660 static struct tifm_driver tifm_ms_driver = {
661  .driver = {
662  .name = DRIVER_NAME,
663  .owner = THIS_MODULE
664  },
665  .id_table = tifm_ms_id_tbl,
666  .probe = tifm_ms_probe,
667  .remove = tifm_ms_remove,
668  .suspend = tifm_ms_suspend,
669  .resume = tifm_ms_resume
670 };
671 
672 static int __init tifm_ms_init(void)
673 {
674  return tifm_register_driver(&tifm_ms_driver);
675 }
676 
677 static void __exit tifm_ms_exit(void)
678 {
679  tifm_unregister_driver(&tifm_ms_driver);
680 }
681 
682 MODULE_AUTHOR("Alex Dubov");
683 MODULE_DESCRIPTION("TI FlashMedia MemoryStick driver");
684 MODULE_LICENSE("GPL");
685 MODULE_DEVICE_TABLE(tifm, tifm_ms_id_tbl);
686 
687 module_init(tifm_ms_init);
688 module_exit(tifm_ms_exit);
Generated on Thu Jan 10 2013 13:53:09 for Linux Kernel by   doxygen 1.8.2