memstick: initial commit for Sony MemoryStick support
[linux-2.6.git] / drivers / memstick / host / tifm_ms.c
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 <asm/io.h>
21
22 #define DRIVER_NAME "tifm_ms"
23 #define DRIVER_VERSION "0.1"
24
25 static int no_dma;
26 module_param(no_dma, bool, 0644);
27
28 #define TIFM_MS_TIMEOUT      0x00100
29 #define TIFM_MS_BADCRC       0x00200
30 #define TIFM_MS_EOTPC        0x01000
31 #define TIFM_MS_INT          0x02000
32
33 /* The meaning of the bit majority in this constant is unknown. */
34 #define TIFM_MS_SERIAL       0x04010
35
36 #define TIFM_MS_SYS_LATCH    0x00100
37 #define TIFM_MS_SYS_NOT_RDY  0x00800
38 #define TIFM_MS_SYS_DATA     0x10000
39
40 /* Hardware flags */
41 enum {
42         CMD_READY  = 0x0001,
43         FIFO_READY = 0x0002,
44         CARD_READY = 0x0004,
45         DATA_CARRY = 0x0008
46 };
47
48 struct tifm_ms {
49         struct tifm_dev         *dev;
50         unsigned short          eject:1,
51                                 no_dma:1;
52         unsigned short          cmd_flags;
53         unsigned int            mode_mask;
54         unsigned int            block_pos;
55         unsigned long           timeout_jiffies;
56
57         struct timer_list       timer;
58         struct memstick_request *req;
59         unsigned int            io_word;
60 };
61
62 static void tifm_ms_read_fifo(struct tifm_ms *host, unsigned int fifo_offset,
63                               struct page *pg, unsigned int page_off,
64                               unsigned int length)
65 {
66         struct tifm_dev *sock = host->dev;
67         unsigned int cnt = 0, off = 0;
68         unsigned char *buf = kmap_atomic(pg, KM_BIO_DST_IRQ) + page_off;
69
70         if (host->cmd_flags & DATA_CARRY) {
71                 while ((fifo_offset & 3) && length) {
72                         buf[off++] = host->io_word & 0xff;
73                         host->io_word >>= 8;
74                         length--;
75                         fifo_offset++;
76                 }
77                 if (!(fifo_offset & 3))
78                         host->cmd_flags &= ~DATA_CARRY;
79                 if (!length)
80                         return;
81         }
82
83         do {
84                 host->io_word = readl(sock->addr + SOCK_FIFO_ACCESS
85                                       + fifo_offset);
86                 cnt = 4;
87                 while (length && cnt) {
88                         buf[off++] = (host->io_word >> 8) & 0xff;
89                         cnt--;
90                         length--;
91                 }
92                 fifo_offset += 4 - cnt;
93         } while (length);
94
95         if (cnt)
96                 host->cmd_flags |= DATA_CARRY;
97
98         kunmap_atomic(buf - page_off, KM_BIO_DST_IRQ);
99 }
100
101 static void tifm_ms_write_fifo(struct tifm_ms *host, unsigned int fifo_offset,
102                                struct page *pg, unsigned int page_off,
103                                unsigned int length)
104 {
105         struct tifm_dev *sock = host->dev;
106         unsigned int cnt = 0, off = 0;
107         unsigned char *buf = kmap_atomic(pg, KM_BIO_SRC_IRQ) + page_off;
108
109         if (host->cmd_flags & DATA_CARRY) {
110                 while (fifo_offset & 3) {
111                         host->io_word |= buf[off++] << (8 * (fifo_offset & 3));
112                         length--;
113                         fifo_offset++;
114                 }
115                 if (!(fifo_offset & 3)) {
116                         writel(host->io_word, sock->addr + SOCK_FIFO_ACCESS
117                                + fifo_offset - 4);
118
119                         host->cmd_flags &= ~DATA_CARRY;
120                 }
121                 if (!length)
122                         return;
123         }
124
125         do {
126                 cnt = 4;
127                 host->io_word = 0;
128                 while (length && cnt) {
129                         host->io_word |= buf[off++] << (4 - cnt);
130                         cnt--;
131                         length--;
132                 }
133                 fifo_offset += 4 - cnt;
134                 if (!cnt)
135                         writel(host->io_word, sock->addr + SOCK_FIFO_ACCESS
136                                               + fifo_offset - 4);
137
138         } while (length);
139
140         if (cnt)
141                 host->cmd_flags |= DATA_CARRY;
142
143         kunmap_atomic(buf - page_off, KM_BIO_SRC_IRQ);
144 }
145
146 static void tifm_ms_move_block(struct tifm_ms *host, unsigned int length)
147 {
148         unsigned int t_size;
149         unsigned int off = host->req->sg.offset + host->block_pos;
150         unsigned int p_off, p_cnt;
151         struct page *pg;
152         unsigned long flags;
153
154         dev_dbg(&host->dev->dev, "moving block\n");
155         local_irq_save(flags);
156         t_size = length;
157         while (t_size) {
158                 pg = nth_page(sg_page(&host->req->sg), off >> PAGE_SHIFT);
159                 p_off = offset_in_page(off);
160                 p_cnt = PAGE_SIZE - p_off;
161                 p_cnt = min(p_cnt, t_size);
162
163                 if (host->req->data_dir == WRITE)
164                         tifm_ms_write_fifo(host, length - t_size,
165                                            pg, p_off, p_cnt);
166                 else
167                         tifm_ms_read_fifo(host, length - t_size,
168                                           pg, p_off, p_cnt);
169
170                 t_size -= p_cnt;
171         }
172         local_irq_restore(flags);
173 }
174
175 static int tifm_ms_transfer_data(struct tifm_ms *host, int skip)
176 {
177         struct tifm_dev *sock = host->dev;
178         unsigned int length = host->req->sg.length - host->block_pos;
179
180         if (!length)
181                 return 1;
182
183         if (length > TIFM_FIFO_SIZE)
184                 length = TIFM_FIFO_SIZE;
185
186         if (!skip) {
187                 tifm_ms_move_block(host, length);
188                 host->block_pos += length;
189         }
190
191         if ((host->req->data_dir == READ)
192             && (host->block_pos == host->req->sg.length))
193                 return 1;
194
195         writel(ilog2(length) - 2, sock->addr + SOCK_FIFO_PAGE_SIZE);
196         if (host->req->data_dir == WRITE)
197                 writel((1 << 8) | TIFM_DMA_TX, sock->addr + SOCK_DMA_CONTROL);
198         else
199                 writel((1 << 8), sock->addr + SOCK_DMA_CONTROL);
200
201         return 0;
202 }
203
204 static int tifm_ms_issue_cmd(struct tifm_ms *host)
205 {
206         struct tifm_dev *sock = host->dev;
207         unsigned char *data;
208         unsigned int data_len = 0, cmd = 0, cmd_mask = 0, cnt, tval = 0;
209
210         host->cmd_flags = 0;
211
212         if (host->req->io_type == MEMSTICK_IO_SG) {
213                 if (!host->no_dma) {
214                         if (1 != tifm_map_sg(sock, &host->req->sg, 1,
215                                              host->req->data_dir == READ
216                                              ? PCI_DMA_FROMDEVICE
217                                              : PCI_DMA_TODEVICE)) {
218                                 host->req->error = -ENOMEM;
219                                 return host->req->error;
220                         }
221                         data_len = sg_dma_len(&host->req->sg);
222                 } else
223                         data_len = host->req->sg.length;
224
225                 writel(TIFM_FIFO_INT_SETALL,
226                        sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
227                 writel(TIFM_FIFO_ENABLE,
228                        sock->addr + SOCK_FIFO_CONTROL);
229                 writel(TIFM_FIFO_INTMASK,
230                        sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
231
232                 if (!host->no_dma) {
233                         writel(ilog2(data_len) - 2,
234                                sock->addr + SOCK_FIFO_PAGE_SIZE);
235                         writel(sg_dma_address(&host->req->sg),
236                                sock->addr + SOCK_DMA_ADDRESS);
237                         if (host->req->data_dir == WRITE)
238                                 writel((1 << 8) | TIFM_DMA_TX | TIFM_DMA_EN,
239                                        sock->addr + SOCK_DMA_CONTROL);
240                         else
241                                 writel((1 << 8) | TIFM_DMA_EN,
242                                        sock->addr + SOCK_DMA_CONTROL);
243                 } else {
244                         tifm_ms_transfer_data(host,
245                                               host->req->data_dir == READ);
246                 }
247
248                 cmd_mask = readl(sock->addr + SOCK_MS_SYSTEM);
249                 cmd_mask |= TIFM_MS_SYS_DATA | TIFM_MS_SYS_NOT_RDY;
250                 writel(cmd_mask, sock->addr + SOCK_MS_SYSTEM);
251         } else if (host->req->io_type == MEMSTICK_IO_VAL) {
252                 data = host->req->data;
253                 data_len = host->req->data_len;
254
255                 cmd_mask = host->mode_mask | 0x2607; /* unknown constant */
256
257                 if (host->req->data_dir == WRITE) {
258                         cmd_mask |= TIFM_MS_SYS_LATCH;
259                         writel(cmd_mask, sock->addr + SOCK_MS_SYSTEM);
260                         for (cnt = 0; (data_len - cnt) >= 4; cnt += 4) {
261                                 writel(TIFM_MS_SYS_LATCH
262                                        | readl(sock->addr + SOCK_MS_SYSTEM),
263                                        sock->addr + SOCK_MS_SYSTEM);
264                                 __raw_writel(*(unsigned int *)(data + cnt),
265                                              sock->addr + SOCK_MS_DATA);
266                                 dev_dbg(&sock->dev, "writing %x\n",
267                                         *(int *)(data + cnt));
268                         }
269                         switch (data_len - cnt) {
270                         case 3:
271                                 tval |= data[cnt + 2] << 16;
272                         case 2:
273                                 tval |= data[cnt + 1] << 8;
274                         case 1:
275                                 tval |= data[cnt];
276                                 writel(TIFM_MS_SYS_LATCH
277                                        | readl(sock->addr + SOCK_MS_SYSTEM),
278                                        sock->addr + SOCK_MS_SYSTEM);
279                                 writel(tval, sock->addr + SOCK_MS_DATA);
280                                 dev_dbg(&sock->dev, "writing %x\n", tval);
281                         }
282
283                         writel(TIFM_MS_SYS_LATCH
284                                | readl(sock->addr + SOCK_MS_SYSTEM),
285                                sock + SOCK_MS_SYSTEM);
286                         writel(0, sock->addr + SOCK_MS_DATA);
287                         dev_dbg(&sock->dev, "writing %x\n", 0);
288
289                 } else
290                         writel(cmd_mask, sock->addr + SOCK_MS_SYSTEM);
291
292                 cmd_mask = readl(sock->addr + SOCK_MS_SYSTEM);
293                 cmd_mask &= ~TIFM_MS_SYS_DATA;
294                 cmd_mask |= TIFM_MS_SYS_NOT_RDY;
295                 dev_dbg(&sock->dev, "mask %x\n", cmd_mask);
296                 writel(cmd_mask, sock->addr + SOCK_MS_SYSTEM);
297         } else
298                 BUG();
299
300         mod_timer(&host->timer, jiffies + host->timeout_jiffies);
301         writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
302                sock->addr + SOCK_CONTROL);
303         host->req->error = 0;
304
305         cmd = (host->req->tpc & 0xf) << 12;
306         cmd |= data_len;
307         writel(cmd, sock->addr + SOCK_MS_COMMAND);
308
309         dev_dbg(&sock->dev, "executing TPC %x, %x\n", cmd, cmd_mask);
310         return 0;
311 }
312
313 static void tifm_ms_complete_cmd(struct tifm_ms *host)
314 {
315         struct tifm_dev *sock = host->dev;
316         struct memstick_host *msh = tifm_get_drvdata(sock);
317         unsigned int tval = 0, data_len;
318         unsigned char *data;
319         int rc;
320
321         del_timer(&host->timer);
322         if (host->req->io_type == MEMSTICK_IO_SG) {
323                 if (!host->no_dma)
324                         tifm_unmap_sg(sock, &host->req->sg, 1,
325                                       host->req->data_dir == READ
326                                       ? PCI_DMA_FROMDEVICE
327                                       : PCI_DMA_TODEVICE);
328         } else if (host->req->io_type == MEMSTICK_IO_VAL) {
329                 writel(~TIFM_MS_SYS_DATA & readl(sock->addr + SOCK_MS_SYSTEM),
330                        sock->addr + SOCK_MS_SYSTEM);
331
332                 data = host->req->data;
333                 data_len = host->req->data_len;
334
335                 if (host->req->data_dir == READ) {
336                         for (rc = 0; (data_len - rc) >= 4; rc += 4)
337                                 *(int *)(data + rc)
338                                         = __raw_readl(sock->addr
339                                                       + SOCK_MS_DATA);
340
341                         if (data_len - rc)
342                                 tval = readl(sock->addr + SOCK_MS_DATA);
343                         switch (data_len - rc) {
344                         case 3:
345                                 data[rc + 2] = (tval >> 16) & 0xff;
346                         case 2:
347                                 data[rc + 1] = (tval >> 8) & 0xff;
348                         case 1:
349                                 data[rc] = tval & 0xff;
350                         }
351                         readl(sock->addr + SOCK_MS_DATA);
352                 }
353         }
354
355         writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL),
356                sock->addr + SOCK_CONTROL);
357
358         do {
359                 rc = memstick_next_req(msh, &host->req);
360         } while (!rc && tifm_ms_issue_cmd(host));
361 }
362
363 static int tifm_ms_check_status(struct tifm_ms *host)
364 {
365         if (!host->req->error) {
366                 if (!(host->cmd_flags & CMD_READY))
367                         return 1;
368                 if ((host->req->io_type == MEMSTICK_IO_SG)
369                     && !(host->cmd_flags & FIFO_READY))
370                         return 1;
371                 if (host->req->need_card_int
372                     && !(host->cmd_flags & CARD_READY))
373                         return 1;
374         }
375         return 0;
376 }
377
378 /* Called from interrupt handler */
379 static void tifm_ms_data_event(struct tifm_dev *sock)
380 {
381         struct tifm_ms *host;
382         unsigned int fifo_status = 0;
383         int rc = 1;
384
385         spin_lock(&sock->lock);
386         host = memstick_priv((struct memstick_host *)tifm_get_drvdata(sock));
387         fifo_status = readl(sock->addr + SOCK_DMA_FIFO_STATUS);
388         dev_dbg(&sock->dev, "data event: fifo_status %x, flags %x\n",
389                 fifo_status, host->cmd_flags);
390
391         if (host->req) {
392                 if (fifo_status & TIFM_FIFO_READY) {
393                         if (!host->no_dma || tifm_ms_transfer_data(host, 0)) {
394                                 host->cmd_flags |= FIFO_READY;
395                                 rc = tifm_ms_check_status(host);
396                         }
397                 }
398         }
399
400         writel(fifo_status, sock->addr + SOCK_DMA_FIFO_STATUS);
401         if (!rc)
402                 tifm_ms_complete_cmd(host);
403
404         spin_unlock(&sock->lock);
405 }
406
407
408 /* Called from interrupt handler */
409 static void tifm_ms_card_event(struct tifm_dev *sock)
410 {
411         struct tifm_ms *host;
412         unsigned int host_status = 0;
413         int rc = 1;
414
415         spin_lock(&sock->lock);
416         host = memstick_priv((struct memstick_host *)tifm_get_drvdata(sock));
417         host_status = readl(sock->addr + SOCK_MS_STATUS);
418         dev_dbg(&sock->dev, "host event: host_status %x, flags %x\n",
419                 host_status, host->cmd_flags);
420
421         if (host->req) {
422                 if (host_status & TIFM_MS_TIMEOUT)
423                         host->req->error = -ETIME;
424                 else if (host_status & TIFM_MS_BADCRC)
425                         host->req->error = -EILSEQ;
426
427                 if (host->req->error) {
428                         writel(TIFM_FIFO_INT_SETALL,
429                                sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
430                         writel(TIFM_DMA_RESET, sock->addr + SOCK_DMA_CONTROL);
431                 }
432
433                 if (host_status & TIFM_MS_EOTPC)
434                         host->cmd_flags |= CMD_READY;
435                 if (host_status & TIFM_MS_INT)
436                         host->cmd_flags |= CARD_READY;
437
438                 rc = tifm_ms_check_status(host);
439
440         }
441
442         writel(TIFM_MS_SYS_NOT_RDY | readl(sock->addr + SOCK_MS_SYSTEM),
443                sock->addr + SOCK_MS_SYSTEM);
444         writel((~TIFM_MS_SYS_DATA) & readl(sock->addr + SOCK_MS_SYSTEM),
445                sock->addr + SOCK_MS_SYSTEM);
446
447         if (!rc)
448                 tifm_ms_complete_cmd(host);
449
450         spin_unlock(&sock->lock);
451         return;
452 }
453
454 static void tifm_ms_request(struct memstick_host *msh)
455 {
456         struct tifm_ms *host = memstick_priv(msh);
457         struct tifm_dev *sock = host->dev;
458         unsigned long flags;
459         int rc;
460
461         spin_lock_irqsave(&sock->lock, flags);
462         if (host->req) {
463                 printk(KERN_ERR "%s : unfinished request detected\n",
464                        sock->dev.bus_id);
465                 spin_unlock_irqrestore(&sock->lock, flags);
466                 tifm_eject(host->dev);
467                 return;
468         }
469
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         return;
486 }
487
488 static void tifm_ms_set_param(struct memstick_host *msh,
489                               enum memstick_param param,
490                               int value)
491 {
492         struct tifm_ms *host = memstick_priv(msh);
493         struct tifm_dev *sock = host->dev;
494         unsigned long flags;
495
496         spin_lock_irqsave(&sock->lock, flags);
497
498         switch (param) {
499         case MEMSTICK_POWER:
500                 /* this is set by card detection mechanism */
501                 break;
502         case MEMSTICK_INTERFACE:
503                 if (value == MEMSTICK_SERIAL) {
504                         host->mode_mask = TIFM_MS_SERIAL;
505                         writel((~TIFM_CTRL_FAST_CLK)
506                                & readl(sock->addr + SOCK_CONTROL),
507                                sock->addr + SOCK_CONTROL);
508                 } else if (value == MEMSTICK_PARALLEL) {
509                         host->mode_mask = 0;
510                         writel(TIFM_CTRL_FAST_CLK
511                                | readl(sock->addr + SOCK_CONTROL),
512                                sock->addr + SOCK_CONTROL);
513                 }
514                 break;
515         };
516
517         spin_unlock_irqrestore(&sock->lock, flags);
518 }
519
520 static void tifm_ms_abort(unsigned long data)
521 {
522         struct tifm_ms *host = (struct tifm_ms *)data;
523
524         dev_dbg(&host->dev->dev, "status %x\n",
525                 readl(host->dev->addr + SOCK_MS_STATUS));
526         printk(KERN_ERR
527                "%s : card failed to respond for a long period of time "
528                "(%x, %x)\n",
529                host->dev->dev.bus_id, host->req ? host->req->tpc : 0,
530                host->cmd_flags);
531
532         tifm_eject(host->dev);
533 }
534
535 static int tifm_ms_initialize_host(struct tifm_ms *host)
536 {
537         struct tifm_dev *sock = host->dev;
538         struct memstick_host *msh = tifm_get_drvdata(sock);
539
540         host->mode_mask = TIFM_MS_SERIAL;
541         writel(0x8000, sock->addr + SOCK_MS_SYSTEM);
542         writel(0x0200 | TIFM_MS_SYS_NOT_RDY, sock->addr + SOCK_MS_SYSTEM);
543         writel(0xffffffff, sock->addr + SOCK_MS_STATUS);
544         if (tifm_has_ms_pif(sock))
545                 msh->caps |= MEMSTICK_CAP_PARALLEL;
546
547         return 0;
548 }
549
550 static int tifm_ms_probe(struct tifm_dev *sock)
551 {
552         struct memstick_host *msh;
553         struct tifm_ms *host;
554         int rc = -EIO;
555
556         if (!(TIFM_SOCK_STATE_OCCUPIED
557               & readl(sock->addr + SOCK_PRESENT_STATE))) {
558                 printk(KERN_WARNING "%s : card gone, unexpectedly\n",
559                        sock->dev.bus_id);
560                 return rc;
561         }
562
563         msh = memstick_alloc_host(sizeof(struct tifm_ms), &sock->dev);
564         if (!msh)
565                 return -ENOMEM;
566
567         host = memstick_priv(msh);
568         tifm_set_drvdata(sock, msh);
569         host->dev = sock;
570         host->timeout_jiffies = msecs_to_jiffies(1000);
571         host->no_dma = no_dma;
572
573         setup_timer(&host->timer, tifm_ms_abort, (unsigned long)host);
574
575         msh->request = tifm_ms_request;
576         msh->set_param = tifm_ms_set_param;
577         sock->card_event = tifm_ms_card_event;
578         sock->data_event = tifm_ms_data_event;
579         rc = tifm_ms_initialize_host(host);
580
581         if (!rc)
582                 rc = memstick_add_host(msh);
583         if (!rc)
584                 return 0;
585
586         memstick_free_host(msh);
587         return rc;
588 }
589
590 static void tifm_ms_remove(struct tifm_dev *sock)
591 {
592         struct memstick_host *msh = tifm_get_drvdata(sock);
593         struct tifm_ms *host = memstick_priv(msh);
594         int rc = 0;
595         unsigned long flags;
596
597         spin_lock_irqsave(&sock->lock, flags);
598         host->eject = 1;
599         if (host->req) {
600                 del_timer(&host->timer);
601                 writel(TIFM_FIFO_INT_SETALL,
602                        sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
603                 writel(TIFM_DMA_RESET, sock->addr + SOCK_DMA_CONTROL);
604                 if ((host->req->io_type == MEMSTICK_IO_SG) && !host->no_dma)
605                         tifm_unmap_sg(sock, &host->req->sg, 1,
606                                       host->req->data_dir == READ
607                                       ? PCI_DMA_TODEVICE
608                                       : PCI_DMA_FROMDEVICE);
609                 host->req->error = -ETIME;
610
611                 do {
612                         rc = memstick_next_req(msh, &host->req);
613                         if (!rc)
614                                 host->req->error = -ETIME;
615                 } while (!rc);
616         }
617         spin_unlock_irqrestore(&sock->lock, flags);
618
619         memstick_remove_host(msh);
620
621         writel(0x0200 | TIFM_MS_SYS_NOT_RDY, sock->addr + SOCK_MS_SYSTEM);
622         writel(0xffffffff, sock->addr + SOCK_MS_STATUS);
623
624         memstick_free_host(msh);
625 }
626
627 #ifdef CONFIG_PM
628
629 static int tifm_ms_suspend(struct tifm_dev *sock, pm_message_t state)
630 {
631         return 0;
632 }
633
634 static int tifm_ms_resume(struct tifm_dev *sock)
635 {
636         struct memstick_host *msh = tifm_get_drvdata(sock);
637         struct tifm_ms *host = memstick_priv(msh);
638
639         tifm_ms_initialize_host(host);
640         memstick_detect_change(msh);
641
642         return 0;
643 }
644
645 #else
646
647 #define tifm_ms_suspend NULL
648 #define tifm_ms_resume NULL
649
650 #endif /* CONFIG_PM */
651
652 static struct tifm_device_id tifm_ms_id_tbl[] = {
653         { TIFM_TYPE_MS }, { 0 }
654 };
655
656 static struct tifm_driver tifm_ms_driver = {
657         .driver = {
658                 .name  = DRIVER_NAME,
659                 .owner = THIS_MODULE
660         },
661         .id_table = tifm_ms_id_tbl,
662         .probe    = tifm_ms_probe,
663         .remove   = tifm_ms_remove,
664         .suspend  = tifm_ms_suspend,
665         .resume   = tifm_ms_resume
666 };
667
668 static int __init tifm_ms_init(void)
669 {
670         return tifm_register_driver(&tifm_ms_driver);
671 }
672
673 static void __exit tifm_ms_exit(void)
674 {
675         tifm_unregister_driver(&tifm_ms_driver);
676 }
677
678 MODULE_AUTHOR("Alex Dubov");
679 MODULE_DESCRIPTION("TI FlashMedia MemoryStick driver");
680 MODULE_LICENSE("GPL");
681 MODULE_DEVICE_TABLE(tifm, tifm_ms_id_tbl);
682 MODULE_VERSION(DRIVER_VERSION);
683
684 module_init(tifm_ms_init);
685 module_exit(tifm_ms_exit);