2 * pcmciamtd.c - MTD driver for PCMCIA flash memory cards
4 * Author: Simon Evans <spse@secret.org.uk>
6 * Copyright (C) 2002 Simon Evans
12 #include <linux/module.h>
13 #include <linux/slab.h>
14 #include <linux/timer.h>
15 #include <linux/init.h>
18 #include <pcmcia/cistpl.h>
19 #include <pcmcia/ds.h>
21 #include <linux/mtd/map.h>
22 #include <linux/mtd/mtd.h>
24 #define info(format, arg...) printk(KERN_INFO "pcmciamtd: " format "\n" , ## arg)
26 #define DRIVER_DESC "PCMCIA Flash memory card driver"
28 /* Size of the PCMCIA address space: 26 bits = 64 MB */
29 #define MAX_PCMCIA_ADDR 0x4000000
31 struct pcmciamtd_dev
{
32 struct pcmcia_device
*p_dev
;
33 caddr_t win_base
; /* ioremapped address of PCMCIA window */
34 unsigned int win_size
; /* size of window */
35 unsigned int offset
; /* offset into card the window currently points at */
36 struct map_info pcmcia_map
;
37 struct mtd_info
*mtd_info
;
39 char mtd_name
[sizeof(struct cistpl_vers_1_t
)];
43 /* Module parameters */
45 /* 2 = do 16-bit transfers, 1 = do 8-bit transfers */
46 static int bankwidth
= 2;
48 /* Speed of memory accesses, in ns */
51 /* Force the size of an SRAM card */
52 static int force_size
;
60 /* Force card to be treated as FLASH, ROM or RAM */
63 MODULE_LICENSE("GPL");
64 MODULE_AUTHOR("Simon Evans <spse@secret.org.uk>");
65 MODULE_DESCRIPTION(DRIVER_DESC
);
66 module_param(bankwidth
, int, 0);
67 MODULE_PARM_DESC(bankwidth
, "Set bankwidth (1=8 bit, 2=16 bit, default=2)");
68 module_param(mem_speed
, int, 0);
69 MODULE_PARM_DESC(mem_speed
, "Set memory access speed in ns");
70 module_param(force_size
, int, 0);
71 MODULE_PARM_DESC(force_size
, "Force size of card in MiB (1-64)");
72 module_param(setvpp
, int, 0);
73 MODULE_PARM_DESC(setvpp
, "Set Vpp (0=Never, 1=On writes, 2=Always on, default=0)");
74 module_param(vpp
, int, 0);
75 MODULE_PARM_DESC(vpp
, "Vpp value in 1/10ths eg 33=3.3V 120=12V (Dangerous)");
76 module_param(mem_type
, int, 0);
77 MODULE_PARM_DESC(mem_type
, "Set Memory type (0=Flash, 1=RAM, 2=ROM, default=0)");
80 /* read/write{8,16} copy_{from,to} routines with window remapping
81 * to access whole card
83 static caddr_t
remap_window(struct map_info
*map
, unsigned long to
)
85 struct pcmciamtd_dev
*dev
= (struct pcmciamtd_dev
*)map
->map_priv_1
;
86 struct resource
*win
= (struct resource
*) map
->map_priv_2
;
90 if (!pcmcia_dev_present(dev
->p_dev
)) {
91 pr_debug("device removed\n");
95 offset
= to
& ~(dev
->win_size
-1);
96 if (offset
!= dev
->offset
) {
97 pr_debug("Remapping window from 0x%8.8x to 0x%8.8x\n",
99 ret
= pcmcia_map_mem_page(dev
->p_dev
, win
, offset
);
102 dev
->offset
= offset
;
104 return dev
->win_base
+ (to
& (dev
->win_size
-1));
108 static map_word
pcmcia_read8_remap(struct map_info
*map
, unsigned long ofs
)
113 addr
= remap_window(map
, ofs
);
117 d
.x
[0] = readb(addr
);
118 pr_debug("ofs = 0x%08lx (%p) data = 0x%02lx\n", ofs
, addr
, d
.x
[0]);
123 static map_word
pcmcia_read16_remap(struct map_info
*map
, unsigned long ofs
)
128 addr
= remap_window(map
, ofs
);
132 d
.x
[0] = readw(addr
);
133 pr_debug("ofs = 0x%08lx (%p) data = 0x%04lx\n", ofs
, addr
, d
.x
[0]);
138 static void pcmcia_copy_from_remap(struct map_info
*map
, void *to
, unsigned long from
, ssize_t len
)
140 struct pcmciamtd_dev
*dev
= (struct pcmciamtd_dev
*)map
->map_priv_1
;
141 unsigned long win_size
= dev
->win_size
;
143 pr_debug("to = %p from = %lu len = %zd\n", to
, from
, len
);
145 int toread
= win_size
- (from
& (win_size
-1));
151 addr
= remap_window(map
, from
);
155 pr_debug("memcpy from %p to %p len = %d\n", addr
, to
, toread
);
156 memcpy_fromio(to
, addr
, toread
);
164 static void pcmcia_write8_remap(struct map_info
*map
, map_word d
, unsigned long adr
)
166 caddr_t addr
= remap_window(map
, adr
);
171 pr_debug("adr = 0x%08lx (%p) data = 0x%02lx\n", adr
, addr
, d
.x
[0]);
172 writeb(d
.x
[0], addr
);
176 static void pcmcia_write16_remap(struct map_info
*map
, map_word d
, unsigned long adr
)
178 caddr_t addr
= remap_window(map
, adr
);
182 pr_debug("adr = 0x%08lx (%p) data = 0x%04lx\n", adr
, addr
, d
.x
[0]);
183 writew(d
.x
[0], addr
);
187 static void pcmcia_copy_to_remap(struct map_info
*map
, unsigned long to
, const void *from
, ssize_t len
)
189 struct pcmciamtd_dev
*dev
= (struct pcmciamtd_dev
*)map
->map_priv_1
;
190 unsigned long win_size
= dev
->win_size
;
192 pr_debug("to = %lu from = %p len = %zd\n", to
, from
, len
);
194 int towrite
= win_size
- (to
& (win_size
-1));
200 addr
= remap_window(map
, to
);
204 pr_debug("memcpy from %p to %p len = %d\n", from
, addr
, towrite
);
205 memcpy_toio(addr
, from
, towrite
);
213 /* read/write{8,16} copy_{from,to} routines with direct access */
215 #define DEV_REMOVED(x) (!(pcmcia_dev_present(((struct pcmciamtd_dev *)map->map_priv_1)->p_dev)))
217 static map_word
pcmcia_read8(struct map_info
*map
, unsigned long ofs
)
219 caddr_t win_base
= (caddr_t
)map
->map_priv_2
;
225 d
.x
[0] = readb(win_base
+ ofs
);
226 pr_debug("ofs = 0x%08lx (%p) data = 0x%02lx\n",
227 ofs
, win_base
+ ofs
, d
.x
[0]);
232 static map_word
pcmcia_read16(struct map_info
*map
, unsigned long ofs
)
234 caddr_t win_base
= (caddr_t
)map
->map_priv_2
;
240 d
.x
[0] = readw(win_base
+ ofs
);
241 pr_debug("ofs = 0x%08lx (%p) data = 0x%04lx\n",
242 ofs
, win_base
+ ofs
, d
.x
[0]);
247 static void pcmcia_copy_from(struct map_info
*map
, void *to
, unsigned long from
, ssize_t len
)
249 caddr_t win_base
= (caddr_t
)map
->map_priv_2
;
254 pr_debug("to = %p from = %lu len = %zd\n", to
, from
, len
);
255 memcpy_fromio(to
, win_base
+ from
, len
);
259 static void pcmcia_write8(struct map_info
*map
, map_word d
, unsigned long adr
)
261 caddr_t win_base
= (caddr_t
)map
->map_priv_2
;
266 pr_debug("adr = 0x%08lx (%p) data = 0x%02lx\n",
267 adr
, win_base
+ adr
, d
.x
[0]);
268 writeb(d
.x
[0], win_base
+ adr
);
272 static void pcmcia_write16(struct map_info
*map
, map_word d
, unsigned long adr
)
274 caddr_t win_base
= (caddr_t
)map
->map_priv_2
;
279 pr_debug("adr = 0x%08lx (%p) data = 0x%04lx\n",
280 adr
, win_base
+ adr
, d
.x
[0]);
281 writew(d
.x
[0], win_base
+ adr
);
285 static void pcmcia_copy_to(struct map_info
*map
, unsigned long to
, const void *from
, ssize_t len
)
287 caddr_t win_base
= (caddr_t
)map
->map_priv_2
;
292 pr_debug("to = %lu from = %p len = %zd\n", to
, from
, len
);
293 memcpy_toio(win_base
+ to
, from
, len
);
297 static void pcmciamtd_set_vpp(struct map_info
*map
, int on
)
299 struct pcmciamtd_dev
*dev
= (struct pcmciamtd_dev
*)map
->map_priv_1
;
300 struct pcmcia_device
*link
= dev
->p_dev
;
302 pr_debug("dev = %p on = %d vpp = %d\n\n", dev
, on
, dev
->vpp
);
303 pcmcia_fixup_vpp(link
, on
? dev
->vpp
: 0);
307 static void pcmciamtd_release(struct pcmcia_device
*link
)
309 struct pcmciamtd_dev
*dev
= link
->priv
;
311 pr_debug("link = 0x%p\n", link
);
313 if (link
->resource
[2]->end
) {
315 iounmap(dev
->win_base
);
316 dev
->win_base
= NULL
;
319 pcmcia_disable_device(link
);
323 static int pcmciamtd_cistpl_format(struct pcmcia_device
*p_dev
,
329 if (!pcmcia_parse_tuple(tuple
, &parse
)) {
330 cistpl_format_t
*t
= &parse
.format
;
331 (void)t
; /* Shut up, gcc */
332 pr_debug("Format type: %u, Error Detection: %u, offset = %u, length =%u\n",
333 t
->type
, t
->edc
, t
->offset
, t
->length
);
338 static int pcmciamtd_cistpl_jedec(struct pcmcia_device
*p_dev
,
345 if (!pcmcia_parse_tuple(tuple
, &parse
)) {
346 cistpl_jedec_t
*t
= &parse
.jedec
;
347 for (i
= 0; i
< t
->nid
; i
++)
348 pr_debug("JEDEC: 0x%02x 0x%02x\n",
349 t
->id
[i
].mfr
, t
->id
[i
].info
);
354 static int pcmciamtd_cistpl_device(struct pcmcia_device
*p_dev
,
358 struct pcmciamtd_dev
*dev
= priv_data
;
360 cistpl_device_t
*t
= &parse
.device
;
363 if (pcmcia_parse_tuple(tuple
, &parse
))
366 pr_debug("Common memory:\n");
367 dev
->pcmcia_map
.size
= t
->dev
[0].size
;
368 /* from here on: DEBUG only */
369 for (i
= 0; i
< t
->ndev
; i
++) {
370 pr_debug("Region %d, type = %u\n", i
, t
->dev
[i
].type
);
371 pr_debug("Region %d, wp = %u\n", i
, t
->dev
[i
].wp
);
372 pr_debug("Region %d, speed = %u ns\n", i
, t
->dev
[i
].speed
);
373 pr_debug("Region %d, size = %u bytes\n", i
, t
->dev
[i
].size
);
378 static int pcmciamtd_cistpl_geo(struct pcmcia_device
*p_dev
,
382 struct pcmciamtd_dev
*dev
= priv_data
;
384 cistpl_device_geo_t
*t
= &parse
.device_geo
;
387 if (pcmcia_parse_tuple(tuple
, &parse
))
390 dev
->pcmcia_map
.bankwidth
= t
->geo
[0].buswidth
;
391 /* from here on: DEBUG only */
392 for (i
= 0; i
< t
->ngeo
; i
++) {
393 pr_debug("region: %d bankwidth = %u\n", i
, t
->geo
[i
].buswidth
);
394 pr_debug("region: %d erase_block = %u\n", i
, t
->geo
[i
].erase_block
);
395 pr_debug("region: %d read_block = %u\n", i
, t
->geo
[i
].read_block
);
396 pr_debug("region: %d write_block = %u\n", i
, t
->geo
[i
].write_block
);
397 pr_debug("region: %d partition = %u\n", i
, t
->geo
[i
].partition
);
398 pr_debug("region: %d interleave = %u\n", i
, t
->geo
[i
].interleave
);
404 static void card_settings(struct pcmciamtd_dev
*dev
, struct pcmcia_device
*p_dev
, int *new_name
)
408 if (p_dev
->prod_id
[0]) {
409 dev
->mtd_name
[0] = '\0';
410 for (i
= 0; i
< 4; i
++) {
412 strcat(dev
->mtd_name
, " ");
413 if (p_dev
->prod_id
[i
])
414 strcat(dev
->mtd_name
, p_dev
->prod_id
[i
]);
416 pr_debug("Found name: %s\n", dev
->mtd_name
);
419 pcmcia_loop_tuple(p_dev
, CISTPL_FORMAT
, pcmciamtd_cistpl_format
, NULL
);
420 pcmcia_loop_tuple(p_dev
, CISTPL_JEDEC_C
, pcmciamtd_cistpl_jedec
, NULL
);
421 pcmcia_loop_tuple(p_dev
, CISTPL_DEVICE
, pcmciamtd_cistpl_device
, dev
);
422 pcmcia_loop_tuple(p_dev
, CISTPL_DEVICE_GEO
, pcmciamtd_cistpl_geo
, dev
);
424 if(!dev
->pcmcia_map
.size
)
425 dev
->pcmcia_map
.size
= MAX_PCMCIA_ADDR
;
427 if(!dev
->pcmcia_map
.bankwidth
)
428 dev
->pcmcia_map
.bankwidth
= 2;
431 dev
->pcmcia_map
.size
= force_size
<< 20;
432 pr_debug("size forced to %dM\n", force_size
);
436 dev
->pcmcia_map
.bankwidth
= bankwidth
;
437 pr_debug("bankwidth forced to %d\n", bankwidth
);
440 dev
->pcmcia_map
.name
= dev
->mtd_name
;
441 if(!dev
->mtd_name
[0]) {
442 strcpy(dev
->mtd_name
, "PCMCIA Memory card");
446 pr_debug("Device: Size: %lu Width:%d Name: %s\n",
447 dev
->pcmcia_map
.size
,
448 dev
->pcmcia_map
.bankwidth
<< 3, dev
->mtd_name
);
452 static int pcmciamtd_config(struct pcmcia_device
*link
)
454 struct pcmciamtd_dev
*dev
= link
->priv
;
455 struct mtd_info
*mtd
= NULL
;
458 static char *probes
[] = { "jedec_probe", "cfi_probe" };
461 pr_debug("link=0x%p\n", link
);
463 card_settings(dev
, link
, &new_name
);
465 dev
->pcmcia_map
.phys
= NO_XIP
;
466 dev
->pcmcia_map
.copy_from
= pcmcia_copy_from_remap
;
467 dev
->pcmcia_map
.copy_to
= pcmcia_copy_to_remap
;
468 if (dev
->pcmcia_map
.bankwidth
== 1) {
469 dev
->pcmcia_map
.read
= pcmcia_read8_remap
;
470 dev
->pcmcia_map
.write
= pcmcia_write8_remap
;
472 dev
->pcmcia_map
.read
= pcmcia_read16_remap
;
473 dev
->pcmcia_map
.write
= pcmcia_write16_remap
;
476 dev
->pcmcia_map
.set_vpp
= pcmciamtd_set_vpp
;
478 /* Request a memory window for PCMCIA. Some architeures can map windows
479 * up to the maximum that PCMCIA can support (64MiB) - this is ideal and
480 * we aim for a window the size of the whole card - otherwise we try
481 * smaller windows until we succeed
484 link
->resource
[2]->flags
|= WIN_MEMORY_TYPE_CM
| WIN_ENABLE
;
485 link
->resource
[2]->flags
|= (dev
->pcmcia_map
.bankwidth
== 1) ?
486 WIN_DATA_WIDTH_8
: WIN_DATA_WIDTH_16
;
487 link
->resource
[2]->start
= 0;
488 link
->resource
[2]->end
= (force_size
) ? force_size
<< 20 :
494 pr_debug("requesting window with size = %luKiB memspeed = %d\n",
495 (unsigned long) resource_size(link
->resource
[2]) >> 10,
497 ret
= pcmcia_request_window(link
, link
->resource
[2], mem_speed
);
498 pr_debug("ret = %d dev->win_size = %d\n", ret
, dev
->win_size
);
501 link
->resource
[2]->start
= 0;
502 link
->resource
[2]->end
= (force_size
) ?
503 force_size
<< 20 : MAX_PCMCIA_ADDR
;
504 link
->resource
[2]->end
>>= j
;
506 pr_debug("Got window of size %luKiB\n", (unsigned long)
507 resource_size(link
->resource
[2]) >> 10);
508 dev
->win_size
= resource_size(link
->resource
[2]);
511 } while (link
->resource
[2]->end
>= 0x1000);
513 pr_debug("dev->win_size = %d\n", dev
->win_size
);
516 dev_err(&dev
->p_dev
->dev
, "Cannot allocate memory window\n");
517 pcmciamtd_release(link
);
520 pr_debug("Allocated a window of %dKiB\n", dev
->win_size
>> 10);
522 /* Get write protect status */
523 dev
->win_base
= ioremap(link
->resource
[2]->start
,
524 resource_size(link
->resource
[2]));
526 dev_err(&dev
->p_dev
->dev
, "ioremap(%pR) failed\n",
528 pcmciamtd_release(link
);
531 pr_debug("mapped window dev = %p @ %pR, base = %p\n",
532 dev
, link
->resource
[2], dev
->win_base
);
535 dev
->pcmcia_map
.map_priv_1
= (unsigned long)dev
;
536 dev
->pcmcia_map
.map_priv_2
= (unsigned long)link
->resource
[2];
538 dev
->vpp
= (vpp
) ? vpp
: link
->socket
->socket
.Vpp
;
540 link
->vpp
= dev
->vpp
;
545 link
->config_index
= 0;
546 pr_debug("Setting Configuration\n");
547 ret
= pcmcia_enable_device(link
);
550 iounmap(dev
->win_base
);
551 dev
->win_base
= NULL
;
557 mtd
= do_map_probe("map_ram", &dev
->pcmcia_map
);
558 } else if(mem_type
== 2) {
559 mtd
= do_map_probe("map_rom", &dev
->pcmcia_map
);
561 for(i
= 0; i
< ARRAY_SIZE(probes
); i
++) {
562 pr_debug("Trying %s\n", probes
[i
]);
563 mtd
= do_map_probe(probes
[i
], &dev
->pcmcia_map
);
567 pr_debug("FAILED: %s\n", probes
[i
]);
572 pr_debug("Can not find an MTD\n");
573 pcmciamtd_release(link
);
578 mtd
->owner
= THIS_MODULE
;
583 /* Since we are using a default name, make it better by adding
586 if(mtd
->size
< 1048576) { /* <1MiB in size, show size in KiB */
587 size
= mtd
->size
>> 10;
590 size
= mtd
->size
>> 20;
593 snprintf(dev
->mtd_name
, sizeof(dev
->mtd_name
), "%d%ciB %s", size
, unit
, "PCMCIA Memory card");
596 /* If the memory found is fits completely into the mapped PCMCIA window,
597 use the faster non-remapping read/write functions */
598 if(mtd
->size
<= dev
->win_size
) {
599 pr_debug("Using non remapping memory functions\n");
600 dev
->pcmcia_map
.map_priv_2
= (unsigned long)dev
->win_base
;
601 if (dev
->pcmcia_map
.bankwidth
== 1) {
602 dev
->pcmcia_map
.read
= pcmcia_read8
;
603 dev
->pcmcia_map
.write
= pcmcia_write8
;
605 dev
->pcmcia_map
.read
= pcmcia_read16
;
606 dev
->pcmcia_map
.write
= pcmcia_write16
;
608 dev
->pcmcia_map
.copy_from
= pcmcia_copy_from
;
609 dev
->pcmcia_map
.copy_to
= pcmcia_copy_to
;
612 if (mtd_device_register(mtd
, NULL
, 0)) {
614 dev
->mtd_info
= NULL
;
615 dev_err(&dev
->p_dev
->dev
,
616 "Could not register the MTD device\n");
617 pcmciamtd_release(link
);
620 dev_info(&dev
->p_dev
->dev
, "mtd%d: %s\n", mtd
->index
, mtd
->name
);
625 static int pcmciamtd_suspend(struct pcmcia_device
*dev
)
627 pr_debug("EVENT_PM_RESUME\n");
629 /* get_lock(link); */
634 static int pcmciamtd_resume(struct pcmcia_device
*dev
)
636 pr_debug("EVENT_PM_SUSPEND\n");
638 /* free_lock(link); */
644 static void pcmciamtd_detach(struct pcmcia_device
*link
)
646 struct pcmciamtd_dev
*dev
= link
->priv
;
648 pr_debug("link=0x%p\n", link
);
651 mtd_device_unregister(dev
->mtd_info
);
652 dev_info(&dev
->p_dev
->dev
, "mtd%d: Removing\n",
653 dev
->mtd_info
->index
);
654 map_destroy(dev
->mtd_info
);
657 pcmciamtd_release(link
);
661 static int pcmciamtd_probe(struct pcmcia_device
*link
)
663 struct pcmciamtd_dev
*dev
;
665 /* Create new memory card device */
666 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
667 if (!dev
) return -ENOMEM
;
668 pr_debug("dev=0x%p\n", dev
);
673 return pcmciamtd_config(link
);
676 static const struct pcmcia_device_id pcmciamtd_ids
[] = {
677 PCMCIA_DEVICE_FUNC_ID(1),
678 PCMCIA_DEVICE_PROD_ID123("IO DATA", "PCS-2M", "2MB SRAM", 0x547e66dc, 0x1fed36cd, 0x36eadd21),
679 PCMCIA_DEVICE_PROD_ID12("IBM", "2MB SRAM", 0xb569a6e5, 0x36eadd21),
680 PCMCIA_DEVICE_PROD_ID12("IBM", "4MB FLASH", 0xb569a6e5, 0x8bc54d2a),
681 PCMCIA_DEVICE_PROD_ID12("IBM", "8MB FLASH", 0xb569a6e5, 0x6df1be3e),
682 PCMCIA_DEVICE_PROD_ID12("Intel", "S2E20SW", 0x816cc815, 0xd14c9dcf),
683 PCMCIA_DEVICE_PROD_ID12("Intel", "S2E8 SW", 0x816cc815, 0xa2d7dedb),
684 PCMCIA_DEVICE_PROD_ID12("intel", "SERIES2-02 ", 0x40ade711, 0x145cea5c),
685 PCMCIA_DEVICE_PROD_ID12("intel", "SERIES2-04 ", 0x40ade711, 0x42064dda),
686 PCMCIA_DEVICE_PROD_ID12("intel", "SERIES2-20 ", 0x40ade711, 0x25ee5cb0),
687 PCMCIA_DEVICE_PROD_ID12("intel", "VALUE SERIES 100 ", 0x40ade711, 0xdf8506d8),
688 PCMCIA_DEVICE_PROD_ID12("KINGMAX TECHNOLOGY INC.", "SRAM 256K Bytes", 0x54d0c69c, 0xad12c29c),
689 PCMCIA_DEVICE_PROD_ID12("Maxtor", "MAXFL MobileMax Flash Memory Card", 0xb68968c8, 0x2dfb47b0),
690 PCMCIA_DEVICE_PROD_ID123("M-Systems", "M-SYS Flash Memory Card", "(c) M-Systems", 0x7ed2ad87, 0x675dc3fb, 0x7aef3965),
691 PCMCIA_DEVICE_PROD_ID12("PRETEC", " 2MB SRAM CARD", 0xebf91155, 0x805360ca),
692 PCMCIA_DEVICE_PROD_ID12("SEIKO EPSON", "WWB101EN20", 0xf9876baf, 0xad0b207b),
693 PCMCIA_DEVICE_PROD_ID12("SEIKO EPSON", "WWB513EN20", 0xf9876baf, 0xe8d884ad),
694 PCMCIA_DEVICE_PROD_ID12("SMART Modular Technologies", " 4MB FLASH Card", 0x96fd8277, 0x737a5b05),
695 PCMCIA_DEVICE_PROD_ID12("Starfish, Inc.", "REX-3000", 0x05ddca47, 0xe7d67bca),
696 PCMCIA_DEVICE_PROD_ID12("Starfish, Inc.", "REX-4100", 0x05ddca47, 0x7bc32944),
697 /* the following was commented out in pcmcia-cs-3.2.7 */
698 /* PCMCIA_DEVICE_PROD_ID12("RATOC Systems,Inc.", "SmartMedia ADAPTER PC Card", 0xf4a2fefe, 0x5885b2ae), */
699 #ifdef CONFIG_MTD_PCMCIA_ANONYMOUS
700 { .match_flags
= PCMCIA_DEV_ID_MATCH_ANONYMOUS
, },
704 MODULE_DEVICE_TABLE(pcmcia
, pcmciamtd_ids
);
706 static struct pcmcia_driver pcmciamtd_driver
= {
708 .probe
= pcmciamtd_probe
,
709 .remove
= pcmciamtd_detach
,
710 .owner
= THIS_MODULE
,
711 .id_table
= pcmciamtd_ids
,
712 .suspend
= pcmciamtd_suspend
,
713 .resume
= pcmciamtd_resume
,
717 static int __init
init_pcmciamtd(void)
719 if(bankwidth
&& bankwidth
!= 1 && bankwidth
!= 2) {
720 info("bad bankwidth (%d), using default", bankwidth
);
723 if(force_size
&& (force_size
< 1 || force_size
> 64)) {
724 info("bad force_size (%d), using default", force_size
);
727 if(mem_type
&& mem_type
!= 1 && mem_type
!= 2) {
728 info("bad mem_type (%d), using default", mem_type
);
731 return pcmcia_register_driver(&pcmciamtd_driver
);
735 static void __exit
exit_pcmciamtd(void)
737 pr_debug(DRIVER_DESC
" unloading");
738 pcmcia_unregister_driver(&pcmciamtd_driver
);
741 module_init(init_pcmciamtd
);
742 module_exit(exit_pcmciamtd
);