1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver for SanDisk SDDR-55 SmartMedia reader 4 * 5 * SDDR55 driver v0.1: 6 * 7 * First release 8 * 9 * Current development and maintenance by: 10 * (c) 2002 Simon Munton 11 */ 12 13 #include <linux/jiffies.h> 14 #include <linux/errno.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 18 #include <scsi/scsi.h> 19 #include <scsi/scsi_cmnd.h> 20 21 #include "usb.h" 22 #include "transport.h" 23 #include "protocol.h" 24 #include "debug.h" 25 #include "scsiglue.h" 26 27 #define DRV_NAME "ums-sddr55" 28 29 MODULE_DESCRIPTION("Driver for SanDisk SDDR-55 SmartMedia reader"); 30 MODULE_AUTHOR("Simon Munton"); 31 MODULE_LICENSE("GPL"); 32 MODULE_IMPORT_NS(USB_STORAGE); 33 34 /* 35 * The table of devices 36 */ 37 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 38 vendorName, productName, useProtocol, useTransport, \ 39 initFunction, flags) \ 40 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ 41 .driver_info = (flags) } 42 43 static struct usb_device_id sddr55_usb_ids[] = { 44 # include "unusual_sddr55.h" 45 { } /* Terminating entry */ 46 }; 47 MODULE_DEVICE_TABLE(usb, sddr55_usb_ids); 48 49 #undef UNUSUAL_DEV 50 51 /* 52 * The flags table 53 */ 54 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 55 vendor_name, product_name, use_protocol, use_transport, \ 56 init_function, Flags) \ 57 { \ 58 .vendorName = vendor_name, \ 59 .productName = product_name, \ 60 .useProtocol = use_protocol, \ 61 .useTransport = use_transport, \ 62 .initFunction = init_function, \ 63 } 64 65 static struct us_unusual_dev sddr55_unusual_dev_list[] = { 66 # include "unusual_sddr55.h" 67 { } /* Terminating entry */ 68 }; 69 70 #undef UNUSUAL_DEV 71 72 73 #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) ) 74 #define LSB_of(s) ((s)&0xFF) 75 #define MSB_of(s) ((s)>>8) 76 #define PAGESIZE 512 77 78 #define set_sense_info(sk, asc, ascq) \ 79 do { \ 80 info->sense_data[2] = sk; \ 81 info->sense_data[12] = asc; \ 82 info->sense_data[13] = ascq; \ 83 } while (0) 84 85 86 struct sddr55_card_info { 87 unsigned long capacity; /* Size of card in bytes */ 88 int max_log_blks; /* maximum number of logical blocks */ 89 int pageshift; /* log2 of pagesize */ 90 int smallpageshift; /* 1 if pagesize == 256 */ 91 int blocksize; /* Size of block in pages */ 92 int blockshift; /* log2 of blocksize */ 93 int blockmask; /* 2^blockshift - 1 */ 94 int read_only; /* non zero if card is write protected */ 95 int force_read_only; /* non zero if we find a map error*/ 96 int *lba_to_pba; /* logical to physical map */ 97 int *pba_to_lba; /* physical to logical map */ 98 int fatal_error; /* set if we detect something nasty */ 99 unsigned long last_access; /* number of jiffies since we last talked to device */ 100 unsigned char sense_data[18]; 101 }; 102 103 104 #define NOT_ALLOCATED 0xffffffff 105 #define BAD_BLOCK 0xffff 106 #define CIS_BLOCK 0x400 107 #define UNUSED_BLOCK 0x3ff 108 109 static int 110 sddr55_bulk_transport(struct us_data *us, int direction, 111 unsigned char *data, unsigned int len) { 112 struct sddr55_card_info *info = (struct sddr55_card_info *)us->extra; 113 unsigned int pipe = (direction == DMA_FROM_DEVICE) ? 114 us->recv_bulk_pipe : us->send_bulk_pipe; 115 116 if (!len) 117 return USB_STOR_XFER_GOOD; 118 info->last_access = jiffies; 119 return usb_stor_bulk_transfer_buf(us, pipe, data, len, NULL); 120 } 121 122 /* 123 * check if card inserted, if there is, update read_only status 124 * return non zero if no card 125 */ 126 127 static int sddr55_status(struct us_data *us) 128 { 129 int result; 130 unsigned char *command = us->iobuf; 131 unsigned char *status = us->iobuf; 132 struct sddr55_card_info *info = (struct sddr55_card_info *)us->extra; 133 134 /* send command */ 135 memset(command, 0, 8); 136 command[5] = 0xB0; 137 command[7] = 0x80; 138 result = sddr55_bulk_transport(us, 139 DMA_TO_DEVICE, command, 8); 140 141 usb_stor_dbg(us, "Result for send_command in status %d\n", result); 142 143 if (result != USB_STOR_XFER_GOOD) { 144 set_sense_info (4, 0, 0); /* hardware error */ 145 return USB_STOR_TRANSPORT_ERROR; 146 } 147 148 result = sddr55_bulk_transport(us, 149 DMA_FROM_DEVICE, status, 4); 150 151 /* expect to get short transfer if no card fitted */ 152 if (result == USB_STOR_XFER_SHORT || result == USB_STOR_XFER_STALLED) { 153 /* had a short transfer, no card inserted, free map memory */ 154 kfree(info->lba_to_pba); 155 kfree(info->pba_to_lba); 156 info->lba_to_pba = NULL; 157 info->pba_to_lba = NULL; 158 159 info->fatal_error = 0; 160 info->force_read_only = 0; 161 162 set_sense_info (2, 0x3a, 0); /* not ready, medium not present */ 163 return USB_STOR_TRANSPORT_FAILED; 164 } 165 166 if (result != USB_STOR_XFER_GOOD) { 167 set_sense_info (4, 0, 0); /* hardware error */ 168 return USB_STOR_TRANSPORT_FAILED; 169 } 170 171 /* check write protect status */ 172 info->read_only = (status[0] & 0x20); 173 174 /* now read status */ 175 result = sddr55_bulk_transport(us, 176 DMA_FROM_DEVICE, status, 2); 177 178 if (result != USB_STOR_XFER_GOOD) { 179 set_sense_info (4, 0, 0); /* hardware error */ 180 } 181 182 return (result == USB_STOR_XFER_GOOD ? 183 USB_STOR_TRANSPORT_GOOD : USB_STOR_TRANSPORT_FAILED); 184 } 185 186 187 static int sddr55_read_data(struct us_data *us, 188 unsigned int lba, 189 unsigned int page, 190 unsigned short sectors) { 191 192 int result = USB_STOR_TRANSPORT_GOOD; 193 unsigned char *command = us->iobuf; 194 unsigned char *status = us->iobuf; 195 struct sddr55_card_info *info = (struct sddr55_card_info *)us->extra; 196 unsigned char *buffer; 197 198 unsigned int pba; 199 unsigned long address; 200 201 unsigned short pages; 202 unsigned int len, offset; 203 struct scatterlist *sg; 204 205 // Since we only read in one block at a time, we have to create 206 // a bounce buffer and move the data a piece at a time between the 207 // bounce buffer and the actual transfer buffer. 208 209 len = min((unsigned int) sectors, (unsigned int) info->blocksize >> 210 info->smallpageshift) * PAGESIZE; 211 buffer = kmalloc(len, GFP_NOIO); 212 if (buffer == NULL) 213 return USB_STOR_TRANSPORT_ERROR; /* out of memory */ 214 offset = 0; 215 sg = NULL; 216 217 while (sectors>0) { 218 219 /* have we got to end? */ 220 if (lba >= info->max_log_blks) 221 break; 222 223 pba = info->lba_to_pba[lba]; 224 225 // Read as many sectors as possible in this block 226 227 pages = min((unsigned int) sectors << info->smallpageshift, 228 info->blocksize - page); 229 len = pages << info->pageshift; 230 231 usb_stor_dbg(us, "Read %02X pages, from PBA %04X (LBA %04X) page %02X\n", 232 pages, pba, lba, page); 233 234 if (pba == NOT_ALLOCATED) { 235 /* no pba for this lba, fill with zeroes */ 236 memset (buffer, 0, len); 237 } else { 238 239 address = (pba << info->blockshift) + page; 240 241 command[0] = 0; 242 command[1] = LSB_of(address>>16); 243 command[2] = LSB_of(address>>8); 244 command[3] = LSB_of(address); 245 246 command[4] = 0; 247 command[5] = 0xB0; 248 command[6] = LSB_of(pages << (1 - info->smallpageshift)); 249 command[7] = 0x85; 250 251 /* send command */ 252 result = sddr55_bulk_transport(us, 253 DMA_TO_DEVICE, command, 8); 254 255 usb_stor_dbg(us, "Result for send_command in read_data %d\n", 256 result); 257 258 if (result != USB_STOR_XFER_GOOD) { 259 result = USB_STOR_TRANSPORT_ERROR; 260 goto leave; 261 } 262 263 /* read data */ 264 result = sddr55_bulk_transport(us, 265 DMA_FROM_DEVICE, buffer, len); 266 267 if (result != USB_STOR_XFER_GOOD) { 268 result = USB_STOR_TRANSPORT_ERROR; 269 goto leave; 270 } 271 272 /* now read status */ 273 result = sddr55_bulk_transport(us, 274 DMA_FROM_DEVICE, status, 2); 275 276 if (result != USB_STOR_XFER_GOOD) { 277 result = USB_STOR_TRANSPORT_ERROR; 278 goto leave; 279 } 280 281 /* check status for error */ 282 if (status[0] == 0xff && status[1] == 0x4) { 283 set_sense_info (3, 0x11, 0); 284 result = USB_STOR_TRANSPORT_FAILED; 285 goto leave; 286 } 287 } 288 289 // Store the data in the transfer buffer 290 usb_stor_access_xfer_buf(buffer, len, us->srb, 291 &sg, &offset, TO_XFER_BUF); 292 293 page = 0; 294 lba++; 295 sectors -= pages >> info->smallpageshift; 296 } 297 298 result = USB_STOR_TRANSPORT_GOOD; 299 300 leave: 301 kfree(buffer); 302 303 return result; 304 } 305 306 static int sddr55_write_data(struct us_data *us, 307 unsigned int lba, 308 unsigned int page, 309 unsigned short sectors) { 310 311 int result = USB_STOR_TRANSPORT_GOOD; 312 unsigned char *command = us->iobuf; 313 unsigned char *status = us->iobuf; 314 struct sddr55_card_info *info = (struct sddr55_card_info *)us->extra; 315 unsigned char *buffer; 316 317 unsigned int pba; 318 unsigned int new_pba; 319 unsigned long address; 320 321 unsigned short pages; 322 int i; 323 unsigned int len, offset; 324 struct scatterlist *sg; 325 326 /* check if we are allowed to write */ 327 if (info->read_only || info->force_read_only) { 328 set_sense_info (7, 0x27, 0); /* read only */ 329 return USB_STOR_TRANSPORT_FAILED; 330 } 331 332 // Since we only write one block at a time, we have to create 333 // a bounce buffer and move the data a piece at a time between the 334 // bounce buffer and the actual transfer buffer. 335 336 len = min((unsigned int) sectors, (unsigned int) info->blocksize >> 337 info->smallpageshift) * PAGESIZE; 338 buffer = kmalloc(len, GFP_NOIO); 339 if (buffer == NULL) 340 return USB_STOR_TRANSPORT_ERROR; 341 offset = 0; 342 sg = NULL; 343 344 while (sectors > 0) { 345 346 /* have we got to end? */ 347 if (lba >= info->max_log_blks) 348 break; 349 350 pba = info->lba_to_pba[lba]; 351 352 // Write as many sectors as possible in this block 353 354 pages = min((unsigned int) sectors << info->smallpageshift, 355 info->blocksize - page); 356 len = pages << info->pageshift; 357 358 // Get the data from the transfer buffer 359 usb_stor_access_xfer_buf(buffer, len, us->srb, 360 &sg, &offset, FROM_XFER_BUF); 361 362 usb_stor_dbg(us, "Write %02X pages, to PBA %04X (LBA %04X) page %02X\n", 363 pages, pba, lba, page); 364 365 command[4] = 0; 366 367 if (pba == NOT_ALLOCATED) { 368 /* no pba allocated for this lba, find a free pba to use */ 369 370 int max_pba = (info->max_log_blks / 250 ) * 256; 371 int found_count = 0; 372 int found_pba = -1; 373 374 /* set pba to first block in zone lba is in */ 375 pba = (lba / 1000) * 1024; 376 377 usb_stor_dbg(us, "No PBA for LBA %04X\n", lba); 378 379 if (max_pba > 1024) 380 max_pba = 1024; 381 382 /* 383 * Scan through the map looking for an unused block 384 * leave 16 unused blocks at start (or as many as 385 * possible) since the sddr55 seems to reuse a used 386 * block when it shouldn't if we don't leave space. 387 */ 388 for (i = 0; i < max_pba; i++, pba++) { 389 if (info->pba_to_lba[pba] == UNUSED_BLOCK) { 390 found_pba = pba; 391 if (found_count++ > 16) 392 break; 393 } 394 } 395 396 pba = found_pba; 397 398 if (pba == -1) { 399 /* oh dear */ 400 usb_stor_dbg(us, "Couldn't find unallocated block\n"); 401 402 set_sense_info (3, 0x31, 0); /* medium error */ 403 result = USB_STOR_TRANSPORT_FAILED; 404 goto leave; 405 } 406 407 usb_stor_dbg(us, "Allocating PBA %04X for LBA %04X\n", 408 pba, lba); 409 410 /* set writing to unallocated block flag */ 411 command[4] = 0x40; 412 } 413 414 address = (pba << info->blockshift) + page; 415 416 command[1] = LSB_of(address>>16); 417 command[2] = LSB_of(address>>8); 418 command[3] = LSB_of(address); 419 420 /* set the lba into the command, modulo 1000 */ 421 command[0] = LSB_of(lba % 1000); 422 command[6] = MSB_of(lba % 1000); 423 424 command[4] |= LSB_of(pages >> info->smallpageshift); 425 command[5] = 0xB0; 426 command[7] = 0x86; 427 428 /* send command */ 429 result = sddr55_bulk_transport(us, 430 DMA_TO_DEVICE, command, 8); 431 432 if (result != USB_STOR_XFER_GOOD) { 433 usb_stor_dbg(us, "Result for send_command in write_data %d\n", 434 result); 435 436 /* set_sense_info is superfluous here? */ 437 set_sense_info (3, 0x3, 0);/* peripheral write error */ 438 result = USB_STOR_TRANSPORT_FAILED; 439 goto leave; 440 } 441 442 /* send the data */ 443 result = sddr55_bulk_transport(us, 444 DMA_TO_DEVICE, buffer, len); 445 446 if (result != USB_STOR_XFER_GOOD) { 447 usb_stor_dbg(us, "Result for send_data in write_data %d\n", 448 result); 449 450 /* set_sense_info is superfluous here? */ 451 set_sense_info (3, 0x3, 0);/* peripheral write error */ 452 result = USB_STOR_TRANSPORT_FAILED; 453 goto leave; 454 } 455 456 /* now read status */ 457 result = sddr55_bulk_transport(us, DMA_FROM_DEVICE, status, 6); 458 459 if (result != USB_STOR_XFER_GOOD) { 460 usb_stor_dbg(us, "Result for get_status in write_data %d\n", 461 result); 462 463 /* set_sense_info is superfluous here? */ 464 set_sense_info (3, 0x3, 0);/* peripheral write error */ 465 result = USB_STOR_TRANSPORT_FAILED; 466 goto leave; 467 } 468 469 new_pba = (status[3] + (status[4] << 8) + (status[5] << 16)) 470 >> info->blockshift; 471 472 /* check status for error */ 473 if (status[0] == 0xff && status[1] == 0x4) { 474 info->pba_to_lba[new_pba] = BAD_BLOCK; 475 476 set_sense_info (3, 0x0c, 0); 477 result = USB_STOR_TRANSPORT_FAILED; 478 goto leave; 479 } 480 481 usb_stor_dbg(us, "Updating maps for LBA %04X: old PBA %04X, new PBA %04X\n", 482 lba, pba, new_pba); 483 484 /* update the lba<->pba maps, note new_pba might be the same as pba */ 485 info->lba_to_pba[lba] = new_pba; 486 info->pba_to_lba[pba] = UNUSED_BLOCK; 487 488 /* check that new_pba wasn't already being used */ 489 if (info->pba_to_lba[new_pba] != UNUSED_BLOCK) { 490 printk(KERN_ERR "sddr55 error: new PBA %04X already in use for LBA %04X\n", 491 new_pba, info->pba_to_lba[new_pba]); 492 info->fatal_error = 1; 493 set_sense_info (3, 0x31, 0); 494 result = USB_STOR_TRANSPORT_FAILED; 495 goto leave; 496 } 497 498 /* update the pba<->lba maps for new_pba */ 499 info->pba_to_lba[new_pba] = lba % 1000; 500 501 page = 0; 502 lba++; 503 sectors -= pages >> info->smallpageshift; 504 } 505 result = USB_STOR_TRANSPORT_GOOD; 506 507 leave: 508 kfree(buffer); 509 return result; 510 } 511 512 static int sddr55_read_deviceID(struct us_data *us, 513 unsigned char *manufacturerID, 514 unsigned char *deviceID) { 515 516 int result; 517 unsigned char *command = us->iobuf; 518 unsigned char *content = us->iobuf; 519 520 memset(command, 0, 8); 521 command[5] = 0xB0; 522 command[7] = 0x84; 523 result = sddr55_bulk_transport(us, DMA_TO_DEVICE, command, 8); 524 525 usb_stor_dbg(us, "Result of send_control for device ID is %d\n", 526 result); 527 528 if (result != USB_STOR_XFER_GOOD) 529 return USB_STOR_TRANSPORT_ERROR; 530 531 result = sddr55_bulk_transport(us, 532 DMA_FROM_DEVICE, content, 4); 533 534 if (result != USB_STOR_XFER_GOOD) 535 return USB_STOR_TRANSPORT_ERROR; 536 537 *manufacturerID = content[0]; 538 *deviceID = content[1]; 539 540 if (content[0] != 0xff) { 541 result = sddr55_bulk_transport(us, 542 DMA_FROM_DEVICE, content, 2); 543 } 544 545 return USB_STOR_TRANSPORT_GOOD; 546 } 547 548 549 static int sddr55_reset(struct us_data *us) 550 { 551 return 0; 552 } 553 554 555 static unsigned long sddr55_get_capacity(struct us_data *us) { 556 557 unsigned char uninitialized_var(manufacturerID); 558 unsigned char uninitialized_var(deviceID); 559 int result; 560 struct sddr55_card_info *info = (struct sddr55_card_info *)us->extra; 561 562 usb_stor_dbg(us, "Reading capacity...\n"); 563 564 result = sddr55_read_deviceID(us, 565 &manufacturerID, 566 &deviceID); 567 568 usb_stor_dbg(us, "Result of read_deviceID is %d\n", result); 569 570 if (result != USB_STOR_XFER_GOOD) 571 return 0; 572 573 usb_stor_dbg(us, "Device ID = %02X\n", deviceID); 574 usb_stor_dbg(us, "Manuf ID = %02X\n", manufacturerID); 575 576 info->pageshift = 9; 577 info->smallpageshift = 0; 578 info->blocksize = 16; 579 info->blockshift = 4; 580 info->blockmask = 15; 581 582 switch (deviceID) { 583 584 case 0x6e: // 1MB 585 case 0xe8: 586 case 0xec: 587 info->pageshift = 8; 588 info->smallpageshift = 1; 589 return 0x00100000; 590 591 case 0xea: // 2MB 592 case 0x64: 593 info->pageshift = 8; 594 info->smallpageshift = 1; 595 /* fall through */ 596 case 0x5d: // 5d is a ROM card with pagesize 512. 597 return 0x00200000; 598 599 case 0xe3: // 4MB 600 case 0xe5: 601 case 0x6b: 602 case 0xd5: 603 return 0x00400000; 604 605 case 0xe6: // 8MB 606 case 0xd6: 607 return 0x00800000; 608 609 case 0x73: // 16MB 610 info->blocksize = 32; 611 info->blockshift = 5; 612 info->blockmask = 31; 613 return 0x01000000; 614 615 case 0x75: // 32MB 616 info->blocksize = 32; 617 info->blockshift = 5; 618 info->blockmask = 31; 619 return 0x02000000; 620 621 case 0x76: // 64MB 622 info->blocksize = 32; 623 info->blockshift = 5; 624 info->blockmask = 31; 625 return 0x04000000; 626 627 case 0x79: // 128MB 628 info->blocksize = 32; 629 info->blockshift = 5; 630 info->blockmask = 31; 631 return 0x08000000; 632 633 default: // unknown 634 return 0; 635 636 } 637 } 638 639 static int sddr55_read_map(struct us_data *us) { 640 641 struct sddr55_card_info *info = (struct sddr55_card_info *)(us->extra); 642 int numblocks; 643 unsigned char *buffer; 644 unsigned char *command = us->iobuf; 645 int i; 646 unsigned short lba; 647 unsigned short max_lba; 648 int result; 649 650 if (!info->capacity) 651 return -1; 652 653 numblocks = info->capacity >> (info->blockshift + info->pageshift); 654 655 buffer = kmalloc_array(numblocks, 2, GFP_NOIO ); 656 657 if (!buffer) 658 return -1; 659 660 memset(command, 0, 8); 661 command[5] = 0xB0; 662 command[6] = numblocks * 2 / 256; 663 command[7] = 0x8A; 664 665 result = sddr55_bulk_transport(us, DMA_TO_DEVICE, command, 8); 666 667 if ( result != USB_STOR_XFER_GOOD) { 668 kfree (buffer); 669 return -1; 670 } 671 672 result = sddr55_bulk_transport(us, DMA_FROM_DEVICE, buffer, numblocks * 2); 673 674 if ( result != USB_STOR_XFER_GOOD) { 675 kfree (buffer); 676 return -1; 677 } 678 679 result = sddr55_bulk_transport(us, DMA_FROM_DEVICE, command, 2); 680 681 if ( result != USB_STOR_XFER_GOOD) { 682 kfree (buffer); 683 return -1; 684 } 685 686 kfree(info->lba_to_pba); 687 kfree(info->pba_to_lba); 688 info->lba_to_pba = kmalloc_array(numblocks, sizeof(int), GFP_NOIO); 689 info->pba_to_lba = kmalloc_array(numblocks, sizeof(int), GFP_NOIO); 690 691 if (info->lba_to_pba == NULL || info->pba_to_lba == NULL) { 692 kfree(info->lba_to_pba); 693 kfree(info->pba_to_lba); 694 info->lba_to_pba = NULL; 695 info->pba_to_lba = NULL; 696 kfree(buffer); 697 return -1; 698 } 699 700 memset(info->lba_to_pba, 0xff, numblocks*sizeof(int)); 701 memset(info->pba_to_lba, 0xff, numblocks*sizeof(int)); 702 703 /* set maximum lba */ 704 max_lba = info->max_log_blks; 705 if (max_lba > 1000) 706 max_lba = 1000; 707 708 /* 709 * Each block is 64 bytes of control data, so block i is located in 710 * scatterlist block i*64/128k = i*(2^6)*(2^-17) = i*(2^-11) 711 */ 712 713 for (i=0; i<numblocks; i++) { 714 int zone = i / 1024; 715 716 lba = short_pack(buffer[i * 2], buffer[i * 2 + 1]); 717 718 /* 719 * Every 1024 physical blocks ("zone"), the LBA numbers 720 * go back to zero, but are within a higher 721 * block of LBA's. Also, there is a maximum of 722 * 1000 LBA's per zone. In other words, in PBA 723 * 1024-2047 you will find LBA 0-999 which are 724 * really LBA 1000-1999. Yes, this wastes 24 725 * physical blocks per zone. Go figure. 726 * These devices can have blocks go bad, so there 727 * are 24 spare blocks to use when blocks do go bad. 728 */ 729 730 /* 731 * SDDR55 returns 0xffff for a bad block, and 0x400 for the 732 * CIS block. (Is this true for cards 8MB or less??) 733 * Record these in the physical to logical map 734 */ 735 736 info->pba_to_lba[i] = lba; 737 738 if (lba >= max_lba) { 739 continue; 740 } 741 742 if (info->lba_to_pba[lba + zone * 1000] != NOT_ALLOCATED && 743 !info->force_read_only) { 744 printk(KERN_WARNING 745 "sddr55: map inconsistency at LBA %04X\n", 746 lba + zone * 1000); 747 info->force_read_only = 1; 748 } 749 750 if (lba<0x10 || (lba>=0x3E0 && lba<0x3EF)) 751 usb_stor_dbg(us, "LBA %04X <-> PBA %04X\n", lba, i); 752 753 info->lba_to_pba[lba + zone * 1000] = i; 754 } 755 756 kfree(buffer); 757 return 0; 758 } 759 760 761 static void sddr55_card_info_destructor(void *extra) { 762 struct sddr55_card_info *info = (struct sddr55_card_info *)extra; 763 764 if (!extra) 765 return; 766 767 kfree(info->lba_to_pba); 768 kfree(info->pba_to_lba); 769 } 770 771 772 /* 773 * Transport for the Sandisk SDDR-55 774 */ 775 static int sddr55_transport(struct scsi_cmnd *srb, struct us_data *us) 776 { 777 int result; 778 static unsigned char inquiry_response[8] = { 779 0x00, 0x80, 0x00, 0x02, 0x1F, 0x00, 0x00, 0x00 780 }; 781 // write-protected for now, no block descriptor support 782 static unsigned char mode_page_01[20] = { 783 0x0, 0x12, 0x00, 0x80, 0x0, 0x0, 0x0, 0x0, 784 0x01, 0x0A, 785 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 786 }; 787 unsigned char *ptr = us->iobuf; 788 unsigned long capacity; 789 unsigned int lba; 790 unsigned int pba; 791 unsigned int page; 792 unsigned short pages; 793 struct sddr55_card_info *info; 794 795 if (!us->extra) { 796 us->extra = kzalloc( 797 sizeof(struct sddr55_card_info), GFP_NOIO); 798 if (!us->extra) 799 return USB_STOR_TRANSPORT_ERROR; 800 us->extra_destructor = sddr55_card_info_destructor; 801 } 802 803 info = (struct sddr55_card_info *)(us->extra); 804 805 if (srb->cmnd[0] == REQUEST_SENSE) { 806 usb_stor_dbg(us, "request sense %02x/%02x/%02x\n", 807 info->sense_data[2], 808 info->sense_data[12], 809 info->sense_data[13]); 810 811 memcpy (ptr, info->sense_data, sizeof info->sense_data); 812 ptr[0] = 0x70; 813 ptr[7] = 11; 814 usb_stor_set_xfer_buf (ptr, sizeof info->sense_data, srb); 815 memset (info->sense_data, 0, sizeof info->sense_data); 816 817 return USB_STOR_TRANSPORT_GOOD; 818 } 819 820 memset (info->sense_data, 0, sizeof info->sense_data); 821 822 /* 823 * Dummy up a response for INQUIRY since SDDR55 doesn't 824 * respond to INQUIRY commands 825 */ 826 827 if (srb->cmnd[0] == INQUIRY) { 828 memcpy(ptr, inquiry_response, 8); 829 fill_inquiry_response(us, ptr, 36); 830 return USB_STOR_TRANSPORT_GOOD; 831 } 832 833 /* 834 * only check card status if the map isn't allocated, ie no card seen yet 835 * or if it's been over half a second since we last accessed it 836 */ 837 if (info->lba_to_pba == NULL || time_after(jiffies, info->last_access + HZ/2)) { 838 839 /* check to see if a card is fitted */ 840 result = sddr55_status (us); 841 if (result) { 842 result = sddr55_status (us); 843 if (!result) { 844 set_sense_info (6, 0x28, 0); /* new media, set unit attention, not ready to ready */ 845 } 846 return USB_STOR_TRANSPORT_FAILED; 847 } 848 } 849 850 /* 851 * if we detected a problem with the map when writing, 852 * don't allow any more access 853 */ 854 if (info->fatal_error) { 855 856 set_sense_info (3, 0x31, 0); 857 return USB_STOR_TRANSPORT_FAILED; 858 } 859 860 if (srb->cmnd[0] == READ_CAPACITY) { 861 862 capacity = sddr55_get_capacity(us); 863 864 if (!capacity) { 865 set_sense_info (3, 0x30, 0); /* incompatible medium */ 866 return USB_STOR_TRANSPORT_FAILED; 867 } 868 869 info->capacity = capacity; 870 871 /* 872 * figure out the maximum logical block number, allowing for 873 * the fact that only 250 out of every 256 are used 874 */ 875 info->max_log_blks = ((info->capacity >> (info->pageshift + info->blockshift)) / 256) * 250; 876 877 /* 878 * Last page in the card, adjust as we only use 250 out of 879 * every 256 pages 880 */ 881 capacity = (capacity / 256) * 250; 882 883 capacity /= PAGESIZE; 884 capacity--; 885 886 ((__be32 *) ptr)[0] = cpu_to_be32(capacity); 887 ((__be32 *) ptr)[1] = cpu_to_be32(PAGESIZE); 888 usb_stor_set_xfer_buf(ptr, 8, srb); 889 890 sddr55_read_map(us); 891 892 return USB_STOR_TRANSPORT_GOOD; 893 } 894 895 if (srb->cmnd[0] == MODE_SENSE_10) { 896 897 memcpy(ptr, mode_page_01, sizeof mode_page_01); 898 ptr[3] = (info->read_only || info->force_read_only) ? 0x80 : 0; 899 usb_stor_set_xfer_buf(ptr, sizeof(mode_page_01), srb); 900 901 if ( (srb->cmnd[2] & 0x3F) == 0x01 ) { 902 usb_stor_dbg(us, "Dummy up request for mode page 1\n"); 903 return USB_STOR_TRANSPORT_GOOD; 904 905 } else if ( (srb->cmnd[2] & 0x3F) == 0x3F ) { 906 usb_stor_dbg(us, "Dummy up request for all mode pages\n"); 907 return USB_STOR_TRANSPORT_GOOD; 908 } 909 910 set_sense_info (5, 0x24, 0); /* invalid field in command */ 911 return USB_STOR_TRANSPORT_FAILED; 912 } 913 914 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { 915 916 usb_stor_dbg(us, "%s medium removal. Not that I can do anything about it...\n", 917 (srb->cmnd[4]&0x03) ? "Prevent" : "Allow"); 918 919 return USB_STOR_TRANSPORT_GOOD; 920 921 } 922 923 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10) { 924 925 page = short_pack(srb->cmnd[3], srb->cmnd[2]); 926 page <<= 16; 927 page |= short_pack(srb->cmnd[5], srb->cmnd[4]); 928 pages = short_pack(srb->cmnd[8], srb->cmnd[7]); 929 930 page <<= info->smallpageshift; 931 932 // convert page to block and page-within-block 933 934 lba = page >> info->blockshift; 935 page = page & info->blockmask; 936 937 // locate physical block corresponding to logical block 938 939 if (lba >= info->max_log_blks) { 940 941 usb_stor_dbg(us, "Error: Requested LBA %04X exceeds maximum block %04X\n", 942 lba, info->max_log_blks - 1); 943 944 set_sense_info (5, 0x24, 0); /* invalid field in command */ 945 946 return USB_STOR_TRANSPORT_FAILED; 947 } 948 949 pba = info->lba_to_pba[lba]; 950 951 if (srb->cmnd[0] == WRITE_10) { 952 usb_stor_dbg(us, "WRITE_10: write block %04X (LBA %04X) page %01X pages %d\n", 953 pba, lba, page, pages); 954 955 return sddr55_write_data(us, lba, page, pages); 956 } else { 957 usb_stor_dbg(us, "READ_10: read block %04X (LBA %04X) page %01X pages %d\n", 958 pba, lba, page, pages); 959 960 return sddr55_read_data(us, lba, page, pages); 961 } 962 } 963 964 965 if (srb->cmnd[0] == TEST_UNIT_READY) { 966 return USB_STOR_TRANSPORT_GOOD; 967 } 968 969 if (srb->cmnd[0] == START_STOP) { 970 return USB_STOR_TRANSPORT_GOOD; 971 } 972 973 set_sense_info (5, 0x20, 0); /* illegal command */ 974 975 return USB_STOR_TRANSPORT_FAILED; // FIXME: sense buffer? 976 } 977 978 static struct scsi_host_template sddr55_host_template; 979 980 static int sddr55_probe(struct usb_interface *intf, 981 const struct usb_device_id *id) 982 { 983 struct us_data *us; 984 int result; 985 986 result = usb_stor_probe1(&us, intf, id, 987 (id - sddr55_usb_ids) + sddr55_unusual_dev_list, 988 &sddr55_host_template); 989 if (result) 990 return result; 991 992 us->transport_name = "SDDR55"; 993 us->transport = sddr55_transport; 994 us->transport_reset = sddr55_reset; 995 us->max_lun = 0; 996 997 result = usb_stor_probe2(us); 998 return result; 999 } 1000 1001 static struct usb_driver sddr55_driver = { 1002 .name = DRV_NAME, 1003 .probe = sddr55_probe, 1004 .disconnect = usb_stor_disconnect, 1005 .suspend = usb_stor_suspend, 1006 .resume = usb_stor_resume, 1007 .reset_resume = usb_stor_reset_resume, 1008 .pre_reset = usb_stor_pre_reset, 1009 .post_reset = usb_stor_post_reset, 1010 .id_table = sddr55_usb_ids, 1011 .soft_unbind = 1, 1012 .no_dynamic_id = 1, 1013 }; 1014 1015 module_usb_stor_driver(sddr55_driver, sddr55_host_template, DRV_NAME); 1016