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