1/* 2 * MTD driver for Alauda chips 3 * 4 * Copyright (C) 2007 Joern Engel <joern@logfs.org> 5 * 6 * Based on drivers/usb/usb-skeleton.c which is: 7 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com) 8 * and on drivers/usb/storage/alauda.c, which is: 9 * (c) 2005 Daniel Drake <dsd@gentoo.org> 10 * 11 * Idea and initial work by Arnd Bergmann <arnd@arndb.de> 12 */ 13#include <linux/kernel.h> 14#include <linux/errno.h> 15#include <linux/init.h> 16#include <linux/slab.h> 17#include <linux/module.h> 18#include <linux/kref.h> 19#include <linux/usb.h> 20#include <linux/mutex.h> 21#include <linux/mtd/mtd.h> 22#include <linux/mtd/nand_ecc.h> 23 24/* Control commands */ 25#define ALAUDA_GET_XD_MEDIA_STATUS 0x08 26#define ALAUDA_ACK_XD_MEDIA_CHANGE 0x0a 27#define ALAUDA_GET_XD_MEDIA_SIG 0x86 28 29/* Common prefix */ 30#define ALAUDA_BULK_CMD 0x40 31 32/* The two ports */ 33#define ALAUDA_PORT_XD 0x00 34#define ALAUDA_PORT_SM 0x01 35 36/* Bulk commands */ 37#define ALAUDA_BULK_READ_PAGE 0x84 38#define ALAUDA_BULK_READ_OOB 0x85 /* don't use, there's a chip bug */ 39#define ALAUDA_BULK_READ_BLOCK 0x94 40#define ALAUDA_BULK_ERASE_BLOCK 0xa3 41#define ALAUDA_BULK_WRITE_PAGE 0xa4 42#define ALAUDA_BULK_WRITE_BLOCK 0xb4 43#define ALAUDA_BULK_RESET_MEDIA 0xe0 44 45/* Address shifting */ 46#define PBA_LO(pba) ((pba & 0xF) << 5) 47#define PBA_HI(pba) (pba >> 3) 48#define PBA_ZONE(pba) (pba >> 11) 49 50#define TIMEOUT HZ 51 52static const struct usb_device_id alauda_table[] = { 53 { USB_DEVICE(0x0584, 0x0008) }, /* Fujifilm DPC-R1 */ 54 { USB_DEVICE(0x07b4, 0x010a) }, /* Olympus MAUSB-10 */ 55 { } 56}; 57MODULE_DEVICE_TABLE(usb, alauda_table); 58 59struct alauda_card { 60 u8 id; /* id byte */ 61 u8 chipshift; /* 1<<chipshift total size */ 62 u8 pageshift; /* 1<<pageshift page size */ 63 u8 blockshift; /* 1<<blockshift block size */ 64}; 65 66struct alauda { 67 struct usb_device *dev; 68 struct usb_interface *interface; 69 struct mtd_info *mtd; 70 struct alauda_card *card; 71 struct mutex card_mutex; 72 u32 pagemask; 73 u32 bytemask; 74 u32 blockmask; 75 unsigned int write_out; 76 unsigned int bulk_in; 77 unsigned int bulk_out; 78 u8 port; 79 struct kref kref; 80}; 81 82static struct alauda_card alauda_card_ids[] = { 83 /* NAND flash */ 84 { 0x6e, 20, 8, 12}, /* 1 MB */ 85 { 0xe8, 20, 8, 12}, /* 1 MB */ 86 { 0xec, 20, 8, 12}, /* 1 MB */ 87 { 0x64, 21, 8, 12}, /* 2 MB */ 88 { 0xea, 21, 8, 12}, /* 2 MB */ 89 { 0x6b, 22, 9, 13}, /* 4 MB */ 90 { 0xe3, 22, 9, 13}, /* 4 MB */ 91 { 0xe5, 22, 9, 13}, /* 4 MB */ 92 { 0xe6, 23, 9, 13}, /* 8 MB */ 93 { 0x73, 24, 9, 14}, /* 16 MB */ 94 { 0x75, 25, 9, 14}, /* 32 MB */ 95 { 0x76, 26, 9, 14}, /* 64 MB */ 96 { 0x79, 27, 9, 14}, /* 128 MB */ 97 { 0x71, 28, 9, 14}, /* 256 MB */ 98 99 /* MASK ROM */ 100 { 0x5d, 21, 9, 13}, /* 2 MB */ 101 { 0xd5, 22, 9, 13}, /* 4 MB */ 102 { 0xd6, 23, 9, 13}, /* 8 MB */ 103 { 0x57, 24, 9, 13}, /* 16 MB */ 104 { 0x58, 25, 9, 13}, /* 32 MB */ 105 { } 106}; 107 108static struct alauda_card *get_card(u8 id) 109{ 110 struct alauda_card *card; 111 112 for (card = alauda_card_ids; card->id; card++) 113 if (card->id == id) 114 return card; 115 return NULL; 116} 117 118static void alauda_delete(struct kref *kref) 119{ 120 struct alauda *al = container_of(kref, struct alauda, kref); 121 122 if (al->mtd) { 123 mtd_device_unregister(al->mtd); 124 kfree(al->mtd); 125 } 126 usb_put_dev(al->dev); 127 kfree(al); 128} 129 130static int alauda_get_media_status(struct alauda *al, void *buf) 131{ 132 int ret; 133 134 mutex_lock(&al->card_mutex); 135 ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0), 136 ALAUDA_GET_XD_MEDIA_STATUS, 0xc0, 0, 1, buf, 2, HZ); 137 mutex_unlock(&al->card_mutex); 138 return ret; 139} 140 141static int alauda_ack_media(struct alauda *al) 142{ 143 int ret; 144 145 mutex_lock(&al->card_mutex); 146 ret = usb_control_msg(al->dev, usb_sndctrlpipe(al->dev, 0), 147 ALAUDA_ACK_XD_MEDIA_CHANGE, 0x40, 0, 1, NULL, 0, HZ); 148 mutex_unlock(&al->card_mutex); 149 return ret; 150} 151 152static int alauda_get_media_signatures(struct alauda *al, void *buf) 153{ 154 int ret; 155 156 mutex_lock(&al->card_mutex); 157 ret = usb_control_msg(al->dev, usb_rcvctrlpipe(al->dev, 0), 158 ALAUDA_GET_XD_MEDIA_SIG, 0xc0, 0, 0, buf, 4, HZ); 159 mutex_unlock(&al->card_mutex); 160 return ret; 161} 162 163static void alauda_reset(struct alauda *al) 164{ 165 u8 command[] = { 166 ALAUDA_BULK_CMD, ALAUDA_BULK_RESET_MEDIA, 0, 0, 167 0, 0, 0, 0, al->port 168 }; 169 mutex_lock(&al->card_mutex); 170 usb_bulk_msg(al->dev, al->bulk_out, command, 9, NULL, HZ); 171 mutex_unlock(&al->card_mutex); 172} 173 174static void correct_data(void *buf, void *read_ecc, 175 int *corrected, int *uncorrected) 176{ 177 u8 calc_ecc[3]; 178 int err; 179 180 nand_calculate_ecc(NULL, buf, calc_ecc); 181 err = nand_correct_data(NULL, buf, read_ecc, calc_ecc); 182 if (err) { 183 if (err > 0) 184 (*corrected)++; 185 else 186 (*uncorrected)++; 187 } 188} 189 190struct alauda_sg_request { 191 struct urb *urb[3]; 192 struct completion comp; 193}; 194 195static void alauda_complete(struct urb *urb) 196{ 197 struct completion *comp = urb->context; 198 199 if (comp) 200 complete(comp); 201} 202 203static int __alauda_read_page(struct mtd_info *mtd, loff_t from, void *buf, 204 void *oob) 205{ 206 struct alauda_sg_request sg; 207 struct alauda *al = mtd->priv; 208 u32 pba = from >> al->card->blockshift; 209 u32 page = (from >> al->card->pageshift) & al->pagemask; 210 u8 command[] = { 211 ALAUDA_BULK_CMD, ALAUDA_BULK_READ_PAGE, PBA_HI(pba), 212 PBA_ZONE(pba), 0, PBA_LO(pba) + page, 1, 0, al->port 213 }; 214 int i, err; 215 216 for (i=0; i<3; i++) 217 sg.urb[i] = NULL; 218 219 err = -ENOMEM; 220 for (i=0; i<3; i++) { 221 sg.urb[i] = usb_alloc_urb(0, GFP_NOIO); 222 if (!sg.urb[i]) 223 goto out; 224 } 225 init_completion(&sg.comp); 226 usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9, 227 alauda_complete, NULL); 228 usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, mtd->writesize, 229 alauda_complete, NULL); 230 usb_fill_bulk_urb(sg.urb[2], al->dev, al->bulk_in, oob, 16, 231 alauda_complete, &sg.comp); 232 233 mutex_lock(&al->card_mutex); 234 for (i=0; i<3; i++) { 235 err = usb_submit_urb(sg.urb[i], GFP_NOIO); 236 if (err) 237 goto cancel; 238 } 239 if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) { 240 err = -ETIMEDOUT; 241cancel: 242 for (i=0; i<3; i++) { 243 usb_kill_urb(sg.urb[i]); 244 } 245 } 246 mutex_unlock(&al->card_mutex); 247 248out: 249 usb_free_urb(sg.urb[0]); 250 usb_free_urb(sg.urb[1]); 251 usb_free_urb(sg.urb[2]); 252 return err; 253} 254 255static int alauda_read_page(struct mtd_info *mtd, loff_t from, 256 void *buf, u8 *oob, int *corrected, int *uncorrected) 257{ 258 int err; 259 260 err = __alauda_read_page(mtd, from, buf, oob); 261 if (err) 262 return err; 263 correct_data(buf, oob+13, corrected, uncorrected); 264 correct_data(buf+256, oob+8, corrected, uncorrected); 265 return 0; 266} 267 268static int alauda_write_page(struct mtd_info *mtd, loff_t to, void *buf, 269 void *oob) 270{ 271 struct alauda_sg_request sg; 272 struct alauda *al = mtd->priv; 273 u32 pba = to >> al->card->blockshift; 274 u32 page = (to >> al->card->pageshift) & al->pagemask; 275 u8 command[] = { 276 ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_PAGE, PBA_HI(pba), 277 PBA_ZONE(pba), 0, PBA_LO(pba) + page, 32, 0, al->port 278 }; 279 int i, err; 280 281 for (i=0; i<3; i++) 282 sg.urb[i] = NULL; 283 284 err = -ENOMEM; 285 for (i=0; i<3; i++) { 286 sg.urb[i] = usb_alloc_urb(0, GFP_NOIO); 287 if (!sg.urb[i]) 288 goto out; 289 } 290 init_completion(&sg.comp); 291 usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9, 292 alauda_complete, NULL); 293 usb_fill_bulk_urb(sg.urb[1], al->dev, al->write_out, buf,mtd->writesize, 294 alauda_complete, NULL); 295 usb_fill_bulk_urb(sg.urb[2], al->dev, al->write_out, oob, 16, 296 alauda_complete, &sg.comp); 297 298 mutex_lock(&al->card_mutex); 299 for (i=0; i<3; i++) { 300 err = usb_submit_urb(sg.urb[i], GFP_NOIO); 301 if (err) 302 goto cancel; 303 } 304 if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) { 305 err = -ETIMEDOUT; 306cancel: 307 for (i=0; i<3; i++) { 308 usb_kill_urb(sg.urb[i]); 309 } 310 } 311 mutex_unlock(&al->card_mutex); 312 313out: 314 usb_free_urb(sg.urb[0]); 315 usb_free_urb(sg.urb[1]); 316 usb_free_urb(sg.urb[2]); 317 return err; 318} 319 320static int alauda_erase_block(struct mtd_info *mtd, loff_t ofs) 321{ 322 struct alauda_sg_request sg; 323 struct alauda *al = mtd->priv; 324 u32 pba = ofs >> al->card->blockshift; 325 u8 command[] = { 326 ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba), 327 PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, al->port 328 }; 329 u8 buf[2]; 330 int i, err; 331 332 for (i=0; i<2; i++) 333 sg.urb[i] = NULL; 334 335 err = -ENOMEM; 336 for (i=0; i<2; i++) { 337 sg.urb[i] = usb_alloc_urb(0, GFP_NOIO); 338 if (!sg.urb[i]) 339 goto out; 340 } 341 init_completion(&sg.comp); 342 usb_fill_bulk_urb(sg.urb[0], al->dev, al->bulk_out, command, 9, 343 alauda_complete, NULL); 344 usb_fill_bulk_urb(sg.urb[1], al->dev, al->bulk_in, buf, 2, 345 alauda_complete, &sg.comp); 346 347 mutex_lock(&al->card_mutex); 348 for (i=0; i<2; i++) { 349 err = usb_submit_urb(sg.urb[i], GFP_NOIO); 350 if (err) 351 goto cancel; 352 } 353 if (!wait_for_completion_timeout(&sg.comp, TIMEOUT)) { 354 err = -ETIMEDOUT; 355cancel: 356 for (i=0; i<2; i++) { 357 usb_kill_urb(sg.urb[i]); 358 } 359 } 360 mutex_unlock(&al->card_mutex); 361 362out: 363 usb_free_urb(sg.urb[0]); 364 usb_free_urb(sg.urb[1]); 365 return err; 366} 367 368static int alauda_read_oob(struct mtd_info *mtd, loff_t from, void *oob) 369{ 370 static u8 ignore_buf[512]; /* write only */ 371 372 return __alauda_read_page(mtd, from, ignore_buf, oob); 373} 374 375static int alauda_isbad(struct mtd_info *mtd, loff_t ofs) 376{ 377 u8 oob[16]; 378 int err; 379 380 err = alauda_read_oob(mtd, ofs, oob); 381 if (err) 382 return err; 383 384 /* A block is marked bad if two or more bits are zero */ 385 return hweight8(oob[5]) >= 7 ? 0 : 1; 386} 387 388static int alauda_bounce_read(struct mtd_info *mtd, loff_t from, size_t len, 389 size_t *retlen, u_char *buf) 390{ 391 struct alauda *al = mtd->priv; 392 void *bounce_buf; 393 int err, corrected=0, uncorrected=0; 394 395 bounce_buf = kmalloc(mtd->writesize, GFP_KERNEL); 396 if (!bounce_buf) 397 return -ENOMEM; 398 399 *retlen = len; 400 while (len) { 401 u8 oob[16]; 402 size_t byte = from & al->bytemask; 403 size_t cplen = min(len, mtd->writesize - byte); 404 405 err = alauda_read_page(mtd, from, bounce_buf, oob, 406 &corrected, &uncorrected); 407 if (err) 408 goto out; 409 410 memcpy(buf, bounce_buf + byte, cplen); 411 buf += cplen; 412 from += cplen; 413 len -= cplen; 414 } 415 err = 0; 416 if (corrected) 417 err = -EUCLEAN; 418 if (uncorrected) 419 err = -EBADMSG; 420out: 421 kfree(bounce_buf); 422 return err; 423} 424 425static int alauda_read(struct mtd_info *mtd, loff_t from, size_t len, 426 size_t *retlen, u_char *buf) 427{ 428 struct alauda *al = mtd->priv; 429 int err, corrected=0, uncorrected=0; 430 431 if ((from & al->bytemask) || (len & al->bytemask)) 432 return alauda_bounce_read(mtd, from, len, retlen, buf); 433 434 *retlen = len; 435 while (len) { 436 u8 oob[16]; 437 438 err = alauda_read_page(mtd, from, buf, oob, 439 &corrected, &uncorrected); 440 if (err) 441 return err; 442 443 buf += mtd->writesize; 444 from += mtd->writesize; 445 len -= mtd->writesize; 446 } 447 err = 0; 448 if (corrected) 449 err = -EUCLEAN; 450 if (uncorrected) 451 err = -EBADMSG; 452 return err; 453} 454 455static int alauda_write(struct mtd_info *mtd, loff_t to, size_t len, 456 size_t *retlen, const u_char *buf) 457{ 458 struct alauda *al = mtd->priv; 459 int err; 460 461 if ((to & al->bytemask) || (len & al->bytemask)) 462 return -EINVAL; 463 464 *retlen = len; 465 while (len) { 466 u32 page = (to >> al->card->pageshift) & al->pagemask; 467 u8 oob[16] = { 'h', 'e', 'l', 'l', 'o', 0xff, 0xff, 0xff, 468 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 469 470 /* don't write to bad blocks */ 471 if (page == 0) { 472 err = alauda_isbad(mtd, to); 473 if (err) { 474 return -EIO; 475 } 476 } 477 nand_calculate_ecc(mtd, buf, &oob[13]); 478 nand_calculate_ecc(mtd, buf+256, &oob[8]); 479 480 err = alauda_write_page(mtd, to, (void*)buf, oob); 481 if (err) 482 return err; 483 484 buf += mtd->writesize; 485 to += mtd->writesize; 486 len -= mtd->writesize; 487 } 488 return 0; 489} 490 491static int __alauda_erase(struct mtd_info *mtd, struct erase_info *instr) 492{ 493 struct alauda *al = mtd->priv; 494 u32 ofs = instr->addr; 495 u32 len = instr->len; 496 int err; 497 498 if ((ofs & al->blockmask) || (len & al->blockmask)) 499 return -EINVAL; 500 501 while (len) { 502 /* don't erase bad blocks */ 503 err = alauda_isbad(mtd, ofs); 504 if (err > 0) 505 err = -EIO; 506 if (err < 0) 507 return err; 508 509 err = alauda_erase_block(mtd, ofs); 510 if (err < 0) 511 return err; 512 513 ofs += mtd->erasesize; 514 len -= mtd->erasesize; 515 } 516 return 0; 517} 518 519static int alauda_erase(struct mtd_info *mtd, struct erase_info *instr) 520{ 521 int err; 522 523 err = __alauda_erase(mtd, instr); 524 instr->state = err ? MTD_ERASE_FAILED : MTD_ERASE_DONE; 525 mtd_erase_callback(instr); 526 return err; 527} 528 529static int alauda_init_media(struct alauda *al) 530{ 531 u8 buf[4], *b0=buf, *b1=buf+1; 532 struct alauda_card *card; 533 struct mtd_info *mtd; 534 int err; 535 536 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL); 537 if (!mtd) 538 return -ENOMEM; 539 540 for (;;) { 541 err = alauda_get_media_status(al, buf); 542 if (err < 0) 543 goto error; 544 if (*b0 & 0x10) 545 break; 546 msleep(20); 547 } 548 549 err = alauda_ack_media(al); 550 if (err) 551 goto error; 552 553 msleep(10); 554 555 err = alauda_get_media_status(al, buf); 556 if (err < 0) 557 goto error; 558 559 if (*b0 != 0x14) { 560 /* media not ready */ 561 err = -EIO; 562 goto error; 563 } 564 err = alauda_get_media_signatures(al, buf); 565 if (err < 0) 566 goto error; 567 568 card = get_card(*b1); 569 if (!card) { 570 printk(KERN_ERR"Alauda: unknown card id %02x\n", *b1); 571 err = -EIO; 572 goto error; 573 } 574 printk(KERN_INFO"pagesize=%x\nerasesize=%x\nsize=%xMiB\n", 575 1<<card->pageshift, 1<<card->blockshift, 576 1<<(card->chipshift-20)); 577 al->card = card; 578 al->pagemask = (1 << (card->blockshift - card->pageshift)) - 1; 579 al->bytemask = (1 << card->pageshift) - 1; 580 al->blockmask = (1 << card->blockshift) - 1; 581 582 mtd->name = "alauda"; 583 mtd->size = 1<<card->chipshift; 584 mtd->erasesize = 1<<card->blockshift; 585 mtd->writesize = 1<<card->pageshift; 586 mtd->type = MTD_NANDFLASH; 587 mtd->flags = MTD_CAP_NANDFLASH; 588 mtd->_read = alauda_read; 589 mtd->_write = alauda_write; 590 mtd->_erase = alauda_erase; 591 mtd->_block_isbad = alauda_isbad; 592 mtd->priv = al; 593 mtd->owner = THIS_MODULE; 594 mtd->ecc_strength = 1; 595 596 err = mtd_device_register(mtd, NULL, 0); 597 if (err) { 598 err = -ENFILE; 599 goto error; 600 } 601 602 al->mtd = mtd; 603 alauda_reset(al); /* no clue whether this is necessary */ 604 return 0; 605error: 606 kfree(mtd); 607 return err; 608} 609 610static int alauda_check_media(struct alauda *al) 611{ 612 u8 buf[2], *b0 = buf, *b1 = buf+1; 613 int err; 614 615 err = alauda_get_media_status(al, buf); 616 if (err < 0) 617 return err; 618 619 if ((*b1 & 0x01) == 0) { 620 /* door open */ 621 return -EIO; 622 } 623 if ((*b0 & 0x80) || ((*b0 & 0x1F) == 0x10)) { 624 /* no media ? */ 625 return -EIO; 626 } 627 if (*b0 & 0x08) { 628 /* media change ? */ 629 return alauda_init_media(al); 630 } 631 return 0; 632} 633 634static int alauda_probe(struct usb_interface *interface, 635 const struct usb_device_id *id) 636{ 637 struct alauda *al; 638 struct usb_host_interface *iface; 639 struct usb_endpoint_descriptor *ep, 640 *ep_in=NULL, *ep_out=NULL, *ep_wr=NULL; 641 int i, err = -ENOMEM; 642 643 al = kzalloc(2*sizeof(*al), GFP_KERNEL); 644 if (!al) 645 goto error; 646 647 kref_init(&al->kref); 648 usb_set_intfdata(interface, al); 649 650 al->dev = usb_get_dev(interface_to_usbdev(interface)); 651 al->interface = interface; 652 653 iface = interface->cur_altsetting; 654 for (i = 0; i < iface->desc.bNumEndpoints; ++i) { 655 ep = &iface->endpoint[i].desc; 656 657 if (usb_endpoint_is_bulk_in(ep)) { 658 ep_in = ep; 659 } else if (usb_endpoint_is_bulk_out(ep)) { 660 if (i==0) 661 ep_wr = ep; 662 else 663 ep_out = ep; 664 } 665 } 666 err = -EIO; 667 if (!ep_wr || !ep_in || !ep_out) 668 goto error; 669 670 al->write_out = usb_sndbulkpipe(al->dev, 671 usb_endpoint_num(ep_wr)); 672 al->bulk_in = usb_rcvbulkpipe(al->dev, 673 usb_endpoint_num(ep_in)); 674 al->bulk_out = usb_sndbulkpipe(al->dev, 675 usb_endpoint_num(ep_out)); 676 677 /* second device is identical up to now */ 678 memcpy(al+1, al, sizeof(*al)); 679 680 mutex_init(&al[0].card_mutex); 681 mutex_init(&al[1].card_mutex); 682 683 al[0].port = ALAUDA_PORT_XD; 684 al[1].port = ALAUDA_PORT_SM; 685 686 dev_info(&interface->dev, "alauda probed\n"); 687 alauda_check_media(al); 688 alauda_check_media(al+1); 689 690 return 0; 691 692error: 693 if (al) 694 kref_put(&al->kref, alauda_delete); 695 return err; 696} 697 698static void alauda_disconnect(struct usb_interface *interface) 699{ 700 struct alauda *al; 701 702 al = usb_get_intfdata(interface); 703 usb_set_intfdata(interface, NULL); 704 705 /* FIXME: prevent more I/O from starting */ 706 707 /* decrement our usage count */ 708 if (al) 709 kref_put(&al->kref, alauda_delete); 710 711 dev_info(&interface->dev, "alauda gone"); 712} 713 714static struct usb_driver alauda_driver = { 715 .name = "alauda", 716 .probe = alauda_probe, 717 .disconnect = alauda_disconnect, 718 .id_table = alauda_table, 719}; 720 721module_usb_driver(alauda_driver); 722 723MODULE_LICENSE("GPL"); 724