1 // SPDX-License-Identifier: GPL-2.0+ 2 #include <linux/jiffies.h> 3 #include <linux/errno.h> 4 #include <linux/module.h> 5 #include <linux/slab.h> 6 7 #include <scsi/scsi.h> 8 #include <scsi/scsi_cmnd.h> 9 10 #include <linux/firmware.h> 11 12 #include "usb.h" 13 #include "transport.h" 14 #include "protocol.h" 15 #include "debug.h" 16 #include "scsiglue.h" 17 18 #define SD_INIT1_FIRMWARE "ene-ub6250/sd_init1.bin" 19 #define SD_INIT2_FIRMWARE "ene-ub6250/sd_init2.bin" 20 #define SD_RW_FIRMWARE "ene-ub6250/sd_rdwr.bin" 21 #define MS_INIT_FIRMWARE "ene-ub6250/ms_init.bin" 22 #define MSP_RW_FIRMWARE "ene-ub6250/msp_rdwr.bin" 23 #define MS_RW_FIRMWARE "ene-ub6250/ms_rdwr.bin" 24 25 #define DRV_NAME "ums_eneub6250" 26 27 MODULE_DESCRIPTION("Driver for ENE UB6250 reader"); 28 MODULE_LICENSE("GPL"); 29 MODULE_FIRMWARE(SD_INIT1_FIRMWARE); 30 MODULE_FIRMWARE(SD_INIT2_FIRMWARE); 31 MODULE_FIRMWARE(SD_RW_FIRMWARE); 32 MODULE_FIRMWARE(MS_INIT_FIRMWARE); 33 MODULE_FIRMWARE(MSP_RW_FIRMWARE); 34 MODULE_FIRMWARE(MS_RW_FIRMWARE); 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)} 44 45 static 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 0x000000 /* No Sense */ 84 #define SS_NOT_READY 0x023A00 /* Medium not present */ 85 #define SS_MEDIUM_ERR 0x031100 /* Unrecovered read error */ 86 #define SS_HW_ERR 0x040800 /* Communication failure */ 87 #define SS_ILLEGAL_REQUEST 0x052000 /* Invalid command */ 88 #define SS_UNIT_ATTENTION 0x062900 /* Reset occurred */ 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 435 /* I/O bounce buffer */ 436 u8 *bbuf; 437 438 /* for 6250 code */ 439 struct SD_STATUS SD_Status; 440 struct MS_STATUS MS_Status; 441 struct SM_STATUS SM_Status; 442 443 /* ----- SD Control Data ---------------- */ 444 /*SD_REGISTER SD_Regs; */ 445 u16 SD_Block_Mult; 446 u8 SD_READ_BL_LEN; 447 u16 SD_C_SIZE; 448 u8 SD_C_SIZE_MULT; 449 450 /* SD/MMC New spec. */ 451 u8 SD_SPEC_VER; 452 u8 SD_CSD_VER; 453 u8 SD20_HIGH_CAPACITY; 454 u32 HC_C_SIZE; 455 u8 MMC_SPEC_VER; 456 u8 MMC_BusWidth; 457 u8 MMC_HIGH_CAPACITY; 458 459 /*----- MS Control Data ---------------- */ 460 bool MS_SWWP; 461 u32 MSP_TotalBlock; 462 struct ms_lib_ctrl MS_Lib; 463 bool MS_IsRWPage; 464 u16 MS_Model; 465 466 /*----- SM Control Data ---------------- */ 467 u8 SM_DeviceID; 468 u8 SM_CardID; 469 470 unsigned char *testbuf; 471 u8 BIN_FLAG; 472 u32 bl_num; 473 int SrbStatus; 474 475 /*------Power Managerment ---------------*/ 476 bool Power_IsResum; 477 }; 478 479 static int ene_sd_init(struct us_data *us); 480 static int ene_ms_init(struct us_data *us); 481 static int ene_load_bincode(struct us_data *us, unsigned char flag); 482 483 static void ene_ub6250_info_destructor(void *extra) 484 { 485 struct ene_ub6250_info *info = (struct ene_ub6250_info *) extra; 486 487 if (!extra) 488 return; 489 kfree(info->bbuf); 490 } 491 492 static int ene_send_scsi_cmd(struct us_data *us, u8 fDir, void *buf, int use_sg) 493 { 494 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 495 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf; 496 497 int result; 498 unsigned int residue; 499 unsigned int cswlen = 0, partial = 0; 500 unsigned int transfer_length = bcb->DataTransferLength; 501 502 /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */ 503 /* send cmd to out endpoint */ 504 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, 505 bcb, US_BULK_CB_WRAP_LEN, NULL); 506 if (result != USB_STOR_XFER_GOOD) { 507 usb_stor_dbg(us, "send cmd to out endpoint fail ---\n"); 508 return USB_STOR_TRANSPORT_ERROR; 509 } 510 511 if (buf) { 512 unsigned int pipe = fDir; 513 514 if (fDir == FDIR_READ) 515 pipe = us->recv_bulk_pipe; 516 else 517 pipe = us->send_bulk_pipe; 518 519 /* Bulk */ 520 if (use_sg) { 521 result = usb_stor_bulk_srb(us, pipe, us->srb); 522 } else { 523 result = usb_stor_bulk_transfer_sg(us, pipe, buf, 524 transfer_length, 0, &partial); 525 } 526 if (result != USB_STOR_XFER_GOOD) { 527 usb_stor_dbg(us, "data transfer fail ---\n"); 528 return USB_STOR_TRANSPORT_ERROR; 529 } 530 } 531 532 /* Get CSW for device status */ 533 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs, 534 US_BULK_CS_WRAP_LEN, &cswlen); 535 536 if (result == USB_STOR_XFER_SHORT && cswlen == 0) { 537 usb_stor_dbg(us, "Received 0-length CSW; retrying...\n"); 538 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 539 bcs, US_BULK_CS_WRAP_LEN, &cswlen); 540 } 541 542 if (result == USB_STOR_XFER_STALLED) { 543 /* get the status again */ 544 usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n"); 545 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, 546 bcs, US_BULK_CS_WRAP_LEN, NULL); 547 } 548 549 if (result != USB_STOR_XFER_GOOD) 550 return USB_STOR_TRANSPORT_ERROR; 551 552 /* check bulk status */ 553 residue = le32_to_cpu(bcs->Residue); 554 555 /* 556 * try to compute the actual residue, based on how much data 557 * was really transferred and what the device tells us 558 */ 559 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) { 560 residue = min(residue, transfer_length); 561 if (us->srb != NULL) 562 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb), 563 (int)residue)); 564 } 565 566 if (bcs->Status != US_BULK_STAT_OK) 567 return USB_STOR_TRANSPORT_ERROR; 568 569 return USB_STOR_TRANSPORT_GOOD; 570 } 571 572 static int do_scsi_request_sense(struct us_data *us, struct scsi_cmnd *srb) 573 { 574 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 575 unsigned char buf[18]; 576 577 memset(buf, 0, 18); 578 buf[0] = 0x70; /* Current error */ 579 buf[2] = info->SrbStatus >> 16; /* Sense key */ 580 buf[7] = 10; /* Additional length */ 581 buf[12] = info->SrbStatus >> 8; /* ASC */ 582 buf[13] = info->SrbStatus; /* ASCQ */ 583 584 usb_stor_set_xfer_buf(buf, sizeof(buf), srb); 585 return USB_STOR_TRANSPORT_GOOD; 586 } 587 588 static int do_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb) 589 { 590 unsigned char data_ptr[36] = { 591 0x00, 0x00, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55, 592 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61, 593 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 594 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30 }; 595 596 usb_stor_set_xfer_buf(data_ptr, 36, srb); 597 return USB_STOR_TRANSPORT_GOOD; 598 } 599 600 static int sd_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb) 601 { 602 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 603 604 if (info->SD_Status.Insert && info->SD_Status.Ready) 605 return USB_STOR_TRANSPORT_GOOD; 606 else { 607 ene_sd_init(us); 608 return USB_STOR_TRANSPORT_GOOD; 609 } 610 611 return USB_STOR_TRANSPORT_GOOD; 612 } 613 614 static int sd_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb) 615 { 616 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 617 unsigned char mediaNoWP[12] = { 618 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00, 619 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 620 unsigned char mediaWP[12] = { 621 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00, 622 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 623 624 if (info->SD_Status.WtP) 625 usb_stor_set_xfer_buf(mediaWP, 12, srb); 626 else 627 usb_stor_set_xfer_buf(mediaNoWP, 12, srb); 628 629 630 return USB_STOR_TRANSPORT_GOOD; 631 } 632 633 static int sd_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb) 634 { 635 u32 bl_num; 636 u32 bl_len; 637 unsigned int offset = 0; 638 unsigned char buf[8]; 639 struct scatterlist *sg = NULL; 640 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 641 642 usb_stor_dbg(us, "sd_scsi_read_capacity\n"); 643 if (info->SD_Status.HiCapacity) { 644 bl_len = 0x200; 645 if (info->SD_Status.IsMMC) 646 bl_num = info->HC_C_SIZE-1; 647 else 648 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1; 649 } else { 650 bl_len = 1 << (info->SD_READ_BL_LEN); 651 bl_num = info->SD_Block_Mult * (info->SD_C_SIZE + 1) 652 * (1 << (info->SD_C_SIZE_MULT + 2)) - 1; 653 } 654 info->bl_num = bl_num; 655 usb_stor_dbg(us, "bl_len = %x\n", bl_len); 656 usb_stor_dbg(us, "bl_num = %x\n", bl_num); 657 658 /*srb->request_bufflen = 8; */ 659 buf[0] = (bl_num >> 24) & 0xff; 660 buf[1] = (bl_num >> 16) & 0xff; 661 buf[2] = (bl_num >> 8) & 0xff; 662 buf[3] = (bl_num >> 0) & 0xff; 663 buf[4] = (bl_len >> 24) & 0xff; 664 buf[5] = (bl_len >> 16) & 0xff; 665 buf[6] = (bl_len >> 8) & 0xff; 666 buf[7] = (bl_len >> 0) & 0xff; 667 668 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF); 669 670 return USB_STOR_TRANSPORT_GOOD; 671 } 672 673 static int sd_scsi_read(struct us_data *us, struct scsi_cmnd *srb) 674 { 675 int result; 676 unsigned char *cdb = srb->cmnd; 677 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 678 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 679 680 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) | 681 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff); 682 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 683 u32 bnByte = bn * 0x200; 684 u32 blenByte = blen * 0x200; 685 686 if (bn > info->bl_num) 687 return USB_STOR_TRANSPORT_ERROR; 688 689 result = ene_load_bincode(us, SD_RW_PATTERN); 690 if (result != USB_STOR_XFER_GOOD) { 691 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n"); 692 return USB_STOR_TRANSPORT_ERROR; 693 } 694 695 if (info->SD_Status.HiCapacity) 696 bnByte = bn; 697 698 /* set up the command wrapper */ 699 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 700 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 701 bcb->DataTransferLength = blenByte; 702 bcb->Flags = US_BULK_FLAG_IN; 703 bcb->CDB[0] = 0xF1; 704 bcb->CDB[5] = (unsigned char)(bnByte); 705 bcb->CDB[4] = (unsigned char)(bnByte>>8); 706 bcb->CDB[3] = (unsigned char)(bnByte>>16); 707 bcb->CDB[2] = (unsigned char)(bnByte>>24); 708 709 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1); 710 return result; 711 } 712 713 static int sd_scsi_write(struct us_data *us, struct scsi_cmnd *srb) 714 { 715 int result; 716 unsigned char *cdb = srb->cmnd; 717 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 718 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 719 720 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) | 721 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff); 722 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 723 u32 bnByte = bn * 0x200; 724 u32 blenByte = blen * 0x200; 725 726 if (bn > info->bl_num) 727 return USB_STOR_TRANSPORT_ERROR; 728 729 result = ene_load_bincode(us, SD_RW_PATTERN); 730 if (result != USB_STOR_XFER_GOOD) { 731 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n"); 732 return USB_STOR_TRANSPORT_ERROR; 733 } 734 735 if (info->SD_Status.HiCapacity) 736 bnByte = bn; 737 738 /* set up the command wrapper */ 739 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 740 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 741 bcb->DataTransferLength = blenByte; 742 bcb->Flags = 0x00; 743 bcb->CDB[0] = 0xF0; 744 bcb->CDB[5] = (unsigned char)(bnByte); 745 bcb->CDB[4] = (unsigned char)(bnByte>>8); 746 bcb->CDB[3] = (unsigned char)(bnByte>>16); 747 bcb->CDB[2] = (unsigned char)(bnByte>>24); 748 749 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1); 750 return result; 751 } 752 753 /* 754 * ENE MS Card 755 */ 756 757 static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk) 758 { 759 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 760 761 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock)) 762 return (u32)-1; 763 764 info->MS_Lib.Phy2LogMap[phyblk] = logblk; 765 info->MS_Lib.Log2PhyMap[logblk] = phyblk; 766 767 return 0; 768 } 769 770 static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark) 771 { 772 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 773 774 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 775 return (u32)-1; 776 777 info->MS_Lib.Phy2LogMap[phyblk] = mark; 778 779 return 0; 780 } 781 782 static int ms_lib_set_initialerrorblock(struct us_data *us, u16 phyblk) 783 { 784 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_INITIAL_ERROR); 785 } 786 787 static int ms_lib_set_bootblockmark(struct us_data *us, u16 phyblk) 788 { 789 return ms_lib_set_logicalblockmark(us, phyblk, MS_LB_BOOT_BLOCK); 790 } 791 792 static int ms_lib_free_logicalmap(struct us_data *us) 793 { 794 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 795 796 kfree(info->MS_Lib.Phy2LogMap); 797 info->MS_Lib.Phy2LogMap = NULL; 798 799 kfree(info->MS_Lib.Log2PhyMap); 800 info->MS_Lib.Log2PhyMap = NULL; 801 802 return 0; 803 } 804 805 static int ms_lib_alloc_logicalmap(struct us_data *us) 806 { 807 u32 i; 808 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 809 810 info->MS_Lib.Phy2LogMap = kmalloc_array(info->MS_Lib.NumberOfPhyBlock, 811 sizeof(u16), 812 GFP_KERNEL); 813 info->MS_Lib.Log2PhyMap = kmalloc_array(info->MS_Lib.NumberOfLogBlock, 814 sizeof(u16), 815 GFP_KERNEL); 816 817 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) { 818 ms_lib_free_logicalmap(us); 819 return (u32)-1; 820 } 821 822 for (i = 0; i < info->MS_Lib.NumberOfPhyBlock; i++) 823 info->MS_Lib.Phy2LogMap[i] = MS_LB_NOT_USED; 824 825 for (i = 0; i < info->MS_Lib.NumberOfLogBlock; i++) 826 info->MS_Lib.Log2PhyMap[i] = MS_LB_NOT_USED; 827 828 return 0; 829 } 830 831 static void ms_lib_clear_writebuf(struct us_data *us) 832 { 833 int i; 834 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 835 836 info->MS_Lib.wrtblk = (u16)-1; 837 ms_lib_clear_pagemap(info); 838 839 if (info->MS_Lib.blkpag) 840 memset(info->MS_Lib.blkpag, 0xff, info->MS_Lib.PagesPerBlock * info->MS_Lib.BytesPerSector); 841 842 if (info->MS_Lib.blkext) { 843 for (i = 0; i < info->MS_Lib.PagesPerBlock; i++) { 844 info->MS_Lib.blkext[i].status1 = MS_REG_ST1_DEFAULT; 845 info->MS_Lib.blkext[i].ovrflg = MS_REG_OVR_DEFAULT; 846 info->MS_Lib.blkext[i].mngflg = MS_REG_MNG_DEFAULT; 847 info->MS_Lib.blkext[i].logadr = MS_LB_NOT_USED; 848 } 849 } 850 } 851 852 static int ms_count_freeblock(struct us_data *us, u16 PhyBlock) 853 { 854 u32 Ende, Count; 855 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 856 857 Ende = PhyBlock + MS_PHYSICAL_BLOCKS_PER_SEGMENT; 858 for (Count = 0; PhyBlock < Ende; PhyBlock++) { 859 switch (info->MS_Lib.Phy2LogMap[PhyBlock]) { 860 case MS_LB_NOT_USED: 861 case MS_LB_NOT_USED_ERASED: 862 Count++; 863 default: 864 break; 865 } 866 } 867 868 return Count; 869 } 870 871 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr, 872 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat) 873 { 874 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 875 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 876 u8 *bbuf = info->bbuf; 877 int result; 878 u32 bn = PhyBlockAddr * 0x20 + PageNum; 879 880 result = ene_load_bincode(us, MS_RW_PATTERN); 881 if (result != USB_STOR_XFER_GOOD) 882 return USB_STOR_TRANSPORT_ERROR; 883 884 /* Read Page Data */ 885 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 886 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 887 bcb->DataTransferLength = 0x200; 888 bcb->Flags = US_BULK_FLAG_IN; 889 bcb->CDB[0] = 0xF1; 890 891 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */ 892 893 bcb->CDB[5] = (unsigned char)(bn); 894 bcb->CDB[4] = (unsigned char)(bn>>8); 895 bcb->CDB[3] = (unsigned char)(bn>>16); 896 bcb->CDB[2] = (unsigned char)(bn>>24); 897 898 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0); 899 if (result != USB_STOR_XFER_GOOD) 900 return USB_STOR_TRANSPORT_ERROR; 901 902 903 /* Read Extra Data */ 904 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 905 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 906 bcb->DataTransferLength = 0x4; 907 bcb->Flags = US_BULK_FLAG_IN; 908 bcb->CDB[0] = 0xF1; 909 bcb->CDB[1] = 0x03; 910 911 bcb->CDB[5] = (unsigned char)(PageNum); 912 bcb->CDB[4] = (unsigned char)(PhyBlockAddr); 913 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8); 914 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16); 915 bcb->CDB[6] = 0x01; 916 917 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0); 918 if (result != USB_STOR_XFER_GOOD) 919 return USB_STOR_TRANSPORT_ERROR; 920 921 ExtraDat->reserved = 0; 922 ExtraDat->intr = 0x80; /* Not yet,fireware support */ 923 ExtraDat->status0 = 0x10; /* Not yet,fireware support */ 924 925 ExtraDat->status1 = 0x00; /* Not yet,fireware support */ 926 ExtraDat->ovrflg = bbuf[0]; 927 ExtraDat->mngflg = bbuf[1]; 928 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]); 929 930 return USB_STOR_TRANSPORT_GOOD; 931 } 932 933 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData) 934 { 935 struct ms_bootblock_sysent *SysEntry; 936 struct ms_bootblock_sysinf *SysInfo; 937 u32 i, result; 938 u8 PageNumber; 939 u8 *PageBuffer; 940 struct ms_lib_type_extdat ExtraData; 941 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 942 943 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 944 if (PageBuffer == NULL) 945 return (u32)-1; 946 947 result = (u32)-1; 948 949 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf); 950 951 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) || 952 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) || 953 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) || 954 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) || 955 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) || 956 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) || 957 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL)) 958 goto exit; 959 /* */ 960 switch (info->MS_Lib.cardType = SysInfo->bCardType) { 961 case MS_SYSINF_CARDTYPE_RDONLY: 962 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); 963 break; 964 case MS_SYSINF_CARDTYPE_RDWR: 965 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY); 966 break; 967 case MS_SYSINF_CARDTYPE_HYBRID: 968 default: 969 goto exit; 970 } 971 972 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize); 973 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber); 974 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2; 975 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE; 976 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT; 977 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize); 978 979 /*Allocate to all number of logicalblock and physicalblock */ 980 if (ms_lib_alloc_logicalmap(us)) 981 goto exit; 982 983 /* Mark the book block */ 984 ms_lib_set_bootblockmark(us, PhyBlock); 985 986 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent); 987 988 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) { 989 u32 EntryOffset, EntrySize; 990 991 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart); 992 993 if (EntryOffset == 0xffffff) 994 continue; 995 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize); 996 997 if (EntrySize == 0) 998 continue; 999 1000 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO) 1001 continue; 1002 1003 if (i == 0) { 1004 u8 PrevPageNumber = 0; 1005 u16 phyblk; 1006 1007 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK) 1008 goto exit; 1009 1010 while (EntrySize > 0) { 1011 1012 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1); 1013 if (PageNumber != PrevPageNumber) { 1014 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) { 1015 case MS_STATUS_SUCCESS: 1016 break; 1017 case MS_STATUS_WRITE_PROTECT: 1018 case MS_ERROR_FLASH_READ: 1019 case MS_STATUS_ERROR: 1020 default: 1021 goto exit; 1022 } 1023 1024 PrevPageNumber = PageNumber; 1025 } 1026 1027 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE))); 1028 if (phyblk < 0x0fff) 1029 ms_lib_set_initialerrorblock(us, phyblk); 1030 1031 EntryOffset += 2; 1032 EntrySize -= 2; 1033 } 1034 } else if (i == 1) { /* CIS/IDI */ 1035 struct ms_bootblock_idi *idi; 1036 1037 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI) 1038 goto exit; 1039 1040 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) { 1041 case MS_STATUS_SUCCESS: 1042 break; 1043 case MS_STATUS_WRITE_PROTECT: 1044 case MS_ERROR_FLASH_READ: 1045 case MS_STATUS_ERROR: 1046 default: 1047 goto exit; 1048 } 1049 1050 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi; 1051 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF) 1052 goto exit; 1053 1054 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector); 1055 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE) 1056 goto exit; 1057 } 1058 } /* End for .. */ 1059 1060 result = 0; 1061 1062 exit: 1063 if (result) 1064 ms_lib_free_logicalmap(us); 1065 1066 kfree(PageBuffer); 1067 1068 result = 0; 1069 return result; 1070 } 1071 1072 static void ms_lib_free_writebuf(struct us_data *us) 1073 { 1074 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1075 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */ 1076 1077 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */ 1078 1079 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */ 1080 1081 if (info->MS_Lib.blkpag) { 1082 kfree(info->MS_Lib.blkpag); /* Arnold test ... */ 1083 info->MS_Lib.blkpag = NULL; 1084 } 1085 1086 if (info->MS_Lib.blkext) { 1087 kfree(info->MS_Lib.blkext); /* Arnold test ... */ 1088 info->MS_Lib.blkext = NULL; 1089 } 1090 } 1091 1092 1093 static void ms_lib_free_allocatedarea(struct us_data *us) 1094 { 1095 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1096 1097 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */ 1098 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */ 1099 1100 /* set struct us point flag to 0 */ 1101 info->MS_Lib.flags = 0; 1102 info->MS_Lib.BytesPerSector = 0; 1103 info->MS_Lib.SectorsPerCylinder = 0; 1104 1105 info->MS_Lib.cardType = 0; 1106 info->MS_Lib.blockSize = 0; 1107 info->MS_Lib.PagesPerBlock = 0; 1108 1109 info->MS_Lib.NumberOfPhyBlock = 0; 1110 info->MS_Lib.NumberOfLogBlock = 0; 1111 } 1112 1113 1114 static int ms_lib_alloc_writebuf(struct us_data *us) 1115 { 1116 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1117 1118 info->MS_Lib.wrtblk = (u16)-1; 1119 1120 info->MS_Lib.blkpag = kmalloc_array(info->MS_Lib.PagesPerBlock, 1121 info->MS_Lib.BytesPerSector, 1122 GFP_KERNEL); 1123 info->MS_Lib.blkext = kmalloc_array(info->MS_Lib.PagesPerBlock, 1124 sizeof(struct ms_lib_type_extdat), 1125 GFP_KERNEL); 1126 1127 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) { 1128 ms_lib_free_writebuf(us); 1129 return (u32)-1; 1130 } 1131 1132 ms_lib_clear_writebuf(us); 1133 1134 return 0; 1135 } 1136 1137 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk) 1138 { 1139 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1140 1141 if (logblk == MS_LB_NOT_USED) 1142 return 0; 1143 1144 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || 1145 (phyblk >= info->MS_Lib.NumberOfPhyBlock)) 1146 return (u32)-1; 1147 1148 info->MS_Lib.Phy2LogMap[phyblk] = logblk; 1149 info->MS_Lib.Log2PhyMap[logblk] = phyblk; 1150 1151 return 0; 1152 } 1153 1154 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy, 1155 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len) 1156 { 1157 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1158 int result; 1159 1160 result = ene_load_bincode(us, MS_RW_PATTERN); 1161 if (result != USB_STOR_XFER_GOOD) 1162 return USB_STOR_TRANSPORT_ERROR; 1163 1164 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1165 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1166 bcb->DataTransferLength = 0x200*len; 1167 bcb->Flags = 0x00; 1168 bcb->CDB[0] = 0xF0; 1169 bcb->CDB[1] = 0x08; 1170 bcb->CDB[4] = (unsigned char)(oldphy); 1171 bcb->CDB[3] = (unsigned char)(oldphy>>8); 1172 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */ 1173 bcb->CDB[7] = (unsigned char)(newphy); 1174 bcb->CDB[6] = (unsigned char)(newphy>>8); 1175 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */ 1176 bcb->CDB[9] = (unsigned char)(PhyBlockAddr); 1177 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8); 1178 bcb->CDB[10] = PageNum; 1179 1180 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 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_read_eraseblock(struct us_data *us, u32 PhyBlockAddr) 1188 { 1189 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1190 int result; 1191 u32 bn = PhyBlockAddr; 1192 1193 result = ene_load_bincode(us, MS_RW_PATTERN); 1194 if (result != USB_STOR_XFER_GOOD) 1195 return USB_STOR_TRANSPORT_ERROR; 1196 1197 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1198 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1199 bcb->DataTransferLength = 0x200; 1200 bcb->Flags = US_BULK_FLAG_IN; 1201 bcb->CDB[0] = 0xF2; 1202 bcb->CDB[1] = 0x06; 1203 bcb->CDB[4] = (unsigned char)(bn); 1204 bcb->CDB[3] = (unsigned char)(bn>>8); 1205 bcb->CDB[2] = (unsigned char)(bn>>16); 1206 1207 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 1208 if (result != USB_STOR_XFER_GOOD) 1209 return USB_STOR_TRANSPORT_ERROR; 1210 1211 return USB_STOR_TRANSPORT_GOOD; 1212 } 1213 1214 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock) 1215 { 1216 unsigned char *PageBuf = NULL; 1217 u16 result = MS_STATUS_SUCCESS; 1218 u16 blk, index = 0; 1219 struct ms_lib_type_extdat extdat; 1220 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1221 1222 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1223 if (PageBuf == NULL) { 1224 result = MS_NO_MEMORY_ERROR; 1225 goto exit; 1226 } 1227 1228 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat); 1229 do { 1230 blk = be16_to_cpu(PageBuf[index]); 1231 if (blk == MS_LB_NOT_USED) 1232 break; 1233 if (blk == info->MS_Lib.Log2PhyMap[0]) { 1234 result = MS_ERROR_FLASH_READ; 1235 break; 1236 } 1237 index++; 1238 } while (1); 1239 1240 exit: 1241 kfree(PageBuf); 1242 return result; 1243 } 1244 1245 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk) 1246 { 1247 u16 log; 1248 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1249 1250 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1251 return (u32)-1; 1252 1253 log = info->MS_Lib.Phy2LogMap[phyblk]; 1254 1255 if (log < info->MS_Lib.NumberOfLogBlock) 1256 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED; 1257 1258 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR) 1259 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR; 1260 1261 return 0; 1262 } 1263 1264 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr, 1265 u8 PageNum, u8 OverwriteFlag) 1266 { 1267 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1268 int result; 1269 1270 result = ene_load_bincode(us, MS_RW_PATTERN); 1271 if (result != USB_STOR_XFER_GOOD) 1272 return USB_STOR_TRANSPORT_ERROR; 1273 1274 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1275 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1276 bcb->DataTransferLength = 0x4; 1277 bcb->Flags = US_BULK_FLAG_IN; 1278 bcb->CDB[0] = 0xF2; 1279 bcb->CDB[1] = 0x05; 1280 bcb->CDB[5] = (unsigned char)(PageNum); 1281 bcb->CDB[4] = (unsigned char)(PhyBlockAddr); 1282 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8); 1283 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16); 1284 bcb->CDB[6] = OverwriteFlag; 1285 bcb->CDB[7] = 0xFF; 1286 bcb->CDB[8] = 0xFF; 1287 bcb->CDB[9] = 0xFF; 1288 1289 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 1290 if (result != USB_STOR_XFER_GOOD) 1291 return USB_STOR_TRANSPORT_ERROR; 1292 1293 return USB_STOR_TRANSPORT_GOOD; 1294 } 1295 1296 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk) 1297 { 1298 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1299 1300 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1301 return MS_STATUS_ERROR; 1302 1303 ms_lib_setacquired_errorblock(us, phyblk); 1304 1305 if (ms_lib_iswritable(info)) 1306 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK)); 1307 1308 return MS_STATUS_SUCCESS; 1309 } 1310 1311 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk) 1312 { 1313 u16 log; 1314 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1315 1316 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1317 return MS_STATUS_ERROR; 1318 1319 log = info->MS_Lib.Phy2LogMap[phyblk]; 1320 1321 if (log < info->MS_Lib.NumberOfLogBlock) 1322 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED; 1323 1324 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED; 1325 1326 if (ms_lib_iswritable(info)) { 1327 switch (ms_read_eraseblock(us, phyblk)) { 1328 case MS_STATUS_SUCCESS: 1329 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED; 1330 return MS_STATUS_SUCCESS; 1331 case MS_ERROR_FLASH_ERASE: 1332 case MS_STATUS_INT_ERROR: 1333 ms_lib_error_phyblock(us, phyblk); 1334 return MS_ERROR_FLASH_ERASE; 1335 case MS_STATUS_ERROR: 1336 default: 1337 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/ 1338 ms_lib_setacquired_errorblock(us, phyblk); 1339 return MS_STATUS_ERROR; 1340 } 1341 } 1342 1343 ms_lib_setacquired_errorblock(us, phyblk); 1344 1345 return MS_STATUS_SUCCESS; 1346 } 1347 1348 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock, 1349 u8 PageNum, struct ms_lib_type_extdat *ExtraDat) 1350 { 1351 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1352 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1353 u8 *bbuf = info->bbuf; 1354 int result; 1355 1356 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1357 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1358 bcb->DataTransferLength = 0x4; 1359 bcb->Flags = US_BULK_FLAG_IN; 1360 bcb->CDB[0] = 0xF1; 1361 bcb->CDB[1] = 0x03; 1362 bcb->CDB[5] = (unsigned char)(PageNum); 1363 bcb->CDB[4] = (unsigned char)(PhyBlock); 1364 bcb->CDB[3] = (unsigned char)(PhyBlock>>8); 1365 bcb->CDB[2] = (unsigned char)(PhyBlock>>16); 1366 bcb->CDB[6] = 0x01; 1367 1368 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0); 1369 if (result != USB_STOR_XFER_GOOD) 1370 return USB_STOR_TRANSPORT_ERROR; 1371 1372 ExtraDat->reserved = 0; 1373 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */ 1374 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */ 1375 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */ 1376 ExtraDat->ovrflg = bbuf[0]; 1377 ExtraDat->mngflg = bbuf[1]; 1378 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]); 1379 1380 return USB_STOR_TRANSPORT_GOOD; 1381 } 1382 1383 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk) 1384 { 1385 u16 blk; 1386 struct ms_lib_type_extdat extdat; /* need check */ 1387 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1388 1389 1390 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1391 return MS_LB_ERROR; 1392 1393 for (blk = phyblk + 1; blk != phyblk; blk++) { 1394 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0) 1395 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1396 1397 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) { 1398 return blk; 1399 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) { 1400 switch (ms_lib_read_extra(us, blk, 0, &extdat)) { 1401 case MS_STATUS_SUCCESS: 1402 case MS_STATUS_SUCCESS_WITH_ECC: 1403 break; 1404 case MS_NOCARD_ERROR: 1405 return MS_NOCARD_ERROR; 1406 case MS_STATUS_INT_ERROR: 1407 return MS_LB_ERROR; 1408 case MS_ERROR_FLASH_READ: 1409 default: 1410 ms_lib_setacquired_errorblock(us, blk); 1411 continue; 1412 } /* End switch */ 1413 1414 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) { 1415 ms_lib_setacquired_errorblock(us, blk); 1416 continue; 1417 } 1418 1419 switch (ms_lib_erase_phyblock(us, blk)) { 1420 case MS_STATUS_SUCCESS: 1421 return blk; 1422 case MS_STATUS_ERROR: 1423 return MS_LB_ERROR; 1424 case MS_ERROR_FLASH_ERASE: 1425 default: 1426 ms_lib_error_phyblock(us, blk); 1427 break; 1428 } 1429 } 1430 } /* End for */ 1431 1432 return MS_LB_ERROR; 1433 } 1434 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk) 1435 { 1436 u16 phyblk; 1437 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1438 1439 phyblk = ms_libconv_to_physical(info, logblk); 1440 if (phyblk >= MS_LB_ERROR) { 1441 if (logblk >= info->MS_Lib.NumberOfLogBlock) 1442 return MS_LB_ERROR; 1443 1444 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT; 1445 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1446 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1; 1447 } 1448 1449 return ms_libsearch_block_from_physical(us, phyblk); 1450 } 1451 1452 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb) 1453 { 1454 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 1455 1456 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */ 1457 if (info->MS_Status.Insert && info->MS_Status.Ready) { 1458 return USB_STOR_TRANSPORT_GOOD; 1459 } else { 1460 ene_ms_init(us); 1461 return USB_STOR_TRANSPORT_GOOD; 1462 } 1463 1464 return USB_STOR_TRANSPORT_GOOD; 1465 } 1466 1467 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb) 1468 { 1469 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1470 unsigned char mediaNoWP[12] = { 1471 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00, 1472 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 1473 unsigned char mediaWP[12] = { 1474 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00, 1475 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 1476 1477 if (info->MS_Status.WtP) 1478 usb_stor_set_xfer_buf(mediaWP, 12, srb); 1479 else 1480 usb_stor_set_xfer_buf(mediaNoWP, 12, srb); 1481 1482 return USB_STOR_TRANSPORT_GOOD; 1483 } 1484 1485 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb) 1486 { 1487 u32 bl_num; 1488 u16 bl_len; 1489 unsigned int offset = 0; 1490 unsigned char buf[8]; 1491 struct scatterlist *sg = NULL; 1492 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1493 1494 usb_stor_dbg(us, "ms_scsi_read_capacity\n"); 1495 bl_len = 0x200; 1496 if (info->MS_Status.IsMSPro) 1497 bl_num = info->MSP_TotalBlock - 1; 1498 else 1499 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1; 1500 1501 info->bl_num = bl_num; 1502 usb_stor_dbg(us, "bl_len = %x\n", bl_len); 1503 usb_stor_dbg(us, "bl_num = %x\n", bl_num); 1504 1505 /*srb->request_bufflen = 8; */ 1506 buf[0] = (bl_num >> 24) & 0xff; 1507 buf[1] = (bl_num >> 16) & 0xff; 1508 buf[2] = (bl_num >> 8) & 0xff; 1509 buf[3] = (bl_num >> 0) & 0xff; 1510 buf[4] = (bl_len >> 24) & 0xff; 1511 buf[5] = (bl_len >> 16) & 0xff; 1512 buf[6] = (bl_len >> 8) & 0xff; 1513 buf[7] = (bl_len >> 0) & 0xff; 1514 1515 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF); 1516 1517 return USB_STOR_TRANSPORT_GOOD; 1518 } 1519 1520 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde) 1521 { 1522 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1523 1524 if (PhyBlock) { 1525 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/ 1526 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/ 1527 } else { 1528 *LogStart = 0; 1529 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/ 1530 } 1531 } 1532 1533 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock, 1534 u8 PageNum, u8 blen, void *buf) 1535 { 1536 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1537 int result; 1538 1539 /* Read Extra Data */ 1540 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1541 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1542 bcb->DataTransferLength = 0x4 * blen; 1543 bcb->Flags = US_BULK_FLAG_IN; 1544 bcb->CDB[0] = 0xF1; 1545 bcb->CDB[1] = 0x03; 1546 bcb->CDB[5] = (unsigned char)(PageNum); 1547 bcb->CDB[4] = (unsigned char)(PhyBlock); 1548 bcb->CDB[3] = (unsigned char)(PhyBlock>>8); 1549 bcb->CDB[2] = (unsigned char)(PhyBlock>>16); 1550 bcb->CDB[6] = blen; 1551 1552 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0); 1553 if (result != USB_STOR_XFER_GOOD) 1554 return USB_STOR_TRANSPORT_ERROR; 1555 1556 return USB_STOR_TRANSPORT_GOOD; 1557 } 1558 1559 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st) 1560 { 1561 u16 PhyBlock, newblk, i; 1562 u16 LogStart, LogEnde; 1563 struct ms_lib_type_extdat extdat; 1564 u32 count = 0, index = 0; 1565 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1566 u8 *bbuf = info->bbuf; 1567 1568 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) { 1569 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde); 1570 1571 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) { 1572 switch (ms_libconv_to_logical(info, PhyBlock)) { 1573 case MS_STATUS_ERROR: 1574 continue; 1575 default: 1576 break; 1577 } 1578 1579 if (count == PhyBlock) { 1580 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80, 1581 bbuf); 1582 count += 0x80; 1583 } 1584 index = (PhyBlock % 0x80) * 4; 1585 1586 extdat.ovrflg = bbuf[index]; 1587 extdat.mngflg = bbuf[index+1]; 1588 extdat.logadr = memstick_logaddr(bbuf[index+2], 1589 bbuf[index+3]); 1590 1591 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) { 1592 ms_lib_setacquired_errorblock(us, PhyBlock); 1593 continue; 1594 } 1595 1596 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) { 1597 ms_lib_erase_phyblock(us, PhyBlock); 1598 continue; 1599 } 1600 1601 if (extdat.logadr != MS_LB_NOT_USED) { 1602 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) { 1603 ms_lib_erase_phyblock(us, PhyBlock); 1604 continue; 1605 } 1606 1607 newblk = ms_libconv_to_physical(info, extdat.logadr); 1608 1609 if (newblk != MS_LB_NOT_USED) { 1610 if (extdat.logadr == 0) { 1611 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock); 1612 if (ms_lib_check_disableblock(us, btBlk1st)) { 1613 ms_lib_set_logicalpair(us, extdat.logadr, newblk); 1614 continue; 1615 } 1616 } 1617 1618 ms_lib_read_extra(us, newblk, 0, &extdat); 1619 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) { 1620 ms_lib_erase_phyblock(us, PhyBlock); 1621 continue; 1622 } else { 1623 ms_lib_erase_phyblock(us, newblk); 1624 } 1625 } 1626 1627 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock); 1628 } 1629 } 1630 } /* End for ... */ 1631 1632 return MS_STATUS_SUCCESS; 1633 } 1634 1635 1636 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb) 1637 { 1638 int result; 1639 unsigned char *cdb = srb->cmnd; 1640 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1641 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1642 1643 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) | 1644 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff); 1645 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 1646 u32 blenByte = blen * 0x200; 1647 1648 if (bn > info->bl_num) 1649 return USB_STOR_TRANSPORT_ERROR; 1650 1651 if (info->MS_Status.IsMSPro) { 1652 result = ene_load_bincode(us, MSP_RW_PATTERN); 1653 if (result != USB_STOR_XFER_GOOD) { 1654 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n"); 1655 return USB_STOR_TRANSPORT_ERROR; 1656 } 1657 1658 /* set up the command wrapper */ 1659 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1660 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1661 bcb->DataTransferLength = blenByte; 1662 bcb->Flags = US_BULK_FLAG_IN; 1663 bcb->CDB[0] = 0xF1; 1664 bcb->CDB[1] = 0x02; 1665 bcb->CDB[5] = (unsigned char)(bn); 1666 bcb->CDB[4] = (unsigned char)(bn>>8); 1667 bcb->CDB[3] = (unsigned char)(bn>>16); 1668 bcb->CDB[2] = (unsigned char)(bn>>24); 1669 1670 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1); 1671 } else { 1672 void *buf; 1673 int offset = 0; 1674 u16 phyblk, logblk; 1675 u8 PageNum; 1676 u16 len; 1677 u32 blkno; 1678 1679 buf = kmalloc(blenByte, GFP_KERNEL); 1680 if (buf == NULL) 1681 return USB_STOR_TRANSPORT_ERROR; 1682 1683 result = ene_load_bincode(us, MS_RW_PATTERN); 1684 if (result != USB_STOR_XFER_GOOD) { 1685 pr_info("Load MS RW pattern Fail !!\n"); 1686 result = USB_STOR_TRANSPORT_ERROR; 1687 goto exit; 1688 } 1689 1690 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock); 1691 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock); 1692 1693 while (1) { 1694 if (blen > (info->MS_Lib.PagesPerBlock-PageNum)) 1695 len = info->MS_Lib.PagesPerBlock-PageNum; 1696 else 1697 len = blen; 1698 1699 phyblk = ms_libconv_to_physical(info, logblk); 1700 blkno = phyblk * 0x20 + PageNum; 1701 1702 /* set up the command wrapper */ 1703 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1704 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1705 bcb->DataTransferLength = 0x200 * len; 1706 bcb->Flags = US_BULK_FLAG_IN; 1707 bcb->CDB[0] = 0xF1; 1708 bcb->CDB[1] = 0x02; 1709 bcb->CDB[5] = (unsigned char)(blkno); 1710 bcb->CDB[4] = (unsigned char)(blkno>>8); 1711 bcb->CDB[3] = (unsigned char)(blkno>>16); 1712 bcb->CDB[2] = (unsigned char)(blkno>>24); 1713 1714 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0); 1715 if (result != USB_STOR_XFER_GOOD) { 1716 pr_info("MS_SCSI_Read --- result = %x\n", result); 1717 result = USB_STOR_TRANSPORT_ERROR; 1718 goto exit; 1719 } 1720 1721 blen -= len; 1722 if (blen <= 0) 1723 break; 1724 logblk++; 1725 PageNum = 0; 1726 offset += MS_BYTES_PER_PAGE*len; 1727 } 1728 usb_stor_set_xfer_buf(buf, blenByte, srb); 1729 exit: 1730 kfree(buf); 1731 } 1732 return result; 1733 } 1734 1735 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb) 1736 { 1737 int result; 1738 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1739 unsigned char *cdb = srb->cmnd; 1740 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1741 1742 u32 bn = ((cdb[2] << 24) & 0xff000000) | 1743 ((cdb[3] << 16) & 0x00ff0000) | 1744 ((cdb[4] << 8) & 0x0000ff00) | 1745 ((cdb[5] << 0) & 0x000000ff); 1746 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 1747 u32 blenByte = blen * 0x200; 1748 1749 if (bn > info->bl_num) 1750 return USB_STOR_TRANSPORT_ERROR; 1751 1752 if (info->MS_Status.IsMSPro) { 1753 result = ene_load_bincode(us, MSP_RW_PATTERN); 1754 if (result != USB_STOR_XFER_GOOD) { 1755 pr_info("Load MSP RW pattern Fail !!\n"); 1756 return USB_STOR_TRANSPORT_ERROR; 1757 } 1758 1759 /* set up the command wrapper */ 1760 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1761 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1762 bcb->DataTransferLength = blenByte; 1763 bcb->Flags = 0x00; 1764 bcb->CDB[0] = 0xF0; 1765 bcb->CDB[1] = 0x04; 1766 bcb->CDB[5] = (unsigned char)(bn); 1767 bcb->CDB[4] = (unsigned char)(bn>>8); 1768 bcb->CDB[3] = (unsigned char)(bn>>16); 1769 bcb->CDB[2] = (unsigned char)(bn>>24); 1770 1771 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1); 1772 } else { 1773 void *buf; 1774 int offset = 0; 1775 u16 PhyBlockAddr; 1776 u8 PageNum; 1777 u16 len, oldphy, newphy; 1778 1779 buf = kmalloc(blenByte, GFP_KERNEL); 1780 if (buf == NULL) 1781 return USB_STOR_TRANSPORT_ERROR; 1782 usb_stor_set_xfer_buf(buf, blenByte, srb); 1783 1784 result = ene_load_bincode(us, MS_RW_PATTERN); 1785 if (result != USB_STOR_XFER_GOOD) { 1786 pr_info("Load MS RW pattern Fail !!\n"); 1787 result = USB_STOR_TRANSPORT_ERROR; 1788 goto exit; 1789 } 1790 1791 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock); 1792 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock); 1793 1794 while (1) { 1795 if (blen > (info->MS_Lib.PagesPerBlock-PageNum)) 1796 len = info->MS_Lib.PagesPerBlock-PageNum; 1797 else 1798 len = blen; 1799 1800 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */ 1801 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr); 1802 1803 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len); 1804 1805 if (result != USB_STOR_XFER_GOOD) { 1806 pr_info("MS_SCSI_Write --- result = %x\n", result); 1807 result = USB_STOR_TRANSPORT_ERROR; 1808 goto exit; 1809 } 1810 1811 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED; 1812 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy); 1813 1814 blen -= len; 1815 if (blen <= 0) 1816 break; 1817 PhyBlockAddr++; 1818 PageNum = 0; 1819 offset += MS_BYTES_PER_PAGE*len; 1820 } 1821 exit: 1822 kfree(buf); 1823 } 1824 return result; 1825 } 1826 1827 /* 1828 * ENE MS Card 1829 */ 1830 1831 static int ene_get_card_type(struct us_data *us, u16 index, void *buf) 1832 { 1833 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1834 int result; 1835 1836 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1837 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1838 bcb->DataTransferLength = 0x01; 1839 bcb->Flags = US_BULK_FLAG_IN; 1840 bcb->CDB[0] = 0xED; 1841 bcb->CDB[2] = (unsigned char)(index>>8); 1842 bcb->CDB[3] = (unsigned char)index; 1843 1844 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0); 1845 return result; 1846 } 1847 1848 static int ene_get_card_status(struct us_data *us, u8 *buf) 1849 { 1850 u16 tmpreg; 1851 u32 reg4b; 1852 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1853 1854 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/ 1855 reg4b = *(u32 *)&buf[0x18]; 1856 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f); 1857 1858 tmpreg = (u16) reg4b; 1859 reg4b = *(u32 *)(&buf[0x14]); 1860 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC) 1861 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff; 1862 1863 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22); 1864 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07; 1865 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC) 1866 info->HC_C_SIZE = *(u32 *)(&buf[0x100]); 1867 1868 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) { 1869 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN); 1870 info->SD_READ_BL_LEN = SD_BLOCK_LEN; 1871 } else { 1872 info->SD_Block_Mult = 1; 1873 } 1874 1875 return USB_STOR_TRANSPORT_GOOD; 1876 } 1877 1878 static int ene_load_bincode(struct us_data *us, unsigned char flag) 1879 { 1880 int err; 1881 char *fw_name = NULL; 1882 unsigned char *buf = NULL; 1883 const struct firmware *sd_fw = NULL; 1884 int result = USB_STOR_TRANSPORT_ERROR; 1885 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1886 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1887 1888 if (info->BIN_FLAG == flag) 1889 return USB_STOR_TRANSPORT_GOOD; 1890 1891 switch (flag) { 1892 /* For SD */ 1893 case SD_INIT1_PATTERN: 1894 usb_stor_dbg(us, "SD_INIT1_PATTERN\n"); 1895 fw_name = SD_INIT1_FIRMWARE; 1896 break; 1897 case SD_INIT2_PATTERN: 1898 usb_stor_dbg(us, "SD_INIT2_PATTERN\n"); 1899 fw_name = SD_INIT2_FIRMWARE; 1900 break; 1901 case SD_RW_PATTERN: 1902 usb_stor_dbg(us, "SD_RW_PATTERN\n"); 1903 fw_name = SD_RW_FIRMWARE; 1904 break; 1905 /* For MS */ 1906 case MS_INIT_PATTERN: 1907 usb_stor_dbg(us, "MS_INIT_PATTERN\n"); 1908 fw_name = MS_INIT_FIRMWARE; 1909 break; 1910 case MSP_RW_PATTERN: 1911 usb_stor_dbg(us, "MSP_RW_PATTERN\n"); 1912 fw_name = MSP_RW_FIRMWARE; 1913 break; 1914 case MS_RW_PATTERN: 1915 usb_stor_dbg(us, "MS_RW_PATTERN\n"); 1916 fw_name = MS_RW_FIRMWARE; 1917 break; 1918 default: 1919 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n"); 1920 goto nofw; 1921 } 1922 1923 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev); 1924 if (err) { 1925 usb_stor_dbg(us, "load firmware %s failed\n", fw_name); 1926 goto nofw; 1927 } 1928 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL); 1929 if (buf == NULL) 1930 goto nofw; 1931 1932 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1933 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1934 bcb->DataTransferLength = sd_fw->size; 1935 bcb->Flags = 0x00; 1936 bcb->CDB[0] = 0xEF; 1937 1938 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0); 1939 if (us->srb != NULL) 1940 scsi_set_resid(us->srb, 0); 1941 info->BIN_FLAG = flag; 1942 kfree(buf); 1943 1944 nofw: 1945 release_firmware(sd_fw); 1946 return result; 1947 } 1948 1949 static int ms_card_init(struct us_data *us) 1950 { 1951 u32 result; 1952 u16 TmpBlock; 1953 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL; 1954 struct ms_lib_type_extdat extdat; 1955 u16 btBlk1st, btBlk2nd; 1956 u32 btBlk1stErred; 1957 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1958 1959 printk(KERN_INFO "MS_CardInit start\n"); 1960 1961 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */ 1962 1963 /* get two PageBuffer */ 1964 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1965 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1966 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) { 1967 result = MS_NO_MEMORY_ERROR; 1968 goto exit; 1969 } 1970 1971 btBlk1st = btBlk2nd = MS_LB_NOT_USED; 1972 btBlk1stErred = 0; 1973 1974 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) { 1975 1976 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) { 1977 case MS_STATUS_SUCCESS: 1978 break; 1979 case MS_STATUS_INT_ERROR: 1980 break; 1981 case MS_STATUS_ERROR: 1982 default: 1983 continue; 1984 } 1985 1986 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG) 1987 continue; 1988 1989 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) || 1990 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) || 1991 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) || 1992 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES)) 1993 continue; 1994 1995 if (btBlk1st != MS_LB_NOT_USED) { 1996 btBlk2nd = TmpBlock; 1997 break; 1998 } 1999 2000 btBlk1st = TmpBlock; 2001 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE); 2002 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER)) 2003 btBlk1stErred = 1; 2004 } 2005 2006 if (btBlk1st == MS_LB_NOT_USED) { 2007 result = MS_STATUS_ERROR; 2008 goto exit; 2009 } 2010 2011 /* write protect */ 2012 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON) 2013 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT); 2014 2015 result = MS_STATUS_ERROR; 2016 /* 1st Boot Block */ 2017 if (btBlk1stErred == 0) 2018 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1); 2019 /* 1st */ 2020 /* 2nd Boot Block */ 2021 if (result && (btBlk2nd != MS_LB_NOT_USED)) 2022 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0); 2023 2024 if (result) { 2025 result = MS_STATUS_ERROR; 2026 goto exit; 2027 } 2028 2029 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++) 2030 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR; 2031 2032 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK; 2033 2034 if (btBlk2nd != MS_LB_NOT_USED) { 2035 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++) 2036 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR; 2037 2038 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK; 2039 } 2040 2041 result = ms_lib_scan_logicalblocknumber(us, btBlk1st); 2042 if (result) 2043 goto exit; 2044 2045 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT; 2046 TmpBlock < info->MS_Lib.NumberOfPhyBlock; 2047 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) { 2048 if (ms_count_freeblock(us, TmpBlock) == 0) { 2049 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT); 2050 break; 2051 } 2052 } 2053 2054 /* write */ 2055 if (ms_lib_alloc_writebuf(us)) { 2056 result = MS_NO_MEMORY_ERROR; 2057 goto exit; 2058 } 2059 2060 result = MS_STATUS_SUCCESS; 2061 2062 exit: 2063 kfree(PageBuffer1); 2064 kfree(PageBuffer0); 2065 2066 printk(KERN_INFO "MS_CardInit end\n"); 2067 return result; 2068 } 2069 2070 static int ene_ms_init(struct us_data *us) 2071 { 2072 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 2073 int result; 2074 u16 MSP_BlockSize, MSP_UserAreaBlocks; 2075 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 2076 u8 *bbuf = info->bbuf; 2077 2078 printk(KERN_INFO "transport --- ENE_MSInit\n"); 2079 2080 /* the same part to test ENE */ 2081 2082 result = ene_load_bincode(us, MS_INIT_PATTERN); 2083 if (result != USB_STOR_XFER_GOOD) { 2084 printk(KERN_ERR "Load MS Init Code Fail !!\n"); 2085 return USB_STOR_TRANSPORT_ERROR; 2086 } 2087 2088 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2089 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2090 bcb->DataTransferLength = 0x200; 2091 bcb->Flags = US_BULK_FLAG_IN; 2092 bcb->CDB[0] = 0xF1; 2093 bcb->CDB[1] = 0x01; 2094 2095 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0); 2096 if (result != USB_STOR_XFER_GOOD) { 2097 printk(KERN_ERR "Execution MS Init Code Fail !!\n"); 2098 return USB_STOR_TRANSPORT_ERROR; 2099 } 2100 /* the same part to test ENE */ 2101 info->MS_Status = *(struct MS_STATUS *) bbuf; 2102 2103 if (info->MS_Status.Insert && info->MS_Status.Ready) { 2104 printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert); 2105 printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready); 2106 printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro); 2107 printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG); 2108 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP); 2109 if (info->MS_Status.IsMSPro) { 2110 MSP_BlockSize = (bbuf[6] << 8) | bbuf[7]; 2111 MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11]; 2112 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks; 2113 } else { 2114 ms_card_init(us); /* Card is MS (to ms.c)*/ 2115 } 2116 usb_stor_dbg(us, "MS Init Code OK !!\n"); 2117 } else { 2118 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]); 2119 return USB_STOR_TRANSPORT_ERROR; 2120 } 2121 2122 return USB_STOR_TRANSPORT_GOOD; 2123 } 2124 2125 static int ene_sd_init(struct us_data *us) 2126 { 2127 int result; 2128 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 2129 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 2130 u8 *bbuf = info->bbuf; 2131 2132 usb_stor_dbg(us, "transport --- ENE_SDInit\n"); 2133 /* SD Init Part-1 */ 2134 result = ene_load_bincode(us, SD_INIT1_PATTERN); 2135 if (result != USB_STOR_XFER_GOOD) { 2136 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n"); 2137 return USB_STOR_TRANSPORT_ERROR; 2138 } 2139 2140 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2141 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2142 bcb->Flags = US_BULK_FLAG_IN; 2143 bcb->CDB[0] = 0xF2; 2144 2145 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 2146 if (result != USB_STOR_XFER_GOOD) { 2147 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n"); 2148 return USB_STOR_TRANSPORT_ERROR; 2149 } 2150 2151 /* SD Init Part-2 */ 2152 result = ene_load_bincode(us, SD_INIT2_PATTERN); 2153 if (result != USB_STOR_XFER_GOOD) { 2154 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n"); 2155 return USB_STOR_TRANSPORT_ERROR; 2156 } 2157 2158 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2159 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2160 bcb->DataTransferLength = 0x200; 2161 bcb->Flags = US_BULK_FLAG_IN; 2162 bcb->CDB[0] = 0xF1; 2163 2164 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0); 2165 if (result != USB_STOR_XFER_GOOD) { 2166 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n"); 2167 return USB_STOR_TRANSPORT_ERROR; 2168 } 2169 2170 info->SD_Status = *(struct SD_STATUS *) bbuf; 2171 if (info->SD_Status.Insert && info->SD_Status.Ready) { 2172 struct SD_STATUS *s = &info->SD_Status; 2173 2174 ene_get_card_status(us, bbuf); 2175 usb_stor_dbg(us, "Insert = %x\n", s->Insert); 2176 usb_stor_dbg(us, "Ready = %x\n", s->Ready); 2177 usb_stor_dbg(us, "IsMMC = %x\n", s->IsMMC); 2178 usb_stor_dbg(us, "HiCapacity = %x\n", s->HiCapacity); 2179 usb_stor_dbg(us, "HiSpeed = %x\n", s->HiSpeed); 2180 usb_stor_dbg(us, "WtP = %x\n", s->WtP); 2181 } else { 2182 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]); 2183 return USB_STOR_TRANSPORT_ERROR; 2184 } 2185 return USB_STOR_TRANSPORT_GOOD; 2186 } 2187 2188 2189 static int ene_init(struct us_data *us) 2190 { 2191 int result; 2192 u8 misc_reg03; 2193 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2194 u8 *bbuf = info->bbuf; 2195 2196 result = ene_get_card_type(us, REG_CARD_STATUS, bbuf); 2197 if (result != USB_STOR_XFER_GOOD) 2198 return USB_STOR_TRANSPORT_ERROR; 2199 2200 misc_reg03 = bbuf[0]; 2201 if (misc_reg03 & 0x01) { 2202 if (!info->SD_Status.Ready) { 2203 result = ene_sd_init(us); 2204 if (result != USB_STOR_XFER_GOOD) 2205 return USB_STOR_TRANSPORT_ERROR; 2206 } 2207 } 2208 if (misc_reg03 & 0x02) { 2209 if (!info->MS_Status.Ready) { 2210 result = ene_ms_init(us); 2211 if (result != USB_STOR_XFER_GOOD) 2212 return USB_STOR_TRANSPORT_ERROR; 2213 } 2214 } 2215 return result; 2216 } 2217 2218 /*----- sd_scsi_irp() ---------*/ 2219 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb) 2220 { 2221 int result; 2222 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra; 2223 2224 switch (srb->cmnd[0]) { 2225 case TEST_UNIT_READY: 2226 result = sd_scsi_test_unit_ready(us, srb); 2227 break; /* 0x00 */ 2228 case REQUEST_SENSE: 2229 result = do_scsi_request_sense(us, srb); 2230 break; /* 0x03 */ 2231 case INQUIRY: 2232 result = do_scsi_inquiry(us, srb); 2233 break; /* 0x12 */ 2234 case MODE_SENSE: 2235 result = sd_scsi_mode_sense(us, srb); 2236 break; /* 0x1A */ 2237 /* 2238 case START_STOP: 2239 result = SD_SCSI_Start_Stop(us, srb); 2240 break; //0x1B 2241 */ 2242 case READ_CAPACITY: 2243 result = sd_scsi_read_capacity(us, srb); 2244 break; /* 0x25 */ 2245 case READ_10: 2246 result = sd_scsi_read(us, srb); 2247 break; /* 0x28 */ 2248 case WRITE_10: 2249 result = sd_scsi_write(us, srb); 2250 break; /* 0x2A */ 2251 default: 2252 info->SrbStatus = SS_ILLEGAL_REQUEST; 2253 result = USB_STOR_TRANSPORT_FAILED; 2254 break; 2255 } 2256 if (result == USB_STOR_TRANSPORT_GOOD) 2257 info->SrbStatus = SS_SUCCESS; 2258 return result; 2259 } 2260 2261 /* 2262 * ms_scsi_irp() 2263 */ 2264 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb) 2265 { 2266 int result; 2267 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra; 2268 2269 switch (srb->cmnd[0]) { 2270 case TEST_UNIT_READY: 2271 result = ms_scsi_test_unit_ready(us, srb); 2272 break; /* 0x00 */ 2273 case REQUEST_SENSE: 2274 result = do_scsi_request_sense(us, srb); 2275 break; /* 0x03 */ 2276 case INQUIRY: 2277 result = do_scsi_inquiry(us, srb); 2278 break; /* 0x12 */ 2279 case MODE_SENSE: 2280 result = ms_scsi_mode_sense(us, srb); 2281 break; /* 0x1A */ 2282 case READ_CAPACITY: 2283 result = ms_scsi_read_capacity(us, srb); 2284 break; /* 0x25 */ 2285 case READ_10: 2286 result = ms_scsi_read(us, srb); 2287 break; /* 0x28 */ 2288 case WRITE_10: 2289 result = ms_scsi_write(us, srb); 2290 break; /* 0x2A */ 2291 default: 2292 info->SrbStatus = SS_ILLEGAL_REQUEST; 2293 result = USB_STOR_TRANSPORT_FAILED; 2294 break; 2295 } 2296 if (result == USB_STOR_TRANSPORT_GOOD) 2297 info->SrbStatus = SS_SUCCESS; 2298 return result; 2299 } 2300 2301 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us) 2302 { 2303 int result = USB_STOR_XFER_GOOD; 2304 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2305 2306 /*US_DEBUG(usb_stor_show_command(us, srb)); */ 2307 scsi_set_resid(srb, 0); 2308 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) 2309 result = ene_init(us); 2310 if (result == USB_STOR_XFER_GOOD) { 2311 result = USB_STOR_TRANSPORT_ERROR; 2312 if (info->SD_Status.Ready) 2313 result = sd_scsi_irp(us, srb); 2314 2315 if (info->MS_Status.Ready) 2316 result = ms_scsi_irp(us, srb); 2317 } 2318 return result; 2319 } 2320 2321 static struct scsi_host_template ene_ub6250_host_template; 2322 2323 static int ene_ub6250_probe(struct usb_interface *intf, 2324 const struct usb_device_id *id) 2325 { 2326 int result; 2327 u8 misc_reg03; 2328 struct us_data *us; 2329 struct ene_ub6250_info *info; 2330 2331 result = usb_stor_probe1(&us, intf, id, 2332 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list, 2333 &ene_ub6250_host_template); 2334 if (result) 2335 return result; 2336 2337 /* FIXME: where should the code alloc extra buf ? */ 2338 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL); 2339 if (!us->extra) 2340 return -ENOMEM; 2341 us->extra_destructor = ene_ub6250_info_destructor; 2342 2343 info = (struct ene_ub6250_info *)(us->extra); 2344 info->bbuf = kmalloc(512, GFP_KERNEL); 2345 if (!info->bbuf) { 2346 kfree(us->extra); 2347 return -ENOMEM; 2348 } 2349 2350 us->transport_name = "ene_ub6250"; 2351 us->transport = ene_transport; 2352 us->max_lun = 0; 2353 2354 result = usb_stor_probe2(us); 2355 if (result) 2356 return result; 2357 2358 /* probe card type */ 2359 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf); 2360 if (result != USB_STOR_XFER_GOOD) { 2361 usb_stor_disconnect(intf); 2362 return USB_STOR_TRANSPORT_ERROR; 2363 } 2364 2365 misc_reg03 = info->bbuf[0]; 2366 if (!(misc_reg03 & 0x01)) { 2367 pr_info("ums_eneub6250: This driver only supports SD/MS cards. " 2368 "It does not support SM cards.\n"); 2369 } 2370 2371 return result; 2372 } 2373 2374 2375 #ifdef CONFIG_PM 2376 2377 static int ene_ub6250_resume(struct usb_interface *iface) 2378 { 2379 u8 tmp = 0; 2380 struct us_data *us = usb_get_intfdata(iface); 2381 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2382 2383 mutex_lock(&us->dev_mutex); 2384 2385 if (us->suspend_resume_hook) 2386 (us->suspend_resume_hook)(us, US_RESUME); 2387 2388 mutex_unlock(&us->dev_mutex); 2389 2390 info->Power_IsResum = true; 2391 /*info->SD_Status.Ready = 0; */ 2392 info->SD_Status = *(struct SD_STATUS *)&tmp; 2393 info->MS_Status = *(struct MS_STATUS *)&tmp; 2394 info->SM_Status = *(struct SM_STATUS *)&tmp; 2395 2396 return 0; 2397 } 2398 2399 static int ene_ub6250_reset_resume(struct usb_interface *iface) 2400 { 2401 u8 tmp = 0; 2402 struct us_data *us = usb_get_intfdata(iface); 2403 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2404 2405 /* Report the reset to the SCSI core */ 2406 usb_stor_reset_resume(iface); 2407 2408 /* 2409 * FIXME: Notify the subdrivers that they need to reinitialize 2410 * the device 2411 */ 2412 info->Power_IsResum = true; 2413 /*info->SD_Status.Ready = 0; */ 2414 info->SD_Status = *(struct SD_STATUS *)&tmp; 2415 info->MS_Status = *(struct MS_STATUS *)&tmp; 2416 info->SM_Status = *(struct SM_STATUS *)&tmp; 2417 2418 return 0; 2419 } 2420 2421 #else 2422 2423 #define ene_ub6250_resume NULL 2424 #define ene_ub6250_reset_resume NULL 2425 2426 #endif 2427 2428 static struct usb_driver ene_ub6250_driver = { 2429 .name = DRV_NAME, 2430 .probe = ene_ub6250_probe, 2431 .disconnect = usb_stor_disconnect, 2432 .suspend = usb_stor_suspend, 2433 .resume = ene_ub6250_resume, 2434 .reset_resume = ene_ub6250_reset_resume, 2435 .pre_reset = usb_stor_pre_reset, 2436 .post_reset = usb_stor_post_reset, 2437 .id_table = ene_ub6250_usb_ids, 2438 .soft_unbind = 1, 2439 .no_dynamic_id = 1, 2440 }; 2441 2442 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME); 2443