1 /* 2 * 3 * This program is free software; you can redistribute it and/or modify it 4 * under the terms of the GNU General Public License as published by the 5 * Free Software Foundation; either version 2, or (at your option) any 6 * later version. 7 * 8 * This program is distributed in the hope that it will be useful, but 9 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License along 14 * with this program; if not, write to the Free Software Foundation, Inc., 15 * 675 Mass Ave, Cambridge, MA 02139, USA. 16 */ 17 #include <linux/jiffies.h> 18 #include <linux/errno.h> 19 #include <linux/module.h> 20 #include <linux/slab.h> 21 22 #include <scsi/scsi.h> 23 #include <scsi/scsi_cmnd.h> 24 25 #include <linux/firmware.h> 26 27 #include "usb.h" 28 #include "transport.h" 29 #include "protocol.h" 30 #include "debug.h" 31 32 MODULE_DESCRIPTION("Driver for ENE UB6250 reader"); 33 MODULE_LICENSE("GPL"); 34 35 36 /* 37 * The table of devices 38 */ 39 #define UNUSUAL_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \ 40 vendorName, productName, useProtocol, useTransport, \ 41 initFunction, flags) \ 42 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \ 43 .driver_info = (flags)|(USB_US_TYPE_STOR<<24) } 44 45 struct usb_device_id ene_ub6250_usb_ids[] = { 46 # include "unusual_ene_ub6250.h" 47 { } /* Terminating entry */ 48 }; 49 MODULE_DEVICE_TABLE(usb, ene_ub6250_usb_ids); 50 51 #undef UNUSUAL_DEV 52 53 /* 54 * The flags table 55 */ 56 #define UNUSUAL_DEV(idVendor, idProduct, bcdDeviceMin, bcdDeviceMax, \ 57 vendor_name, product_name, use_protocol, use_transport, \ 58 init_function, Flags) \ 59 { \ 60 .vendorName = vendor_name, \ 61 .productName = product_name, \ 62 .useProtocol = use_protocol, \ 63 .useTransport = use_transport, \ 64 .initFunction = init_function, \ 65 } 66 67 static struct us_unusual_dev ene_ub6250_unusual_dev_list[] = { 68 # include "unusual_ene_ub6250.h" 69 { } /* Terminating entry */ 70 }; 71 72 #undef UNUSUAL_DEV 73 74 75 76 /* ENE bin code len */ 77 #define ENE_BIN_CODE_LEN 0x800 78 /* EnE HW Register */ 79 #define REG_CARD_STATUS 0xFF83 80 #define REG_HW_TRAP1 0xFF89 81 82 /* SRB Status */ 83 #define SS_SUCCESS 0x00 /* No Sense */ 84 #define SS_NOT_READY 0x02 85 #define SS_MEDIUM_ERR 0x03 86 #define SS_HW_ERR 0x04 87 #define SS_ILLEGAL_REQUEST 0x05 88 #define SS_UNIT_ATTENTION 0x06 89 90 /* ENE Load FW Pattern */ 91 #define SD_INIT1_PATTERN 1 92 #define SD_INIT2_PATTERN 2 93 #define SD_RW_PATTERN 3 94 #define MS_INIT_PATTERN 4 95 #define MSP_RW_PATTERN 5 96 #define MS_RW_PATTERN 6 97 #define SM_INIT_PATTERN 7 98 #define SM_RW_PATTERN 8 99 100 #define FDIR_WRITE 0 101 #define FDIR_READ 1 102 103 /* For MS Card */ 104 105 /* Status Register 1 */ 106 #define MS_REG_ST1_MB 0x80 /* media busy */ 107 #define MS_REG_ST1_FB1 0x40 /* flush busy 1 */ 108 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */ 109 #define MS_REG_ST1_UCDT 0x10 /* unable to correct data */ 110 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */ 111 #define MS_REG_ST1_UCEX 0x04 /* unable to correct extra */ 112 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */ 113 #define MS_REG_ST1_UCFG 0x01 /* unable to correct overwrite flag */ 114 #define MS_REG_ST1_DEFAULT (MS_REG_ST1_MB | MS_REG_ST1_FB1 | MS_REG_ST1_DTER | MS_REG_ST1_UCDT | MS_REG_ST1_EXER | MS_REG_ST1_UCEX | MS_REG_ST1_FGER | MS_REG_ST1_UCFG) 115 116 /* Overwrite Area */ 117 #define MS_REG_OVR_BKST 0x80 /* block status */ 118 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */ 119 #define MS_REG_OVR_BKST_NG 0x00 /* NG */ 120 #define MS_REG_OVR_PGST0 0x40 /* page status */ 121 #define MS_REG_OVR_PGST1 0x20 122 #define MS_REG_OVR_PGST_MASK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) 123 #define MS_REG_OVR_PGST_OK (MS_REG_OVR_PGST0 | MS_REG_OVR_PGST1) /* OK */ 124 #define MS_REG_OVR_PGST_NG MS_REG_OVR_PGST1 /* NG */ 125 #define MS_REG_OVR_PGST_DATA_ERROR 0x00 /* data error */ 126 #define MS_REG_OVR_UDST 0x10 /* update status */ 127 #define MS_REG_OVR_UDST_UPDATING 0x00 /* updating */ 128 #define MS_REG_OVR_UDST_NO_UPDATE MS_REG_OVR_UDST 129 #define MS_REG_OVR_RESERVED 0x08 130 #define MS_REG_OVR_DEFAULT (MS_REG_OVR_BKST_OK | MS_REG_OVR_PGST_OK | MS_REG_OVR_UDST_NO_UPDATE | MS_REG_OVR_RESERVED) 131 132 /* Management Flag */ 133 #define MS_REG_MNG_SCMS0 0x20 /* serial copy management system */ 134 #define MS_REG_MNG_SCMS1 0x10 135 #define MS_REG_MNG_SCMS_MASK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1) 136 #define MS_REG_MNG_SCMS_COPY_OK (MS_REG_MNG_SCMS0 | MS_REG_MNG_SCMS1) 137 #define MS_REG_MNG_SCMS_ONE_COPY MS_REG_MNG_SCMS1 138 #define MS_REG_MNG_SCMS_NO_COPY 0x00 139 #define MS_REG_MNG_ATFLG 0x08 /* address transfer table flag */ 140 #define MS_REG_MNG_ATFLG_OTHER MS_REG_MNG_ATFLG /* other */ 141 #define MS_REG_MNG_ATFLG_ATTBL 0x00 /* address transfer table */ 142 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */ 143 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */ 144 #define MS_REG_MNG_SYSFLG_BOOT 0x00 /* system block */ 145 #define MS_REG_MNG_RESERVED 0xc3 146 #define MS_REG_MNG_DEFAULT (MS_REG_MNG_SCMS_COPY_OK | MS_REG_MNG_ATFLG_OTHER | MS_REG_MNG_SYSFLG_USER | MS_REG_MNG_RESERVED) 147 148 149 #define MS_MAX_PAGES_PER_BLOCK 32 150 #define MS_MAX_INITIAL_ERROR_BLOCKS 10 151 #define MS_LIB_BITS_PER_BYTE 8 152 153 #define MS_SYSINF_FORMAT_FAT 1 154 #define MS_SYSINF_USAGE_GENERAL 0 155 156 #define MS_SYSINF_MSCLASS_TYPE_1 1 157 #define MS_SYSINF_PAGE_SIZE MS_BYTES_PER_PAGE /* fixed */ 158 159 #define MS_SYSINF_CARDTYPE_RDONLY 1 160 #define MS_SYSINF_CARDTYPE_RDWR 2 161 #define MS_SYSINF_CARDTYPE_HYBRID 3 162 #define MS_SYSINF_SECURITY 0x01 163 #define MS_SYSINF_SECURITY_NO_SUPPORT MS_SYSINF_SECURITY 164 #define MS_SYSINF_SECURITY_SUPPORT 0 165 166 #define MS_SYSINF_RESERVED1 1 167 #define MS_SYSINF_RESERVED2 1 168 169 #define MS_SYSENT_TYPE_INVALID_BLOCK 0x01 170 #define MS_SYSENT_TYPE_CIS_IDI 0x0a /* CIS/IDI */ 171 172 #define SIZE_OF_KIRO 1024 173 #define BYTE_MASK 0xff 174 175 /* ms error code */ 176 #define MS_STATUS_WRITE_PROTECT 0x0106 177 #define MS_STATUS_SUCCESS 0x0000 178 #define MS_ERROR_FLASH_READ 0x8003 179 #define MS_ERROR_FLASH_ERASE 0x8005 180 #define MS_LB_ERROR 0xfff0 181 #define MS_LB_BOOT_BLOCK 0xfff1 182 #define MS_LB_INITIAL_ERROR 0xfff2 183 #define MS_STATUS_SUCCESS_WITH_ECC 0xfff3 184 #define MS_LB_ACQUIRED_ERROR 0xfff4 185 #define MS_LB_NOT_USED_ERASED 0xfff5 186 #define MS_NOCARD_ERROR 0xfff8 187 #define MS_NO_MEMORY_ERROR 0xfff9 188 #define MS_STATUS_INT_ERROR 0xfffa 189 #define MS_STATUS_ERROR 0xfffe 190 #define MS_LB_NOT_USED 0xffff 191 192 #define MS_REG_MNG_SYSFLG 0x04 /* system flag */ 193 #define MS_REG_MNG_SYSFLG_USER MS_REG_MNG_SYSFLG /* user block */ 194 195 #define MS_BOOT_BLOCK_ID 0x0001 196 #define MS_BOOT_BLOCK_FORMAT_VERSION 0x0100 197 #define MS_BOOT_BLOCK_DATA_ENTRIES 2 198 199 #define MS_NUMBER_OF_SYSTEM_ENTRY 4 200 #define MS_NUMBER_OF_BOOT_BLOCK 2 201 #define MS_BYTES_PER_PAGE 512 202 #define MS_LOGICAL_BLOCKS_PER_SEGMENT 496 203 #define MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT 494 204 205 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT 0x200 /* 512 */ 206 #define MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK 0x1ff 207 208 /* overwrite area */ 209 #define MS_REG_OVR_BKST 0x80 /* block status */ 210 #define MS_REG_OVR_BKST_OK MS_REG_OVR_BKST /* OK */ 211 #define MS_REG_OVR_BKST_NG 0x00 /* NG */ 212 213 /* Status Register 1 */ 214 #define MS_REG_ST1_DTER 0x20 /* error on data(corrected) */ 215 #define MS_REG_ST1_EXER 0x08 /* error on extra(corrected) */ 216 #define MS_REG_ST1_FGER 0x02 /* error on overwrite flag(corrected) */ 217 218 /* MemoryStick Register */ 219 /* Status Register 0 */ 220 #define MS_REG_ST0_WP 0x01 /* write protected */ 221 #define MS_REG_ST0_WP_ON MS_REG_ST0_WP 222 223 #define MS_LIB_CTRL_RDONLY 0 224 #define MS_LIB_CTRL_WRPROTECT 1 225 226 /*dphy->log table */ 227 #define ms_libconv_to_logical(pdx, PhyBlock) (((PhyBlock) >= (pdx)->MS_Lib.NumberOfPhyBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Phy2LogMap[PhyBlock]) 228 #define ms_libconv_to_physical(pdx, LogBlock) (((LogBlock) >= (pdx)->MS_Lib.NumberOfLogBlock) ? MS_STATUS_ERROR : (pdx)->MS_Lib.Log2PhyMap[LogBlock]) 229 230 #define ms_lib_ctrl_set(pdx, Flag) ((pdx)->MS_Lib.flags |= (1 << (Flag))) 231 #define ms_lib_ctrl_reset(pdx, Flag) ((pdx)->MS_Lib.flags &= ~(1 << (Flag))) 232 #define ms_lib_ctrl_check(pdx, Flag) ((pdx)->MS_Lib.flags & (1 << (Flag))) 233 234 #define ms_lib_iswritable(pdx) ((ms_lib_ctrl_check((pdx), MS_LIB_CTRL_RDONLY) == 0) && (ms_lib_ctrl_check(pdx, MS_LIB_CTRL_WRPROTECT) == 0)) 235 #define ms_lib_clear_pagemap(pdx) memset((pdx)->MS_Lib.pagemap, 0, sizeof((pdx)->MS_Lib.pagemap)) 236 #define memstick_logaddr(logadr1, logadr0) ((((u16)(logadr1)) << 8) | (logadr0)) 237 238 239 struct SD_STATUS { 240 u8 Insert:1; 241 u8 Ready:1; 242 u8 MediaChange:1; 243 u8 IsMMC:1; 244 u8 HiCapacity:1; 245 u8 HiSpeed:1; 246 u8 WtP:1; 247 u8 Reserved:1; 248 }; 249 250 struct MS_STATUS { 251 u8 Insert:1; 252 u8 Ready:1; 253 u8 MediaChange:1; 254 u8 IsMSPro:1; 255 u8 IsMSPHG:1; 256 u8 Reserved1:1; 257 u8 WtP:1; 258 u8 Reserved2:1; 259 }; 260 261 struct SM_STATUS { 262 u8 Insert:1; 263 u8 Ready:1; 264 u8 MediaChange:1; 265 u8 Reserved:3; 266 u8 WtP:1; 267 u8 IsMS:1; 268 }; 269 270 struct ms_bootblock_cis { 271 u8 bCistplDEVICE[6]; /* 0 */ 272 u8 bCistplDEVICE0C[6]; /* 6 */ 273 u8 bCistplJEDECC[4]; /* 12 */ 274 u8 bCistplMANFID[6]; /* 16 */ 275 u8 bCistplVER1[32]; /* 22 */ 276 u8 bCistplFUNCID[4]; /* 54 */ 277 u8 bCistplFUNCE0[4]; /* 58 */ 278 u8 bCistplFUNCE1[5]; /* 62 */ 279 u8 bCistplCONF[7]; /* 67 */ 280 u8 bCistplCFTBLENT0[10];/* 74 */ 281 u8 bCistplCFTBLENT1[8]; /* 84 */ 282 u8 bCistplCFTBLENT2[12];/* 92 */ 283 u8 bCistplCFTBLENT3[8]; /* 104 */ 284 u8 bCistplCFTBLENT4[17];/* 112 */ 285 u8 bCistplCFTBLENT5[8]; /* 129 */ 286 u8 bCistplCFTBLENT6[17];/* 137 */ 287 u8 bCistplCFTBLENT7[8]; /* 154 */ 288 u8 bCistplNOLINK[3]; /* 162 */ 289 } ; 290 291 struct ms_bootblock_idi { 292 #define MS_IDI_GENERAL_CONF 0x848A 293 u16 wIDIgeneralConfiguration; /* 0 */ 294 u16 wIDInumberOfCylinder; /* 1 */ 295 u16 wIDIreserved0; /* 2 */ 296 u16 wIDInumberOfHead; /* 3 */ 297 u16 wIDIbytesPerTrack; /* 4 */ 298 u16 wIDIbytesPerSector; /* 5 */ 299 u16 wIDIsectorsPerTrack; /* 6 */ 300 u16 wIDItotalSectors[2]; /* 7-8 high,low */ 301 u16 wIDIreserved1[11]; /* 9-19 */ 302 u16 wIDIbufferType; /* 20 */ 303 u16 wIDIbufferSize; /* 21 */ 304 u16 wIDIlongCmdECC; /* 22 */ 305 u16 wIDIfirmVersion[4]; /* 23-26 */ 306 u16 wIDImodelName[20]; /* 27-46 */ 307 u16 wIDIreserved2; /* 47 */ 308 u16 wIDIlongWordSupported; /* 48 */ 309 u16 wIDIdmaSupported; /* 49 */ 310 u16 wIDIreserved3; /* 50 */ 311 u16 wIDIpioTiming; /* 51 */ 312 u16 wIDIdmaTiming; /* 52 */ 313 u16 wIDItransferParameter; /* 53 */ 314 u16 wIDIformattedCylinder; /* 54 */ 315 u16 wIDIformattedHead; /* 55 */ 316 u16 wIDIformattedSectorsPerTrack;/* 56 */ 317 u16 wIDIformattedTotalSectors[2];/* 57-58 */ 318 u16 wIDImultiSector; /* 59 */ 319 u16 wIDIlbaSectors[2]; /* 60-61 */ 320 u16 wIDIsingleWordDMA; /* 62 */ 321 u16 wIDImultiWordDMA; /* 63 */ 322 u16 wIDIreserved4[192]; /* 64-255 */ 323 }; 324 325 struct ms_bootblock_sysent_rec { 326 u32 dwStart; 327 u32 dwSize; 328 u8 bType; 329 u8 bReserved[3]; 330 }; 331 332 struct ms_bootblock_sysent { 333 struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY]; 334 }; 335 336 struct ms_bootblock_sysinf { 337 u8 bMsClass; /* must be 1 */ 338 u8 bCardType; /* see below */ 339 u16 wBlockSize; /* n KB */ 340 u16 wBlockNumber; /* number of physical block */ 341 u16 wTotalBlockNumber; /* number of logical block */ 342 u16 wPageSize; /* must be 0x200 */ 343 u8 bExtraSize; /* 0x10 */ 344 u8 bSecuritySupport; 345 u8 bAssemblyDate[8]; 346 u8 bFactoryArea[4]; 347 u8 bAssemblyMakerCode; 348 u8 bAssemblyMachineCode[3]; 349 u16 wMemoryMakerCode; 350 u16 wMemoryDeviceCode; 351 u16 wMemorySize; 352 u8 bReserved1; 353 u8 bReserved2; 354 u8 bVCC; 355 u8 bVPP; 356 u16 wControllerChipNumber; 357 u16 wControllerFunction; /* New MS */ 358 u8 bReserved3[9]; /* New MS */ 359 u8 bParallelSupport; /* New MS */ 360 u16 wFormatValue; /* New MS */ 361 u8 bFormatType; 362 u8 bUsage; 363 u8 bDeviceType; 364 u8 bReserved4[22]; 365 u8 bFUValue3; 366 u8 bFUValue4; 367 u8 bReserved5[15]; 368 }; 369 370 struct ms_bootblock_header { 371 u16 wBlockID; 372 u16 wFormatVersion; 373 u8 bReserved1[184]; 374 u8 bNumberOfDataEntry; 375 u8 bReserved2[179]; 376 }; 377 378 struct ms_bootblock_page0 { 379 struct ms_bootblock_header header; 380 struct ms_bootblock_sysent sysent; 381 struct ms_bootblock_sysinf sysinf; 382 }; 383 384 struct ms_bootblock_cis_idi { 385 union { 386 struct ms_bootblock_cis cis; 387 u8 dmy[256]; 388 } cis; 389 390 union { 391 struct ms_bootblock_idi idi; 392 u8 dmy[256]; 393 } idi; 394 395 }; 396 397 /* ENE MS Lib struct */ 398 struct ms_lib_type_extdat { 399 u8 reserved; 400 u8 intr; 401 u8 status0; 402 u8 status1; 403 u8 ovrflg; 404 u8 mngflg; 405 u16 logadr; 406 }; 407 408 struct ms_lib_ctrl { 409 u32 flags; 410 u32 BytesPerSector; 411 u32 NumberOfCylinder; 412 u32 SectorsPerCylinder; 413 u16 cardType; /* R/W, RO, Hybrid */ 414 u16 blockSize; 415 u16 PagesPerBlock; 416 u16 NumberOfPhyBlock; 417 u16 NumberOfLogBlock; 418 u16 NumberOfSegment; 419 u16 *Phy2LogMap; /* phy2log table */ 420 u16 *Log2PhyMap; /* log2phy table */ 421 u16 wrtblk; 422 unsigned char *pagemap[(MS_MAX_PAGES_PER_BLOCK + (MS_LIB_BITS_PER_BYTE-1)) / MS_LIB_BITS_PER_BYTE]; 423 unsigned char *blkpag; 424 struct ms_lib_type_extdat *blkext; 425 unsigned char copybuf[512]; 426 }; 427 428 429 /* SD Block Length */ 430 /* 2^9 = 512 Bytes, The HW maximum read/write data length */ 431 #define SD_BLOCK_LEN 9 432 433 struct ene_ub6250_info { 434 /* for 6250 code */ 435 struct SD_STATUS SD_Status; 436 struct MS_STATUS MS_Status; 437 struct SM_STATUS SM_Status; 438 439 /* ----- SD Control Data ---------------- */ 440 /*SD_REGISTER SD_Regs; */ 441 u16 SD_Block_Mult; 442 u8 SD_READ_BL_LEN; 443 u16 SD_C_SIZE; 444 u8 SD_C_SIZE_MULT; 445 446 /* SD/MMC New spec. */ 447 u8 SD_SPEC_VER; 448 u8 SD_CSD_VER; 449 u8 SD20_HIGH_CAPACITY; 450 u32 HC_C_SIZE; 451 u8 MMC_SPEC_VER; 452 u8 MMC_BusWidth; 453 u8 MMC_HIGH_CAPACITY; 454 455 /*----- MS Control Data ---------------- */ 456 bool MS_SWWP; 457 u32 MSP_TotalBlock; 458 struct ms_lib_ctrl MS_Lib; 459 bool MS_IsRWPage; 460 u16 MS_Model; 461 462 /*----- SM Control Data ---------------- */ 463 u8 SM_DeviceID; 464 u8 SM_CardID; 465 466 unsigned char *testbuf; 467 u8 BIN_FLAG; 468 u32 bl_num; 469 int SrbStatus; 470 471 /*------Power Managerment ---------------*/ 472 bool Power_IsResum; 473 }; 474 475 static int ene_sd_init(struct us_data *us); 476 static int ene_ms_init(struct us_data *us); 477 static int ene_load_bincode(struct us_data *us, unsigned char flag); 478 479 static void ene_ub6250_info_destructor(void *extra) 480 { 481 if (!extra) 482 return; 483 } 484 485 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg) 486 { 487 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 488 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf; 489 490 int result; 491 unsigned int residue; 492 unsigned int cswlen = 0, partial = 0; 493 unsigned int transfer_length = bcb->DataTransferLength; 494 495 /* US_DEBUGP("transport --- ene_send_scsi_cmd\n"); */ 496 /* send cmd to out endpoint */ 497 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 498 bcb, US_BULK_CB_WRAP_LEN, NULL); 499 if (result != USB_STOR_XFER_GOOD) { 500 US_DEBUGP("send cmd to out endpoint fail ---\n"); 501 return USB_STOR_TRANSPORT_ERROR; 502 } 503 504 if (buf) { 505 unsigned int pipe = fDir; 506 507 if (fDir == FDIR_READ) 508 pipe = us->recv_bulk_pipe; 509 else 510 pipe = us->send_bulk_pipe; 511 512 /* Bulk */ 513 if (use_sg) { 514 result = usb_stor_bulk_srb(us, pipe, us->srb); 515 } else { 516 result = usb_stor_bulk_transfer_sg(us, pipe, buf, 517 transfer_length, 0, &partial); 518 } 519 if (result != USB_STOR_XFER_GOOD) { 520 US_DEBUGP("data transfer fail ---\n"); 521 return USB_STOR_TRANSPORT_ERROR; 522 } 523 } 524 525 /* Get CSW for device status */ 526 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs, 527 US_BULK_CS_WRAP_LEN, &cswlen); 528 529 if (result == USB_STOR_XFER_SHORT && cswlen == 0) { 530 US_DEBUGP("Received 0-length CSW; retrying...\n"); 531 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 532 bcs, US_BULK_CS_WRAP_LEN, &cswlen); 533 } 534 535 if (result == USB_STOR_XFER_STALLED) { 536 /* get the status again */ 537 US_DEBUGP("Attempting to get CSW (2nd try)...\n"); 538 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 539 bcs, US_BULK_CS_WRAP_LEN, NULL); 540 } 541 542 if (result != USB_STOR_XFER_GOOD) 543 return USB_STOR_TRANSPORT_ERROR; 544 545 /* check bulk status */ 546 residue = le32_to_cpu(bcs->Residue); 547 548 /* try to compute the actual residue, based on how much data 549 * was really transferred and what the device tells us */ 550 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) { 551 residue = min(residue, transfer_length); 552 if (us->srb != NULL) 553 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb), 554 (int)residue)); 555 } 556 557 if (bcs->Status != US_BULK_STAT_OK) 558 return USB_STOR_TRANSPORT_ERROR; 559 560 return USB_STOR_TRANSPORT_GOOD; 561 } 562 563 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb) 564 { 565 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 566 567 if (info->SD_Status.Insert && info->SD_Status.Ready) 568 return USB_STOR_TRANSPORT_GOOD; 569 else { 570 ene_sd_init(us); 571 return USB_STOR_TRANSPORT_GOOD; 572 } 573 574 return USB_STOR_TRANSPORT_GOOD; 575 } 576 577 static int sd_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb) 578 { 579 unsigned char data_ptr[36] = { 580 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55, 581 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61, 582 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 583 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 }; 584 585 usb_stor_set_xfer_buf(data_ptr, 36, srb); 586 return USB_STOR_TRANSPORT_GOOD; 587 } 588 589 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb) 590 { 591 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 592 unsigned char mediaNoWP[12] = { 593 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00, 594 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 595 unsigned char mediaWP[12] = { 596 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00, 597 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 598 599 if (info->SD_Status.WtP) 600 usb_stor_set_xfer_buf(mediaWP, 12, srb); 601 else 602 usb_stor_set_xfer_buf(mediaNoWP, 12, srb); 603 604 605 return USB_STOR_TRANSPORT_GOOD; 606 } 607 608 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb) 609 { 610 u32 bl_num; 611 u16 bl_len; 612 unsigned int offset = 0; 613 unsigned char buf[8]; 614 struct scatterlist *sg = NULL; 615 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 616 617 US_DEBUGP("sd_scsi_read_capacity\n"); 618 if (info->SD_Status.HiCapacity) { 619 bl_len = 0x200; 620 if (info->SD_Status.IsMMC) 621 bl_num = info->HC_C_SIZE-1; 622 else 623 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1; 624 } else { 625 bl_len = 1<<(info->SD_READ_BL_LEN); 626 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1) 627 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1; 628 } 629 info->bl_num = bl_num; 630 US_DEBUGP("bl_len = %x\n", bl_len); 631 US_DEBUGP("bl_num = %x\n", bl_num); 632 633 /*srb->request_bufflen = 8; */ 634 buf[0] = (bl_num >> 24) & 0xff; 635 buf[1] = (bl_num >> 16) & 0xff; 636 buf[2] = (bl_num >> 8) & 0xff; 637 buf[3] = (bl_num >> 0) & 0xff; 638 buf[4] = (bl_len >> 24) & 0xff; 639 buf[5] = (bl_len >> 16) & 0xff; 640 buf[6] = (bl_len >> 8) & 0xff; 641 buf[7] = (bl_len >> 0) & 0xff; 642 643 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF); 644 645 return USB_STOR_TRANSPORT_GOOD; 646 } 647 648 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb) 649 { 650 int result; 651 unsigned char *cdb = srb->cmnd; 652 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 653 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 654 655 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) | 656 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff); 657 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 658 u32 bnByte = bn * 0x200; 659 u32 blenByte = blen * 0x200; 660 661 if (bn > info->bl_num) 662 return USB_STOR_TRANSPORT_ERROR; 663 664 result = ene_load_bincode(us, SD_RW_PATTERN); 665 if (result != USB_STOR_XFER_GOOD) { 666 US_DEBUGP("Load SD RW pattern Fail !!\n"); 667 return USB_STOR_TRANSPORT_ERROR; 668 } 669 670 if (info->SD_Status.HiCapacity) 671 bnByte = bn; 672 673 /* set up the command wrapper */ 674 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 675 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 676 bcb->DataTransferLength = blenByte; 677 bcb->Flags = 0x80; 678 bcb->CDB[0] = 0xF1; 679 bcb->CDB[5] = (unsigned char)(bnByte); 680 bcb->CDB[4] = (unsigned char)(bnByte>>8); 681 bcb->CDB[3] = (unsigned char)(bnByte>>16); 682 bcb->CDB[2] = (unsigned char)(bnByte>>24); 683 684 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1); 685 return result; 686 } 687 688 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb) 689 { 690 int result; 691 unsigned char *cdb = srb->cmnd; 692 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 693 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 694 695 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) | 696 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff); 697 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 698 u32 bnByte = bn * 0x200; 699 u32 blenByte = blen * 0x200; 700 701 if (bn > info->bl_num) 702 return USB_STOR_TRANSPORT_ERROR; 703 704 result = ene_load_bincode(us, SD_RW_PATTERN); 705 if (result != USB_STOR_XFER_GOOD) { 706 US_DEBUGP("Load SD RW pattern Fail !!\n"); 707 return USB_STOR_TRANSPORT_ERROR; 708 } 709 710 if (info->SD_Status.HiCapacity) 711 bnByte = bn; 712 713 /* set up the command wrapper */ 714 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 715 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 716 bcb->DataTransferLength = blenByte; 717 bcb->Flags = 0x00; 718 bcb->CDB[0] = 0xF0; 719 bcb->CDB[5] = (unsigned char)(bnByte); 720 bcb->CDB[4] = (unsigned char)(bnByte>>8); 721 bcb->CDB[3] = (unsigned char)(bnByte>>16); 722 bcb->CDB[2] = (unsigned char)(bnByte>>24); 723 724 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1); 725 return result; 726 } 727 728 /* 729 * ENE MS Card 730 */ 731 732 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk) 733 { 734 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 735 736 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock)) 737 return (u32)-1; 738 739 info->MS_Lib.Phy2LogMap[phyblk] = logblk; 740 info->MS_Lib.Log2PhyMap[logblk] = phyblk; 741 742 return 0; 743 } 744 745 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark) 746 { 747 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 748 749 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 750 return (u32)-1; 751 752 info->MS_Lib.Phy2LogMap[phyblk] = mark; 753 754 return 0; 755 } 756 757 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk) 758 { 759 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR); 760 } 761 762 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk) 763 { 764 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK); 765 } 766 767 static int ms_lib_free_logicalmap(struct us_data *us) 768 { 769 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 770 771 kfree(info->MS_Lib.Phy2LogMap); 772 info->MS_Lib.Phy2LogMap = NULL; 773 774 kfree(info->MS_Lib.Log2PhyMap); 775 info->MS_Lib.Log2PhyMap = NULL; 776 777 return 0; 778 } 779 780 int ms_lib_alloc_logicalmap(struct us_data *us) 781 { 782 u32 i; 783 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 784 785 info->MS_Lib.Phy2LogMap = kmalloc(info->MS_Lib.NumberOfPhyBlock * sizeof(u16), GFP_KERNEL); 786 info->MS_Lib.Log2PhyMap = kmalloc(info->MS_Lib.NumberOfLogBlock * sizeof(u16), GFP_KERNEL); 787 788 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) { 789 ms_lib_free_logicalmap(us); 790 return (u32)-1; 791 } 792 793 for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++) 794 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED; 795 796 for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++) 797 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED; 798 799 return 0; 800 } 801 802 static void ms_lib_clear_writebuf(struct us_data *us) 803 { 804 int i; 805 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 806 807 info->MS_Lib.wrtblk = (u16)-1; 808 ms_lib_clear_pagemap(info); 809 810 if (info->MS_Lib.blkpag) 811 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector); 812 813 if (info->MS_Lib.blkext) { 814 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) { 815 info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT; 816 info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT; 817 info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT; 818 info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED; 819 } 820 } 821 } 822 823 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock) 824 { 825 u32 Ende, Count; 826 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 827 828 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT; 829 for (Count = 0; PhyBlock < Ende; PhyBlock++) { 830 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) { 831 case MS_LB_NOT_USED: 832 case MS_LB_NOT_USED_ERASED: 833 Count++; 834 default: 835 break; 836 } 837 } 838 839 return Count; 840 } 841 842 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr, 843 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat) 844 { 845 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 846 int result; 847 u8 ExtBuf[4]; 848 u32 bn = PhyBlockAddr * 0x20 + PageNum; 849 850 /* printk(KERN_INFO "MS --- MS_ReaderReadPage, 851 PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */ 852 853 result = ene_load_bincode(us, MS_RW_PATTERN); 854 if (result != USB_STOR_XFER_GOOD) 855 return USB_STOR_TRANSPORT_ERROR; 856 857 /* Read Page Data */ 858 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 859 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 860 bcb->DataTransferLength = 0x200; 861 bcb->Flags = 0x80; 862 bcb->CDB[0] = 0xF1; 863 864 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */ 865 866 bcb->CDB[5] = (unsigned char)(bn); 867 bcb->CDB[4] = (unsigned char)(bn>>8); 868 bcb->CDB[3] = (unsigned char)(bn>>16); 869 bcb->CDB[2] = (unsigned char)(bn>>24); 870 871 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0); 872 if (result != USB_STOR_XFER_GOOD) 873 return USB_STOR_TRANSPORT_ERROR; 874 875 876 /* Read Extra Data */ 877 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 878 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 879 bcb->DataTransferLength = 0x4; 880 bcb->Flags = 0x80; 881 bcb->CDB[0] = 0xF1; 882 bcb->CDB[1] = 0x03; 883 884 bcb->CDB[5] = (unsigned char)(PageNum); 885 bcb->CDB[4] = (unsigned char)(PhyBlockAddr); 886 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8); 887 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16); 888 bcb->CDB[6] = 0x01; 889 890 result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0); 891 if (result != USB_STOR_XFER_GOOD) 892 return USB_STOR_TRANSPORT_ERROR; 893 894 ExtraDat->reserved = 0; 895 ExtraDat->intr = 0x80; /* Not yet,fireware support */ 896 ExtraDat->status0 = 0x10; /* Not yet,fireware support */ 897 898 ExtraDat->status1 = 0x00; /* Not yet,fireware support */ 899 ExtraDat->ovrflg = ExtBuf[0]; 900 ExtraDat->mngflg = ExtBuf[1]; 901 ExtraDat->logadr = memstick_logaddr(ExtBuf[2], ExtBuf[3]); 902 903 return USB_STOR_TRANSPORT_GOOD; 904 } 905 906 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData) 907 { 908 struct ms_bootblock_sysent *SysEntry; 909 struct ms_bootblock_sysinf *SysInfo; 910 u32 i, result; 911 u8 PageNumber; 912 u8 *PageBuffer; 913 struct ms_lib_type_extdat ExtraData; 914 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 915 916 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 917 if (PageBuffer == NULL) 918 return (u32)-1; 919 920 result = (u32)-1; 921 922 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf); 923 924 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) || 925 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) || 926 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) || 927 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) || 928 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) || 929 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) || 930 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL)) 931 goto exit; 932 /* */ 933 switch (info->MS_Lib.cardType = SysInfo->bCardType) { 934 case MS_SYSINF_CARDTYPE_RDONLY: 935 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); 936 break; 937 case MS_SYSINF_CARDTYPE_RDWR: 938 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY); 939 break; 940 case MS_SYSINF_CARDTYPE_HYBRID: 941 default: 942 goto exit; 943 } 944 945 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize); 946 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber); 947 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2; 948 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE; 949 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT; 950 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize); 951 952 /*Allocate to all number of logicalblock and physicalblock */ 953 if (ms_lib_alloc_logicalmap(us)) 954 goto exit; 955 956 /* Mark the book block */ 957 ms_lib_set_bootblockmark(us, PhyBlock); 958 959 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent); 960 961 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) { 962 u32 EntryOffset, EntrySize; 963 964 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart); 965 966 if (EntryOffset == 0xffffff) 967 continue; 968 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize); 969 970 if (EntrySize == 0) 971 continue; 972 973 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO) 974 continue; 975 976 if (i == 0) { 977 u8 PrevPageNumber = 0; 978 u16 phyblk; 979 980 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK) 981 goto exit; 982 983 while (EntrySize > 0) { 984 985 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1); 986 if (PageNumber != PrevPageNumber) { 987 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) { 988 case MS_STATUS_SUCCESS: 989 break; 990 case MS_STATUS_WRITE_PROTECT: 991 case MS_ERROR_FLASH_READ: 992 case MS_STATUS_ERROR: 993 default: 994 goto exit; 995 } 996 997 PrevPageNumber = PageNumber; 998 } 999 1000 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE))); 1001 if (phyblk < 0x0fff) 1002 ms_lib_set_initialerrorblock(us, phyblk); 1003 1004 EntryOffset += 2; 1005 EntrySize -= 2; 1006 } 1007 } else if (i == 1) { /* CIS/IDI */ 1008 struct ms_bootblock_idi *idi; 1009 1010 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI) 1011 goto exit; 1012 1013 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) { 1014 case MS_STATUS_SUCCESS: 1015 break; 1016 case MS_STATUS_WRITE_PROTECT: 1017 case MS_ERROR_FLASH_READ: 1018 case MS_STATUS_ERROR: 1019 default: 1020 goto exit; 1021 } 1022 1023 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi; 1024 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF) 1025 goto exit; 1026 1027 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector); 1028 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE) 1029 goto exit; 1030 } 1031 } /* End for .. */ 1032 1033 result = 0; 1034 1035 exit: 1036 if (result) 1037 ms_lib_free_logicalmap(us); 1038 1039 kfree(PageBuffer); 1040 1041 result = 0; 1042 return result; 1043 } 1044 1045 static void ms_lib_free_writebuf(struct us_data *us) 1046 { 1047 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1048 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */ 1049 1050 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */ 1051 1052 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */ 1053 1054 if (info->MS_Lib.blkpag) { 1055 kfree((u8 *)(info->MS_Lib.blkpag)); /* Arnold test ... */ 1056 info->MS_Lib.blkpag = NULL; 1057 } 1058 1059 if (info->MS_Lib.blkext) { 1060 kfree((u8 *)(info->MS_Lib.blkext)); /* Arnold test ... */ 1061 info->MS_Lib.blkext = NULL; 1062 } 1063 } 1064 1065 1066 static void ms_lib_free_allocatedarea(struct us_data *us) 1067 { 1068 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1069 1070 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */ 1071 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */ 1072 1073 /* set struct us point flag to 0 */ 1074 info->MS_Lib.flags = 0; 1075 info->MS_Lib.BytesPerSector = 0; 1076 info->MS_Lib.SectorsPerCylinder = 0; 1077 1078 info->MS_Lib.cardType = 0; 1079 info->MS_Lib.blockSize = 0; 1080 info->MS_Lib.PagesPerBlock = 0; 1081 1082 info->MS_Lib.NumberOfPhyBlock = 0; 1083 info->MS_Lib.NumberOfLogBlock = 0; 1084 } 1085 1086 1087 static int ms_lib_alloc_writebuf(struct us_data *us) 1088 { 1089 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1090 1091 info->MS_Lib.wrtblk = (u16)-1; 1092 1093 info->MS_Lib.blkpag = kmalloc(info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector, GFP_KERNEL); 1094 info->MS_Lib.blkext = kmalloc(info->MS_Lib.PagesPerBlock * sizeof(struct ms_lib_type_extdat), GFP_KERNEL); 1095 1096 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) { 1097 ms_lib_free_writebuf(us); 1098 return (u32)-1; 1099 } 1100 1101 ms_lib_clear_writebuf(us); 1102 1103 return 0; 1104 } 1105 1106 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk) 1107 { 1108 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1109 1110 if (logblk == MS_LB_NOT_USED) 1111 return 0; 1112 1113 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || 1114 (phyblk >= info->MS_Lib.NumberOfPhyBlock)) 1115 return (u32)-1; 1116 1117 info->MS_Lib.Phy2LogMap[phyblk] = logblk; 1118 info->MS_Lib.Log2PhyMap[logblk] = phyblk; 1119 1120 return 0; 1121 } 1122 1123 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy, 1124 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len) 1125 { 1126 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1127 int result; 1128 1129 /* printk(KERN_INFO "MS_ReaderCopyBlock --- PhyBlockAddr = %x, 1130 PageNum = %x\n", PhyBlockAddr, PageNum); */ 1131 result = ene_load_bincode(us, MS_RW_PATTERN); 1132 if (result != USB_STOR_XFER_GOOD) 1133 return USB_STOR_TRANSPORT_ERROR; 1134 1135 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1136 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1137 bcb->DataTransferLength = 0x200*len; 1138 bcb->Flags = 0x00; 1139 bcb->CDB[0] = 0xF0; 1140 bcb->CDB[1] = 0x08; 1141 bcb->CDB[4] = (unsigned char)(oldphy); 1142 bcb->CDB[3] = (unsigned char)(oldphy>>8); 1143 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */ 1144 bcb->CDB[7] = (unsigned char)(newphy); 1145 bcb->CDB[6] = (unsigned char)(newphy>>8); 1146 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */ 1147 bcb->CDB[9] = (unsigned char)(PhyBlockAddr); 1148 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8); 1149 bcb->CDB[10] = PageNum; 1150 1151 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0); 1152 if (result != USB_STOR_XFER_GOOD) 1153 return USB_STOR_TRANSPORT_ERROR; 1154 1155 return USB_STOR_TRANSPORT_GOOD; 1156 } 1157 1158 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr) 1159 { 1160 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1161 int result; 1162 u32 bn = PhyBlockAddr; 1163 1164 /* printk(KERN_INFO "MS --- ms_read_eraseblock, 1165 PhyBlockAddr = %x\n", PhyBlockAddr); */ 1166 result = ene_load_bincode(us, MS_RW_PATTERN); 1167 if (result != USB_STOR_XFER_GOOD) 1168 return USB_STOR_TRANSPORT_ERROR; 1169 1170 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1171 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1172 bcb->DataTransferLength = 0x200; 1173 bcb->Flags = 0x80; 1174 bcb->CDB[0] = 0xF2; 1175 bcb->CDB[1] = 0x06; 1176 bcb->CDB[4] = (unsigned char)(bn); 1177 bcb->CDB[3] = (unsigned char)(bn>>8); 1178 bcb->CDB[2] = (unsigned char)(bn>>16); 1179 1180 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 1181 if (result != USB_STOR_XFER_GOOD) 1182 return USB_STOR_TRANSPORT_ERROR; 1183 1184 return USB_STOR_TRANSPORT_GOOD; 1185 } 1186 1187 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock) 1188 { 1189 unsigned char *PageBuf = NULL; 1190 u16 result = MS_STATUS_SUCCESS; 1191 u16 blk, index = 0; 1192 struct ms_lib_type_extdat extdat; 1193 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1194 1195 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1196 if (PageBuf == NULL) { 1197 result = MS_NO_MEMORY_ERROR; 1198 goto exit; 1199 } 1200 1201 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat); 1202 do { 1203 blk = be16_to_cpu(PageBuf[index]); 1204 if (blk == MS_LB_NOT_USED) 1205 break; 1206 if (blk == info->MS_Lib.Log2PhyMap[0]) { 1207 result = MS_ERROR_FLASH_READ; 1208 break; 1209 } 1210 index++; 1211 } while (1); 1212 1213 exit: 1214 kfree(PageBuf); 1215 return result; 1216 } 1217 1218 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk) 1219 { 1220 u16 log; 1221 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1222 1223 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1224 return (u32)-1; 1225 1226 log = info->MS_Lib.Phy2LogMap[phyblk]; 1227 1228 if (log < info->MS_Lib.NumberOfLogBlock) 1229 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED; 1230 1231 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR) 1232 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR; 1233 1234 return 0; 1235 } 1236 1237 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr, 1238 u8 PageNum, u8 OverwriteFlag) 1239 { 1240 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1241 int result; 1242 1243 /* printk("MS --- MS_LibOverwriteExtra, 1244 PhyBlockAddr = %x, PageNum = %x\n", PhyBlockAddr, PageNum); */ 1245 result = ene_load_bincode(us, MS_RW_PATTERN); 1246 if (result != USB_STOR_XFER_GOOD) 1247 return USB_STOR_TRANSPORT_ERROR; 1248 1249 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1250 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1251 bcb->DataTransferLength = 0x4; 1252 bcb->Flags = 0x80; 1253 bcb->CDB[0] = 0xF2; 1254 bcb->CDB[1] = 0x05; 1255 bcb->CDB[5] = (unsigned char)(PageNum); 1256 bcb->CDB[4] = (unsigned char)(PhyBlockAddr); 1257 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8); 1258 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16); 1259 bcb->CDB[6] = OverwriteFlag; 1260 bcb->CDB[7] = 0xFF; 1261 bcb->CDB[8] = 0xFF; 1262 bcb->CDB[9] = 0xFF; 1263 1264 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 1265 if (result != USB_STOR_XFER_GOOD) 1266 return USB_STOR_TRANSPORT_ERROR; 1267 1268 return USB_STOR_TRANSPORT_GOOD; 1269 } 1270 1271 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk) 1272 { 1273 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1274 1275 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1276 return MS_STATUS_ERROR; 1277 1278 ms_lib_setacquired_errorblock(us, phyblk); 1279 1280 if (ms_lib_iswritable(info)) 1281 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK)); 1282 1283 return MS_STATUS_SUCCESS; 1284 } 1285 1286 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk) 1287 { 1288 u16 log; 1289 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1290 1291 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1292 return MS_STATUS_ERROR; 1293 1294 log = info->MS_Lib.Phy2LogMap[phyblk]; 1295 1296 if (log < info->MS_Lib.NumberOfLogBlock) 1297 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED; 1298 1299 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED; 1300 1301 if (ms_lib_iswritable(info)) { 1302 switch (ms_read_eraseblock(us, phyblk)) { 1303 case MS_STATUS_SUCCESS: 1304 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED; 1305 return MS_STATUS_SUCCESS; 1306 case MS_ERROR_FLASH_ERASE: 1307 case MS_STATUS_INT_ERROR: 1308 ms_lib_error_phyblock(us, phyblk); 1309 return MS_ERROR_FLASH_ERASE; 1310 case MS_STATUS_ERROR: 1311 default: 1312 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/ 1313 ms_lib_setacquired_errorblock(us, phyblk); 1314 return MS_STATUS_ERROR; 1315 } 1316 } 1317 1318 ms_lib_setacquired_errorblock(us, phyblk); 1319 1320 return MS_STATUS_SUCCESS; 1321 } 1322 1323 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock, 1324 u8 PageNum, struct ms_lib_type_extdat *ExtraDat) 1325 { 1326 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1327 int result; 1328 u8 ExtBuf[4]; 1329 1330 /* printk("MS_LibReadExtra --- PhyBlock = %x, PageNum = %x\n", PhyBlock, PageNum); */ 1331 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1332 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1333 bcb->DataTransferLength = 0x4; 1334 bcb->Flags = 0x80; 1335 bcb->CDB[0] = 0xF1; 1336 bcb->CDB[1] = 0x03; 1337 bcb->CDB[5] = (unsigned char)(PageNum); 1338 bcb->CDB[4] = (unsigned char)(PhyBlock); 1339 bcb->CDB[3] = (unsigned char)(PhyBlock>>8); 1340 bcb->CDB[2] = (unsigned char)(PhyBlock>>16); 1341 bcb->CDB[6] = 0x01; 1342 1343 result = ene_send_scsi_cmd(us, FDIR_READ, &ExtBuf, 0); 1344 if (result != USB_STOR_XFER_GOOD) 1345 return USB_STOR_TRANSPORT_ERROR; 1346 1347 ExtraDat->reserved = 0; 1348 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */ 1349 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */ 1350 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */ 1351 ExtraDat->ovrflg = ExtBuf[0]; 1352 ExtraDat->mngflg = ExtBuf[1]; 1353 ExtraDat->logadr = memstick_logaddr(ExtBuf[2], ExtBuf[3]); 1354 1355 return USB_STOR_TRANSPORT_GOOD; 1356 } 1357 1358 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk) 1359 { 1360 u16 Newblk; 1361 u16 blk; 1362 struct ms_lib_type_extdat extdat; /* need check */ 1363 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1364 1365 1366 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1367 return MS_LB_ERROR; 1368 1369 for (blk = phyblk + 1; blk != phyblk; blk++) { 1370 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0) 1371 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1372 1373 Newblk = info->MS_Lib.Phy2LogMap[blk]; 1374 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) { 1375 return blk; 1376 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) { 1377 switch (ms_lib_read_extra(us, blk, 0, &extdat)) { 1378 case MS_STATUS_SUCCESS: 1379 case MS_STATUS_SUCCESS_WITH_ECC: 1380 break; 1381 case MS_NOCARD_ERROR: 1382 return MS_NOCARD_ERROR; 1383 case MS_STATUS_INT_ERROR: 1384 return MS_LB_ERROR; 1385 case MS_ERROR_FLASH_READ: 1386 default: 1387 ms_lib_setacquired_errorblock(us, blk); 1388 continue; 1389 } /* End switch */ 1390 1391 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) { 1392 ms_lib_setacquired_errorblock(us, blk); 1393 continue; 1394 } 1395 1396 switch (ms_lib_erase_phyblock(us, blk)) { 1397 case MS_STATUS_SUCCESS: 1398 return blk; 1399 case MS_STATUS_ERROR: 1400 return MS_LB_ERROR; 1401 case MS_ERROR_FLASH_ERASE: 1402 default: 1403 ms_lib_error_phyblock(us, blk); 1404 break; 1405 } 1406 } 1407 } /* End for */ 1408 1409 return MS_LB_ERROR; 1410 } 1411 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk) 1412 { 1413 u16 phyblk; 1414 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1415 1416 phyblk = ms_libconv_to_physical(info, logblk); 1417 if (phyblk >= MS_LB_ERROR) { 1418 if (logblk >= info->MS_Lib.NumberOfLogBlock) 1419 return MS_LB_ERROR; 1420 1421 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT; 1422 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1423 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1; 1424 } 1425 1426 return ms_libsearch_block_from_physical(us, phyblk); 1427 } 1428 1429 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb) 1430 { 1431 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 1432 1433 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */ 1434 if (info->MS_Status.Insert && info->MS_Status.Ready) { 1435 return USB_STOR_TRANSPORT_GOOD; 1436 } else { 1437 ene_ms_init(us); 1438 return USB_STOR_TRANSPORT_GOOD; 1439 } 1440 1441 return USB_STOR_TRANSPORT_GOOD; 1442 } 1443 1444 static int ms_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb) 1445 { 1446 /* pr_info("MS_SCSI_Inquiry\n"); */ 1447 unsigned char data_ptr[36] = { 1448 0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55, 1449 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61, 1450 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 1451 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30}; 1452 1453 usb_stor_set_xfer_buf(data_ptr, 36, srb); 1454 return USB_STOR_TRANSPORT_GOOD; 1455 } 1456 1457 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb) 1458 { 1459 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1460 unsigned char mediaNoWP[12] = { 1461 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00, 1462 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 1463 unsigned char mediaWP[12] = { 1464 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00, 1465 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 1466 1467 if (info->MS_Status.WtP) 1468 usb_stor_set_xfer_buf(mediaWP, 12, srb); 1469 else 1470 usb_stor_set_xfer_buf(mediaNoWP, 12, srb); 1471 1472 return USB_STOR_TRANSPORT_GOOD; 1473 } 1474 1475 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb) 1476 { 1477 u32 bl_num; 1478 u16 bl_len; 1479 unsigned int offset = 0; 1480 unsigned char buf[8]; 1481 struct scatterlist *sg = NULL; 1482 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1483 1484 US_DEBUGP("ms_scsi_read_capacity\n"); 1485 bl_len = 0x200; 1486 if (info->MS_Status.IsMSPro) 1487 bl_num = info->MSP_TotalBlock - 1; 1488 else 1489 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1; 1490 1491 info->bl_num = bl_num; 1492 US_DEBUGP("bl_len = %x\n", bl_len); 1493 US_DEBUGP("bl_num = %x\n", bl_num); 1494 1495 /*srb->request_bufflen = 8; */ 1496 buf[0] = (bl_num >> 24) & 0xff; 1497 buf[1] = (bl_num >> 16) & 0xff; 1498 buf[2] = (bl_num >> 8) & 0xff; 1499 buf[3] = (bl_num >> 0) & 0xff; 1500 buf[4] = (bl_len >> 24) & 0xff; 1501 buf[5] = (bl_len >> 16) & 0xff; 1502 buf[6] = (bl_len >> 8) & 0xff; 1503 buf[7] = (bl_len >> 0) & 0xff; 1504 1505 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF); 1506 1507 return USB_STOR_TRANSPORT_GOOD; 1508 } 1509 1510 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde) 1511 { 1512 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1513 1514 if (PhyBlock) { 1515 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/ 1516 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/ 1517 } else { 1518 *LogStart = 0; 1519 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/ 1520 } 1521 } 1522 1523 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock, 1524 u8 PageNum, u8 blen, void *buf) 1525 { 1526 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1527 int result; 1528 1529 /* printk("MS_LibReadExtraBlock --- PhyBlock = %x, 1530 PageNum = %x, blen = %x\n", PhyBlock, PageNum, blen); */ 1531 1532 /* Read Extra Data */ 1533 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1534 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1535 bcb->DataTransferLength = 0x4 * blen; 1536 bcb->Flags = 0x80; 1537 bcb->CDB[0] = 0xF1; 1538 bcb->CDB[1] = 0x03; 1539 bcb->CDB[5] = (unsigned char)(PageNum); 1540 bcb->CDB[4] = (unsigned char)(PhyBlock); 1541 bcb->CDB[3] = (unsigned char)(PhyBlock>>8); 1542 bcb->CDB[2] = (unsigned char)(PhyBlock>>16); 1543 bcb->CDB[6] = blen; 1544 1545 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0); 1546 if (result != USB_STOR_XFER_GOOD) 1547 return USB_STOR_TRANSPORT_ERROR; 1548 1549 return USB_STOR_TRANSPORT_GOOD; 1550 } 1551 1552 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st) 1553 { 1554 u16 PhyBlock, newblk, i; 1555 u16 LogStart, LogEnde; 1556 struct ms_lib_type_extdat extdat; 1557 u8 buf[0x200]; 1558 u32 count = 0, index = 0; 1559 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1560 1561 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) { 1562 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde); 1563 1564 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) { 1565 switch (ms_libconv_to_logical(info, PhyBlock)) { 1566 case MS_STATUS_ERROR: 1567 continue; 1568 default: 1569 break; 1570 } 1571 1572 if (count == PhyBlock) { 1573 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80, &buf); 1574 count += 0x80; 1575 } 1576 index = (PhyBlock % 0x80) * 4; 1577 1578 extdat.ovrflg = buf[index]; 1579 extdat.mngflg = buf[index+1]; 1580 extdat.logadr = memstick_logaddr(buf[index+2], buf[index+3]); 1581 1582 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) { 1583 ms_lib_setacquired_errorblock(us, PhyBlock); 1584 continue; 1585 } 1586 1587 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) { 1588 ms_lib_erase_phyblock(us, PhyBlock); 1589 continue; 1590 } 1591 1592 if (extdat.logadr != MS_LB_NOT_USED) { 1593 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) { 1594 ms_lib_erase_phyblock(us, PhyBlock); 1595 continue; 1596 } 1597 1598 newblk = ms_libconv_to_physical(info, extdat.logadr); 1599 1600 if (newblk != MS_LB_NOT_USED) { 1601 if (extdat.logadr == 0) { 1602 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock); 1603 if (ms_lib_check_disableblock(us, btBlk1st)) { 1604 ms_lib_set_logicalpair(us, extdat.logadr, newblk); 1605 continue; 1606 } 1607 } 1608 1609 ms_lib_read_extra(us, newblk, 0, &extdat); 1610 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) { 1611 ms_lib_erase_phyblock(us, PhyBlock); 1612 continue; 1613 } else { 1614 ms_lib_erase_phyblock(us, newblk); 1615 } 1616 } 1617 1618 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock); 1619 } 1620 } 1621 } /* End for ... */ 1622 1623 return MS_STATUS_SUCCESS; 1624 } 1625 1626 1627 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb) 1628 { 1629 int result; 1630 unsigned char *cdb = srb->cmnd; 1631 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1632 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1633 1634 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) | 1635 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff); 1636 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 1637 u32 blenByte = blen * 0x200; 1638 1639 if (bn > info->bl_num) 1640 return USB_STOR_TRANSPORT_ERROR; 1641 1642 if (info->MS_Status.IsMSPro) { 1643 result = ene_load_bincode(us, MSP_RW_PATTERN); 1644 if (result != USB_STOR_XFER_GOOD) { 1645 US_DEBUGP("Load MPS RW pattern Fail !!\n"); 1646 return USB_STOR_TRANSPORT_ERROR; 1647 } 1648 1649 /* set up the command wrapper */ 1650 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1651 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1652 bcb->DataTransferLength = blenByte; 1653 bcb->Flags = 0x80; 1654 bcb->CDB[0] = 0xF1; 1655 bcb->CDB[1] = 0x02; 1656 bcb->CDB[5] = (unsigned char)(bn); 1657 bcb->CDB[4] = (unsigned char)(bn>>8); 1658 bcb->CDB[3] = (unsigned char)(bn>>16); 1659 bcb->CDB[2] = (unsigned char)(bn>>24); 1660 1661 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1); 1662 } else { 1663 void *buf; 1664 int offset = 0; 1665 u16 phyblk, logblk; 1666 u8 PageNum; 1667 u16 len; 1668 u32 blkno; 1669 1670 buf = kmalloc(blenByte, GFP_KERNEL); 1671 if (buf == NULL) 1672 return USB_STOR_TRANSPORT_ERROR; 1673 1674 result = ene_load_bincode(us, MS_RW_PATTERN); 1675 if (result != USB_STOR_XFER_GOOD) { 1676 pr_info("Load MS RW pattern Fail !!\n"); 1677 result = USB_STOR_TRANSPORT_ERROR; 1678 goto exit; 1679 } 1680 1681 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock); 1682 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock); 1683 1684 while (1) { 1685 if (blen > (info->MS_Lib.PagesPerBlock-PageNum)) 1686 len = info->MS_Lib.PagesPerBlock-PageNum; 1687 else 1688 len = blen; 1689 1690 phyblk = ms_libconv_to_physical(info, logblk); 1691 blkno = phyblk * 0x20 + PageNum; 1692 1693 /* set up the command wrapper */ 1694 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1695 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1696 bcb->DataTransferLength = 0x200 * len; 1697 bcb->Flags = 0x80; 1698 bcb->CDB[0] = 0xF1; 1699 bcb->CDB[1] = 0x02; 1700 bcb->CDB[5] = (unsigned char)(blkno); 1701 bcb->CDB[4] = (unsigned char)(blkno>>8); 1702 bcb->CDB[3] = (unsigned char)(blkno>>16); 1703 bcb->CDB[2] = (unsigned char)(blkno>>24); 1704 1705 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0); 1706 if (result != USB_STOR_XFER_GOOD) { 1707 pr_info("MS_SCSI_Read --- result = %x\n", result); 1708 result = USB_STOR_TRANSPORT_ERROR; 1709 goto exit; 1710 } 1711 1712 blen -= len; 1713 if (blen <= 0) 1714 break; 1715 logblk++; 1716 PageNum = 0; 1717 offset += MS_BYTES_PER_PAGE*len; 1718 } 1719 usb_stor_set_xfer_buf(buf, blenByte, srb); 1720 exit: 1721 kfree(buf); 1722 } 1723 return result; 1724 } 1725 1726 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb) 1727 { 1728 int result; 1729 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1730 unsigned char *cdb = srb->cmnd; 1731 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1732 1733 u32 bn = ((cdb[2] << 24) & 0xff000000) | 1734 ((cdb[3] << 16) & 0x00ff0000) | 1735 ((cdb[4] << 8) & 0x0000ff00) | 1736 ((cdb[5] << 0) & 0x000000ff); 1737 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 1738 u32 blenByte = blen * 0x200; 1739 1740 if (bn > info->bl_num) 1741 return USB_STOR_TRANSPORT_ERROR; 1742 1743 if (info->MS_Status.IsMSPro) { 1744 result = ene_load_bincode(us, MSP_RW_PATTERN); 1745 if (result != USB_STOR_XFER_GOOD) { 1746 pr_info("Load MSP RW pattern Fail !!\n"); 1747 return USB_STOR_TRANSPORT_ERROR; 1748 } 1749 1750 /* set up the command wrapper */ 1751 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1752 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1753 bcb->DataTransferLength = blenByte; 1754 bcb->Flags = 0x00; 1755 bcb->CDB[0] = 0xF0; 1756 bcb->CDB[1] = 0x04; 1757 bcb->CDB[5] = (unsigned char)(bn); 1758 bcb->CDB[4] = (unsigned char)(bn>>8); 1759 bcb->CDB[3] = (unsigned char)(bn>>16); 1760 bcb->CDB[2] = (unsigned char)(bn>>24); 1761 1762 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1); 1763 } else { 1764 void *buf; 1765 int offset; 1766 u16 PhyBlockAddr; 1767 u8 PageNum; 1768 u32 result; 1769 u16 len, oldphy, newphy; 1770 1771 buf = kmalloc(blenByte, GFP_KERNEL); 1772 if (buf == NULL) 1773 return USB_STOR_TRANSPORT_ERROR; 1774 usb_stor_set_xfer_buf(buf, blenByte, srb); 1775 1776 result = ene_load_bincode(us, MS_RW_PATTERN); 1777 if (result != USB_STOR_XFER_GOOD) { 1778 pr_info("Load MS RW pattern Fail !!\n"); 1779 result = USB_STOR_TRANSPORT_ERROR; 1780 goto exit; 1781 } 1782 1783 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock); 1784 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock); 1785 1786 while (1) { 1787 if (blen > (info->MS_Lib.PagesPerBlock-PageNum)) 1788 len = info->MS_Lib.PagesPerBlock-PageNum; 1789 else 1790 len = blen; 1791 1792 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */ 1793 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr); 1794 1795 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len); 1796 1797 if (result != USB_STOR_XFER_GOOD) { 1798 pr_info("MS_SCSI_Write --- result = %x\n", result); 1799 result = USB_STOR_TRANSPORT_ERROR; 1800 goto exit; 1801 } 1802 1803 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED; 1804 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy); 1805 1806 blen -= len; 1807 if (blen <= 0) 1808 break; 1809 PhyBlockAddr++; 1810 PageNum = 0; 1811 offset += MS_BYTES_PER_PAGE*len; 1812 } 1813 exit: 1814 kfree(buf); 1815 } 1816 return result; 1817 } 1818 1819 /* 1820 * ENE MS Card 1821 */ 1822 1823 static int ene_get_card_type(struct us_data *us, u16 index, void *buf) 1824 { 1825 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1826 int result; 1827 1828 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1829 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1830 bcb->DataTransferLength = 0x01; 1831 bcb->Flags = 0x80; 1832 bcb->CDB[0] = 0xED; 1833 bcb->CDB[2] = (unsigned char)(index>>8); 1834 bcb->CDB[3] = (unsigned char)index; 1835 1836 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0); 1837 return result; 1838 } 1839 1840 static int ene_get_card_status(struct us_data *us, u8 *buf) 1841 { 1842 u16 tmpreg; 1843 u32 reg4b; 1844 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1845 1846 /*US_DEBUGP("transport --- ENE_ReadSDReg\n");*/ 1847 reg4b = *(u32 *)&buf[0x18]; 1848 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f); 1849 1850 tmpreg = (u16) reg4b; 1851 reg4b = *(u32 *)(&buf[0x14]); 1852 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC) 1853 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff; 1854 1855 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22); 1856 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07; 1857 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC) 1858 info->HC_C_SIZE = *(u32 *)(&buf[0x100]); 1859 1860 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) { 1861 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN); 1862 info->SD_READ_BL_LEN = SD_BLOCK_LEN; 1863 } else { 1864 info->SD_Block_Mult = 1; 1865 } 1866 1867 return USB_STOR_TRANSPORT_GOOD; 1868 } 1869 1870 static int ene_load_bincode(struct us_data *us, unsigned char flag) 1871 { 1872 int err; 1873 char *fw_name = NULL; 1874 unsigned char *buf = NULL; 1875 const struct firmware *sd_fw = NULL; 1876 int result = USB_STOR_TRANSPORT_ERROR; 1877 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1878 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1879 1880 if (info->BIN_FLAG == flag) 1881 return USB_STOR_TRANSPORT_GOOD; 1882 1883 switch (flag) { 1884 /* For SD */ 1885 case SD_INIT1_PATTERN: 1886 US_DEBUGP("SD_INIT1_PATTERN\n"); 1887 fw_name = "ene-ub6250/sd_init1.bin"; 1888 break; 1889 case SD_INIT2_PATTERN: 1890 US_DEBUGP("SD_INIT2_PATTERN\n"); 1891 fw_name = "ene-ub6250/sd_init2.bin"; 1892 break; 1893 case SD_RW_PATTERN: 1894 US_DEBUGP("SD_RDWR_PATTERN\n"); 1895 fw_name = "ene-ub6250/sd_rdwr.bin"; 1896 break; 1897 /* For MS */ 1898 case MS_INIT_PATTERN: 1899 US_DEBUGP("MS_INIT_PATTERN\n"); 1900 fw_name = "ene-ub6250/ms_init.bin"; 1901 break; 1902 case MSP_RW_PATTERN: 1903 US_DEBUGP("MSP_RW_PATTERN\n"); 1904 fw_name = "ene-ub6250/msp_rdwr.bin"; 1905 break; 1906 case MS_RW_PATTERN: 1907 US_DEBUGP("MS_RW_PATTERN\n"); 1908 fw_name = "ene-ub6250/ms_rdwr.bin"; 1909 break; 1910 default: 1911 US_DEBUGP("----------- Unknown PATTERN ----------\n"); 1912 goto nofw; 1913 } 1914 1915 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev); 1916 if (err) { 1917 US_DEBUGP("load firmware %s failed\n", fw_name); 1918 goto nofw; 1919 } 1920 buf = kmalloc(sd_fw->size, GFP_KERNEL); 1921 if (buf == NULL) { 1922 US_DEBUGP("Malloc memory for fireware failed!\n"); 1923 goto nofw; 1924 } 1925 memcpy(buf, sd_fw->data, sd_fw->size); 1926 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1927 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1928 bcb->DataTransferLength = sd_fw->size; 1929 bcb->Flags = 0x00; 1930 bcb->CDB[0] = 0xEF; 1931 1932 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0); 1933 info->BIN_FLAG = flag; 1934 kfree(buf); 1935 1936 nofw: 1937 if (sd_fw != NULL) { 1938 release_firmware(sd_fw); 1939 sd_fw = NULL; 1940 } 1941 1942 return result; 1943 } 1944 1945 static int ms_card_init(struct us_data *us) 1946 { 1947 u32 result; 1948 u16 TmpBlock; 1949 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL; 1950 struct ms_lib_type_extdat extdat; 1951 u16 btBlk1st, btBlk2nd; 1952 u32 btBlk1stErred; 1953 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1954 1955 printk(KERN_INFO "MS_CardInit start\n"); 1956 1957 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */ 1958 1959 /* get two PageBuffer */ 1960 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1961 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1962 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) { 1963 result = MS_NO_MEMORY_ERROR; 1964 goto exit; 1965 } 1966 1967 btBlk1st = btBlk2nd = MS_LB_NOT_USED; 1968 btBlk1stErred = 0; 1969 1970 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) { 1971 1972 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) { 1973 case MS_STATUS_SUCCESS: 1974 break; 1975 case MS_STATUS_INT_ERROR: 1976 break; 1977 case MS_STATUS_ERROR: 1978 default: 1979 continue; 1980 } 1981 1982 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG) 1983 continue; 1984 1985 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) || 1986 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) || 1987 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) || 1988 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES)) 1989 continue; 1990 1991 if (btBlk1st != MS_LB_NOT_USED) { 1992 btBlk2nd = TmpBlock; 1993 break; 1994 } 1995 1996 btBlk1st = TmpBlock; 1997 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE); 1998 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER)) 1999 btBlk1stErred = 1; 2000 } 2001 2002 if (btBlk1st == MS_LB_NOT_USED) { 2003 result = MS_STATUS_ERROR; 2004 goto exit; 2005 } 2006 2007 /* write protect */ 2008 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON) 2009 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT); 2010 2011 result = MS_STATUS_ERROR; 2012 /* 1st Boot Block */ 2013 if (btBlk1stErred == 0) 2014 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1); 2015 /* 1st */ 2016 /* 2nd Boot Block */ 2017 if (result && (btBlk2nd != MS_LB_NOT_USED)) 2018 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0); 2019 2020 if (result) { 2021 result = MS_STATUS_ERROR; 2022 goto exit; 2023 } 2024 2025 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++) 2026 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR; 2027 2028 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK; 2029 2030 if (btBlk2nd != MS_LB_NOT_USED) { 2031 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++) 2032 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR; 2033 2034 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK; 2035 } 2036 2037 result = ms_lib_scan_logicalblocknumber(us, btBlk1st); 2038 if (result) 2039 goto exit; 2040 2041 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT; 2042 TmpBlock < info->MS_Lib.NumberOfPhyBlock; 2043 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) { 2044 if (ms_count_freeblock(us, TmpBlock) == 0) { 2045 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT); 2046 break; 2047 } 2048 } 2049 2050 /* write */ 2051 if (ms_lib_alloc_writebuf(us)) { 2052 result = MS_NO_MEMORY_ERROR; 2053 goto exit; 2054 } 2055 2056 result = MS_STATUS_SUCCESS; 2057 2058 exit: 2059 kfree(PageBuffer1); 2060 kfree(PageBuffer0); 2061 2062 printk(KERN_INFO "MS_CardInit end\n"); 2063 return result; 2064 } 2065 2066 static int ene_ms_init(struct us_data *us) 2067 { 2068 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 2069 int result; 2070 u8 buf[0x200]; 2071 u16 MSP_BlockSize, MSP_UserAreaBlocks; 2072 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 2073 2074 printk(KERN_INFO "transport --- ENE_MSInit\n"); 2075 2076 /* the same part to test ENE */ 2077 2078 result = ene_load_bincode(us, MS_INIT_PATTERN); 2079 if (result != USB_STOR_XFER_GOOD) { 2080 printk(KERN_ERR "Load MS Init Code Fail !!\n"); 2081 return USB_STOR_TRANSPORT_ERROR; 2082 } 2083 2084 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2085 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2086 bcb->DataTransferLength = 0x200; 2087 bcb->Flags = 0x80; 2088 bcb->CDB[0] = 0xF1; 2089 bcb->CDB[1] = 0x01; 2090 2091 result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0); 2092 if (result != USB_STOR_XFER_GOOD) { 2093 printk(KERN_ERR "Execution MS Init Code Fail !!\n"); 2094 return USB_STOR_TRANSPORT_ERROR; 2095 } 2096 /* the same part to test ENE */ 2097 info->MS_Status = *(struct MS_STATUS *)&buf[0]; 2098 2099 if (info->MS_Status.Insert && info->MS_Status.Ready) { 2100 printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert); 2101 printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready); 2102 printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro); 2103 printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG); 2104 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP); 2105 if (info->MS_Status.IsMSPro) { 2106 MSP_BlockSize = (buf[6] << 8) | buf[7]; 2107 MSP_UserAreaBlocks = (buf[10] << 8) | buf[11]; 2108 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks; 2109 } else { 2110 ms_card_init(us); /* Card is MS (to ms.c)*/ 2111 } 2112 US_DEBUGP("MS Init Code OK !!\n"); 2113 } else { 2114 US_DEBUGP("MS Card Not Ready --- %x\n", buf[0]); 2115 return USB_STOR_TRANSPORT_ERROR; 2116 } 2117 2118 return USB_STOR_TRANSPORT_GOOD; 2119 } 2120 2121 static int ene_sd_init(struct us_data *us) 2122 { 2123 int result; 2124 u8 buf[0x200]; 2125 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 2126 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 2127 2128 US_DEBUGP("transport --- ENE_SDInit\n"); 2129 /* SD Init Part-1 */ 2130 result = ene_load_bincode(us, SD_INIT1_PATTERN); 2131 if (result != USB_STOR_XFER_GOOD) { 2132 US_DEBUGP("Load SD Init Code Part-1 Fail !!\n"); 2133 return USB_STOR_TRANSPORT_ERROR; 2134 } 2135 2136 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2137 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2138 bcb->Flags = 0x80; 2139 bcb->CDB[0] = 0xF2; 2140 2141 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 2142 if (result != USB_STOR_XFER_GOOD) { 2143 US_DEBUGP("Execution SD Init Code Fail !!\n"); 2144 return USB_STOR_TRANSPORT_ERROR; 2145 } 2146 2147 /* SD Init Part-2 */ 2148 result = ene_load_bincode(us, SD_INIT2_PATTERN); 2149 if (result != USB_STOR_XFER_GOOD) { 2150 US_DEBUGP("Load SD Init Code Part-2 Fail !!\n"); 2151 return USB_STOR_TRANSPORT_ERROR; 2152 } 2153 2154 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2155 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2156 bcb->DataTransferLength = 0x200; 2157 bcb->Flags = 0x80; 2158 bcb->CDB[0] = 0xF1; 2159 2160 result = ene_send_scsi_cmd(us, FDIR_READ, &buf, 0); 2161 if (result != USB_STOR_XFER_GOOD) { 2162 US_DEBUGP("Execution SD Init Code Fail !!\n"); 2163 return USB_STOR_TRANSPORT_ERROR; 2164 } 2165 2166 info->SD_Status = *(struct SD_STATUS *)&buf[0]; 2167 if (info->SD_Status.Insert && info->SD_Status.Ready) { 2168 ene_get_card_status(us, (unsigned char *)&buf); 2169 US_DEBUGP("Insert = %x\n", info->SD_Status.Insert); 2170 US_DEBUGP("Ready = %x\n", info->SD_Status.Ready); 2171 US_DEBUGP("IsMMC = %x\n", info->SD_Status.IsMMC); 2172 US_DEBUGP("HiCapacity = %x\n", info->SD_Status.HiCapacity); 2173 US_DEBUGP("HiSpeed = %x\n", info->SD_Status.HiSpeed); 2174 US_DEBUGP("WtP = %x\n", info->SD_Status.WtP); 2175 } else { 2176 US_DEBUGP("SD Card Not Ready --- %x\n", buf[0]); 2177 return USB_STOR_TRANSPORT_ERROR; 2178 } 2179 return USB_STOR_TRANSPORT_GOOD; 2180 } 2181 2182 2183 static int ene_init(struct us_data *us) 2184 { 2185 int result; 2186 u8 misc_reg03 = 0; 2187 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2188 2189 result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03); 2190 if (result != USB_STOR_XFER_GOOD) 2191 return USB_STOR_TRANSPORT_ERROR; 2192 2193 if (misc_reg03 & 0x01) { 2194 if (!info->SD_Status.Ready) { 2195 result = ene_sd_init(us); 2196 if (result != USB_STOR_XFER_GOOD) 2197 return USB_STOR_TRANSPORT_ERROR; 2198 } 2199 } 2200 if (misc_reg03 & 0x02) { 2201 if (!info->MS_Status.Ready) { 2202 result = ene_ms_init(us); 2203 if (result != USB_STOR_XFER_GOOD) 2204 return USB_STOR_TRANSPORT_ERROR; 2205 } 2206 } 2207 return result; 2208 } 2209 2210 /*----- sd_scsi_irp() ---------*/ 2211 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb) 2212 { 2213 int result; 2214 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra; 2215 2216 info->SrbStatus = SS_SUCCESS; 2217 switch (srb->cmnd[0]) { 2218 case TEST_UNIT_READY: 2219 result = sd_scsi_test_unit_ready(us, srb); 2220 break; /* 0x00 */ 2221 case INQUIRY: 2222 result = sd_scsi_inquiry(us, srb); 2223 break; /* 0x12 */ 2224 case MODE_SENSE: 2225 result = sd_scsi_mode_sense(us, srb); 2226 break; /* 0x1A */ 2227 /* 2228 case START_STOP: 2229 result = SD_SCSI_Start_Stop(us, srb); 2230 break; //0x1B 2231 */ 2232 case READ_CAPACITY: 2233 result = sd_scsi_read_capacity(us, srb); 2234 break; /* 0x25 */ 2235 case READ_10: 2236 result = sd_scsi_read(us, srb); 2237 break; /* 0x28 */ 2238 case WRITE_10: 2239 result = sd_scsi_write(us, srb); 2240 break; /* 0x2A */ 2241 default: 2242 info->SrbStatus = SS_ILLEGAL_REQUEST; 2243 result = USB_STOR_TRANSPORT_FAILED; 2244 break; 2245 } 2246 return result; 2247 } 2248 2249 /* 2250 * ms_scsi_irp() 2251 */ 2252 int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb) 2253 { 2254 int result; 2255 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra; 2256 info->SrbStatus = SS_SUCCESS; 2257 switch (srb->cmnd[0]) { 2258 case TEST_UNIT_READY: 2259 result = ms_scsi_test_unit_ready(us, srb); 2260 break; /* 0x00 */ 2261 case INQUIRY: 2262 result = ms_scsi_inquiry(us, srb); 2263 break; /* 0x12 */ 2264 case MODE_SENSE: 2265 result = ms_scsi_mode_sense(us, srb); 2266 break; /* 0x1A */ 2267 case READ_CAPACITY: 2268 result = ms_scsi_read_capacity(us, srb); 2269 break; /* 0x25 */ 2270 case READ_10: 2271 result = ms_scsi_read(us, srb); 2272 break; /* 0x28 */ 2273 case WRITE_10: 2274 result = ms_scsi_write(us, srb); 2275 break; /* 0x2A */ 2276 default: 2277 info->SrbStatus = SS_ILLEGAL_REQUEST; 2278 result = USB_STOR_TRANSPORT_FAILED; 2279 break; 2280 } 2281 return result; 2282 } 2283 2284 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us) 2285 { 2286 int result = 0; 2287 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2288 2289 /*US_DEBUG(usb_stor_show_command(srb)); */ 2290 scsi_set_resid(srb, 0); 2291 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) { 2292 result = ene_init(us); 2293 } else { 2294 if (info->SD_Status.Ready) 2295 result = sd_scsi_irp(us, srb); 2296 2297 if (info->MS_Status.Ready) 2298 result = ms_scsi_irp(us, srb); 2299 } 2300 return 0; 2301 } 2302 2303 2304 static int ene_ub6250_probe(struct usb_interface *intf, 2305 const struct usb_device_id *id) 2306 { 2307 int result; 2308 u8 misc_reg03 = 0; 2309 struct us_data *us; 2310 2311 result = usb_stor_probe1(&us, intf, id, 2312 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list); 2313 if (result) 2314 return result; 2315 2316 /* FIXME: where should the code alloc extra buf ? */ 2317 if (!us->extra) { 2318 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL); 2319 if (!us->extra) 2320 return -ENOMEM; 2321 us->extra_destructor = ene_ub6250_info_destructor; 2322 } 2323 2324 us->transport_name = "ene_ub6250"; 2325 us->transport = ene_transport; 2326 us->max_lun = 0; 2327 2328 result = usb_stor_probe2(us); 2329 if (result) 2330 return result; 2331 2332 /* probe card type */ 2333 result = ene_get_card_type(us, REG_CARD_STATUS, &misc_reg03); 2334 if (result != USB_STOR_XFER_GOOD) { 2335 usb_stor_disconnect(intf); 2336 return USB_STOR_TRANSPORT_ERROR; 2337 } 2338 2339 if (!(misc_reg03 & 0x01)) { 2340 pr_info("ums_eneub6250: The driver only supports SD/MS card. " 2341 "To use SM card, please build driver/staging/keucr\n"); 2342 } 2343 2344 return result; 2345 } 2346 2347 2348 #ifdef CONFIG_PM 2349 2350 static int ene_ub6250_resume(struct usb_interface *iface) 2351 { 2352 u8 tmp = 0; 2353 struct us_data *us = usb_get_intfdata(iface); 2354 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2355 2356 mutex_lock(&us->dev_mutex); 2357 2358 US_DEBUGP("%s\n", __func__); 2359 if (us->suspend_resume_hook) 2360 (us->suspend_resume_hook)(us, US_RESUME); 2361 2362 mutex_unlock(&us->dev_mutex); 2363 2364 info->Power_IsResum = true; 2365 /*info->SD_Status.Ready = 0; */ 2366 info->SD_Status = *(struct SD_STATUS *)&tmp; 2367 info->MS_Status = *(struct MS_STATUS *)&tmp; 2368 info->SM_Status = *(struct SM_STATUS *)&tmp; 2369 2370 return 0; 2371 } 2372 2373 static int ene_ub6250_reset_resume(struct usb_interface *iface) 2374 { 2375 u8 tmp = 0; 2376 struct us_data *us = usb_get_intfdata(iface); 2377 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2378 US_DEBUGP("%s\n", __func__); 2379 /* Report the reset to the SCSI core */ 2380 usb_stor_reset_resume(iface); 2381 2382 /* FIXME: Notify the subdrivers that they need to reinitialize 2383 * the device */ 2384 info->Power_IsResum = true; 2385 /*info->SD_Status.Ready = 0; */ 2386 info->SD_Status = *(struct SD_STATUS *)&tmp; 2387 info->MS_Status = *(struct MS_STATUS *)&tmp; 2388 info->SM_Status = *(struct SM_STATUS *)&tmp; 2389 2390 return 0; 2391 } 2392 2393 #else 2394 2395 #define ene_ub6250_resume NULL 2396 #define ene_ub6250_reset_resume NULL 2397 2398 #endif 2399 2400 static struct usb_driver ene_ub6250_driver = { 2401 .name = "ums_eneub6250", 2402 .probe = ene_ub6250_probe, 2403 .disconnect = usb_stor_disconnect, 2404 .suspend = usb_stor_suspend, 2405 .resume = ene_ub6250_resume, 2406 .reset_resume = ene_ub6250_reset_resume, 2407 .pre_reset = usb_stor_pre_reset, 2408 .post_reset = usb_stor_post_reset, 2409 .id_table = ene_ub6250_usb_ids, 2410 .soft_unbind = 1, 2411 }; 2412 2413 static int __init ene_ub6250_init(void) 2414 { 2415 return usb_register(&ene_ub6250_driver); 2416 } 2417 2418 static void __exit ene_ub6250_exit(void) 2419 { 2420 usb_deregister(&ene_ub6250_driver); 2421 } 2422 2423 module_init(ene_ub6250_init); 2424 module_exit(ene_ub6250_exit); 2425