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