pcmcia: convert pcmcia_request_configuration to pcmcia_enable_device
[linux-2.6.git] / drivers / mtd / maps / pcmciamtd.c
1 /*
2  * pcmciamtd.c - MTD driver for PCMCIA flash memory cards
3  *
4  * Author: Simon Evans <spse@secret.org.uk>
5  *
6  * Copyright (C) 2002 Simon Evans
7  *
8  * Licence: GPL
9  *
10  */
11
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/timer.h>
15 #include <linux/init.h>
16 #include <asm/io.h>
17 #include <asm/system.h>
18
19 #include <pcmcia/cistpl.h>
20 #include <pcmcia/ds.h>
21
22 #include <linux/mtd/map.h>
23 #include <linux/mtd/mtd.h>
24
25 #ifdef CONFIG_MTD_DEBUG
26 static int debug = CONFIG_MTD_DEBUG_VERBOSE;
27 module_param(debug, int, 0);
28 MODULE_PARM_DESC(debug, "Set Debug Level 0=quiet, 5=noisy");
29 #undef DEBUG
30 #define DEBUG(n, format, arg...) \
31         if (n <= debug) {        \
32                 printk(KERN_DEBUG __FILE__ ":%s(): " format "\n", __func__ , ## arg); \
33         }
34
35 #else
36 #undef DEBUG
37 #define DEBUG(n, arg...)
38 static const int debug = 0;
39 #endif
40
41 #define info(format, arg...) printk(KERN_INFO "pcmciamtd: " format "\n" , ## arg)
42
43 #define DRIVER_DESC     "PCMCIA Flash memory card driver"
44
45 /* Size of the PCMCIA address space: 26 bits = 64 MB */
46 #define MAX_PCMCIA_ADDR 0x4000000
47
48 struct pcmciamtd_dev {
49         struct pcmcia_device    *p_dev;
50         caddr_t         win_base;       /* ioremapped address of PCMCIA window */
51         unsigned int    win_size;       /* size of window */
52         unsigned int    offset;         /* offset into card the window currently points at */
53         struct map_info pcmcia_map;
54         struct mtd_info *mtd_info;
55         int             vpp;
56         char            mtd_name[sizeof(struct cistpl_vers_1_t)];
57 };
58
59
60 /* Module parameters */
61
62 /* 2 = do 16-bit transfers, 1 = do 8-bit transfers */
63 static int bankwidth = 2;
64
65 /* Speed of memory accesses, in ns */
66 static int mem_speed;
67
68 /* Force the size of an SRAM card */
69 static int force_size;
70
71 /* Force Vpp */
72 static int vpp;
73
74 /* Set Vpp */
75 static int setvpp;
76
77 /* Force card to be treated as FLASH, ROM or RAM */
78 static int mem_type;
79
80 MODULE_LICENSE("GPL");
81 MODULE_AUTHOR("Simon Evans <spse@secret.org.uk>");
82 MODULE_DESCRIPTION(DRIVER_DESC);
83 module_param(bankwidth, int, 0);
84 MODULE_PARM_DESC(bankwidth, "Set bankwidth (1=8 bit, 2=16 bit, default=2)");
85 module_param(mem_speed, int, 0);
86 MODULE_PARM_DESC(mem_speed, "Set memory access speed in ns");
87 module_param(force_size, int, 0);
88 MODULE_PARM_DESC(force_size, "Force size of card in MiB (1-64)");
89 module_param(setvpp, int, 0);
90 MODULE_PARM_DESC(setvpp, "Set Vpp (0=Never, 1=On writes, 2=Always on, default=0)");
91 module_param(vpp, int, 0);
92 MODULE_PARM_DESC(vpp, "Vpp value in 1/10ths eg 33=3.3V 120=12V (Dangerous)");
93 module_param(mem_type, int, 0);
94 MODULE_PARM_DESC(mem_type, "Set Memory type (0=Flash, 1=RAM, 2=ROM, default=0)");
95
96
97 /* read/write{8,16} copy_{from,to} routines with window remapping
98  * to access whole card
99  */
100 static caddr_t remap_window(struct map_info *map, unsigned long to)
101 {
102         struct pcmciamtd_dev *dev = (struct pcmciamtd_dev *)map->map_priv_1;
103         struct resource *win = (struct resource *) map->map_priv_2;
104         unsigned int offset;
105         int ret;
106
107         if (!pcmcia_dev_present(dev->p_dev)) {
108                 DEBUG(1, "device removed");
109                 return 0;
110         }
111
112         offset = to & ~(dev->win_size-1);
113         if (offset != dev->offset) {
114                 DEBUG(2, "Remapping window from 0x%8.8x to 0x%8.8x",
115                       dev->offset, offset);
116                 ret = pcmcia_map_mem_page(dev->p_dev, win, offset);
117                 if (ret != 0)
118                         return NULL;
119                 dev->offset = offset;
120         }
121         return dev->win_base + (to & (dev->win_size-1));
122 }
123
124
125 static map_word pcmcia_read8_remap(struct map_info *map, unsigned long ofs)
126 {
127         caddr_t addr;
128         map_word d = {{0}};
129
130         addr = remap_window(map, ofs);
131         if(!addr)
132                 return d;
133
134         d.x[0] = readb(addr);
135         DEBUG(3, "ofs = 0x%08lx (%p) data = 0x%02lx", ofs, addr, d.x[0]);
136         return d;
137 }
138
139
140 static map_word pcmcia_read16_remap(struct map_info *map, unsigned long ofs)
141 {
142         caddr_t addr;
143         map_word d = {{0}};
144
145         addr = remap_window(map, ofs);
146         if(!addr)
147                 return d;
148
149         d.x[0] = readw(addr);
150         DEBUG(3, "ofs = 0x%08lx (%p) data = 0x%04lx", ofs, addr, d.x[0]);
151         return d;
152 }
153
154
155 static void pcmcia_copy_from_remap(struct map_info *map, void *to, unsigned long from, ssize_t len)
156 {
157         struct pcmciamtd_dev *dev = (struct pcmciamtd_dev *)map->map_priv_1;
158         unsigned long win_size = dev->win_size;
159
160         DEBUG(3, "to = %p from = %lu len = %zd", to, from, len);
161         while(len) {
162                 int toread = win_size - (from & (win_size-1));
163                 caddr_t addr;
164
165                 if(toread > len)
166                         toread = len;
167
168                 addr = remap_window(map, from);
169                 if(!addr)
170                         return;
171
172                 DEBUG(4, "memcpy from %p to %p len = %d", addr, to, toread);
173                 memcpy_fromio(to, addr, toread);
174                 len -= toread;
175                 to += toread;
176                 from += toread;
177         }
178 }
179
180
181 static void pcmcia_write8_remap(struct map_info *map, map_word d, unsigned long adr)
182 {
183         caddr_t addr = remap_window(map, adr);
184
185         if(!addr)
186                 return;
187
188         DEBUG(3, "adr = 0x%08lx (%p)  data = 0x%02lx", adr, addr, d.x[0]);
189         writeb(d.x[0], addr);
190 }
191
192
193 static void pcmcia_write16_remap(struct map_info *map, map_word d, unsigned long adr)
194 {
195         caddr_t addr = remap_window(map, adr);
196         if(!addr)
197                 return;
198
199         DEBUG(3, "adr = 0x%08lx (%p)  data = 0x%04lx", adr, addr, d.x[0]);
200         writew(d.x[0], addr);
201 }
202
203
204 static void pcmcia_copy_to_remap(struct map_info *map, unsigned long to, const void *from, ssize_t len)
205 {
206         struct pcmciamtd_dev *dev = (struct pcmciamtd_dev *)map->map_priv_1;
207         unsigned long win_size = dev->win_size;
208
209         DEBUG(3, "to = %lu from = %p len = %zd", to, from, len);
210         while(len) {
211                 int towrite = win_size - (to & (win_size-1));
212                 caddr_t addr;
213
214                 if(towrite > len)
215                         towrite = len;
216
217                 addr = remap_window(map, to);
218                 if(!addr)
219                         return;
220
221                 DEBUG(4, "memcpy from %p to %p len = %d", from, addr, towrite);
222                 memcpy_toio(addr, from, towrite);
223                 len -= towrite;
224                 to += towrite;
225                 from += towrite;
226         }
227 }
228
229
230 /* read/write{8,16} copy_{from,to} routines with direct access */
231
232 #define DEV_REMOVED(x)  (!(pcmcia_dev_present(((struct pcmciamtd_dev *)map->map_priv_1)->p_dev)))
233
234 static map_word pcmcia_read8(struct map_info *map, unsigned long ofs)
235 {
236         caddr_t win_base = (caddr_t)map->map_priv_2;
237         map_word d = {{0}};
238
239         if(DEV_REMOVED(map))
240                 return d;
241
242         d.x[0] = readb(win_base + ofs);
243         DEBUG(3, "ofs = 0x%08lx (%p) data = 0x%02lx",
244               ofs, win_base + ofs, d.x[0]);
245         return d;
246 }
247
248
249 static map_word pcmcia_read16(struct map_info *map, unsigned long ofs)
250 {
251         caddr_t win_base = (caddr_t)map->map_priv_2;
252         map_word d = {{0}};
253
254         if(DEV_REMOVED(map))
255                 return d;
256
257         d.x[0] = readw(win_base + ofs);
258         DEBUG(3, "ofs = 0x%08lx (%p) data = 0x%04lx",
259               ofs, win_base + ofs, d.x[0]);
260         return d;
261 }
262
263
264 static void pcmcia_copy_from(struct map_info *map, void *to, unsigned long from, ssize_t len)
265 {
266         caddr_t win_base = (caddr_t)map->map_priv_2;
267
268         if(DEV_REMOVED(map))
269                 return;
270
271         DEBUG(3, "to = %p from = %lu len = %zd", to, from, len);
272         memcpy_fromio(to, win_base + from, len);
273 }
274
275
276 static void pcmcia_write8(struct map_info *map, map_word d, unsigned long adr)
277 {
278         caddr_t win_base = (caddr_t)map->map_priv_2;
279
280         if(DEV_REMOVED(map))
281                 return;
282
283         DEBUG(3, "adr = 0x%08lx (%p)  data = 0x%02lx",
284               adr, win_base + adr, d.x[0]);
285         writeb(d.x[0], win_base + adr);
286 }
287
288
289 static void pcmcia_write16(struct map_info *map, map_word d, unsigned long adr)
290 {
291         caddr_t win_base = (caddr_t)map->map_priv_2;
292
293         if(DEV_REMOVED(map))
294                 return;
295
296         DEBUG(3, "adr = 0x%08lx (%p)  data = 0x%04lx",
297               adr, win_base + adr, d.x[0]);
298         writew(d.x[0], win_base + adr);
299 }
300
301
302 static void pcmcia_copy_to(struct map_info *map, unsigned long to, const void *from, ssize_t len)
303 {
304         caddr_t win_base = (caddr_t)map->map_priv_2;
305
306         if(DEV_REMOVED(map))
307                 return;
308
309         DEBUG(3, "to = %lu from = %p len = %zd", to, from, len);
310         memcpy_toio(win_base + to, from, len);
311 }
312
313
314 static void pcmciamtd_set_vpp(struct map_info *map, int on)
315 {
316         struct pcmciamtd_dev *dev = (struct pcmciamtd_dev *)map->map_priv_1;
317         struct pcmcia_device *link = dev->p_dev;
318
319         DEBUG(2, "dev = %p on = %d vpp = %d\n", dev, on, dev->vpp);
320         pcmcia_fixup_vpp(link, on ? dev->vpp : 0);
321 }
322
323
324 /* After a card is removed, pcmciamtd_release() will unregister the
325  * device, and release the PCMCIA configuration.  If the device is
326  * still open, this will be postponed until it is closed.
327  */
328
329 static void pcmciamtd_release(struct pcmcia_device *link)
330 {
331         struct pcmciamtd_dev *dev = link->priv;
332
333         DEBUG(3, "link = 0x%p", link);
334
335         if (link->resource[2]->end) {
336                 if(dev->win_base) {
337                         iounmap(dev->win_base);
338                         dev->win_base = NULL;
339                 }
340         }
341         pcmcia_disable_device(link);
342 }
343
344
345 #ifdef CONFIG_MTD_DEBUG
346 static int pcmciamtd_cistpl_format(struct pcmcia_device *p_dev,
347                                 tuple_t *tuple,
348                                 void *priv_data)
349 {
350         cisparse_t parse;
351
352         if (!pcmcia_parse_tuple(tuple, &parse)) {
353                 cistpl_format_t *t = &parse.format;
354                 (void)t; /* Shut up, gcc */
355                 DEBUG(2, "Format type: %u, Error Detection: %u, offset = %u, length =%u",
356                         t->type, t->edc, t->offset, t->length);
357         }
358         return -ENOSPC;
359 }
360
361 static int pcmciamtd_cistpl_jedec(struct pcmcia_device *p_dev,
362                                 tuple_t *tuple,
363                                 void *priv_data)
364 {
365         cisparse_t parse;
366         int i;
367
368         if (!pcmcia_parse_tuple(tuple, &parse)) {
369                 cistpl_jedec_t *t = &parse.jedec;
370                 for (i = 0; i < t->nid; i++)
371                         DEBUG(2, "JEDEC: 0x%02x 0x%02x",
372                               t->id[i].mfr, t->id[i].info);
373         }
374         return -ENOSPC;
375 }
376 #endif
377
378 static int pcmciamtd_cistpl_device(struct pcmcia_device *p_dev,
379                                 tuple_t *tuple,
380                                 void *priv_data)
381 {
382         struct pcmciamtd_dev *dev = priv_data;
383         cisparse_t parse;
384         cistpl_device_t *t = &parse.device;
385         int i;
386
387         if (pcmcia_parse_tuple(tuple, &parse))
388                 return -EINVAL;
389
390         DEBUG(2, "Common memory:");
391         dev->pcmcia_map.size = t->dev[0].size;
392         /* from here on: DEBUG only */
393         for (i = 0; i < t->ndev; i++) {
394                 DEBUG(2, "Region %d, type = %u", i, t->dev[i].type);
395                 DEBUG(2, "Region %d, wp = %u", i, t->dev[i].wp);
396                 DEBUG(2, "Region %d, speed = %u ns", i, t->dev[i].speed);
397                 DEBUG(2, "Region %d, size = %u bytes", i, t->dev[i].size);
398         }
399         return 0;
400 }
401
402 static int pcmciamtd_cistpl_geo(struct pcmcia_device *p_dev,
403                                 tuple_t *tuple,
404                                 void *priv_data)
405 {
406         struct pcmciamtd_dev *dev = priv_data;
407         cisparse_t parse;
408         cistpl_device_geo_t *t = &parse.device_geo;
409         int i;
410
411         if (pcmcia_parse_tuple(tuple, &parse))
412                 return -EINVAL;
413
414         dev->pcmcia_map.bankwidth = t->geo[0].buswidth;
415         /* from here on: DEBUG only */
416         for (i = 0; i < t->ngeo; i++) {
417                 DEBUG(2, "region: %d bankwidth = %u", i, t->geo[i].buswidth);
418                 DEBUG(2, "region: %d erase_block = %u", i, t->geo[i].erase_block);
419                 DEBUG(2, "region: %d read_block = %u", i, t->geo[i].read_block);
420                 DEBUG(2, "region: %d write_block = %u", i, t->geo[i].write_block);
421                 DEBUG(2, "region: %d partition = %u", i, t->geo[i].partition);
422                 DEBUG(2, "region: %d interleave = %u", i, t->geo[i].interleave);
423         }
424         return 0;
425 }
426
427
428 static void card_settings(struct pcmciamtd_dev *dev, struct pcmcia_device *p_dev, int *new_name)
429 {
430         int i;
431
432         if (p_dev->prod_id[0]) {
433                 dev->mtd_name[0] = '\0';
434                 for (i = 0; i < 4; i++) {
435                         if (i)
436                                 strcat(dev->mtd_name, " ");
437                         if (p_dev->prod_id[i])
438                                 strcat(dev->mtd_name, p_dev->prod_id[i]);
439                 }
440                 DEBUG(2, "Found name: %s", dev->mtd_name);
441         }
442
443 #ifdef CONFIG_MTD_DEBUG
444         pcmcia_loop_tuple(p_dev, CISTPL_FORMAT, pcmciamtd_cistpl_format, NULL);
445         pcmcia_loop_tuple(p_dev, CISTPL_JEDEC_C, pcmciamtd_cistpl_jedec, NULL);
446 #endif
447         pcmcia_loop_tuple(p_dev, CISTPL_DEVICE, pcmciamtd_cistpl_device, dev);
448         pcmcia_loop_tuple(p_dev, CISTPL_DEVICE_GEO, pcmciamtd_cistpl_geo, dev);
449
450         if(!dev->pcmcia_map.size)
451                 dev->pcmcia_map.size = MAX_PCMCIA_ADDR;
452
453         if(!dev->pcmcia_map.bankwidth)
454                 dev->pcmcia_map.bankwidth = 2;
455
456         if(force_size) {
457                 dev->pcmcia_map.size = force_size << 20;
458                 DEBUG(2, "size forced to %dM", force_size);
459         }
460
461         if(bankwidth) {
462                 dev->pcmcia_map.bankwidth = bankwidth;
463                 DEBUG(2, "bankwidth forced to %d", bankwidth);
464         }
465
466         dev->pcmcia_map.name = dev->mtd_name;
467         if(!dev->mtd_name[0]) {
468                 strcpy(dev->mtd_name, "PCMCIA Memory card");
469                 *new_name = 1;
470         }
471
472         DEBUG(1, "Device: Size: %lu Width:%d Name: %s",
473               dev->pcmcia_map.size,
474               dev->pcmcia_map.bankwidth << 3, dev->mtd_name);
475 }
476
477
478 /* pcmciamtd_config() is scheduled to run after a CARD_INSERTION event
479  * is received, to configure the PCMCIA socket, and to make the
480  * MTD device available to the system.
481  */
482
483 static int pcmciamtd_config(struct pcmcia_device *link)
484 {
485         struct pcmciamtd_dev *dev = link->priv;
486         struct mtd_info *mtd = NULL;
487         int ret;
488         int i, j = 0;
489         static char *probes[] = { "jedec_probe", "cfi_probe" };
490         int new_name = 0;
491
492         DEBUG(3, "link=0x%p", link);
493
494         card_settings(dev, link, &new_name);
495
496         dev->pcmcia_map.phys = NO_XIP;
497         dev->pcmcia_map.copy_from = pcmcia_copy_from_remap;
498         dev->pcmcia_map.copy_to = pcmcia_copy_to_remap;
499         if (dev->pcmcia_map.bankwidth == 1) {
500                 dev->pcmcia_map.read = pcmcia_read8_remap;
501                 dev->pcmcia_map.write = pcmcia_write8_remap;
502         } else {
503                 dev->pcmcia_map.read = pcmcia_read16_remap;
504                 dev->pcmcia_map.write = pcmcia_write16_remap;
505         }
506         if(setvpp == 1)
507                 dev->pcmcia_map.set_vpp = pcmciamtd_set_vpp;
508
509         /* Request a memory window for PCMCIA. Some architeures can map windows
510          * upto the maximum that PCMCIA can support (64MiB) - this is ideal and
511          * we aim for a window the size of the whole card - otherwise we try
512          * smaller windows until we succeed
513          */
514
515         link->resource[2]->flags |=  WIN_MEMORY_TYPE_CM | WIN_ENABLE;
516         link->resource[2]->flags |= (dev->pcmcia_map.bankwidth == 1) ?
517                                         WIN_DATA_WIDTH_8 : WIN_DATA_WIDTH_16;
518         link->resource[2]->start = 0;
519         link->resource[2]->end = (force_size) ? force_size << 20 :
520                                         MAX_PCMCIA_ADDR;
521         dev->win_size = 0;
522
523         do {
524                 int ret;
525                 DEBUG(2, "requesting window with size = %luKiB memspeed = %d",
526                         (unsigned long) resource_size(link->resource[2]) >> 10,
527                         mem_speed);
528                 ret = pcmcia_request_window(link, link->resource[2], mem_speed);
529                 DEBUG(2, "ret = %d dev->win_size = %d", ret, dev->win_size);
530                 if(ret) {
531                         j++;
532                         link->resource[2]->start = 0;
533                         link->resource[2]->end = (force_size) ?
534                                         force_size << 20 : MAX_PCMCIA_ADDR;
535                         link->resource[2]->end >>= j;
536                 } else {
537                         DEBUG(2, "Got window of size %luKiB", (unsigned long)
538                                 resource_size(link->resource[2]) >> 10);
539                         dev->win_size = resource_size(link->resource[2]);
540                         break;
541                 }
542         } while (link->resource[2]->end >= 0x1000);
543
544         DEBUG(2, "dev->win_size = %d", dev->win_size);
545
546         if(!dev->win_size) {
547                 dev_err(&dev->p_dev->dev, "Cannot allocate memory window\n");
548                 pcmciamtd_release(link);
549                 return -ENODEV;
550         }
551         DEBUG(1, "Allocated a window of %dKiB", dev->win_size >> 10);
552
553         /* Get write protect status */
554         dev->win_base = ioremap(link->resource[2]->start,
555                                 resource_size(link->resource[2]));
556         if(!dev->win_base) {
557                 dev_err(&dev->p_dev->dev, "ioremap(%pR) failed\n",
558                         link->resource[2]);
559                 pcmciamtd_release(link);
560                 return -ENODEV;
561         }
562         DEBUG(1, "mapped window dev = %p @ %pR, base = %p",
563               dev, link->resource[2], dev->win_base);
564
565         dev->offset = 0;
566         dev->pcmcia_map.map_priv_1 = (unsigned long)dev;
567         dev->pcmcia_map.map_priv_2 = (unsigned long)link->resource[2];
568
569         dev->vpp = (vpp) ? vpp : link->socket->socket.Vpp;
570         if(setvpp == 2) {
571                 link->vpp = dev->vpp;
572         } else {
573                 link->vpp = 0;
574         }
575
576         link->config_index = 0;
577         DEBUG(2, "Setting Configuration");
578         ret = pcmcia_enable_device(link);
579         if (ret != 0) {
580                 if (dev->win_base) {
581                         iounmap(dev->win_base);
582                         dev->win_base = NULL;
583                 }
584                 return -ENODEV;
585         }
586
587         if(mem_type == 1) {
588                 mtd = do_map_probe("map_ram", &dev->pcmcia_map);
589         } else if(mem_type == 2) {
590                 mtd = do_map_probe("map_rom", &dev->pcmcia_map);
591         } else {
592                 for(i = 0; i < ARRAY_SIZE(probes); i++) {
593                         DEBUG(1, "Trying %s", probes[i]);
594                         mtd = do_map_probe(probes[i], &dev->pcmcia_map);
595                         if(mtd)
596                                 break;
597
598                         DEBUG(1, "FAILED: %s", probes[i]);
599                 }
600         }
601
602         if(!mtd) {
603                 DEBUG(1, "Can not find an MTD");
604                 pcmciamtd_release(link);
605                 return -ENODEV;
606         }
607
608         dev->mtd_info = mtd;
609         mtd->owner = THIS_MODULE;
610
611         if(new_name) {
612                 int size = 0;
613                 char unit = ' ';
614                 /* Since we are using a default name, make it better by adding
615                  * in the size
616                  */
617                 if(mtd->size < 1048576) { /* <1MiB in size, show size in KiB */
618                         size = mtd->size >> 10;
619                         unit = 'K';
620                 } else {
621                         size = mtd->size >> 20;
622                         unit = 'M';
623                 }
624                 snprintf(dev->mtd_name, sizeof(dev->mtd_name), "%d%ciB %s", size, unit, "PCMCIA Memory card");
625         }
626
627         /* If the memory found is fits completely into the mapped PCMCIA window,
628            use the faster non-remapping read/write functions */
629         if(mtd->size <= dev->win_size) {
630                 DEBUG(1, "Using non remapping memory functions");
631                 dev->pcmcia_map.map_priv_2 = (unsigned long)dev->win_base;
632                 if (dev->pcmcia_map.bankwidth == 1) {
633                         dev->pcmcia_map.read = pcmcia_read8;
634                         dev->pcmcia_map.write = pcmcia_write8;
635                 } else {
636                         dev->pcmcia_map.read = pcmcia_read16;
637                         dev->pcmcia_map.write = pcmcia_write16;
638                 }
639                 dev->pcmcia_map.copy_from = pcmcia_copy_from;
640                 dev->pcmcia_map.copy_to = pcmcia_copy_to;
641         }
642
643         if(add_mtd_device(mtd)) {
644                 map_destroy(mtd);
645                 dev->mtd_info = NULL;
646                 dev_err(&dev->p_dev->dev,
647                         "Could not register the MTD device\n");
648                 pcmciamtd_release(link);
649                 return -ENODEV;
650         }
651         dev_info(&dev->p_dev->dev, "mtd%d: %s\n", mtd->index, mtd->name);
652         return 0;
653
654         dev_err(&dev->p_dev->dev, "CS Error, exiting\n");
655         pcmciamtd_release(link);
656         return -ENODEV;
657 }
658
659
660 static int pcmciamtd_suspend(struct pcmcia_device *dev)
661 {
662         DEBUG(2, "EVENT_PM_RESUME");
663
664         /* get_lock(link); */
665
666         return 0;
667 }
668
669 static int pcmciamtd_resume(struct pcmcia_device *dev)
670 {
671         DEBUG(2, "EVENT_PM_SUSPEND");
672
673         /* free_lock(link); */
674
675         return 0;
676 }
677
678
679 /* This deletes a driver "instance".  The device is de-registered
680  * with Card Services.  If it has been released, all local data
681  * structures are freed.  Otherwise, the structures will be freed
682  * when the device is released.
683  */
684
685 static void pcmciamtd_detach(struct pcmcia_device *link)
686 {
687         struct pcmciamtd_dev *dev = link->priv;
688
689         DEBUG(3, "link=0x%p", link);
690
691         if(dev->mtd_info) {
692                 del_mtd_device(dev->mtd_info);
693                 dev_info(&dev->p_dev->dev, "mtd%d: Removing\n",
694                          dev->mtd_info->index);
695                 map_destroy(dev->mtd_info);
696         }
697
698         pcmciamtd_release(link);
699 }
700
701
702 /* pcmciamtd_attach() creates an "instance" of the driver, allocating
703  * local data structures for one device.  The device is registered
704  * with Card Services.
705  */
706
707 static int pcmciamtd_probe(struct pcmcia_device *link)
708 {
709         struct pcmciamtd_dev *dev;
710
711         /* Create new memory card device */
712         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
713         if (!dev) return -ENOMEM;
714         DEBUG(1, "dev=0x%p", dev);
715
716         dev->p_dev = link;
717         link->priv = dev;
718
719         return pcmciamtd_config(link);
720 }
721
722 static struct pcmcia_device_id pcmciamtd_ids[] = {
723         PCMCIA_DEVICE_FUNC_ID(1),
724         PCMCIA_DEVICE_PROD_ID123("IO DATA", "PCS-2M", "2MB SRAM", 0x547e66dc, 0x1fed36cd, 0x36eadd21),
725         PCMCIA_DEVICE_PROD_ID12("IBM", "2MB SRAM", 0xb569a6e5, 0x36eadd21),
726         PCMCIA_DEVICE_PROD_ID12("IBM", "4MB FLASH", 0xb569a6e5, 0x8bc54d2a),
727         PCMCIA_DEVICE_PROD_ID12("IBM", "8MB FLASH", 0xb569a6e5, 0x6df1be3e),
728         PCMCIA_DEVICE_PROD_ID12("Intel", "S2E20SW", 0x816cc815, 0xd14c9dcf),
729         PCMCIA_DEVICE_PROD_ID12("Intel", "S2E8 SW", 0x816cc815, 0xa2d7dedb),
730         PCMCIA_DEVICE_PROD_ID12("intel", "SERIES2-02 ", 0x40ade711, 0x145cea5c),
731         PCMCIA_DEVICE_PROD_ID12("intel", "SERIES2-04 ", 0x40ade711, 0x42064dda),
732         PCMCIA_DEVICE_PROD_ID12("intel", "SERIES2-20 ", 0x40ade711, 0x25ee5cb0),
733         PCMCIA_DEVICE_PROD_ID12("intel", "VALUE SERIES 100 ", 0x40ade711, 0xdf8506d8),
734         PCMCIA_DEVICE_PROD_ID12("KINGMAX TECHNOLOGY INC.", "SRAM 256K Bytes", 0x54d0c69c, 0xad12c29c),
735         PCMCIA_DEVICE_PROD_ID12("Maxtor", "MAXFL MobileMax Flash Memory Card", 0xb68968c8, 0x2dfb47b0),
736         PCMCIA_DEVICE_PROD_ID123("M-Systems", "M-SYS Flash Memory Card", "(c) M-Systems", 0x7ed2ad87, 0x675dc3fb, 0x7aef3965),
737         PCMCIA_DEVICE_PROD_ID12("PRETEC", "  2MB SRAM CARD", 0xebf91155, 0x805360ca),
738         PCMCIA_DEVICE_PROD_ID12("SEIKO EPSON", "WWB101EN20", 0xf9876baf, 0xad0b207b),
739         PCMCIA_DEVICE_PROD_ID12("SEIKO EPSON", "WWB513EN20", 0xf9876baf, 0xe8d884ad),
740         PCMCIA_DEVICE_PROD_ID12("SMART Modular Technologies", " 4MB FLASH Card", 0x96fd8277, 0x737a5b05),
741         PCMCIA_DEVICE_PROD_ID12("Starfish, Inc.", "REX-3000", 0x05ddca47, 0xe7d67bca),
742         PCMCIA_DEVICE_PROD_ID12("Starfish, Inc.", "REX-4100", 0x05ddca47, 0x7bc32944),
743         /* the following was commented out in pcmcia-cs-3.2.7 */
744         /* PCMCIA_DEVICE_PROD_ID12("RATOC Systems,Inc.", "SmartMedia ADAPTER PC Card", 0xf4a2fefe, 0x5885b2ae), */
745 #ifdef CONFIG_MTD_PCMCIA_ANONYMOUS
746         { .match_flags = PCMCIA_DEV_ID_MATCH_ANONYMOUS, },
747 #endif
748         PCMCIA_DEVICE_NULL
749 };
750 MODULE_DEVICE_TABLE(pcmcia, pcmciamtd_ids);
751
752 static struct pcmcia_driver pcmciamtd_driver = {
753         .drv            = {
754                 .name   = "pcmciamtd"
755         },
756         .probe          = pcmciamtd_probe,
757         .remove         = pcmciamtd_detach,
758         .owner          = THIS_MODULE,
759         .id_table       = pcmciamtd_ids,
760         .suspend        = pcmciamtd_suspend,
761         .resume         = pcmciamtd_resume,
762 };
763
764
765 static int __init init_pcmciamtd(void)
766 {
767         info(DRIVER_DESC);
768
769         if(bankwidth && bankwidth != 1 && bankwidth != 2) {
770                 info("bad bankwidth (%d), using default", bankwidth);
771                 bankwidth = 2;
772         }
773         if(force_size && (force_size < 1 || force_size > 64)) {
774                 info("bad force_size (%d), using default", force_size);
775                 force_size = 0;
776         }
777         if(mem_type && mem_type != 1 && mem_type != 2) {
778                 info("bad mem_type (%d), using default", mem_type);
779                 mem_type = 0;
780         }
781         return pcmcia_register_driver(&pcmciamtd_driver);
782 }
783
784
785 static void __exit exit_pcmciamtd(void)
786 {
787         DEBUG(1, DRIVER_DESC " unloading");
788         pcmcia_unregister_driver(&pcmciamtd_driver);
789 }
790
791 module_init(init_pcmciamtd);
792 module_exit(exit_pcmciamtd);