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/slab.h> 12 #include <linux/sched.h> 13 #include <linux/delay.h> 14 #include <linux/maple.h> 15 #include <linux/mtd/mtd.h> 16 #include <linux/mtd/map.h> 17 18 struct vmu_cache { 19 unsigned char *buffer; /* Cache */ 20 unsigned int block; /* Which block was cached */ 21 unsigned long jiffies_atc; /* When was it cached? */ 22 int valid; 23 }; 24 25 struct mdev_part { 26 struct maple_device *mdev; 27 int partition; 28 }; 29 30 struct vmupart { 31 u16 user_blocks; 32 u16 root_block; 33 u16 numblocks; 34 char *name; 35 struct vmu_cache *pcache; 36 }; 37 38 struct memcard { 39 u16 tempA; 40 u16 tempB; 41 u32 partitions; 42 u32 blocklen; 43 u32 writecnt; 44 u32 readcnt; 45 u32 removeable; 46 int partition; 47 int read; 48 unsigned char *blockread; 49 struct vmupart *parts; 50 struct mtd_info *mtd; 51 }; 52 53 struct vmu_block { 54 unsigned int num; /* block number */ 55 unsigned int ofs; /* block offset */ 56 }; 57 58 static struct vmu_block *ofs_to_block(unsigned long src_ofs, 59 struct mtd_info *mtd, int partition) 60 { 61 struct vmu_block *vblock; 62 struct maple_device *mdev; 63 struct memcard *card; 64 struct mdev_part *mpart; 65 int num; 66 67 mpart = mtd->priv; 68 mdev = mpart->mdev; 69 card = maple_get_drvdata(mdev); 70 71 if (src_ofs >= card->parts[partition].numblocks * card->blocklen) 72 goto failed; 73 74 num = src_ofs / card->blocklen; 75 if (num > card->parts[partition].numblocks) 76 goto failed; 77 78 vblock = kmalloc(sizeof(struct vmu_block), GFP_KERNEL); 79 if (!vblock) 80 goto failed; 81 82 vblock->num = num; 83 vblock->ofs = src_ofs % card->blocklen; 84 return vblock; 85 86 failed: 87 return NULL; 88 } 89 90 /* Maple bus callback function for reads */ 91 static void vmu_blockread(struct mapleq *mq) 92 { 93 struct maple_device *mdev; 94 struct memcard *card; 95 96 mdev = mq->dev; 97 card = maple_get_drvdata(mdev); 98 /* copy the read in data */ 99 100 if (unlikely(!card->blockread)) 101 return; 102 103 memcpy(card->blockread, mq->recvbuf->buf + 12, 104 card->blocklen/card->readcnt); 105 106 } 107 108 /* Interface with maple bus to read blocks 109 * caching the results so that other parts 110 * of the driver can access block reads */ 111 static int maple_vmu_read_block(unsigned int num, unsigned char *buf, 112 struct mtd_info *mtd) 113 { 114 struct memcard *card; 115 struct mdev_part *mpart; 116 struct maple_device *mdev; 117 int partition, error = 0, x, wait; 118 unsigned char *blockread = NULL; 119 struct vmu_cache *pcache; 120 __be32 sendbuf; 121 122 mpart = mtd->priv; 123 mdev = mpart->mdev; 124 partition = mpart->partition; 125 card = maple_get_drvdata(mdev); 126 pcache = card->parts[partition].pcache; 127 pcache->valid = 0; 128 129 /* prepare the cache for this block */ 130 if (!pcache->buffer) { 131 pcache->buffer = kmalloc(card->blocklen, GFP_KERNEL); 132 if (!pcache->buffer) { 133 dev_err(&mdev->dev, "VMU at (%d, %d) - read fails due" 134 " to lack of memory\n", mdev->port, 135 mdev->unit); 136 error = -ENOMEM; 137 goto outB; 138 } 139 } 140 141 /* 142 * Reads may be phased - again the hardware spec 143 * supports this - though may not be any devices in 144 * the wild that implement it, but we will here 145 */ 146 for (x = 0; x < card->readcnt; x++) { 147 sendbuf = cpu_to_be32(partition << 24 | x << 16 | num); 148 149 if (atomic_read(&mdev->busy) == 1) { 150 wait_event_interruptible_timeout(mdev->maple_wait, 151 atomic_read(&mdev->busy) == 0, HZ); 152 if (atomic_read(&mdev->busy) == 1) { 153 dev_notice(&mdev->dev, "VMU at (%d, %d)" 154 " is busy\n", mdev->port, mdev->unit); 155 error = -EAGAIN; 156 goto outB; 157 } 158 } 159 160 atomic_set(&mdev->busy, 1); 161 blockread = kmalloc(card->blocklen/card->readcnt, GFP_KERNEL); 162 if (!blockread) { 163 error = -ENOMEM; 164 atomic_set(&mdev->busy, 0); 165 goto outB; 166 } 167 card->blockread = blockread; 168 169 maple_getcond_callback(mdev, vmu_blockread, 0, 170 MAPLE_FUNC_MEMCARD); 171 error = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD, 172 MAPLE_COMMAND_BREAD, 2, &sendbuf); 173 /* Very long timeouts seem to be needed when box is stressed */ 174 wait = wait_event_interruptible_timeout(mdev->maple_wait, 175 (atomic_read(&mdev->busy) == 0 || 176 atomic_read(&mdev->busy) == 2), HZ * 3); 177 /* 178 * MTD layer does not handle hotplugging well 179 * so have to return errors when VMU is unplugged 180 * in the middle of a read (busy == 2) 181 */ 182 if (error || atomic_read(&mdev->busy) == 2) { 183 if (atomic_read(&mdev->busy) == 2) 184 error = -ENXIO; 185 atomic_set(&mdev->busy, 0); 186 card->blockread = NULL; 187 goto outA; 188 } 189 if (wait == 0 || wait == -ERESTARTSYS) { 190 card->blockread = NULL; 191 atomic_set(&mdev->busy, 0); 192 error = -EIO; 193 list_del_init(&(mdev->mq->list)); 194 kfree(mdev->mq->sendbuf); 195 mdev->mq->sendbuf = NULL; 196 if (wait == -ERESTARTSYS) { 197 dev_warn(&mdev->dev, "VMU read on (%d, %d)" 198 " interrupted on block 0x%X\n", 199 mdev->port, mdev->unit, num); 200 } else 201 dev_notice(&mdev->dev, "VMU read on (%d, %d)" 202 " timed out on block 0x%X\n", 203 mdev->port, mdev->unit, num); 204 goto outA; 205 } 206 207 memcpy(buf + (card->blocklen/card->readcnt) * x, blockread, 208 card->blocklen/card->readcnt); 209 210 memcpy(pcache->buffer + (card->blocklen/card->readcnt) * x, 211 card->blockread, card->blocklen/card->readcnt); 212 card->blockread = NULL; 213 pcache->block = num; 214 pcache->jiffies_atc = jiffies; 215 pcache->valid = 1; 216 kfree(blockread); 217 } 218 219 return error; 220 221 outA: 222 kfree(blockread); 223 outB: 224 return error; 225 } 226 227 /* communicate with maple bus for phased writing */ 228 static int maple_vmu_write_block(unsigned int num, const unsigned char *buf, 229 struct mtd_info *mtd) 230 { 231 struct memcard *card; 232 struct mdev_part *mpart; 233 struct maple_device *mdev; 234 int partition, error, locking, x, phaselen, wait; 235 __be32 *sendbuf; 236 237 mpart = mtd->priv; 238 mdev = mpart->mdev; 239 partition = mpart->partition; 240 card = maple_get_drvdata(mdev); 241 242 phaselen = card->blocklen/card->writecnt; 243 244 sendbuf = kmalloc(phaselen + 4, GFP_KERNEL); 245 if (!sendbuf) { 246 error = -ENOMEM; 247 goto fail_nosendbuf; 248 } 249 for (x = 0; x < card->writecnt; x++) { 250 sendbuf[0] = cpu_to_be32(partition << 24 | x << 16 | num); 251 memcpy(&sendbuf[1], buf + phaselen * x, phaselen); 252 /* wait until the device is not busy doing something else 253 * or 1 second - which ever is longer */ 254 if (atomic_read(&mdev->busy) == 1) { 255 wait_event_interruptible_timeout(mdev->maple_wait, 256 atomic_read(&mdev->busy) == 0, HZ); 257 if (atomic_read(&mdev->busy) == 1) { 258 error = -EBUSY; 259 dev_notice(&mdev->dev, "VMU write at (%d, %d)" 260 "failed - device is busy\n", 261 mdev->port, mdev->unit); 262 goto fail_nolock; 263 } 264 } 265 atomic_set(&mdev->busy, 1); 266 267 locking = maple_add_packet(mdev, MAPLE_FUNC_MEMCARD, 268 MAPLE_COMMAND_BWRITE, phaselen / 4 + 2, sendbuf); 269 wait = wait_event_interruptible_timeout(mdev->maple_wait, 270 atomic_read(&mdev->busy) == 0, HZ/10); 271 if (locking) { 272 error = -EIO; 273 atomic_set(&mdev->busy, 0); 274 goto fail_nolock; 275 } 276 if (atomic_read(&mdev->busy) == 2) { 277 atomic_set(&mdev->busy, 0); 278 } else if (wait == 0 || wait == -ERESTARTSYS) { 279 error = -EIO; 280 dev_warn(&mdev->dev, "Write at (%d, %d) of block" 281 " 0x%X at phase %d failed: could not" 282 " communicate with VMU", mdev->port, 283 mdev->unit, num, x); 284 atomic_set(&mdev->busy, 0); 285 kfree(mdev->mq->sendbuf); 286 mdev->mq->sendbuf = NULL; 287 list_del_init(&(mdev->mq->list)); 288 goto fail_nolock; 289 } 290 } 291 kfree(sendbuf); 292 293 return card->blocklen; 294 295 fail_nolock: 296 kfree(sendbuf); 297 fail_nosendbuf: 298 dev_err(&mdev->dev, "VMU (%d, %d): write failed\n", mdev->port, 299 mdev->unit); 300 return error; 301 } 302 303 /* mtd function to simulate reading byte by byte */ 304 static unsigned char vmu_flash_read_char(unsigned long ofs, int *retval, 305 struct mtd_info *mtd) 306 { 307 struct vmu_block *vblock; 308 struct memcard *card; 309 struct mdev_part *mpart; 310 struct maple_device *mdev; 311 unsigned char *buf, ret; 312 int partition, error; 313 314 mpart = mtd->priv; 315 mdev = mpart->mdev; 316 partition = mpart->partition; 317 card = maple_get_drvdata(mdev); 318 *retval = 0; 319 320 buf = kmalloc(card->blocklen, GFP_KERNEL); 321 if (!buf) { 322 *retval = 1; 323 ret = -ENOMEM; 324 goto finish; 325 } 326 327 vblock = ofs_to_block(ofs, mtd, partition); 328 if (!vblock) { 329 *retval = 3; 330 ret = -ENOMEM; 331 goto out_buf; 332 } 333 334 error = maple_vmu_read_block(vblock->num, buf, mtd); 335 if (error) { 336 ret = error; 337 *retval = 2; 338 goto out_vblock; 339 } 340 341 ret = buf[vblock->ofs]; 342 343 out_vblock: 344 kfree(vblock); 345 out_buf: 346 kfree(buf); 347 finish: 348 return ret; 349 } 350 351 /* mtd higher order function to read flash */ 352 static int vmu_flash_read(struct mtd_info *mtd, loff_t from, size_t len, 353 size_t *retlen, u_char *buf) 354 { 355 struct maple_device *mdev; 356 struct memcard *card; 357 struct mdev_part *mpart; 358 struct vmu_cache *pcache; 359 struct vmu_block *vblock; 360 int index = 0, retval, partition, leftover, numblocks; 361 unsigned char cx; 362 363 if (len < 1) 364 return -EIO; 365 366 mpart = mtd->priv; 367 mdev = mpart->mdev; 368 partition = mpart->partition; 369 card = maple_get_drvdata(mdev); 370 371 numblocks = card->parts[partition].numblocks; 372 if (from + len > numblocks * card->blocklen) 373 len = numblocks * card->blocklen - from; 374 if (len == 0) 375 return -EIO; 376 /* Have we cached this bit already? */ 377 pcache = card->parts[partition].pcache; 378 do { 379 vblock = ofs_to_block(from + index, mtd, partition); 380 if (!vblock) 381 return -ENOMEM; 382 /* Have we cached this and is the cache valid and timely? */ 383 if (pcache->valid && 384 time_before(jiffies, pcache->jiffies_atc + HZ) && 385 (pcache->block == vblock->num)) { 386 /* we have cached it, so do necessary copying */ 387 leftover = card->blocklen - vblock->ofs; 388 if (vblock->ofs + len - index < card->blocklen) { 389 /* only a bit of this block to copy */ 390 memcpy(buf + index, 391 pcache->buffer + vblock->ofs, 392 len - index); 393 index = len; 394 } else { 395 /* otherwise copy remainder of whole block */ 396 memcpy(buf + index, pcache->buffer + 397 vblock->ofs, leftover); 398 index += leftover; 399 } 400 } else { 401 /* 402 * Not cached so read one byte - 403 * but cache the rest of the block 404 */ 405 cx = vmu_flash_read_char(from + index, &retval, mtd); 406 if (retval) { 407 *retlen = index; 408 kfree(vblock); 409 return cx; 410 } 411 memset(buf + index, cx, 1); 412 index++; 413 } 414 kfree(vblock); 415 } while (len > index); 416 *retlen = index; 417 418 return 0; 419 } 420 421 static int vmu_flash_write(struct mtd_info *mtd, loff_t to, size_t len, 422 size_t *retlen, const u_char *buf) 423 { 424 struct maple_device *mdev; 425 struct memcard *card; 426 struct mdev_part *mpart; 427 int index = 0, partition, error = 0, numblocks; 428 struct vmu_cache *pcache; 429 struct vmu_block *vblock; 430 unsigned char *buffer; 431 432 mpart = mtd->priv; 433 mdev = mpart->mdev; 434 partition = mpart->partition; 435 card = maple_get_drvdata(mdev); 436 437 /* simple sanity checks */ 438 if (len < 1) { 439 error = -EIO; 440 goto failed; 441 } 442 numblocks = card->parts[partition].numblocks; 443 if (to + len > numblocks * card->blocklen) 444 len = numblocks * card->blocklen - to; 445 if (len == 0) { 446 error = -EIO; 447 goto failed; 448 } 449 450 vblock = ofs_to_block(to, mtd, partition); 451 if (!vblock) { 452 error = -ENOMEM; 453 goto failed; 454 } 455 456 buffer = kmalloc(card->blocklen, GFP_KERNEL); 457 if (!buffer) { 458 error = -ENOMEM; 459 goto fail_buffer; 460 } 461 462 do { 463 /* Read in the block we are to write to */ 464 error = maple_vmu_read_block(vblock->num, buffer, mtd); 465 if (error) 466 goto fail_io; 467 468 do { 469 buffer[vblock->ofs] = buf[index]; 470 vblock->ofs++; 471 index++; 472 if (index >= len) 473 break; 474 } while (vblock->ofs < card->blocklen); 475 476 /* write out new buffer */ 477 error = maple_vmu_write_block(vblock->num, buffer, mtd); 478 /* invalidate the cache */ 479 pcache = card->parts[partition].pcache; 480 pcache->valid = 0; 481 482 if (error != card->blocklen) 483 goto fail_io; 484 485 vblock->num++; 486 vblock->ofs = 0; 487 } while (len > index); 488 489 kfree(buffer); 490 *retlen = index; 491 kfree(vblock); 492 return 0; 493 494 fail_io: 495 kfree(buffer); 496 fail_buffer: 497 kfree(vblock); 498 failed: 499 dev_err(&mdev->dev, "VMU write failing with error %d\n", error); 500 return error; 501 } 502 503 static void vmu_flash_sync(struct mtd_info *mtd) 504 { 505 /* Do nothing here */ 506 } 507 508 /* Maple bus callback function to recursively query hardware details */ 509 static void vmu_queryblocks(struct mapleq *mq) 510 { 511 struct maple_device *mdev; 512 unsigned short *res; 513 struct memcard *card; 514 __be32 partnum; 515 struct vmu_cache *pcache; 516 struct mdev_part *mpart; 517 struct mtd_info *mtd_cur; 518 struct vmupart *part_cur; 519 int error; 520 521 mdev = mq->dev; 522 card = maple_get_drvdata(mdev); 523 res = (unsigned short *) (mq->recvbuf->buf); 524 card->tempA = res[12]; 525 card->tempB = res[6]; 526 527 dev_info(&mdev->dev, "VMU device at partition %d has %d user " 528 "blocks with a root block at %d\n", card->partition, 529 card->tempA, card->tempB); 530 531 part_cur = &card->parts[card->partition]; 532 part_cur->user_blocks = card->tempA; 533 part_cur->root_block = card->tempB; 534 part_cur->numblocks = card->tempB + 1; 535 part_cur->name = kmalloc(12, GFP_KERNEL); 536 if (!part_cur->name) 537 goto fail_name; 538 539 sprintf(part_cur->name, "vmu%d.%d.%d", 540 mdev->port, mdev->unit, card->partition); 541 mtd_cur = &card->mtd[card->partition]; 542 mtd_cur->name = part_cur->name; 543 mtd_cur->type = 8; 544 mtd_cur->flags = MTD_WRITEABLE|MTD_NO_ERASE; 545 mtd_cur->size = part_cur->numblocks * card->blocklen; 546 mtd_cur->erasesize = card->blocklen; 547 mtd_cur->write = vmu_flash_write; 548 mtd_cur->read = vmu_flash_read; 549 mtd_cur->sync = vmu_flash_sync; 550 mtd_cur->writesize = card->blocklen; 551 552 mpart = kmalloc(sizeof(struct mdev_part), GFP_KERNEL); 553 if (!mpart) 554 goto fail_mpart; 555 556 mpart->mdev = mdev; 557 mpart->partition = card->partition; 558 mtd_cur->priv = mpart; 559 mtd_cur->owner = THIS_MODULE; 560 561 pcache = kzalloc(sizeof(struct vmu_cache), GFP_KERNEL); 562 if (!pcache) 563 goto fail_cache_create; 564 part_cur->pcache = pcache; 565 566 error = add_mtd_device(mtd_cur); 567 if (error) 568 goto fail_mtd_register; 569 570 maple_getcond_callback(mdev, NULL, 0, 571 MAPLE_FUNC_MEMCARD); 572 573 /* 574 * Set up a recursive call to the (probably theoretical) 575 * second or more partition 576 */ 577 if (++card->partition < card->partitions) { 578 partnum = cpu_to_be32(card->partition << 24); 579 maple_getcond_callback(mdev, vmu_queryblocks, 0, 580 MAPLE_FUNC_MEMCARD); 581 maple_add_packet(mdev, MAPLE_FUNC_MEMCARD, 582 MAPLE_COMMAND_GETMINFO, 2, &partnum); 583 } 584 return; 585 586 fail_mtd_register: 587 dev_err(&mdev->dev, "Could not register maple device at (%d, %d)" 588 "error is 0x%X\n", mdev->port, mdev->unit, error); 589 for (error = 0; error <= card->partition; error++) { 590 kfree(((card->parts)[error]).pcache); 591 ((card->parts)[error]).pcache = NULL; 592 } 593 fail_cache_create: 594 fail_mpart: 595 for (error = 0; error <= card->partition; error++) { 596 kfree(((card->mtd)[error]).priv); 597 ((card->mtd)[error]).priv = NULL; 598 } 599 maple_getcond_callback(mdev, NULL, 0, 600 MAPLE_FUNC_MEMCARD); 601 kfree(part_cur->name); 602 fail_name: 603 return; 604 } 605 606 /* Handles very basic info about the flash, queries for details */ 607 static int __devinit vmu_connect(struct maple_device *mdev) 608 { 609 unsigned long test_flash_data, basic_flash_data; 610 int c, error; 611 struct memcard *card; 612 u32 partnum = 0; 613 614 test_flash_data = be32_to_cpu(mdev->devinfo.function); 615 /* Need to count how many bits are set - to find out which 616 * function_data element has details of the memory card 617 */ 618 c = hweight_long(test_flash_data); 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"); 833