drivers/mtd/maps/vmu-flash.c

   1 /* vmu-flash.c
   2  * Driver for SEGA Dreamcast Visual Memory Unit
   3  *
   4  * Copyright (c) Adrian McMenamin 2002 - 2009
   5  * Copyright (c) Paul Mundt 2001
   6  *
   7  * Licensed under version 2 of the
   8  * GNU General Public Licence
   9  */
  10 #include <linux/init.h>
  11 #include <linux/sched.h>
  12 #include <linux/delay.h>
  13 #include <linux/maple.h>
  14 #include <linux/mtd/mtd.h>
  15 #include <linux/mtd/map.h>
  16
  17 struct vmu_cache {
  18         unsigned char *buffer;          /* Cache */
  19         unsigned int block;             /* Which block was cached */
  20         unsigned long jiffies_atc;      /* When was it cached? */
  21         int valid;
  22 };
  23
  24 struct mdev_part {
  25         struct maple_device *mdev;
  26         int partition;
  27 };
  28
  29 struct vmupart {
  30         u16 user_blocks;
  31         u16 root_block;
  32         u16 numblocks;
  33         char *name;
  34         struct vmu_cache *pcache;
  35 };
  36
  37 struct memcard {
  38         u16 tempA;
  39         u16 tempB;
  40         u32 partitions;
  41         u32 blocklen;
  42         u32 writecnt;
  43         u32 readcnt;
  44         u32 removeable;
  45         int partition;
  46         int read;
  47         unsigned char *blockread;
  48         struct vmupart *parts;
  49         struct mtd_info *mtd;
  50 };
  51
  52 struct vmu_block {
  53         unsigned int num; /* block number */
  54         unsigned int ofs; /* block offset */
  55 };
  56
  57 static struct vmu_block *ofs_to_block(unsigned long src_ofs,
  58         struct mtd_info *mtd, int partition)
  59 {
  60         struct vmu_block *vblock;
  61         struct maple_device *mdev;
  62         struct memcard *card;
  63         struct mdev_part *mpart;
  64         int num;
  65
  66         mpart = mtd->priv;
  67         mdev = mpart->mdev;
  68         card = maple_get_drvdata(mdev);
  69
  70         if (src_ofs >= card->parts[partition].numblocks * card->blocklen)
  71                 goto failed;
  72
  73         num = src_ofs / card->blocklen;
  74         if (num > card->parts[partition].numblocks)
  75                 goto failed;
  76
  77         vblock = kmalloc(sizeof(struct vmu_block), GFP_KERNEL);
  78         if (!vblock)
  79                 goto failed;
  80
  81         vblock->num = num;
  82         vblock->ofs = src_ofs % card->blocklen;
  83         return vblock;
  84
  85 failed:
  86         return NULL;
  87 }
  88
  89 /* Maple bus callback function for reads */
  90 static void vmu_blockread(struct mapleq *mq)
  91 {
  92         struct maple_device *mdev;
  93         struct memcard *card;
  94
  95         mdev = mq->dev;
  96         card = maple_get_drvdata(mdev);
  97         /* copy the read in data */
  98
  99         if (unlikely(!card->blockread))
 100                 return;
 101
 102         memcpy(card->blockread, mq->recvbuf->buf + 12,
 103                 card->blocklen/card->readcnt);
 104
 105 }
 106
 107 /* Interface with maple bus to read blocks
 108  * caching the results so that other parts
 109  * of the driver can access block reads */
 110 static int maple_vmu_read_block(unsigned int num, unsigned char *buf,
 111         struct mtd_info *mtd)
 112 {
 113         struct memcard *card;
 114         struct mdev_part *mpart;
 115         struct maple_device *mdev;
 116         int partition, error = 0, x, wait;
 117         unsigned char *blockread = NULL;
 118         struct vmu_cache *pcache;
 119         __be32 sendbuf;
 120
 121         mpart = mtd->priv;
 122         mdev = mpart->mdev;
 123         partition = mpart->partition;
 124         card = maple_get_drvdata(mdev);
 125         pcache = card->parts[partition].pcache;
 126         pcache->valid = 0;
 127
 128         /* prepare the cache for this block */
 129         if (!pcache->buffer) {
 130                 pcache->buffer = kmalloc(card->blocklen, GFP_KERNEL);
 131                 if (!pcache->buffer) {
 132                         dev_err(&mdev->dev, "VMU at (%d, %d) - read fails due"
 133                                 " to lack of memory\n", mdev->port,
 134                                 mdev->unit);
 135                         error = -ENOMEM;
 136                         goto outB;
 137                 }
 138         }
 139
 140         /*
 141         * Reads may be phased - again the hardware spec
 142         * supports this - though may not be any devices in
 143         * the wild that implement it, but we will here
 144         */
 145         for (x = 0; x < card->readcnt; x++) {
 146                 sendbuf = cpu_to_be32(partition << 24 | x << 16 | num);
 147
 148                 if (atomic_read(&mdev->busy) == 1) {
 149                         wait_event_interruptible_timeout(mdev->maple_wait,
 150                                 atomic_read(&mdev->busy) == 0, HZ);
 151                         if (atomic_read(&mdev->busy) == 1) {
 152                                 dev_notice(&mdev->dev, "VMU at (%d, %d)"
 153                                         " is busy\n", mdev->port, mdev->unit);
 154                                 error = -EAGAIN;
 155                                 goto outB;
 156                         }
 157                 }
 158
 159                 atomic_set(&mdev->busy, 1);
 160                 blockread = kmalloc(card->blocklen/card->readcnt, GFP_KERNEL);
 161                 if (!blockread) {
 162                         error = -ENOMEM;
 163                         atomic_set(&mdev->busy, 0);
 164                         goto outB;
 165                 }
 166                 card->blockread = blockread;
 167
 168                 maple_getcond_callback(mdev, vmu_blockread, 0,
 169                         MAPLE_FUNC_MEMCARD);
 170                 error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
 171                                 MAPLE_COMMAND_BREAD, 2, &sendbuf);
 172                 /* Very long timeouts seem to be needed when box is stressed */
 173                 wait = wait_event_interruptible_timeout(mdev->maple_wait,
 174                         (atomic_read(&mdev->busy) == 0 ||
 175                         atomic_read(&mdev->busy) == 2), HZ * 3);
 176                 /*
 177                 * MTD layer does not handle hotplugging well
 178                 * so have to return errors when VMU is unplugged
 179                 * in the middle of a read (busy == 2)
 180                 */
 181                 if (error || atomic_read(&mdev->busy) == 2) {
 182                         if (atomic_read(&mdev->busy) == 2)
 183                                 error = -ENXIO;
 184                         atomic_set(&mdev->busy, 0);
 185                         card->blockread = NULL;
 186                         goto outA;
 187                 }
 188                 if (wait == 0 || wait == -ERESTARTSYS) {
 189                         card->blockread = NULL;
 190                         atomic_set(&mdev->busy, 0);
 191                         error = -EIO;
 192                         list_del_init(&(mdev->mq->list));
 193                         kfree(mdev->mq->sendbuf);
 194                         mdev->mq->sendbuf = NULL;
 195                         if (wait == -ERESTARTSYS) {
 196                                 dev_warn(&mdev->dev, "VMU read on (%d, %d)"
 197                                         " interrupted on block 0x%X\n",
 198                                         mdev->port, mdev->unit, num);
 199                         } else
 200                                 dev_notice(&mdev->dev, "VMU read on (%d, %d)"
 201                                         " timed out on block 0x%X\n",
 202                                         mdev->port, mdev->unit, num);
 203                         goto outA;
 204                 }
 205
 206                 memcpy(buf + (card->blocklen/card->readcnt) * x, blockread,
 207                         card->blocklen/card->readcnt);
 208
 209                 memcpy(pcache->buffer + (card->blocklen/card->readcnt) * x,
 210                         card->blockread, card->blocklen/card->readcnt);
 211                 card->blockread = NULL;
 212                 pcache->block = num;
 213                 pcache->jiffies_atc = jiffies;
 214                 pcache->valid = 1;
 215                 kfree(blockread);
 216         }
 217
 218         return error;
 219
 220 outA:
 221         kfree(blockread);
 222 outB:
 223         return error;
 224 }
 225
 226 /* communicate with maple bus for phased writing */
 227 static int maple_vmu_write_block(unsigned int num, const unsigned char *buf,
 228         struct mtd_info *mtd)
 229 {
 230         struct memcard *card;
 231         struct mdev_part *mpart;
 232         struct maple_device *mdev;
 233         int partition, error, locking, x, phaselen, wait;
 234         __be32 *sendbuf;
 235
 236         mpart = mtd->priv;
 237         mdev = mpart->mdev;
 238         partition = mpart->partition;
 239         card = maple_get_drvdata(mdev);
 240
 241         phaselen = card->blocklen/card->writecnt;
 242
 243         sendbuf = kmalloc(phaselen + 4, GFP_KERNEL);
 244         if (!sendbuf) {
 245                 error = -ENOMEM;
 246                 goto fail_nosendbuf;
 247         }
 248         for (x = 0; x < card->writecnt; x++) {
 249                 sendbuf[0] = cpu_to_be32(partition << 24 | x << 16 | num);
 250                 memcpy(&sendbuf[1], buf + phaselen * x, phaselen);
 251                 /* wait until the device is not busy doing something else
 252                 * or 1 second - which ever is longer */
 253                 if (atomic_read(&mdev->busy) == 1) {
 254                         wait_event_interruptible_timeout(mdev->maple_wait,
 255                                 atomic_read(&mdev->busy) == 0, HZ);
 256                         if (atomic_read(&mdev->busy) == 1) {
 257                                 error = -EBUSY;
 258                                 dev_notice(&mdev->dev, "VMU write at (%d, %d)"
 259                                         "failed - device is busy\n",
 260                                         mdev->port, mdev->unit);
 261                                 goto fail_nolock;
 262                         }
 263                 }
 264                 atomic_set(&mdev->busy, 1);
 265
 266                 locking = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
 267                         MAPLE_COMMAND_BWRITE, phaselen / 4 + 2, sendbuf);
 268                 wait = wait_event_interruptible_timeout(mdev->maple_wait,
 269                         atomic_read(&mdev->busy) == 0, HZ/10);
 270                 if (locking) {
 271                         error = -EIO;
 272                         atomic_set(&mdev->busy, 0);
 273                         goto fail_nolock;
 274                 }
 275                 if (atomic_read(&mdev->busy) == 2) {
 276                         atomic_set(&mdev->busy, 0);
 277                 } else if (wait == 0 || wait == -ERESTARTSYS) {
 278                         error = -EIO;
 279                         dev_warn(&mdev->dev, "Write at (%d, %d) of block"
 280                                 " 0x%X at phase %d failed: could not"
 281                                 " communicate with VMU", mdev->port,
 282                                 mdev->unit, num, x);
 283                         atomic_set(&mdev->busy, 0);
 284                         kfree(mdev->mq->sendbuf);
 285                         mdev->mq->sendbuf = NULL;
 286                         list_del_init(&(mdev->mq->list));
 287                         goto fail_nolock;
 288                 }
 289         }
 290         kfree(sendbuf);
 291
 292         return card->blocklen;
 293
 294 fail_nolock:
 295         kfree(sendbuf);
 296 fail_nosendbuf:
 297         dev_err(&mdev->dev, "VMU (%d, %d): write failed\n", mdev->port,
 298                 mdev->unit);
 299         return error;
 300 }
 301
 302 /* mtd function to simulate reading byte by byte */
 303 static unsigned char vmu_flash_read_char(unsigned long ofs, int *retval,
 304         struct mtd_info *mtd)
 305 {
 306         struct vmu_block *vblock;
 307         struct memcard *card;
 308         struct mdev_part *mpart;
 309         struct maple_device *mdev;
 310         unsigned char *buf, ret;
 311         int partition, error;
 312
 313         mpart = mtd->priv;
 314         mdev = mpart->mdev;
 315         partition = mpart->partition;
 316         card = maple_get_drvdata(mdev);
 317         *retval =  0;
 318
 319         buf = kmalloc(card->blocklen, GFP_KERNEL);
 320         if (!buf) {
 321                 *retval = 1;
 322                 ret = -ENOMEM;
 323                 goto finish;
 324         }
 325
 326         vblock = ofs_to_block(ofs, mtd, partition);
 327         if (!vblock) {
 328                 *retval = 3;
 329                 ret = -ENOMEM;
 330                 goto out_buf;
 331         }
 332
 333         error = maple_vmu_read_block(vblock->num, buf, mtd);
 334         if (error) {
 335                 ret = error;
 336                 *retval = 2;
 337                 goto out_vblock;
 338         }
 339
 340         ret = buf[vblock->ofs];
 341
 342 out_vblock:
 343         kfree(vblock);
 344 out_buf:
 345         kfree(buf);
 346 finish:
 347         return ret;
 348 }
 349
 350 /* mtd higher order function to read flash */
 351 static int vmu_flash_read(struct mtd_info *mtd, loff_t from, size_t len,
 352         size_t *retlen,  u_char *buf)
 353 {
 354         struct maple_device *mdev;
 355         struct memcard *card;
 356         struct mdev_part *mpart;
 357         struct vmu_cache *pcache;
 358         struct vmu_block *vblock;
 359         int index = 0, retval, partition, leftover, numblocks;
 360         unsigned char cx;
 361
 362         if (len < 1)
 363                 return -EIO;
 364
 365         mpart = mtd->priv;
 366         mdev = mpart->mdev;
 367         partition = mpart->partition;
 368         card = maple_get_drvdata(mdev);
 369
 370         numblocks = card->parts[partition].numblocks;
 371         if (from + len > numblocks * card->blocklen)
 372                 len = numblocks * card->blocklen - from;
 373         if (len == 0)
 374                 return -EIO;
 375         /* Have we cached this bit already? */
 376         pcache = card->parts[partition].pcache;
 377         do {
 378                 vblock =  ofs_to_block(from + index, mtd, partition);
 379                 if (!vblock)
 380                         return -ENOMEM;
 381                 /* Have we cached this and is the cache valid and timely? */
 382                 if (pcache->valid &&
 383                         time_before(jiffies, pcache->jiffies_atc + HZ) &&
 384                         (pcache->block == vblock->num)) {
 385                         /* we have cached it, so do necessary copying */
 386                         leftover = card->blocklen - vblock->ofs;
 387                         if (vblock->ofs + len - index < card->blocklen) {
 388                                 /* only a bit of this block to copy */
 389                                 memcpy(buf + index,
 390                                         pcache->buffer + vblock->ofs,
 391                                         len - index);
 392                                 index = len;
 393                         } else {
 394                                 /* otherwise copy remainder of whole block */
 395                                 memcpy(buf + index, pcache->buffer +
 396                                         vblock->ofs, leftover);
 397                                 index += leftover;
 398                         }
 399                 } else {
 400                         /*
 401                         * Not cached so read one byte -
 402                         * but cache the rest of the block
 403                         */
 404                         cx = vmu_flash_read_char(from + index, &retval, mtd);
 405                         if (retval) {
 406                                 *retlen = index;
 407                                 kfree(vblock);
 408                                 return cx;
 409                         }
 410                         memset(buf + index, cx, 1);
 411                         index++;
 412                 }
 413                 kfree(vblock);
 414         } while (len > index);
 415         *retlen = index;
 416
 417         return 0;
 418 }
 419
 420 static int vmu_flash_write(struct mtd_info *mtd, loff_t to, size_t len,
 421         size_t *retlen, const u_char *buf)
 422 {
 423         struct maple_device *mdev;
 424         struct memcard *card;
 425         struct mdev_part *mpart;
 426         int index = 0, partition, error = 0, numblocks;
 427         struct vmu_cache *pcache;
 428         struct vmu_block *vblock;
 429         unsigned char *buffer;
 430
 431         mpart = mtd->priv;
 432         mdev = mpart->mdev;
 433         partition = mpart->partition;
 434         card = maple_get_drvdata(mdev);
 435
 436         /* simple sanity checks */
 437         if (len < 1) {
 438                 error = -EIO;
 439                 goto failed;
 440         }
 441         numblocks = card->parts[partition].numblocks;
 442         if (to + len > numblocks * card->blocklen)
 443                 len = numblocks * card->blocklen - to;
 444         if (len == 0) {
 445                 error = -EIO;
 446                 goto failed;
 447         }
 448
 449         vblock = ofs_to_block(to, mtd, partition);
 450         if (!vblock) {
 451                 error = -ENOMEM;
 452                 goto failed;
 453         }
 454
 455         buffer = kmalloc(card->blocklen, GFP_KERNEL);
 456         if (!buffer) {
 457                 error = -ENOMEM;
 458                 goto fail_buffer;
 459         }
 460
 461         do {
 462                 /* Read in the block we are to write to */
 463                 error = maple_vmu_read_block(vblock->num, buffer, mtd);
 464                 if (error)
 465                         goto fail_io;
 466
 467                 do {
 468                         buffer[vblock->ofs] = buf[index];
 469                         vblock->ofs++;
 470                         index++;
 471                         if (index >= len)
 472                                 break;
 473                 } while (vblock->ofs < card->blocklen);
 474
 475                 /* write out new buffer */
 476                 error = maple_vmu_write_block(vblock->num, buffer, mtd);
 477                 /* invalidate the cache */
 478                 pcache = card->parts[partition].pcache;
 479                 pcache->valid = 0;
 480
 481                 if (error != card->blocklen)
 482                         goto fail_io;
 483
 484                 vblock->num++;
 485                 vblock->ofs = 0;
 486         } while (len > index);
 487
 488         kfree(buffer);
 489         *retlen = index;
 490         kfree(vblock);
 491         return 0;
 492
 493 fail_io:
 494         kfree(buffer);
 495 fail_buffer:
 496         kfree(vblock);
 497 failed:
 498         dev_err(&mdev->dev, "VMU write failing with error %d\n", error);
 499         return error;
 500 }
 501
 502 static void vmu_flash_sync(struct mtd_info *mtd)
 503 {
 504         /* Do nothing here */
 505 }
 506
 507 /* Maple bus callback function to recursively query hardware details */
 508 static void vmu_queryblocks(struct mapleq *mq)
 509 {
 510         struct maple_device *mdev;
 511         unsigned short *res;
 512         struct memcard *card;
 513         __be32 partnum;
 514         struct vmu_cache *pcache;
 515         struct mdev_part *mpart;
 516         struct mtd_info *mtd_cur;
 517         struct vmupart *part_cur;
 518         int error;
 519
 520         mdev = mq->dev;
 521         card = maple_get_drvdata(mdev);
 522         res = (unsigned short *) (mq->recvbuf->buf);
 523         card->tempA = res[12];
 524         card->tempB = res[6];
 525
 526         dev_info(&mdev->dev, "VMU device at partition %d has %d user "
 527                 "blocks with a root block at %d\n", card->partition,
 528                 card->tempA, card->tempB);
 529
 530         part_cur = &card->parts[card->partition];
 531         part_cur->user_blocks = card->tempA;
 532         part_cur->root_block = card->tempB;
 533         part_cur->numblocks = card->tempB + 1;
 534         part_cur->name = kmalloc(12, GFP_KERNEL);
 535         if (!part_cur->name)
 536                 goto fail_name;
 537
 538         sprintf(part_cur->name, "vmu%d.%d.%d",
 539                 mdev->port, mdev->unit, card->partition);
 540         mtd_cur = &card->mtd[card->partition];
 541         mtd_cur->name = part_cur->name;
 542         mtd_cur->type = 8;
 543         mtd_cur->flags = MTD_WRITEABLE|MTD_NO_ERASE;
 544         mtd_cur->size = part_cur->numblocks * card->blocklen;
 545         mtd_cur->erasesize = card->blocklen;
 546         mtd_cur->write = vmu_flash_write;
 547         mtd_cur->read = vmu_flash_read;
 548         mtd_cur->sync = vmu_flash_sync;
 549         mtd_cur->writesize = card->blocklen;
 550
 551         mpart = kmalloc(sizeof(struct mdev_part), GFP_KERNEL);
 552         if (!mpart)
 553                 goto fail_mpart;
 554
 555         mpart->mdev = mdev;
 556         mpart->partition = card->partition;
 557         mtd_cur->priv = mpart;
 558         mtd_cur->owner = THIS_MODULE;
 559
 560         pcache = kzalloc(sizeof(struct vmu_cache), GFP_KERNEL);
 561         if (!pcache)
 562                 goto fail_cache_create;
 563         part_cur->pcache = pcache;
 564
 565         error = add_mtd_device(mtd_cur);
 566         if (error)
 567                 goto fail_mtd_register;
 568
 569         maple_getcond_callback(mdev, NULL, 0,
 570                 MAPLE_FUNC_MEMCARD);
 571
 572         /*
 573         * Set up a recursive call to the (probably theoretical)
 574         * second or more partition
 575         */
 576         if (++card->partition < card->partitions) {
 577                 partnum = cpu_to_be32(card->partition << 24);
 578                 maple_getcond_callback(mdev, vmu_queryblocks, 0,
 579                         MAPLE_FUNC_MEMCARD);
 580                 maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
 581                         MAPLE_COMMAND_GETMINFO, 2, &partnum);
 582         }
 583         return;
 584
 585 fail_mtd_register:
 586         dev_err(&mdev->dev, "Could not register maple device at (%d, %d)"
 587                 "error is 0x%X\n", mdev->port, mdev->unit, error);
 588         for (error = 0; error <= card->partition; error++) {
 589                 kfree(((card->parts)[error]).pcache);
 590                 ((card->parts)[error]).pcache = NULL;
 591         }
 592 fail_cache_create:
 593 fail_mpart:
 594         for (error = 0; error <= card->partition; error++) {
 595                 kfree(((card->mtd)[error]).priv);
 596                 ((card->mtd)[error]).priv = NULL;
 597         }
 598         maple_getcond_callback(mdev, NULL, 0,
 599                 MAPLE_FUNC_MEMCARD);
 600         kfree(part_cur->name);
 601 fail_name:
 602         return;
 603 }
 604
 605 /* Handles very basic info about the flash, queries for details */
 606 static int __devinit vmu_connect(struct maple_device *mdev)
 607 {
 608         unsigned long test_flash_data, basic_flash_data;
 609         int c, error;
 610         struct memcard *card;
 611         u32 partnum = 0;
 612
 613         test_flash_data = be32_to_cpu(mdev->devinfo.function);
 614         /* Need to count how many bits are set - to find out which
 615          * function_data element has details of the memory card:
 616          * using Brian Kernighan's/Peter Wegner's method */
 617         for (c = 0; test_flash_data; c++)
 618                 test_flash_data &= test_flash_data - 1;
 619
 620         basic_flash_data = be32_to_cpu(mdev->devinfo.function_data[c - 1]);
 621
 622         card = kmalloc(sizeof(struct memcard), GFP_KERNEL);
 623         if (!card) {
 624                 error = ENOMEM;
 625                 goto fail_nomem;
 626         }
 627
 628         card->partitions = (basic_flash_data >> 24 & 0xFF) + 1;
 629         card->blocklen = ((basic_flash_data >> 16 & 0xFF) + 1) << 5;
 630         card->writecnt = basic_flash_data >> 12 & 0xF;
 631         card->readcnt = basic_flash_data >> 8 & 0xF;
 632         card->removeable = basic_flash_data >> 7 & 1;
 633
 634         card->partition = 0;
 635
 636         /*
 637         * Not sure there are actually any multi-partition devices in the
 638         * real world, but the hardware supports them, so, so will we
 639         */
 640         card->parts = kmalloc(sizeof(struct vmupart) * card->partitions,
 641                 GFP_KERNEL);
 642         if (!card->parts) {
 643                 error = -ENOMEM;
 644                 goto fail_partitions;
 645         }
 646
 647         card->mtd = kmalloc(sizeof(struct mtd_info) * card->partitions,
 648                 GFP_KERNEL);
 649         if (!card->mtd) {
 650                 error = -ENOMEM;
 651                 goto fail_mtd_info;
 652         }
 653
 654         maple_set_drvdata(mdev, card);
 655
 656         /*
 657         * We want to trap meminfo not get cond
 658         * so set interval to zero, but rely on maple bus
 659         * driver to pass back the results of the meminfo
 660         */
 661         maple_getcond_callback(mdev, vmu_queryblocks, 0,
 662                 MAPLE_FUNC_MEMCARD);
 663
 664         /* Make sure we are clear to go */
 665         if (atomic_read(&mdev->busy) == 1) {
 666                 wait_event_interruptible_timeout(mdev->maple_wait,
 667                         atomic_read(&mdev->busy) == 0, HZ);
 668                 if (atomic_read(&mdev->busy) == 1) {
 669                         dev_notice(&mdev->dev, "VMU at (%d, %d) is busy\n",
 670                                 mdev->port, mdev->unit);
 671                         error = -EAGAIN;
 672                         goto fail_device_busy;
 673                 }
 674         }
 675
 676         atomic_set(&mdev->busy, 1);
 677
 678         /*
 679         * Set up the minfo call: vmu_queryblocks will handle
 680         * the information passed back
 681         */
 682         error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD,
 683                 MAPLE_COMMAND_GETMINFO, 2, &partnum);
 684         if (error) {
 685                 dev_err(&mdev->dev, "Could not lock VMU at (%d, %d)"
 686                         " error is 0x%X\n", mdev->port, mdev->unit, error);
 687                 goto fail_mtd_info;
 688         }
 689         return 0;
 690
 691 fail_device_busy:
 692         kfree(card->mtd);
 693 fail_mtd_info:
 694         kfree(card->parts);
 695 fail_partitions:
 696         kfree(card);
 697 fail_nomem:
 698         return error;
 699 }
 700
 701 static void __devexit vmu_disconnect(struct maple_device *mdev)
 702 {
 703         struct memcard *card;
 704         struct mdev_part *mpart;
 705         int x;
 706
 707         mdev->callback = NULL;
 708         card = maple_get_drvdata(mdev);
 709         for (x = 0; x < card->partitions; x++) {
 710                 mpart = ((card->mtd)[x]).priv;
 711                 mpart->mdev = NULL;
 712                 del_mtd_device(&((card->mtd)[x]));
 713                 kfree(((card->parts)[x]).name);
 714         }
 715         kfree(card->parts);
 716         kfree(card->mtd);
 717         kfree(card);
 718 }
 719
 720 /* Callback to handle eccentricities of both mtd subsystem
 721  * and general flakyness of Dreamcast VMUs
 722  */
 723 static int vmu_can_unload(struct maple_device *mdev)
 724 {
 725         struct memcard *card;
 726         int x;
 727         struct mtd_info *mtd;
 728
 729         card = maple_get_drvdata(mdev);
 730         for (x = 0; x < card->partitions; x++) {
 731                 mtd = &((card->mtd)[x]);
 732                 if (mtd->usecount > 0)
 733                         return 0;
 734         }
 735         return 1;
 736 }
 737
 738 #define ERRSTR "VMU at (%d, %d) file error -"
 739
 740 static void vmu_file_error(struct maple_device *mdev, void *recvbuf)
 741 {
 742         enum maple_file_errors error = ((int *)recvbuf)[1];
 743
 744         switch (error) {
 745
 746         case MAPLE_FILEERR_INVALID_PARTITION:
 747                 dev_notice(&mdev->dev, ERRSTR " invalid partition number\n",
 748                         mdev->port, mdev->unit);
 749                 break;
 750
 751         case MAPLE_FILEERR_PHASE_ERROR:
 752                 dev_notice(&mdev->dev, ERRSTR " phase error\n",
 753                         mdev->port, mdev->unit);
 754                 break;
 755
 756         case MAPLE_FILEERR_INVALID_BLOCK:
 757                 dev_notice(&mdev->dev, ERRSTR " invalid block number\n",
 758                         mdev->port, mdev->unit);
 759                 break;
 760
 761         case MAPLE_FILEERR_WRITE_ERROR:
 762                 dev_notice(&mdev->dev, ERRSTR " write error\n",
 763                         mdev->port, mdev->unit);
 764                 break;
 765
 766         case MAPLE_FILEERR_INVALID_WRITE_LENGTH:
 767                 dev_notice(&mdev->dev, ERRSTR " invalid write length\n",
 768                         mdev->port, mdev->unit);
 769                 break;
 770
 771         case MAPLE_FILEERR_BAD_CRC:
 772                 dev_notice(&mdev->dev, ERRSTR " bad CRC\n",
 773                         mdev->port, mdev->unit);
 774                 break;
 775
 776         default:
 777                 dev_notice(&mdev->dev, ERRSTR " 0x%X\n",
 778                         mdev->port, mdev->unit, error);
 779         }
 780 }
 781
 782
 783 static int __devinit probe_maple_vmu(struct device *dev)
 784 {
 785         int error;
 786         struct maple_device *mdev = to_maple_dev(dev);
 787         struct maple_driver *mdrv = to_maple_driver(dev->driver);
 788
 789         mdev->can_unload = vmu_can_unload;
 790         mdev->fileerr_handler = vmu_file_error;
 791         mdev->driver = mdrv;
 792
 793         error = vmu_connect(mdev);
 794         if (error)
 795                 return error;
 796
 797         return 0;
 798 }
 799
 800 static int __devexit remove_maple_vmu(struct device *dev)
 801 {
 802         struct maple_device *mdev = to_maple_dev(dev);
 803
 804         vmu_disconnect(mdev);
 805         return 0;
 806 }
 807
 808 static struct maple_driver vmu_flash_driver = {
 809         .function =     MAPLE_FUNC_MEMCARD,
 810         .drv = {
 811                 .name =         "Dreamcast_visual_memory",
 812                 .probe =        probe_maple_vmu,
 813                 .remove =       __devexit_p(remove_maple_vmu),
 814         },
 815 };
 816
 817 static int __init vmu_flash_map_init(void)
 818 {
 819         return maple_driver_register(&vmu_flash_driver);
 820 }
 821
 822 static void __exit vmu_flash_map_exit(void)
 823 {
 824         maple_driver_unregister(&vmu_flash_driver);
 825 }
 826
 827 module_init(vmu_flash_map_init);
 828 module_exit(vmu_flash_map_exit);
 829
 830 MODULE_LICENSE("GPL");
 831 MODULE_AUTHOR("Adrian McMenamin");
 832 MODULE_DESCRIPTION("Flash mapping for Sega Dreamcast visual memory");