1 /* 2 * Driver for Alauda-based card readers 3 * 4 * Current development and maintenance by: 5 * (c) 2005 Daniel Drake <dsd@gentoo.org> 6 * 7 * The 'Alauda' is a chip manufacturered by RATOC for OEM use. 8 * 9 * Alauda implements a vendor-specific command set to access two media reader 10 * ports (XD, SmartMedia). This driver converts SCSI commands to the commands 11 * which are accepted by these devices. 12 * 13 * The driver was developed through reverse-engineering, with the help of the 14 * sddr09 driver which has many similarities, and with some help from the 15 * (very old) vendor-supplied GPL sma03 driver. 16 * 17 * For protocol info, see http://alauda.sourceforge.net 18 * 19 * This program is free software; you can redistribute it and/or modify it 20 * under the terms of the GNU General Public License as published by the 21 * Free Software Foundation; either version 2, or (at your option) any 22 * later version. 23 * 24 * This program is distributed in the hope that it will be useful, but 25 * WITHOUT ANY WARRANTY; without even the implied warranty of 26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 27 * General Public License for more details. 28 * 29 * You should have received a copy of the GNU General Public License along 30 * with this program; if not, write to the Free Software Foundation, Inc., 31 * 675 Mass Ave, Cambridge, MA 02139, USA. 32 */ 33 34 #include <linux/module.h> 35 #include <linux/slab.h> 36 37 #include <scsi/scsi.h> 38 #include <scsi/scsi_cmnd.h> 39 #include <scsi/scsi_device.h> 40 41 #include "usb.h" 42 #include "transport.h" 43 #include "protocol.h" 44 #include "debug.h" 45 #include "scsiglue.h" 46 47 #define DRV_NAME "ums-alauda" 48 49 MODULE_DESCRIPTION("Driver for Alauda-based card readers"); 50 MODULE_AUTHOR("Daniel Drake <dsd@gentoo.org>"); 51 MODULE_LICENSE("GPL"); 52 53 /* 54 * Status bytes 55 */ 56 #define ALAUDA_STATUS_ERROR 0x01 57 #define ALAUDA_STATUS_READY 0x40 58 59 /* 60 * Control opcodes (for request field) 61 */ 62 #define ALAUDA_GET_XD_MEDIA_STATUS 0x08 63 #define ALAUDA_GET_SM_MEDIA_STATUS 0x98 64 #define ALAUDA_ACK_XD_MEDIA_CHANGE 0x0a 65 #define ALAUDA_ACK_SM_MEDIA_CHANGE 0x9a 66 #define ALAUDA_GET_XD_MEDIA_SIG 0x86 67 #define ALAUDA_GET_SM_MEDIA_SIG 0x96 68 69 /* 70 * Bulk command identity (byte 0) 71 */ 72 #define ALAUDA_BULK_CMD 0x40 73 74 /* 75 * Bulk opcodes (byte 1) 76 */ 77 #define ALAUDA_BULK_GET_REDU_DATA 0x85 78 #define ALAUDA_BULK_READ_BLOCK 0x94 79 #define ALAUDA_BULK_ERASE_BLOCK 0xa3 80 #define ALAUDA_BULK_WRITE_BLOCK 0xb4 81 #define ALAUDA_BULK_GET_STATUS2 0xb7 82 #define ALAUDA_BULK_RESET_MEDIA 0xe0 83 84 /* 85 * Port to operate on (byte 8) 86 */ 87 #define ALAUDA_PORT_XD 0x00 88 #define ALAUDA_PORT_SM 0x01 89 90 /* 91 * LBA and PBA are unsigned ints. Special values. 92 */ 93 #define UNDEF 0xffff 94 #define SPARE 0xfffe 95 #define UNUSABLE 0xfffd 96 97 struct alauda_media_info { 98 unsigned long capacity; /* total media size in bytes */ 99 unsigned int pagesize; /* page size in bytes */ 100 unsigned int blocksize; /* number of pages per block */ 101 unsigned int uzonesize; /* number of usable blocks per zone */ 102 unsigned int zonesize; /* number of blocks per zone */ 103 unsigned int blockmask; /* mask to get page from address */ 104 105 unsigned char pageshift; 106 unsigned char blockshift; 107 unsigned char zoneshift; 108 109 u16 **lba_to_pba; /* logical to physical block map */ 110 u16 **pba_to_lba; /* physical to logical block map */ 111 }; 112 113 struct alauda_info { 114 struct alauda_media_info port[2]; 115 int wr_ep; /* endpoint to write data out of */ 116 117 unsigned char sense_key; 118 unsigned long sense_asc; /* additional sense code */ 119 unsigned long sense_ascq; /* additional sense code qualifier */ 120 }; 121 122 #define short_pack(lsb,msb) ( ((u16)(lsb)) | ( ((u16)(msb))<<8 ) ) 123 #define LSB_of(s) ((s)&0xFF) 124 #define MSB_of(s) ((s)>>8) 125 126 #define MEDIA_PORT(us) us->srb->device->lun 127 #define MEDIA_INFO(us) ((struct alauda_info *)us->extra)->port[MEDIA_PORT(us)] 128 129 #define PBA_LO(pba) ((pba & 0xF) << 5) 130 #define PBA_HI(pba) (pba >> 3) 131 #define PBA_ZONE(pba) (pba >> 11) 132 133 static int init_alauda(struct us_data *us); 134 135 136 /* 137 * The table of devices 138 */ 139 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 140 vendorName, productName, useProtocol, useTransport, \ 141 initFunction, flags) \ 142 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ 143 .driver_info = (flags) } 144 145 static struct usb_device_id alauda_usb_ids[] = { 146 # include "unusual_alauda.h" 147 { } /* Terminating entry */ 148 }; 149 MODULE_DEVICE_TABLE(usb, alauda_usb_ids); 150 151 #undef UNUSUAL_DEV 152 153 /* 154 * The flags table 155 */ 156 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 157 vendor_name, product_name, use_protocol, use_transport, \ 158 init_function, Flags) \ 159 { \ 160 .vendorName = vendor_name, \ 161 .productName = product_name, \ 162 .useProtocol = use_protocol, \ 163 .useTransport = use_transport, \ 164 .initFunction = init_function, \ 165 } 166 167 static struct us_unusual_dev alauda_unusual_dev_list[] = { 168 # include "unusual_alauda.h" 169 { } /* Terminating entry */ 170 }; 171 172 #undef UNUSUAL_DEV 173 174 175 /* 176 * Media handling 177 */ 178 179 struct alauda_card_info { 180 unsigned char id; /* id byte */ 181 unsigned char chipshift; /* 1<<cs bytes total capacity */ 182 unsigned char pageshift; /* 1<<ps bytes in a page */ 183 unsigned char blockshift; /* 1<<bs pages per block */ 184 unsigned char zoneshift; /* 1<<zs blocks per zone */ 185 }; 186 187 static struct alauda_card_info alauda_card_ids[] = { 188 /* NAND flash */ 189 { 0x6e, 20, 8, 4, 8}, /* 1 MB */ 190 { 0xe8, 20, 8, 4, 8}, /* 1 MB */ 191 { 0xec, 20, 8, 4, 8}, /* 1 MB */ 192 { 0x64, 21, 8, 4, 9}, /* 2 MB */ 193 { 0xea, 21, 8, 4, 9}, /* 2 MB */ 194 { 0x6b, 22, 9, 4, 9}, /* 4 MB */ 195 { 0xe3, 22, 9, 4, 9}, /* 4 MB */ 196 { 0xe5, 22, 9, 4, 9}, /* 4 MB */ 197 { 0xe6, 23, 9, 4, 10}, /* 8 MB */ 198 { 0x73, 24, 9, 5, 10}, /* 16 MB */ 199 { 0x75, 25, 9, 5, 10}, /* 32 MB */ 200 { 0x76, 26, 9, 5, 10}, /* 64 MB */ 201 { 0x79, 27, 9, 5, 10}, /* 128 MB */ 202 { 0x71, 28, 9, 5, 10}, /* 256 MB */ 203 204 /* MASK ROM */ 205 { 0x5d, 21, 9, 4, 8}, /* 2 MB */ 206 { 0xd5, 22, 9, 4, 9}, /* 4 MB */ 207 { 0xd6, 23, 9, 4, 10}, /* 8 MB */ 208 { 0x57, 24, 9, 4, 11}, /* 16 MB */ 209 { 0x58, 25, 9, 4, 12}, /* 32 MB */ 210 { 0,} 211 }; 212 213 static struct alauda_card_info *alauda_card_find_id(unsigned char id) 214 { 215 int i; 216 217 for (i = 0; alauda_card_ids[i].id != 0; i++) 218 if (alauda_card_ids[i].id == id) 219 return &(alauda_card_ids[i]); 220 return NULL; 221 } 222 223 /* 224 * ECC computation. 225 */ 226 227 static unsigned char parity[256]; 228 static unsigned char ecc2[256]; 229 230 static void nand_init_ecc(void) 231 { 232 int i, j, a; 233 234 parity[0] = 0; 235 for (i = 1; i < 256; i++) 236 parity[i] = (parity[i&(i-1)] ^ 1); 237 238 for (i = 0; i < 256; i++) { 239 a = 0; 240 for (j = 0; j < 8; j++) { 241 if (i & (1<<j)) { 242 if ((j & 1) == 0) 243 a ^= 0x04; 244 if ((j & 2) == 0) 245 a ^= 0x10; 246 if ((j & 4) == 0) 247 a ^= 0x40; 248 } 249 } 250 ecc2[i] = ~(a ^ (a<<1) ^ (parity[i] ? 0xa8 : 0)); 251 } 252 } 253 254 /* compute 3-byte ecc on 256 bytes */ 255 static void nand_compute_ecc(unsigned char *data, unsigned char *ecc) 256 { 257 int i, j, a; 258 unsigned char par = 0, bit, bits[8] = {0}; 259 260 /* collect 16 checksum bits */ 261 for (i = 0; i < 256; i++) { 262 par ^= data[i]; 263 bit = parity[data[i]]; 264 for (j = 0; j < 8; j++) 265 if ((i & (1<<j)) == 0) 266 bits[j] ^= bit; 267 } 268 269 /* put 4+4+4 = 12 bits in the ecc */ 270 a = (bits[3] << 6) + (bits[2] << 4) + (bits[1] << 2) + bits[0]; 271 ecc[0] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0)); 272 273 a = (bits[7] << 6) + (bits[6] << 4) + (bits[5] << 2) + bits[4]; 274 ecc[1] = ~(a ^ (a<<1) ^ (parity[par] ? 0xaa : 0)); 275 276 ecc[2] = ecc2[par]; 277 } 278 279 static int nand_compare_ecc(unsigned char *data, unsigned char *ecc) 280 { 281 return (data[0] == ecc[0] && data[1] == ecc[1] && data[2] == ecc[2]); 282 } 283 284 static void nand_store_ecc(unsigned char *data, unsigned char *ecc) 285 { 286 memcpy(data, ecc, 3); 287 } 288 289 /* 290 * Alauda driver 291 */ 292 293 /* 294 * Forget our PBA <---> LBA mappings for a particular port 295 */ 296 static void alauda_free_maps (struct alauda_media_info *media_info) 297 { 298 unsigned int shift = media_info->zoneshift 299 + media_info->blockshift + media_info->pageshift; 300 unsigned int num_zones = media_info->capacity >> shift; 301 unsigned int i; 302 303 if (media_info->lba_to_pba != NULL) 304 for (i = 0; i < num_zones; i++) { 305 kfree(media_info->lba_to_pba[i]); 306 media_info->lba_to_pba[i] = NULL; 307 } 308 309 if (media_info->pba_to_lba != NULL) 310 for (i = 0; i < num_zones; i++) { 311 kfree(media_info->pba_to_lba[i]); 312 media_info->pba_to_lba[i] = NULL; 313 } 314 } 315 316 /* 317 * Returns 2 bytes of status data 318 * The first byte describes media status, and second byte describes door status 319 */ 320 static int alauda_get_media_status(struct us_data *us, unsigned char *data) 321 { 322 int rc; 323 unsigned char command; 324 325 if (MEDIA_PORT(us) == ALAUDA_PORT_XD) 326 command = ALAUDA_GET_XD_MEDIA_STATUS; 327 else 328 command = ALAUDA_GET_SM_MEDIA_STATUS; 329 330 rc = usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe, 331 command, 0xc0, 0, 1, data, 2); 332 333 usb_stor_dbg(us, "Media status %02X %02X\n", data[0], data[1]); 334 335 return rc; 336 } 337 338 /* 339 * Clears the "media was changed" bit so that we know when it changes again 340 * in the future. 341 */ 342 static int alauda_ack_media(struct us_data *us) 343 { 344 unsigned char command; 345 346 if (MEDIA_PORT(us) == ALAUDA_PORT_XD) 347 command = ALAUDA_ACK_XD_MEDIA_CHANGE; 348 else 349 command = ALAUDA_ACK_SM_MEDIA_CHANGE; 350 351 return usb_stor_ctrl_transfer(us, us->send_ctrl_pipe, 352 command, 0x40, 0, 1, NULL, 0); 353 } 354 355 /* 356 * Retrieves a 4-byte media signature, which indicates manufacturer, capacity, 357 * and some other details. 358 */ 359 static int alauda_get_media_signature(struct us_data *us, unsigned char *data) 360 { 361 unsigned char command; 362 363 if (MEDIA_PORT(us) == ALAUDA_PORT_XD) 364 command = ALAUDA_GET_XD_MEDIA_SIG; 365 else 366 command = ALAUDA_GET_SM_MEDIA_SIG; 367 368 return usb_stor_ctrl_transfer(us, us->recv_ctrl_pipe, 369 command, 0xc0, 0, 0, data, 4); 370 } 371 372 /* 373 * Resets the media status (but not the whole device?) 374 */ 375 static int alauda_reset_media(struct us_data *us) 376 { 377 unsigned char *command = us->iobuf; 378 379 memset(command, 0, 9); 380 command[0] = ALAUDA_BULK_CMD; 381 command[1] = ALAUDA_BULK_RESET_MEDIA; 382 command[8] = MEDIA_PORT(us); 383 384 return usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 385 command, 9, NULL); 386 } 387 388 /* 389 * Examines the media and deduces capacity, etc. 390 */ 391 static int alauda_init_media(struct us_data *us) 392 { 393 unsigned char *data = us->iobuf; 394 int ready = 0; 395 struct alauda_card_info *media_info; 396 unsigned int num_zones; 397 398 while (ready == 0) { 399 msleep(20); 400 401 if (alauda_get_media_status(us, data) != USB_STOR_XFER_GOOD) 402 return USB_STOR_TRANSPORT_ERROR; 403 404 if (data[0] & 0x10) 405 ready = 1; 406 } 407 408 usb_stor_dbg(us, "We are ready for action!\n"); 409 410 if (alauda_ack_media(us) != USB_STOR_XFER_GOOD) 411 return USB_STOR_TRANSPORT_ERROR; 412 413 msleep(10); 414 415 if (alauda_get_media_status(us, data) != USB_STOR_XFER_GOOD) 416 return USB_STOR_TRANSPORT_ERROR; 417 418 if (data[0] != 0x14) { 419 usb_stor_dbg(us, "Media not ready after ack\n"); 420 return USB_STOR_TRANSPORT_ERROR; 421 } 422 423 if (alauda_get_media_signature(us, data) != USB_STOR_XFER_GOOD) 424 return USB_STOR_TRANSPORT_ERROR; 425 426 usb_stor_dbg(us, "Media signature: %4ph\n", data); 427 media_info = alauda_card_find_id(data[1]); 428 if (media_info == NULL) { 429 pr_warn("alauda_init_media: Unrecognised media signature: %4ph\n", 430 data); 431 return USB_STOR_TRANSPORT_ERROR; 432 } 433 434 MEDIA_INFO(us).capacity = 1 << media_info->chipshift; 435 usb_stor_dbg(us, "Found media with capacity: %ldMB\n", 436 MEDIA_INFO(us).capacity >> 20); 437 438 MEDIA_INFO(us).pageshift = media_info->pageshift; 439 MEDIA_INFO(us).blockshift = media_info->blockshift; 440 MEDIA_INFO(us).zoneshift = media_info->zoneshift; 441 442 MEDIA_INFO(us).pagesize = 1 << media_info->pageshift; 443 MEDIA_INFO(us).blocksize = 1 << media_info->blockshift; 444 MEDIA_INFO(us).zonesize = 1 << media_info->zoneshift; 445 446 MEDIA_INFO(us).uzonesize = ((1 << media_info->zoneshift) / 128) * 125; 447 MEDIA_INFO(us).blockmask = MEDIA_INFO(us).blocksize - 1; 448 449 num_zones = MEDIA_INFO(us).capacity >> (MEDIA_INFO(us).zoneshift 450 + MEDIA_INFO(us).blockshift + MEDIA_INFO(us).pageshift); 451 MEDIA_INFO(us).pba_to_lba = kcalloc(num_zones, sizeof(u16*), GFP_NOIO); 452 MEDIA_INFO(us).lba_to_pba = kcalloc(num_zones, sizeof(u16*), GFP_NOIO); 453 454 if (alauda_reset_media(us) != USB_STOR_XFER_GOOD) 455 return USB_STOR_TRANSPORT_ERROR; 456 457 return USB_STOR_TRANSPORT_GOOD; 458 } 459 460 /* 461 * Examines the media status and does the right thing when the media has gone, 462 * appeared, or changed. 463 */ 464 static int alauda_check_media(struct us_data *us) 465 { 466 struct alauda_info *info = (struct alauda_info *) us->extra; 467 unsigned char status[2]; 468 int rc; 469 470 rc = alauda_get_media_status(us, status); 471 472 /* Check for no media or door open */ 473 if ((status[0] & 0x80) || ((status[0] & 0x1F) == 0x10) 474 || ((status[1] & 0x01) == 0)) { 475 usb_stor_dbg(us, "No media, or door open\n"); 476 alauda_free_maps(&MEDIA_INFO(us)); 477 info->sense_key = 0x02; 478 info->sense_asc = 0x3A; 479 info->sense_ascq = 0x00; 480 return USB_STOR_TRANSPORT_FAILED; 481 } 482 483 /* Check for media change */ 484 if (status[0] & 0x08) { 485 usb_stor_dbg(us, "Media change detected\n"); 486 alauda_free_maps(&MEDIA_INFO(us)); 487 alauda_init_media(us); 488 489 info->sense_key = UNIT_ATTENTION; 490 info->sense_asc = 0x28; 491 info->sense_ascq = 0x00; 492 return USB_STOR_TRANSPORT_FAILED; 493 } 494 495 return USB_STOR_TRANSPORT_GOOD; 496 } 497 498 /* 499 * Checks the status from the 2nd status register 500 * Returns 3 bytes of status data, only the first is known 501 */ 502 static int alauda_check_status2(struct us_data *us) 503 { 504 int rc; 505 unsigned char command[] = { 506 ALAUDA_BULK_CMD, ALAUDA_BULK_GET_STATUS2, 507 0, 0, 0, 0, 3, 0, MEDIA_PORT(us) 508 }; 509 unsigned char data[3]; 510 511 rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 512 command, 9, NULL); 513 if (rc != USB_STOR_XFER_GOOD) 514 return rc; 515 516 rc = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 517 data, 3, NULL); 518 if (rc != USB_STOR_XFER_GOOD) 519 return rc; 520 521 usb_stor_dbg(us, "%3ph\n", data); 522 if (data[0] & ALAUDA_STATUS_ERROR) 523 return USB_STOR_XFER_ERROR; 524 525 return USB_STOR_XFER_GOOD; 526 } 527 528 /* 529 * Gets the redundancy data for the first page of a PBA 530 * Returns 16 bytes. 531 */ 532 static int alauda_get_redu_data(struct us_data *us, u16 pba, unsigned char *data) 533 { 534 int rc; 535 unsigned char command[] = { 536 ALAUDA_BULK_CMD, ALAUDA_BULK_GET_REDU_DATA, 537 PBA_HI(pba), PBA_ZONE(pba), 0, PBA_LO(pba), 0, 0, MEDIA_PORT(us) 538 }; 539 540 rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 541 command, 9, NULL); 542 if (rc != USB_STOR_XFER_GOOD) 543 return rc; 544 545 return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 546 data, 16, NULL); 547 } 548 549 /* 550 * Finds the first unused PBA in a zone 551 * Returns the absolute PBA of an unused PBA, or 0 if none found. 552 */ 553 static u16 alauda_find_unused_pba(struct alauda_media_info *info, 554 unsigned int zone) 555 { 556 u16 *pba_to_lba = info->pba_to_lba[zone]; 557 unsigned int i; 558 559 for (i = 0; i < info->zonesize; i++) 560 if (pba_to_lba[i] == UNDEF) 561 return (zone << info->zoneshift) + i; 562 563 return 0; 564 } 565 566 /* 567 * Reads the redundancy data for all PBA's in a zone 568 * Produces lba <--> pba mappings 569 */ 570 static int alauda_read_map(struct us_data *us, unsigned int zone) 571 { 572 unsigned char *data = us->iobuf; 573 int result; 574 int i, j; 575 unsigned int zonesize = MEDIA_INFO(us).zonesize; 576 unsigned int uzonesize = MEDIA_INFO(us).uzonesize; 577 unsigned int lba_offset, lba_real, blocknum; 578 unsigned int zone_base_lba = zone * uzonesize; 579 unsigned int zone_base_pba = zone * zonesize; 580 u16 *lba_to_pba = kcalloc(zonesize, sizeof(u16), GFP_NOIO); 581 u16 *pba_to_lba = kcalloc(zonesize, sizeof(u16), GFP_NOIO); 582 if (lba_to_pba == NULL || pba_to_lba == NULL) { 583 result = USB_STOR_TRANSPORT_ERROR; 584 goto error; 585 } 586 587 usb_stor_dbg(us, "Mapping blocks for zone %d\n", zone); 588 589 /* 1024 PBA's per zone */ 590 for (i = 0; i < zonesize; i++) 591 lba_to_pba[i] = pba_to_lba[i] = UNDEF; 592 593 for (i = 0; i < zonesize; i++) { 594 blocknum = zone_base_pba + i; 595 596 result = alauda_get_redu_data(us, blocknum, data); 597 if (result != USB_STOR_XFER_GOOD) { 598 result = USB_STOR_TRANSPORT_ERROR; 599 goto error; 600 } 601 602 /* special PBAs have control field 0^16 */ 603 for (j = 0; j < 16; j++) 604 if (data[j] != 0) 605 goto nonz; 606 pba_to_lba[i] = UNUSABLE; 607 usb_stor_dbg(us, "PBA %d has no logical mapping\n", blocknum); 608 continue; 609 610 nonz: 611 /* unwritten PBAs have control field FF^16 */ 612 for (j = 0; j < 16; j++) 613 if (data[j] != 0xff) 614 goto nonff; 615 continue; 616 617 nonff: 618 /* normal PBAs start with six FFs */ 619 if (j < 6) { 620 usb_stor_dbg(us, "PBA %d has no logical mapping: reserved area = %02X%02X%02X%02X data status %02X block status %02X\n", 621 blocknum, 622 data[0], data[1], data[2], data[3], 623 data[4], data[5]); 624 pba_to_lba[i] = UNUSABLE; 625 continue; 626 } 627 628 if ((data[6] >> 4) != 0x01) { 629 usb_stor_dbg(us, "PBA %d has invalid address field %02X%02X/%02X%02X\n", 630 blocknum, data[6], data[7], 631 data[11], data[12]); 632 pba_to_lba[i] = UNUSABLE; 633 continue; 634 } 635 636 /* check even parity */ 637 if (parity[data[6] ^ data[7]]) { 638 printk(KERN_WARNING 639 "alauda_read_map: Bad parity in LBA for block %d" 640 " (%02X %02X)\n", i, data[6], data[7]); 641 pba_to_lba[i] = UNUSABLE; 642 continue; 643 } 644 645 lba_offset = short_pack(data[7], data[6]); 646 lba_offset = (lba_offset & 0x07FF) >> 1; 647 lba_real = lba_offset + zone_base_lba; 648 649 /* 650 * Every 1024 physical blocks ("zone"), the LBA numbers 651 * go back to zero, but are within a higher block of LBA's. 652 * Also, there is a maximum of 1000 LBA's per zone. 653 * In other words, in PBA 1024-2047 you will find LBA 0-999 654 * which are really LBA 1000-1999. This allows for 24 bad 655 * or special physical blocks per zone. 656 */ 657 658 if (lba_offset >= uzonesize) { 659 printk(KERN_WARNING 660 "alauda_read_map: Bad low LBA %d for block %d\n", 661 lba_real, blocknum); 662 continue; 663 } 664 665 if (lba_to_pba[lba_offset] != UNDEF) { 666 printk(KERN_WARNING 667 "alauda_read_map: " 668 "LBA %d seen for PBA %d and %d\n", 669 lba_real, lba_to_pba[lba_offset], blocknum); 670 continue; 671 } 672 673 pba_to_lba[i] = lba_real; 674 lba_to_pba[lba_offset] = blocknum; 675 continue; 676 } 677 678 MEDIA_INFO(us).lba_to_pba[zone] = lba_to_pba; 679 MEDIA_INFO(us).pba_to_lba[zone] = pba_to_lba; 680 result = 0; 681 goto out; 682 683 error: 684 kfree(lba_to_pba); 685 kfree(pba_to_lba); 686 out: 687 return result; 688 } 689 690 /* 691 * Checks to see whether we have already mapped a certain zone 692 * If we haven't, the map is generated 693 */ 694 static void alauda_ensure_map_for_zone(struct us_data *us, unsigned int zone) 695 { 696 if (MEDIA_INFO(us).lba_to_pba[zone] == NULL 697 || MEDIA_INFO(us).pba_to_lba[zone] == NULL) 698 alauda_read_map(us, zone); 699 } 700 701 /* 702 * Erases an entire block 703 */ 704 static int alauda_erase_block(struct us_data *us, u16 pba) 705 { 706 int rc; 707 unsigned char command[] = { 708 ALAUDA_BULK_CMD, ALAUDA_BULK_ERASE_BLOCK, PBA_HI(pba), 709 PBA_ZONE(pba), 0, PBA_LO(pba), 0x02, 0, MEDIA_PORT(us) 710 }; 711 unsigned char buf[2]; 712 713 usb_stor_dbg(us, "Erasing PBA %d\n", pba); 714 715 rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 716 command, 9, NULL); 717 if (rc != USB_STOR_XFER_GOOD) 718 return rc; 719 720 rc = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 721 buf, 2, NULL); 722 if (rc != USB_STOR_XFER_GOOD) 723 return rc; 724 725 usb_stor_dbg(us, "Erase result: %02X %02X\n", buf[0], buf[1]); 726 return rc; 727 } 728 729 /* 730 * Reads data from a certain offset page inside a PBA, including interleaved 731 * redundancy data. Returns (pagesize+64)*pages bytes in data. 732 */ 733 static int alauda_read_block_raw(struct us_data *us, u16 pba, 734 unsigned int page, unsigned int pages, unsigned char *data) 735 { 736 int rc; 737 unsigned char command[] = { 738 ALAUDA_BULK_CMD, ALAUDA_BULK_READ_BLOCK, PBA_HI(pba), 739 PBA_ZONE(pba), 0, PBA_LO(pba) + page, pages, 0, MEDIA_PORT(us) 740 }; 741 742 usb_stor_dbg(us, "pba %d page %d count %d\n", pba, page, pages); 743 744 rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 745 command, 9, NULL); 746 if (rc != USB_STOR_XFER_GOOD) 747 return rc; 748 749 return usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 750 data, (MEDIA_INFO(us).pagesize + 64) * pages, NULL); 751 } 752 753 /* 754 * Reads data from a certain offset page inside a PBA, excluding redundancy 755 * data. Returns pagesize*pages bytes in data. Note that data must be big enough 756 * to hold (pagesize+64)*pages bytes of data, but you can ignore those 'extra' 757 * trailing bytes outside this function. 758 */ 759 static int alauda_read_block(struct us_data *us, u16 pba, 760 unsigned int page, unsigned int pages, unsigned char *data) 761 { 762 int i, rc; 763 unsigned int pagesize = MEDIA_INFO(us).pagesize; 764 765 rc = alauda_read_block_raw(us, pba, page, pages, data); 766 if (rc != USB_STOR_XFER_GOOD) 767 return rc; 768 769 /* Cut out the redundancy data */ 770 for (i = 0; i < pages; i++) { 771 int dest_offset = i * pagesize; 772 int src_offset = i * (pagesize + 64); 773 memmove(data + dest_offset, data + src_offset, pagesize); 774 } 775 776 return rc; 777 } 778 779 /* 780 * Writes an entire block of data and checks status after write. 781 * Redundancy data must be already included in data. Data should be 782 * (pagesize+64)*blocksize bytes in length. 783 */ 784 static int alauda_write_block(struct us_data *us, u16 pba, unsigned char *data) 785 { 786 int rc; 787 struct alauda_info *info = (struct alauda_info *) us->extra; 788 unsigned char command[] = { 789 ALAUDA_BULK_CMD, ALAUDA_BULK_WRITE_BLOCK, PBA_HI(pba), 790 PBA_ZONE(pba), 0, PBA_LO(pba), 32, 0, MEDIA_PORT(us) 791 }; 792 793 usb_stor_dbg(us, "pba %d\n", pba); 794 795 rc = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 796 command, 9, NULL); 797 if (rc != USB_STOR_XFER_GOOD) 798 return rc; 799 800 rc = usb_stor_bulk_transfer_buf(us, info->wr_ep, data, 801 (MEDIA_INFO(us).pagesize + 64) * MEDIA_INFO(us).blocksize, 802 NULL); 803 if (rc != USB_STOR_XFER_GOOD) 804 return rc; 805 806 return alauda_check_status2(us); 807 } 808 809 /* 810 * Write some data to a specific LBA. 811 */ 812 static int alauda_write_lba(struct us_data *us, u16 lba, 813 unsigned int page, unsigned int pages, 814 unsigned char *ptr, unsigned char *blockbuffer) 815 { 816 u16 pba, lbap, new_pba; 817 unsigned char *bptr, *cptr, *xptr; 818 unsigned char ecc[3]; 819 int i, result; 820 unsigned int uzonesize = MEDIA_INFO(us).uzonesize; 821 unsigned int zonesize = MEDIA_INFO(us).zonesize; 822 unsigned int pagesize = MEDIA_INFO(us).pagesize; 823 unsigned int blocksize = MEDIA_INFO(us).blocksize; 824 unsigned int lba_offset = lba % uzonesize; 825 unsigned int new_pba_offset; 826 unsigned int zone = lba / uzonesize; 827 828 alauda_ensure_map_for_zone(us, zone); 829 830 pba = MEDIA_INFO(us).lba_to_pba[zone][lba_offset]; 831 if (pba == 1) { 832 /* Maybe it is impossible to write to PBA 1. 833 Fake success, but don't do anything. */ 834 printk(KERN_WARNING 835 "alauda_write_lba: avoid writing to pba 1\n"); 836 return USB_STOR_TRANSPORT_GOOD; 837 } 838 839 new_pba = alauda_find_unused_pba(&MEDIA_INFO(us), zone); 840 if (!new_pba) { 841 printk(KERN_WARNING 842 "alauda_write_lba: Out of unused blocks\n"); 843 return USB_STOR_TRANSPORT_ERROR; 844 } 845 846 /* read old contents */ 847 if (pba != UNDEF) { 848 result = alauda_read_block_raw(us, pba, 0, 849 blocksize, blockbuffer); 850 if (result != USB_STOR_XFER_GOOD) 851 return result; 852 } else { 853 memset(blockbuffer, 0, blocksize * (pagesize + 64)); 854 } 855 856 lbap = (lba_offset << 1) | 0x1000; 857 if (parity[MSB_of(lbap) ^ LSB_of(lbap)]) 858 lbap ^= 1; 859 860 /* check old contents and fill lba */ 861 for (i = 0; i < blocksize; i++) { 862 bptr = blockbuffer + (i * (pagesize + 64)); 863 cptr = bptr + pagesize; 864 nand_compute_ecc(bptr, ecc); 865 if (!nand_compare_ecc(cptr+13, ecc)) { 866 usb_stor_dbg(us, "Warning: bad ecc in page %d- of pba %d\n", 867 i, pba); 868 nand_store_ecc(cptr+13, ecc); 869 } 870 nand_compute_ecc(bptr + (pagesize / 2), ecc); 871 if (!nand_compare_ecc(cptr+8, ecc)) { 872 usb_stor_dbg(us, "Warning: bad ecc in page %d+ of pba %d\n", 873 i, pba); 874 nand_store_ecc(cptr+8, ecc); 875 } 876 cptr[6] = cptr[11] = MSB_of(lbap); 877 cptr[7] = cptr[12] = LSB_of(lbap); 878 } 879 880 /* copy in new stuff and compute ECC */ 881 xptr = ptr; 882 for (i = page; i < page+pages; i++) { 883 bptr = blockbuffer + (i * (pagesize + 64)); 884 cptr = bptr + pagesize; 885 memcpy(bptr, xptr, pagesize); 886 xptr += pagesize; 887 nand_compute_ecc(bptr, ecc); 888 nand_store_ecc(cptr+13, ecc); 889 nand_compute_ecc(bptr + (pagesize / 2), ecc); 890 nand_store_ecc(cptr+8, ecc); 891 } 892 893 result = alauda_write_block(us, new_pba, blockbuffer); 894 if (result != USB_STOR_XFER_GOOD) 895 return result; 896 897 new_pba_offset = new_pba - (zone * zonesize); 898 MEDIA_INFO(us).pba_to_lba[zone][new_pba_offset] = lba; 899 MEDIA_INFO(us).lba_to_pba[zone][lba_offset] = new_pba; 900 usb_stor_dbg(us, "Remapped LBA %d to PBA %d\n", lba, new_pba); 901 902 if (pba != UNDEF) { 903 unsigned int pba_offset = pba - (zone * zonesize); 904 result = alauda_erase_block(us, pba); 905 if (result != USB_STOR_XFER_GOOD) 906 return result; 907 MEDIA_INFO(us).pba_to_lba[zone][pba_offset] = UNDEF; 908 } 909 910 return USB_STOR_TRANSPORT_GOOD; 911 } 912 913 /* 914 * Read data from a specific sector address 915 */ 916 static int alauda_read_data(struct us_data *us, unsigned long address, 917 unsigned int sectors) 918 { 919 unsigned char *buffer; 920 u16 lba, max_lba; 921 unsigned int page, len, offset; 922 unsigned int blockshift = MEDIA_INFO(us).blockshift; 923 unsigned int pageshift = MEDIA_INFO(us).pageshift; 924 unsigned int blocksize = MEDIA_INFO(us).blocksize; 925 unsigned int pagesize = MEDIA_INFO(us).pagesize; 926 unsigned int uzonesize = MEDIA_INFO(us).uzonesize; 927 struct scatterlist *sg; 928 int result; 929 930 /* 931 * Since we only read in one block at a time, we have to create 932 * a bounce buffer and move the data a piece at a time between the 933 * bounce buffer and the actual transfer buffer. 934 * We make this buffer big enough to hold temporary redundancy data, 935 * which we use when reading the data blocks. 936 */ 937 938 len = min(sectors, blocksize) * (pagesize + 64); 939 buffer = kmalloc(len, GFP_NOIO); 940 if (buffer == NULL) { 941 printk(KERN_WARNING "alauda_read_data: Out of memory\n"); 942 return USB_STOR_TRANSPORT_ERROR; 943 } 944 945 /* Figure out the initial LBA and page */ 946 lba = address >> blockshift; 947 page = (address & MEDIA_INFO(us).blockmask); 948 max_lba = MEDIA_INFO(us).capacity >> (blockshift + pageshift); 949 950 result = USB_STOR_TRANSPORT_GOOD; 951 offset = 0; 952 sg = NULL; 953 954 while (sectors > 0) { 955 unsigned int zone = lba / uzonesize; /* integer division */ 956 unsigned int lba_offset = lba - (zone * uzonesize); 957 unsigned int pages; 958 u16 pba; 959 alauda_ensure_map_for_zone(us, zone); 960 961 /* Not overflowing capacity? */ 962 if (lba >= max_lba) { 963 usb_stor_dbg(us, "Error: Requested lba %u exceeds maximum %u\n", 964 lba, max_lba); 965 result = USB_STOR_TRANSPORT_ERROR; 966 break; 967 } 968 969 /* Find number of pages we can read in this block */ 970 pages = min(sectors, blocksize - page); 971 len = pages << pageshift; 972 973 /* Find where this lba lives on disk */ 974 pba = MEDIA_INFO(us).lba_to_pba[zone][lba_offset]; 975 976 if (pba == UNDEF) { /* this lba was never written */ 977 usb_stor_dbg(us, "Read %d zero pages (LBA %d) page %d\n", 978 pages, lba, page); 979 980 /* This is not really an error. It just means 981 that the block has never been written. 982 Instead of returning USB_STOR_TRANSPORT_ERROR 983 it is better to return all zero data. */ 984 985 memset(buffer, 0, len); 986 } else { 987 usb_stor_dbg(us, "Read %d pages, from PBA %d (LBA %d) page %d\n", 988 pages, pba, lba, page); 989 990 result = alauda_read_block(us, pba, page, pages, buffer); 991 if (result != USB_STOR_TRANSPORT_GOOD) 992 break; 993 } 994 995 /* Store the data in the transfer buffer */ 996 usb_stor_access_xfer_buf(buffer, len, us->srb, 997 &sg, &offset, TO_XFER_BUF); 998 999 page = 0; 1000 lba++; 1001 sectors -= pages; 1002 } 1003 1004 kfree(buffer); 1005 return result; 1006 } 1007 1008 /* 1009 * Write data to a specific sector address 1010 */ 1011 static int alauda_write_data(struct us_data *us, unsigned long address, 1012 unsigned int sectors) 1013 { 1014 unsigned char *buffer, *blockbuffer; 1015 unsigned int page, len, offset; 1016 unsigned int blockshift = MEDIA_INFO(us).blockshift; 1017 unsigned int pageshift = MEDIA_INFO(us).pageshift; 1018 unsigned int blocksize = MEDIA_INFO(us).blocksize; 1019 unsigned int pagesize = MEDIA_INFO(us).pagesize; 1020 struct scatterlist *sg; 1021 u16 lba, max_lba; 1022 int result; 1023 1024 /* 1025 * Since we don't write the user data directly to the device, 1026 * we have to create a bounce buffer and move the data a piece 1027 * at a time between the bounce buffer and the actual transfer buffer. 1028 */ 1029 1030 len = min(sectors, blocksize) * pagesize; 1031 buffer = kmalloc(len, GFP_NOIO); 1032 if (buffer == NULL) { 1033 printk(KERN_WARNING "alauda_write_data: Out of memory\n"); 1034 return USB_STOR_TRANSPORT_ERROR; 1035 } 1036 1037 /* 1038 * We also need a temporary block buffer, where we read in the old data, 1039 * overwrite parts with the new data, and manipulate the redundancy data 1040 */ 1041 blockbuffer = kmalloc((pagesize + 64) * blocksize, GFP_NOIO); 1042 if (blockbuffer == NULL) { 1043 printk(KERN_WARNING "alauda_write_data: Out of memory\n"); 1044 kfree(buffer); 1045 return USB_STOR_TRANSPORT_ERROR; 1046 } 1047 1048 /* Figure out the initial LBA and page */ 1049 lba = address >> blockshift; 1050 page = (address & MEDIA_INFO(us).blockmask); 1051 max_lba = MEDIA_INFO(us).capacity >> (pageshift + blockshift); 1052 1053 result = USB_STOR_TRANSPORT_GOOD; 1054 offset = 0; 1055 sg = NULL; 1056 1057 while (sectors > 0) { 1058 /* Write as many sectors as possible in this block */ 1059 unsigned int pages = min(sectors, blocksize - page); 1060 len = pages << pageshift; 1061 1062 /* Not overflowing capacity? */ 1063 if (lba >= max_lba) { 1064 usb_stor_dbg(us, "Requested lba %u exceeds maximum %u\n", 1065 lba, max_lba); 1066 result = USB_STOR_TRANSPORT_ERROR; 1067 break; 1068 } 1069 1070 /* Get the data from the transfer buffer */ 1071 usb_stor_access_xfer_buf(buffer, len, us->srb, 1072 &sg, &offset, FROM_XFER_BUF); 1073 1074 result = alauda_write_lba(us, lba, page, pages, buffer, 1075 blockbuffer); 1076 if (result != USB_STOR_TRANSPORT_GOOD) 1077 break; 1078 1079 page = 0; 1080 lba++; 1081 sectors -= pages; 1082 } 1083 1084 kfree(buffer); 1085 kfree(blockbuffer); 1086 return result; 1087 } 1088 1089 /* 1090 * Our interface with the rest of the world 1091 */ 1092 1093 static void alauda_info_destructor(void *extra) 1094 { 1095 struct alauda_info *info = (struct alauda_info *) extra; 1096 int port; 1097 1098 if (!info) 1099 return; 1100 1101 for (port = 0; port < 2; port++) { 1102 struct alauda_media_info *media_info = &info->port[port]; 1103 1104 alauda_free_maps(media_info); 1105 kfree(media_info->lba_to_pba); 1106 kfree(media_info->pba_to_lba); 1107 } 1108 } 1109 1110 /* 1111 * Initialize alauda_info struct and find the data-write endpoint 1112 */ 1113 static int init_alauda(struct us_data *us) 1114 { 1115 struct alauda_info *info; 1116 struct usb_host_interface *altsetting = us->pusb_intf->cur_altsetting; 1117 nand_init_ecc(); 1118 1119 us->extra = kzalloc(sizeof(struct alauda_info), GFP_NOIO); 1120 if (!us->extra) 1121 return USB_STOR_TRANSPORT_ERROR; 1122 1123 info = (struct alauda_info *) us->extra; 1124 us->extra_destructor = alauda_info_destructor; 1125 1126 info->wr_ep = usb_sndbulkpipe(us->pusb_dev, 1127 altsetting->endpoint[0].desc.bEndpointAddress 1128 & USB_ENDPOINT_NUMBER_MASK); 1129 1130 return USB_STOR_TRANSPORT_GOOD; 1131 } 1132 1133 static int alauda_transport(struct scsi_cmnd *srb, struct us_data *us) 1134 { 1135 int rc; 1136 struct alauda_info *info = (struct alauda_info *) us->extra; 1137 unsigned char *ptr = us->iobuf; 1138 static unsigned char inquiry_response[36] = { 1139 0x00, 0x80, 0x00, 0x01, 0x1F, 0x00, 0x00, 0x00 1140 }; 1141 1142 if (srb->cmnd[0] == INQUIRY) { 1143 usb_stor_dbg(us, "INQUIRY - Returning bogus response\n"); 1144 memcpy(ptr, inquiry_response, sizeof(inquiry_response)); 1145 fill_inquiry_response(us, ptr, 36); 1146 return USB_STOR_TRANSPORT_GOOD; 1147 } 1148 1149 if (srb->cmnd[0] == TEST_UNIT_READY) { 1150 usb_stor_dbg(us, "TEST_UNIT_READY\n"); 1151 return alauda_check_media(us); 1152 } 1153 1154 if (srb->cmnd[0] == READ_CAPACITY) { 1155 unsigned int num_zones; 1156 unsigned long capacity; 1157 1158 rc = alauda_check_media(us); 1159 if (rc != USB_STOR_TRANSPORT_GOOD) 1160 return rc; 1161 1162 num_zones = MEDIA_INFO(us).capacity >> (MEDIA_INFO(us).zoneshift 1163 + MEDIA_INFO(us).blockshift + MEDIA_INFO(us).pageshift); 1164 1165 capacity = num_zones * MEDIA_INFO(us).uzonesize 1166 * MEDIA_INFO(us).blocksize; 1167 1168 /* Report capacity and page size */ 1169 ((__be32 *) ptr)[0] = cpu_to_be32(capacity - 1); 1170 ((__be32 *) ptr)[1] = cpu_to_be32(512); 1171 1172 usb_stor_set_xfer_buf(ptr, 8, srb); 1173 return USB_STOR_TRANSPORT_GOOD; 1174 } 1175 1176 if (srb->cmnd[0] == READ_10) { 1177 unsigned int page, pages; 1178 1179 rc = alauda_check_media(us); 1180 if (rc != USB_STOR_TRANSPORT_GOOD) 1181 return rc; 1182 1183 page = short_pack(srb->cmnd[3], srb->cmnd[2]); 1184 page <<= 16; 1185 page |= short_pack(srb->cmnd[5], srb->cmnd[4]); 1186 pages = short_pack(srb->cmnd[8], srb->cmnd[7]); 1187 1188 usb_stor_dbg(us, "READ_10: page %d pagect %d\n", page, pages); 1189 1190 return alauda_read_data(us, page, pages); 1191 } 1192 1193 if (srb->cmnd[0] == WRITE_10) { 1194 unsigned int page, pages; 1195 1196 rc = alauda_check_media(us); 1197 if (rc != USB_STOR_TRANSPORT_GOOD) 1198 return rc; 1199 1200 page = short_pack(srb->cmnd[3], srb->cmnd[2]); 1201 page <<= 16; 1202 page |= short_pack(srb->cmnd[5], srb->cmnd[4]); 1203 pages = short_pack(srb->cmnd[8], srb->cmnd[7]); 1204 1205 usb_stor_dbg(us, "WRITE_10: page %d pagect %d\n", page, pages); 1206 1207 return alauda_write_data(us, page, pages); 1208 } 1209 1210 if (srb->cmnd[0] == REQUEST_SENSE) { 1211 usb_stor_dbg(us, "REQUEST_SENSE\n"); 1212 1213 memset(ptr, 0, 18); 1214 ptr[0] = 0xF0; 1215 ptr[2] = info->sense_key; 1216 ptr[7] = 11; 1217 ptr[12] = info->sense_asc; 1218 ptr[13] = info->sense_ascq; 1219 usb_stor_set_xfer_buf(ptr, 18, srb); 1220 1221 return USB_STOR_TRANSPORT_GOOD; 1222 } 1223 1224 if (srb->cmnd[0] == ALLOW_MEDIUM_REMOVAL) { 1225 /* sure. whatever. not like we can stop the user from popping 1226 the media out of the device (no locking doors, etc) */ 1227 return USB_STOR_TRANSPORT_GOOD; 1228 } 1229 1230 usb_stor_dbg(us, "Gah! Unknown command: %d (0x%x)\n", 1231 srb->cmnd[0], srb->cmnd[0]); 1232 info->sense_key = 0x05; 1233 info->sense_asc = 0x20; 1234 info->sense_ascq = 0x00; 1235 return USB_STOR_TRANSPORT_FAILED; 1236 } 1237 1238 static struct scsi_host_template alauda_host_template; 1239 1240 static int alauda_probe(struct usb_interface *intf, 1241 const struct usb_device_id *id) 1242 { 1243 struct us_data *us; 1244 int result; 1245 1246 result = usb_stor_probe1(&us, intf, id, 1247 (id - alauda_usb_ids) + alauda_unusual_dev_list, 1248 &alauda_host_template); 1249 if (result) 1250 return result; 1251 1252 us->transport_name = "Alauda Control/Bulk"; 1253 us->transport = alauda_transport; 1254 us->transport_reset = usb_stor_Bulk_reset; 1255 us->max_lun = 1; 1256 1257 result = usb_stor_probe2(us); 1258 return result; 1259 } 1260 1261 static struct usb_driver alauda_driver = { 1262 .name = DRV_NAME, 1263 .probe = alauda_probe, 1264 .disconnect = usb_stor_disconnect, 1265 .suspend = usb_stor_suspend, 1266 .resume = usb_stor_resume, 1267 .reset_resume = usb_stor_reset_resume, 1268 .pre_reset = usb_stor_pre_reset, 1269 .post_reset = usb_stor_post_reset, 1270 .id_table = alauda_usb_ids, 1271 .soft_unbind = 1, 1272 .no_dynamic_id = 1, 1273 }; 1274 1275 module_usb_stor_driver(alauda_driver, alauda_host_template, DRV_NAME); 1276