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 default: 865 break; 866 } 867 } 868 869 return Count; 870 } 871 872 static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr, 873 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat) 874 { 875 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 876 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 877 u8 *bbuf = info->bbuf; 878 int result; 879 u32 bn = PhyBlockAddr * 0x20 + PageNum; 880 881 result = ene_load_bincode(us, MS_RW_PATTERN); 882 if (result != USB_STOR_XFER_GOOD) 883 return USB_STOR_TRANSPORT_ERROR; 884 885 /* Read Page Data */ 886 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 887 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 888 bcb->DataTransferLength = 0x200; 889 bcb->Flags = US_BULK_FLAG_IN; 890 bcb->CDB[0] = 0xF1; 891 892 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */ 893 894 bcb->CDB[5] = (unsigned char)(bn); 895 bcb->CDB[4] = (unsigned char)(bn>>8); 896 bcb->CDB[3] = (unsigned char)(bn>>16); 897 bcb->CDB[2] = (unsigned char)(bn>>24); 898 899 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0); 900 if (result != USB_STOR_XFER_GOOD) 901 return USB_STOR_TRANSPORT_ERROR; 902 903 904 /* Read Extra Data */ 905 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 906 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 907 bcb->DataTransferLength = 0x4; 908 bcb->Flags = US_BULK_FLAG_IN; 909 bcb->CDB[0] = 0xF1; 910 bcb->CDB[1] = 0x03; 911 912 bcb->CDB[5] = (unsigned char)(PageNum); 913 bcb->CDB[4] = (unsigned char)(PhyBlockAddr); 914 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8); 915 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16); 916 bcb->CDB[6] = 0x01; 917 918 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0); 919 if (result != USB_STOR_XFER_GOOD) 920 return USB_STOR_TRANSPORT_ERROR; 921 922 ExtraDat->reserved = 0; 923 ExtraDat->intr = 0x80; /* Not yet,fireware support */ 924 ExtraDat->status0 = 0x10; /* Not yet,fireware support */ 925 926 ExtraDat->status1 = 0x00; /* Not yet,fireware support */ 927 ExtraDat->ovrflg = bbuf[0]; 928 ExtraDat->mngflg = bbuf[1]; 929 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]); 930 931 return USB_STOR_TRANSPORT_GOOD; 932 } 933 934 static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData) 935 { 936 struct ms_bootblock_sysent *SysEntry; 937 struct ms_bootblock_sysinf *SysInfo; 938 u32 i, result; 939 u8 PageNumber; 940 u8 *PageBuffer; 941 struct ms_lib_type_extdat ExtraData; 942 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 943 944 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 945 if (PageBuffer == NULL) 946 return (u32)-1; 947 948 result = (u32)-1; 949 950 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf); 951 952 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) || 953 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) || 954 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) || 955 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) || 956 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) || 957 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) || 958 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL)) 959 goto exit; 960 /* */ 961 switch (info->MS_Lib.cardType = SysInfo->bCardType) { 962 case MS_SYSINF_CARDTYPE_RDONLY: 963 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); 964 break; 965 case MS_SYSINF_CARDTYPE_RDWR: 966 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY); 967 break; 968 case MS_SYSINF_CARDTYPE_HYBRID: 969 default: 970 goto exit; 971 } 972 973 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize); 974 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber); 975 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2; 976 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE; 977 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT; 978 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize); 979 980 /*Allocate to all number of logicalblock and physicalblock */ 981 if (ms_lib_alloc_logicalmap(us)) 982 goto exit; 983 984 /* Mark the book block */ 985 ms_lib_set_bootblockmark(us, PhyBlock); 986 987 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent); 988 989 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) { 990 u32 EntryOffset, EntrySize; 991 992 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart); 993 994 if (EntryOffset == 0xffffff) 995 continue; 996 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize); 997 998 if (EntrySize == 0) 999 continue; 1000 1001 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO) 1002 continue; 1003 1004 if (i == 0) { 1005 u8 PrevPageNumber = 0; 1006 u16 phyblk; 1007 1008 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK) 1009 goto exit; 1010 1011 while (EntrySize > 0) { 1012 1013 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1); 1014 if (PageNumber != PrevPageNumber) { 1015 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) { 1016 case MS_STATUS_SUCCESS: 1017 break; 1018 case MS_STATUS_WRITE_PROTECT: 1019 case MS_ERROR_FLASH_READ: 1020 case MS_STATUS_ERROR: 1021 default: 1022 goto exit; 1023 } 1024 1025 PrevPageNumber = PageNumber; 1026 } 1027 1028 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE))); 1029 if (phyblk < 0x0fff) 1030 ms_lib_set_initialerrorblock(us, phyblk); 1031 1032 EntryOffset += 2; 1033 EntrySize -= 2; 1034 } 1035 } else if (i == 1) { /* CIS/IDI */ 1036 struct ms_bootblock_idi *idi; 1037 1038 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI) 1039 goto exit; 1040 1041 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) { 1042 case MS_STATUS_SUCCESS: 1043 break; 1044 case MS_STATUS_WRITE_PROTECT: 1045 case MS_ERROR_FLASH_READ: 1046 case MS_STATUS_ERROR: 1047 default: 1048 goto exit; 1049 } 1050 1051 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi; 1052 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF) 1053 goto exit; 1054 1055 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector); 1056 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE) 1057 goto exit; 1058 } 1059 } /* End for .. */ 1060 1061 result = 0; 1062 1063 exit: 1064 if (result) 1065 ms_lib_free_logicalmap(us); 1066 1067 kfree(PageBuffer); 1068 1069 result = 0; 1070 return result; 1071 } 1072 1073 static void ms_lib_free_writebuf(struct us_data *us) 1074 { 1075 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1076 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */ 1077 1078 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */ 1079 1080 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */ 1081 1082 if (info->MS_Lib.blkpag) { 1083 kfree(info->MS_Lib.blkpag); /* Arnold test ... */ 1084 info->MS_Lib.blkpag = NULL; 1085 } 1086 1087 if (info->MS_Lib.blkext) { 1088 kfree(info->MS_Lib.blkext); /* Arnold test ... */ 1089 info->MS_Lib.blkext = NULL; 1090 } 1091 } 1092 1093 1094 static void ms_lib_free_allocatedarea(struct us_data *us) 1095 { 1096 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1097 1098 ms_lib_free_writebuf(us); /* Free MS_Lib.pagemap */ 1099 ms_lib_free_logicalmap(us); /* kfree MS_Lib.Phy2LogMap and MS_Lib.Log2PhyMap */ 1100 1101 /* set struct us point flag to 0 */ 1102 info->MS_Lib.flags = 0; 1103 info->MS_Lib.BytesPerSector = 0; 1104 info->MS_Lib.SectorsPerCylinder = 0; 1105 1106 info->MS_Lib.cardType = 0; 1107 info->MS_Lib.blockSize = 0; 1108 info->MS_Lib.PagesPerBlock = 0; 1109 1110 info->MS_Lib.NumberOfPhyBlock = 0; 1111 info->MS_Lib.NumberOfLogBlock = 0; 1112 } 1113 1114 1115 static int ms_lib_alloc_writebuf(struct us_data *us) 1116 { 1117 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1118 1119 info->MS_Lib.wrtblk = (u16)-1; 1120 1121 info->MS_Lib.blkpag = kmalloc_array(info->MS_Lib.PagesPerBlock, 1122 info->MS_Lib.BytesPerSector, 1123 GFP_KERNEL); 1124 info->MS_Lib.blkext = kmalloc_array(info->MS_Lib.PagesPerBlock, 1125 sizeof(struct ms_lib_type_extdat), 1126 GFP_KERNEL); 1127 1128 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) { 1129 ms_lib_free_writebuf(us); 1130 return (u32)-1; 1131 } 1132 1133 ms_lib_clear_writebuf(us); 1134 1135 return 0; 1136 } 1137 1138 static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk) 1139 { 1140 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1141 1142 if (logblk == MS_LB_NOT_USED) 1143 return 0; 1144 1145 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || 1146 (phyblk >= info->MS_Lib.NumberOfPhyBlock)) 1147 return (u32)-1; 1148 1149 info->MS_Lib.Phy2LogMap[phyblk] = logblk; 1150 info->MS_Lib.Log2PhyMap[logblk] = phyblk; 1151 1152 return 0; 1153 } 1154 1155 static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy, 1156 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len) 1157 { 1158 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1159 int result; 1160 1161 result = ene_load_bincode(us, MS_RW_PATTERN); 1162 if (result != USB_STOR_XFER_GOOD) 1163 return USB_STOR_TRANSPORT_ERROR; 1164 1165 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1166 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1167 bcb->DataTransferLength = 0x200*len; 1168 bcb->Flags = 0x00; 1169 bcb->CDB[0] = 0xF0; 1170 bcb->CDB[1] = 0x08; 1171 bcb->CDB[4] = (unsigned char)(oldphy); 1172 bcb->CDB[3] = (unsigned char)(oldphy>>8); 1173 bcb->CDB[2] = 0; /* (BYTE)(oldphy>>16) */ 1174 bcb->CDB[7] = (unsigned char)(newphy); 1175 bcb->CDB[6] = (unsigned char)(newphy>>8); 1176 bcb->CDB[5] = 0; /* (BYTE)(newphy>>16) */ 1177 bcb->CDB[9] = (unsigned char)(PhyBlockAddr); 1178 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8); 1179 bcb->CDB[10] = PageNum; 1180 1181 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0); 1182 if (result != USB_STOR_XFER_GOOD) 1183 return USB_STOR_TRANSPORT_ERROR; 1184 1185 return USB_STOR_TRANSPORT_GOOD; 1186 } 1187 1188 static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr) 1189 { 1190 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1191 int result; 1192 u32 bn = PhyBlockAddr; 1193 1194 result = ene_load_bincode(us, MS_RW_PATTERN); 1195 if (result != USB_STOR_XFER_GOOD) 1196 return USB_STOR_TRANSPORT_ERROR; 1197 1198 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1199 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1200 bcb->DataTransferLength = 0x200; 1201 bcb->Flags = US_BULK_FLAG_IN; 1202 bcb->CDB[0] = 0xF2; 1203 bcb->CDB[1] = 0x06; 1204 bcb->CDB[4] = (unsigned char)(bn); 1205 bcb->CDB[3] = (unsigned char)(bn>>8); 1206 bcb->CDB[2] = (unsigned char)(bn>>16); 1207 1208 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 1209 if (result != USB_STOR_XFER_GOOD) 1210 return USB_STOR_TRANSPORT_ERROR; 1211 1212 return USB_STOR_TRANSPORT_GOOD; 1213 } 1214 1215 static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock) 1216 { 1217 unsigned char *PageBuf = NULL; 1218 u16 result = MS_STATUS_SUCCESS; 1219 u16 blk, index = 0; 1220 struct ms_lib_type_extdat extdat; 1221 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1222 1223 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1224 if (PageBuf == NULL) { 1225 result = MS_NO_MEMORY_ERROR; 1226 goto exit; 1227 } 1228 1229 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat); 1230 do { 1231 blk = be16_to_cpu(PageBuf[index]); 1232 if (blk == MS_LB_NOT_USED) 1233 break; 1234 if (blk == info->MS_Lib.Log2PhyMap[0]) { 1235 result = MS_ERROR_FLASH_READ; 1236 break; 1237 } 1238 index++; 1239 } while (1); 1240 1241 exit: 1242 kfree(PageBuf); 1243 return result; 1244 } 1245 1246 static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk) 1247 { 1248 u16 log; 1249 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1250 1251 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1252 return (u32)-1; 1253 1254 log = info->MS_Lib.Phy2LogMap[phyblk]; 1255 1256 if (log < info->MS_Lib.NumberOfLogBlock) 1257 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED; 1258 1259 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR) 1260 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR; 1261 1262 return 0; 1263 } 1264 1265 static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr, 1266 u8 PageNum, u8 OverwriteFlag) 1267 { 1268 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1269 int result; 1270 1271 result = ene_load_bincode(us, MS_RW_PATTERN); 1272 if (result != USB_STOR_XFER_GOOD) 1273 return USB_STOR_TRANSPORT_ERROR; 1274 1275 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1276 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1277 bcb->DataTransferLength = 0x4; 1278 bcb->Flags = US_BULK_FLAG_IN; 1279 bcb->CDB[0] = 0xF2; 1280 bcb->CDB[1] = 0x05; 1281 bcb->CDB[5] = (unsigned char)(PageNum); 1282 bcb->CDB[4] = (unsigned char)(PhyBlockAddr); 1283 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8); 1284 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16); 1285 bcb->CDB[6] = OverwriteFlag; 1286 bcb->CDB[7] = 0xFF; 1287 bcb->CDB[8] = 0xFF; 1288 bcb->CDB[9] = 0xFF; 1289 1290 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 1291 if (result != USB_STOR_XFER_GOOD) 1292 return USB_STOR_TRANSPORT_ERROR; 1293 1294 return USB_STOR_TRANSPORT_GOOD; 1295 } 1296 1297 static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk) 1298 { 1299 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1300 1301 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1302 return MS_STATUS_ERROR; 1303 1304 ms_lib_setacquired_errorblock(us, phyblk); 1305 1306 if (ms_lib_iswritable(info)) 1307 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK)); 1308 1309 return MS_STATUS_SUCCESS; 1310 } 1311 1312 static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk) 1313 { 1314 u16 log; 1315 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1316 1317 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1318 return MS_STATUS_ERROR; 1319 1320 log = info->MS_Lib.Phy2LogMap[phyblk]; 1321 1322 if (log < info->MS_Lib.NumberOfLogBlock) 1323 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED; 1324 1325 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED; 1326 1327 if (ms_lib_iswritable(info)) { 1328 switch (ms_read_eraseblock(us, phyblk)) { 1329 case MS_STATUS_SUCCESS: 1330 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED; 1331 return MS_STATUS_SUCCESS; 1332 case MS_ERROR_FLASH_ERASE: 1333 case MS_STATUS_INT_ERROR: 1334 ms_lib_error_phyblock(us, phyblk); 1335 return MS_ERROR_FLASH_ERASE; 1336 case MS_STATUS_ERROR: 1337 default: 1338 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY); /* MS_LibCtrlSet will used by ENE_MSInit ,need check, and why us to info*/ 1339 ms_lib_setacquired_errorblock(us, phyblk); 1340 return MS_STATUS_ERROR; 1341 } 1342 } 1343 1344 ms_lib_setacquired_errorblock(us, phyblk); 1345 1346 return MS_STATUS_SUCCESS; 1347 } 1348 1349 static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock, 1350 u8 PageNum, struct ms_lib_type_extdat *ExtraDat) 1351 { 1352 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1353 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1354 u8 *bbuf = info->bbuf; 1355 int result; 1356 1357 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1358 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1359 bcb->DataTransferLength = 0x4; 1360 bcb->Flags = US_BULK_FLAG_IN; 1361 bcb->CDB[0] = 0xF1; 1362 bcb->CDB[1] = 0x03; 1363 bcb->CDB[5] = (unsigned char)(PageNum); 1364 bcb->CDB[4] = (unsigned char)(PhyBlock); 1365 bcb->CDB[3] = (unsigned char)(PhyBlock>>8); 1366 bcb->CDB[2] = (unsigned char)(PhyBlock>>16); 1367 bcb->CDB[6] = 0x01; 1368 1369 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0); 1370 if (result != USB_STOR_XFER_GOOD) 1371 return USB_STOR_TRANSPORT_ERROR; 1372 1373 ExtraDat->reserved = 0; 1374 ExtraDat->intr = 0x80; /* Not yet, waiting for fireware support */ 1375 ExtraDat->status0 = 0x10; /* Not yet, waiting for fireware support */ 1376 ExtraDat->status1 = 0x00; /* Not yet, waiting for fireware support */ 1377 ExtraDat->ovrflg = bbuf[0]; 1378 ExtraDat->mngflg = bbuf[1]; 1379 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]); 1380 1381 return USB_STOR_TRANSPORT_GOOD; 1382 } 1383 1384 static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk) 1385 { 1386 u16 blk; 1387 struct ms_lib_type_extdat extdat; /* need check */ 1388 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1389 1390 1391 if (phyblk >= info->MS_Lib.NumberOfPhyBlock) 1392 return MS_LB_ERROR; 1393 1394 for (blk = phyblk + 1; blk != phyblk; blk++) { 1395 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0) 1396 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1397 1398 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) { 1399 return blk; 1400 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) { 1401 switch (ms_lib_read_extra(us, blk, 0, &extdat)) { 1402 case MS_STATUS_SUCCESS: 1403 case MS_STATUS_SUCCESS_WITH_ECC: 1404 break; 1405 case MS_NOCARD_ERROR: 1406 return MS_NOCARD_ERROR; 1407 case MS_STATUS_INT_ERROR: 1408 return MS_LB_ERROR; 1409 case MS_ERROR_FLASH_READ: 1410 default: 1411 ms_lib_setacquired_errorblock(us, blk); 1412 continue; 1413 } /* End switch */ 1414 1415 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) { 1416 ms_lib_setacquired_errorblock(us, blk); 1417 continue; 1418 } 1419 1420 switch (ms_lib_erase_phyblock(us, blk)) { 1421 case MS_STATUS_SUCCESS: 1422 return blk; 1423 case MS_STATUS_ERROR: 1424 return MS_LB_ERROR; 1425 case MS_ERROR_FLASH_ERASE: 1426 default: 1427 ms_lib_error_phyblock(us, blk); 1428 break; 1429 } 1430 } 1431 } /* End for */ 1432 1433 return MS_LB_ERROR; 1434 } 1435 static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk) 1436 { 1437 u16 phyblk; 1438 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1439 1440 phyblk = ms_libconv_to_physical(info, logblk); 1441 if (phyblk >= MS_LB_ERROR) { 1442 if (logblk >= info->MS_Lib.NumberOfLogBlock) 1443 return MS_LB_ERROR; 1444 1445 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT; 1446 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1447 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1; 1448 } 1449 1450 return ms_libsearch_block_from_physical(us, phyblk); 1451 } 1452 1453 static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb) 1454 { 1455 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 1456 1457 /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */ 1458 if (info->MS_Status.Insert && info->MS_Status.Ready) { 1459 return USB_STOR_TRANSPORT_GOOD; 1460 } else { 1461 ene_ms_init(us); 1462 return USB_STOR_TRANSPORT_GOOD; 1463 } 1464 1465 return USB_STOR_TRANSPORT_GOOD; 1466 } 1467 1468 static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb) 1469 { 1470 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1471 unsigned char mediaNoWP[12] = { 1472 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00, 1473 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 1474 unsigned char mediaWP[12] = { 1475 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00, 1476 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 }; 1477 1478 if (info->MS_Status.WtP) 1479 usb_stor_set_xfer_buf(mediaWP, 12, srb); 1480 else 1481 usb_stor_set_xfer_buf(mediaNoWP, 12, srb); 1482 1483 return USB_STOR_TRANSPORT_GOOD; 1484 } 1485 1486 static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb) 1487 { 1488 u32 bl_num; 1489 u16 bl_len; 1490 unsigned int offset = 0; 1491 unsigned char buf[8]; 1492 struct scatterlist *sg = NULL; 1493 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1494 1495 usb_stor_dbg(us, "ms_scsi_read_capacity\n"); 1496 bl_len = 0x200; 1497 if (info->MS_Status.IsMSPro) 1498 bl_num = info->MSP_TotalBlock - 1; 1499 else 1500 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1; 1501 1502 info->bl_num = bl_num; 1503 usb_stor_dbg(us, "bl_len = %x\n", bl_len); 1504 usb_stor_dbg(us, "bl_num = %x\n", bl_num); 1505 1506 /*srb->request_bufflen = 8; */ 1507 buf[0] = (bl_num >> 24) & 0xff; 1508 buf[1] = (bl_num >> 16) & 0xff; 1509 buf[2] = (bl_num >> 8) & 0xff; 1510 buf[3] = (bl_num >> 0) & 0xff; 1511 buf[4] = (bl_len >> 24) & 0xff; 1512 buf[5] = (bl_len >> 16) & 0xff; 1513 buf[6] = (bl_len >> 8) & 0xff; 1514 buf[7] = (bl_len >> 0) & 0xff; 1515 1516 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF); 1517 1518 return USB_STOR_TRANSPORT_GOOD; 1519 } 1520 1521 static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde) 1522 { 1523 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT; 1524 1525 if (PhyBlock) { 1526 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/ 1527 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;/*496*/ 1528 } else { 1529 *LogStart = 0; 1530 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;/*494*/ 1531 } 1532 } 1533 1534 static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock, 1535 u8 PageNum, u8 blen, void *buf) 1536 { 1537 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1538 int result; 1539 1540 /* Read Extra Data */ 1541 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1542 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1543 bcb->DataTransferLength = 0x4 * blen; 1544 bcb->Flags = US_BULK_FLAG_IN; 1545 bcb->CDB[0] = 0xF1; 1546 bcb->CDB[1] = 0x03; 1547 bcb->CDB[5] = (unsigned char)(PageNum); 1548 bcb->CDB[4] = (unsigned char)(PhyBlock); 1549 bcb->CDB[3] = (unsigned char)(PhyBlock>>8); 1550 bcb->CDB[2] = (unsigned char)(PhyBlock>>16); 1551 bcb->CDB[6] = blen; 1552 1553 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0); 1554 if (result != USB_STOR_XFER_GOOD) 1555 return USB_STOR_TRANSPORT_ERROR; 1556 1557 return USB_STOR_TRANSPORT_GOOD; 1558 } 1559 1560 static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st) 1561 { 1562 u16 PhyBlock, newblk, i; 1563 u16 LogStart, LogEnde; 1564 struct ms_lib_type_extdat extdat; 1565 u32 count = 0, index = 0; 1566 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1567 u8 *bbuf = info->bbuf; 1568 1569 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) { 1570 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde); 1571 1572 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) { 1573 switch (ms_libconv_to_logical(info, PhyBlock)) { 1574 case MS_STATUS_ERROR: 1575 continue; 1576 default: 1577 break; 1578 } 1579 1580 if (count == PhyBlock) { 1581 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80, 1582 bbuf); 1583 count += 0x80; 1584 } 1585 index = (PhyBlock % 0x80) * 4; 1586 1587 extdat.ovrflg = bbuf[index]; 1588 extdat.mngflg = bbuf[index+1]; 1589 extdat.logadr = memstick_logaddr(bbuf[index+2], 1590 bbuf[index+3]); 1591 1592 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) { 1593 ms_lib_setacquired_errorblock(us, PhyBlock); 1594 continue; 1595 } 1596 1597 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) { 1598 ms_lib_erase_phyblock(us, PhyBlock); 1599 continue; 1600 } 1601 1602 if (extdat.logadr != MS_LB_NOT_USED) { 1603 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) { 1604 ms_lib_erase_phyblock(us, PhyBlock); 1605 continue; 1606 } 1607 1608 newblk = ms_libconv_to_physical(info, extdat.logadr); 1609 1610 if (newblk != MS_LB_NOT_USED) { 1611 if (extdat.logadr == 0) { 1612 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock); 1613 if (ms_lib_check_disableblock(us, btBlk1st)) { 1614 ms_lib_set_logicalpair(us, extdat.logadr, newblk); 1615 continue; 1616 } 1617 } 1618 1619 ms_lib_read_extra(us, newblk, 0, &extdat); 1620 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) { 1621 ms_lib_erase_phyblock(us, PhyBlock); 1622 continue; 1623 } else { 1624 ms_lib_erase_phyblock(us, newblk); 1625 } 1626 } 1627 1628 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock); 1629 } 1630 } 1631 } /* End for ... */ 1632 1633 return MS_STATUS_SUCCESS; 1634 } 1635 1636 1637 static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb) 1638 { 1639 int result; 1640 unsigned char *cdb = srb->cmnd; 1641 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1642 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1643 1644 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) | 1645 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff); 1646 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 1647 u32 blenByte = blen * 0x200; 1648 1649 if (bn > info->bl_num) 1650 return USB_STOR_TRANSPORT_ERROR; 1651 1652 if (info->MS_Status.IsMSPro) { 1653 result = ene_load_bincode(us, MSP_RW_PATTERN); 1654 if (result != USB_STOR_XFER_GOOD) { 1655 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n"); 1656 return USB_STOR_TRANSPORT_ERROR; 1657 } 1658 1659 /* set up the command wrapper */ 1660 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1661 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1662 bcb->DataTransferLength = blenByte; 1663 bcb->Flags = US_BULK_FLAG_IN; 1664 bcb->CDB[0] = 0xF1; 1665 bcb->CDB[1] = 0x02; 1666 bcb->CDB[5] = (unsigned char)(bn); 1667 bcb->CDB[4] = (unsigned char)(bn>>8); 1668 bcb->CDB[3] = (unsigned char)(bn>>16); 1669 bcb->CDB[2] = (unsigned char)(bn>>24); 1670 1671 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1); 1672 } else { 1673 void *buf; 1674 int offset = 0; 1675 u16 phyblk, logblk; 1676 u8 PageNum; 1677 u16 len; 1678 u32 blkno; 1679 1680 buf = kmalloc(blenByte, GFP_KERNEL); 1681 if (buf == NULL) 1682 return USB_STOR_TRANSPORT_ERROR; 1683 1684 result = ene_load_bincode(us, MS_RW_PATTERN); 1685 if (result != USB_STOR_XFER_GOOD) { 1686 pr_info("Load MS RW pattern Fail !!\n"); 1687 result = USB_STOR_TRANSPORT_ERROR; 1688 goto exit; 1689 } 1690 1691 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock); 1692 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock); 1693 1694 while (1) { 1695 if (blen > (info->MS_Lib.PagesPerBlock-PageNum)) 1696 len = info->MS_Lib.PagesPerBlock-PageNum; 1697 else 1698 len = blen; 1699 1700 phyblk = ms_libconv_to_physical(info, logblk); 1701 blkno = phyblk * 0x20 + PageNum; 1702 1703 /* set up the command wrapper */ 1704 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1705 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1706 bcb->DataTransferLength = 0x200 * len; 1707 bcb->Flags = US_BULK_FLAG_IN; 1708 bcb->CDB[0] = 0xF1; 1709 bcb->CDB[1] = 0x02; 1710 bcb->CDB[5] = (unsigned char)(blkno); 1711 bcb->CDB[4] = (unsigned char)(blkno>>8); 1712 bcb->CDB[3] = (unsigned char)(blkno>>16); 1713 bcb->CDB[2] = (unsigned char)(blkno>>24); 1714 1715 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0); 1716 if (result != USB_STOR_XFER_GOOD) { 1717 pr_info("MS_SCSI_Read --- result = %x\n", result); 1718 result = USB_STOR_TRANSPORT_ERROR; 1719 goto exit; 1720 } 1721 1722 blen -= len; 1723 if (blen <= 0) 1724 break; 1725 logblk++; 1726 PageNum = 0; 1727 offset += MS_BYTES_PER_PAGE*len; 1728 } 1729 usb_stor_set_xfer_buf(buf, blenByte, srb); 1730 exit: 1731 kfree(buf); 1732 } 1733 return result; 1734 } 1735 1736 static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb) 1737 { 1738 int result; 1739 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1740 unsigned char *cdb = srb->cmnd; 1741 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1742 1743 u32 bn = ((cdb[2] << 24) & 0xff000000) | 1744 ((cdb[3] << 16) & 0x00ff0000) | 1745 ((cdb[4] << 8) & 0x0000ff00) | 1746 ((cdb[5] << 0) & 0x000000ff); 1747 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff); 1748 u32 blenByte = blen * 0x200; 1749 1750 if (bn > info->bl_num) 1751 return USB_STOR_TRANSPORT_ERROR; 1752 1753 if (info->MS_Status.IsMSPro) { 1754 result = ene_load_bincode(us, MSP_RW_PATTERN); 1755 if (result != USB_STOR_XFER_GOOD) { 1756 pr_info("Load MSP RW pattern Fail !!\n"); 1757 return USB_STOR_TRANSPORT_ERROR; 1758 } 1759 1760 /* set up the command wrapper */ 1761 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1762 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1763 bcb->DataTransferLength = blenByte; 1764 bcb->Flags = 0x00; 1765 bcb->CDB[0] = 0xF0; 1766 bcb->CDB[1] = 0x04; 1767 bcb->CDB[5] = (unsigned char)(bn); 1768 bcb->CDB[4] = (unsigned char)(bn>>8); 1769 bcb->CDB[3] = (unsigned char)(bn>>16); 1770 bcb->CDB[2] = (unsigned char)(bn>>24); 1771 1772 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1); 1773 } else { 1774 void *buf; 1775 int offset = 0; 1776 u16 PhyBlockAddr; 1777 u8 PageNum; 1778 u16 len, oldphy, newphy; 1779 1780 buf = kmalloc(blenByte, GFP_KERNEL); 1781 if (buf == NULL) 1782 return USB_STOR_TRANSPORT_ERROR; 1783 usb_stor_set_xfer_buf(buf, blenByte, srb); 1784 1785 result = ene_load_bincode(us, MS_RW_PATTERN); 1786 if (result != USB_STOR_XFER_GOOD) { 1787 pr_info("Load MS RW pattern Fail !!\n"); 1788 result = USB_STOR_TRANSPORT_ERROR; 1789 goto exit; 1790 } 1791 1792 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock); 1793 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock); 1794 1795 while (1) { 1796 if (blen > (info->MS_Lib.PagesPerBlock-PageNum)) 1797 len = info->MS_Lib.PagesPerBlock-PageNum; 1798 else 1799 len = blen; 1800 1801 oldphy = ms_libconv_to_physical(info, PhyBlockAddr); /* need check us <-> info */ 1802 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr); 1803 1804 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len); 1805 1806 if (result != USB_STOR_XFER_GOOD) { 1807 pr_info("MS_SCSI_Write --- result = %x\n", result); 1808 result = USB_STOR_TRANSPORT_ERROR; 1809 goto exit; 1810 } 1811 1812 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED; 1813 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy); 1814 1815 blen -= len; 1816 if (blen <= 0) 1817 break; 1818 PhyBlockAddr++; 1819 PageNum = 0; 1820 offset += MS_BYTES_PER_PAGE*len; 1821 } 1822 exit: 1823 kfree(buf); 1824 } 1825 return result; 1826 } 1827 1828 /* 1829 * ENE MS Card 1830 */ 1831 1832 static int ene_get_card_type(struct us_data *us, u16 index, void *buf) 1833 { 1834 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1835 int result; 1836 1837 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1838 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1839 bcb->DataTransferLength = 0x01; 1840 bcb->Flags = US_BULK_FLAG_IN; 1841 bcb->CDB[0] = 0xED; 1842 bcb->CDB[2] = (unsigned char)(index>>8); 1843 bcb->CDB[3] = (unsigned char)index; 1844 1845 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0); 1846 return result; 1847 } 1848 1849 static int ene_get_card_status(struct us_data *us, u8 *buf) 1850 { 1851 u16 tmpreg; 1852 u32 reg4b; 1853 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1854 1855 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/ 1856 reg4b = *(u32 *)&buf[0x18]; 1857 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f); 1858 1859 tmpreg = (u16) reg4b; 1860 reg4b = *(u32 *)(&buf[0x14]); 1861 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC) 1862 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff; 1863 1864 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22); 1865 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07; 1866 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC) 1867 info->HC_C_SIZE = *(u32 *)(&buf[0x100]); 1868 1869 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) { 1870 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN); 1871 info->SD_READ_BL_LEN = SD_BLOCK_LEN; 1872 } else { 1873 info->SD_Block_Mult = 1; 1874 } 1875 1876 return USB_STOR_TRANSPORT_GOOD; 1877 } 1878 1879 static int ene_load_bincode(struct us_data *us, unsigned char flag) 1880 { 1881 int err; 1882 char *fw_name = NULL; 1883 unsigned char *buf = NULL; 1884 const struct firmware *sd_fw = NULL; 1885 int result = USB_STOR_TRANSPORT_ERROR; 1886 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 1887 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1888 1889 if (info->BIN_FLAG == flag) 1890 return USB_STOR_TRANSPORT_GOOD; 1891 1892 switch (flag) { 1893 /* For SD */ 1894 case SD_INIT1_PATTERN: 1895 usb_stor_dbg(us, "SD_INIT1_PATTERN\n"); 1896 fw_name = SD_INIT1_FIRMWARE; 1897 break; 1898 case SD_INIT2_PATTERN: 1899 usb_stor_dbg(us, "SD_INIT2_PATTERN\n"); 1900 fw_name = SD_INIT2_FIRMWARE; 1901 break; 1902 case SD_RW_PATTERN: 1903 usb_stor_dbg(us, "SD_RW_PATTERN\n"); 1904 fw_name = SD_RW_FIRMWARE; 1905 break; 1906 /* For MS */ 1907 case MS_INIT_PATTERN: 1908 usb_stor_dbg(us, "MS_INIT_PATTERN\n"); 1909 fw_name = MS_INIT_FIRMWARE; 1910 break; 1911 case MSP_RW_PATTERN: 1912 usb_stor_dbg(us, "MSP_RW_PATTERN\n"); 1913 fw_name = MSP_RW_FIRMWARE; 1914 break; 1915 case MS_RW_PATTERN: 1916 usb_stor_dbg(us, "MS_RW_PATTERN\n"); 1917 fw_name = MS_RW_FIRMWARE; 1918 break; 1919 default: 1920 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n"); 1921 goto nofw; 1922 } 1923 1924 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev); 1925 if (err) { 1926 usb_stor_dbg(us, "load firmware %s failed\n", fw_name); 1927 goto nofw; 1928 } 1929 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL); 1930 if (buf == NULL) 1931 goto nofw; 1932 1933 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 1934 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 1935 bcb->DataTransferLength = sd_fw->size; 1936 bcb->Flags = 0x00; 1937 bcb->CDB[0] = 0xEF; 1938 1939 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0); 1940 if (us->srb != NULL) 1941 scsi_set_resid(us->srb, 0); 1942 info->BIN_FLAG = flag; 1943 kfree(buf); 1944 1945 nofw: 1946 release_firmware(sd_fw); 1947 return result; 1948 } 1949 1950 static int ms_card_init(struct us_data *us) 1951 { 1952 u32 result; 1953 u16 TmpBlock; 1954 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL; 1955 struct ms_lib_type_extdat extdat; 1956 u16 btBlk1st, btBlk2nd; 1957 u32 btBlk1stErred; 1958 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 1959 1960 printk(KERN_INFO "MS_CardInit start\n"); 1961 1962 ms_lib_free_allocatedarea(us); /* Clean buffer and set struct us_data flag to 0 */ 1963 1964 /* get two PageBuffer */ 1965 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1966 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL); 1967 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) { 1968 result = MS_NO_MEMORY_ERROR; 1969 goto exit; 1970 } 1971 1972 btBlk1st = btBlk2nd = MS_LB_NOT_USED; 1973 btBlk1stErred = 0; 1974 1975 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) { 1976 1977 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) { 1978 case MS_STATUS_SUCCESS: 1979 break; 1980 case MS_STATUS_INT_ERROR: 1981 break; 1982 case MS_STATUS_ERROR: 1983 default: 1984 continue; 1985 } 1986 1987 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG) 1988 continue; 1989 1990 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) || 1991 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) || 1992 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) || 1993 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES)) 1994 continue; 1995 1996 if (btBlk1st != MS_LB_NOT_USED) { 1997 btBlk2nd = TmpBlock; 1998 break; 1999 } 2000 2001 btBlk1st = TmpBlock; 2002 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE); 2003 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER)) 2004 btBlk1stErred = 1; 2005 } 2006 2007 if (btBlk1st == MS_LB_NOT_USED) { 2008 result = MS_STATUS_ERROR; 2009 goto exit; 2010 } 2011 2012 /* write protect */ 2013 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON) 2014 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT); 2015 2016 result = MS_STATUS_ERROR; 2017 /* 1st Boot Block */ 2018 if (btBlk1stErred == 0) 2019 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1); 2020 /* 1st */ 2021 /* 2nd Boot Block */ 2022 if (result && (btBlk2nd != MS_LB_NOT_USED)) 2023 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0); 2024 2025 if (result) { 2026 result = MS_STATUS_ERROR; 2027 goto exit; 2028 } 2029 2030 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++) 2031 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR; 2032 2033 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK; 2034 2035 if (btBlk2nd != MS_LB_NOT_USED) { 2036 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++) 2037 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR; 2038 2039 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK; 2040 } 2041 2042 result = ms_lib_scan_logicalblocknumber(us, btBlk1st); 2043 if (result) 2044 goto exit; 2045 2046 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT; 2047 TmpBlock < info->MS_Lib.NumberOfPhyBlock; 2048 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) { 2049 if (ms_count_freeblock(us, TmpBlock) == 0) { 2050 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT); 2051 break; 2052 } 2053 } 2054 2055 /* write */ 2056 if (ms_lib_alloc_writebuf(us)) { 2057 result = MS_NO_MEMORY_ERROR; 2058 goto exit; 2059 } 2060 2061 result = MS_STATUS_SUCCESS; 2062 2063 exit: 2064 kfree(PageBuffer1); 2065 kfree(PageBuffer0); 2066 2067 printk(KERN_INFO "MS_CardInit end\n"); 2068 return result; 2069 } 2070 2071 static int ene_ms_init(struct us_data *us) 2072 { 2073 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 2074 int result; 2075 u16 MSP_BlockSize, MSP_UserAreaBlocks; 2076 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 2077 u8 *bbuf = info->bbuf; 2078 2079 printk(KERN_INFO "transport --- ENE_MSInit\n"); 2080 2081 /* the same part to test ENE */ 2082 2083 result = ene_load_bincode(us, MS_INIT_PATTERN); 2084 if (result != USB_STOR_XFER_GOOD) { 2085 printk(KERN_ERR "Load MS Init Code Fail !!\n"); 2086 return USB_STOR_TRANSPORT_ERROR; 2087 } 2088 2089 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2090 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2091 bcb->DataTransferLength = 0x200; 2092 bcb->Flags = US_BULK_FLAG_IN; 2093 bcb->CDB[0] = 0xF1; 2094 bcb->CDB[1] = 0x01; 2095 2096 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0); 2097 if (result != USB_STOR_XFER_GOOD) { 2098 printk(KERN_ERR "Execution MS Init Code Fail !!\n"); 2099 return USB_STOR_TRANSPORT_ERROR; 2100 } 2101 /* the same part to test ENE */ 2102 info->MS_Status = *(struct MS_STATUS *) bbuf; 2103 2104 if (info->MS_Status.Insert && info->MS_Status.Ready) { 2105 printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert); 2106 printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready); 2107 printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro); 2108 printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG); 2109 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP); 2110 if (info->MS_Status.IsMSPro) { 2111 MSP_BlockSize = (bbuf[6] << 8) | bbuf[7]; 2112 MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11]; 2113 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks; 2114 } else { 2115 ms_card_init(us); /* Card is MS (to ms.c)*/ 2116 } 2117 usb_stor_dbg(us, "MS Init Code OK !!\n"); 2118 } else { 2119 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]); 2120 return USB_STOR_TRANSPORT_ERROR; 2121 } 2122 2123 return USB_STOR_TRANSPORT_GOOD; 2124 } 2125 2126 static int ene_sd_init(struct us_data *us) 2127 { 2128 int result; 2129 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf; 2130 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra; 2131 u8 *bbuf = info->bbuf; 2132 2133 usb_stor_dbg(us, "transport --- ENE_SDInit\n"); 2134 /* SD Init Part-1 */ 2135 result = ene_load_bincode(us, SD_INIT1_PATTERN); 2136 if (result != USB_STOR_XFER_GOOD) { 2137 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n"); 2138 return USB_STOR_TRANSPORT_ERROR; 2139 } 2140 2141 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2142 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2143 bcb->Flags = US_BULK_FLAG_IN; 2144 bcb->CDB[0] = 0xF2; 2145 2146 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0); 2147 if (result != USB_STOR_XFER_GOOD) { 2148 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n"); 2149 return USB_STOR_TRANSPORT_ERROR; 2150 } 2151 2152 /* SD Init Part-2 */ 2153 result = ene_load_bincode(us, SD_INIT2_PATTERN); 2154 if (result != USB_STOR_XFER_GOOD) { 2155 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n"); 2156 return USB_STOR_TRANSPORT_ERROR; 2157 } 2158 2159 memset(bcb, 0, sizeof(struct bulk_cb_wrap)); 2160 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN); 2161 bcb->DataTransferLength = 0x200; 2162 bcb->Flags = US_BULK_FLAG_IN; 2163 bcb->CDB[0] = 0xF1; 2164 2165 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0); 2166 if (result != USB_STOR_XFER_GOOD) { 2167 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n"); 2168 return USB_STOR_TRANSPORT_ERROR; 2169 } 2170 2171 info->SD_Status = *(struct SD_STATUS *) bbuf; 2172 if (info->SD_Status.Insert && info->SD_Status.Ready) { 2173 struct SD_STATUS *s = &info->SD_Status; 2174 2175 ene_get_card_status(us, bbuf); 2176 usb_stor_dbg(us, "Insert = %x\n", s->Insert); 2177 usb_stor_dbg(us, "Ready = %x\n", s->Ready); 2178 usb_stor_dbg(us, "IsMMC = %x\n", s->IsMMC); 2179 usb_stor_dbg(us, "HiCapacity = %x\n", s->HiCapacity); 2180 usb_stor_dbg(us, "HiSpeed = %x\n", s->HiSpeed); 2181 usb_stor_dbg(us, "WtP = %x\n", s->WtP); 2182 } else { 2183 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]); 2184 return USB_STOR_TRANSPORT_ERROR; 2185 } 2186 return USB_STOR_TRANSPORT_GOOD; 2187 } 2188 2189 2190 static int ene_init(struct us_data *us) 2191 { 2192 int result; 2193 u8 misc_reg03; 2194 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2195 u8 *bbuf = info->bbuf; 2196 2197 result = ene_get_card_type(us, REG_CARD_STATUS, bbuf); 2198 if (result != USB_STOR_XFER_GOOD) 2199 return USB_STOR_TRANSPORT_ERROR; 2200 2201 misc_reg03 = bbuf[0]; 2202 if (misc_reg03 & 0x01) { 2203 if (!info->SD_Status.Ready) { 2204 result = ene_sd_init(us); 2205 if (result != USB_STOR_XFER_GOOD) 2206 return USB_STOR_TRANSPORT_ERROR; 2207 } 2208 } 2209 if (misc_reg03 & 0x02) { 2210 if (!info->MS_Status.Ready) { 2211 result = ene_ms_init(us); 2212 if (result != USB_STOR_XFER_GOOD) 2213 return USB_STOR_TRANSPORT_ERROR; 2214 } 2215 } 2216 return result; 2217 } 2218 2219 /*----- sd_scsi_irp() ---------*/ 2220 static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb) 2221 { 2222 int result; 2223 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra; 2224 2225 switch (srb->cmnd[0]) { 2226 case TEST_UNIT_READY: 2227 result = sd_scsi_test_unit_ready(us, srb); 2228 break; /* 0x00 */ 2229 case REQUEST_SENSE: 2230 result = do_scsi_request_sense(us, srb); 2231 break; /* 0x03 */ 2232 case INQUIRY: 2233 result = do_scsi_inquiry(us, srb); 2234 break; /* 0x12 */ 2235 case MODE_SENSE: 2236 result = sd_scsi_mode_sense(us, srb); 2237 break; /* 0x1A */ 2238 /* 2239 case START_STOP: 2240 result = SD_SCSI_Start_Stop(us, srb); 2241 break; //0x1B 2242 */ 2243 case READ_CAPACITY: 2244 result = sd_scsi_read_capacity(us, srb); 2245 break; /* 0x25 */ 2246 case READ_10: 2247 result = sd_scsi_read(us, srb); 2248 break; /* 0x28 */ 2249 case WRITE_10: 2250 result = sd_scsi_write(us, srb); 2251 break; /* 0x2A */ 2252 default: 2253 info->SrbStatus = SS_ILLEGAL_REQUEST; 2254 result = USB_STOR_TRANSPORT_FAILED; 2255 break; 2256 } 2257 if (result == USB_STOR_TRANSPORT_GOOD) 2258 info->SrbStatus = SS_SUCCESS; 2259 return result; 2260 } 2261 2262 /* 2263 * ms_scsi_irp() 2264 */ 2265 static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb) 2266 { 2267 int result; 2268 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra; 2269 2270 switch (srb->cmnd[0]) { 2271 case TEST_UNIT_READY: 2272 result = ms_scsi_test_unit_ready(us, srb); 2273 break; /* 0x00 */ 2274 case REQUEST_SENSE: 2275 result = do_scsi_request_sense(us, srb); 2276 break; /* 0x03 */ 2277 case INQUIRY: 2278 result = do_scsi_inquiry(us, srb); 2279 break; /* 0x12 */ 2280 case MODE_SENSE: 2281 result = ms_scsi_mode_sense(us, srb); 2282 break; /* 0x1A */ 2283 case READ_CAPACITY: 2284 result = ms_scsi_read_capacity(us, srb); 2285 break; /* 0x25 */ 2286 case READ_10: 2287 result = ms_scsi_read(us, srb); 2288 break; /* 0x28 */ 2289 case WRITE_10: 2290 result = ms_scsi_write(us, srb); 2291 break; /* 0x2A */ 2292 default: 2293 info->SrbStatus = SS_ILLEGAL_REQUEST; 2294 result = USB_STOR_TRANSPORT_FAILED; 2295 break; 2296 } 2297 if (result == USB_STOR_TRANSPORT_GOOD) 2298 info->SrbStatus = SS_SUCCESS; 2299 return result; 2300 } 2301 2302 static int ene_transport(struct scsi_cmnd *srb, struct us_data *us) 2303 { 2304 int result = USB_STOR_XFER_GOOD; 2305 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2306 2307 /*US_DEBUG(usb_stor_show_command(us, srb)); */ 2308 scsi_set_resid(srb, 0); 2309 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready))) 2310 result = ene_init(us); 2311 if (result == USB_STOR_XFER_GOOD) { 2312 result = USB_STOR_TRANSPORT_ERROR; 2313 if (info->SD_Status.Ready) 2314 result = sd_scsi_irp(us, srb); 2315 2316 if (info->MS_Status.Ready) 2317 result = ms_scsi_irp(us, srb); 2318 } 2319 return result; 2320 } 2321 2322 static struct scsi_host_template ene_ub6250_host_template; 2323 2324 static int ene_ub6250_probe(struct usb_interface *intf, 2325 const struct usb_device_id *id) 2326 { 2327 int result; 2328 u8 misc_reg03; 2329 struct us_data *us; 2330 struct ene_ub6250_info *info; 2331 2332 result = usb_stor_probe1(&us, intf, id, 2333 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list, 2334 &ene_ub6250_host_template); 2335 if (result) 2336 return result; 2337 2338 /* FIXME: where should the code alloc extra buf ? */ 2339 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL); 2340 if (!us->extra) 2341 return -ENOMEM; 2342 us->extra_destructor = ene_ub6250_info_destructor; 2343 2344 info = (struct ene_ub6250_info *)(us->extra); 2345 info->bbuf = kmalloc(512, GFP_KERNEL); 2346 if (!info->bbuf) { 2347 kfree(us->extra); 2348 return -ENOMEM; 2349 } 2350 2351 us->transport_name = "ene_ub6250"; 2352 us->transport = ene_transport; 2353 us->max_lun = 0; 2354 2355 result = usb_stor_probe2(us); 2356 if (result) 2357 return result; 2358 2359 /* probe card type */ 2360 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf); 2361 if (result != USB_STOR_XFER_GOOD) { 2362 usb_stor_disconnect(intf); 2363 return USB_STOR_TRANSPORT_ERROR; 2364 } 2365 2366 misc_reg03 = info->bbuf[0]; 2367 if (!(misc_reg03 & 0x01)) { 2368 pr_info("ums_eneub6250: This driver only supports SD/MS cards. " 2369 "It does not support SM cards.\n"); 2370 } 2371 2372 return result; 2373 } 2374 2375 2376 #ifdef CONFIG_PM 2377 2378 static int ene_ub6250_resume(struct usb_interface *iface) 2379 { 2380 u8 tmp = 0; 2381 struct us_data *us = usb_get_intfdata(iface); 2382 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2383 2384 mutex_lock(&us->dev_mutex); 2385 2386 if (us->suspend_resume_hook) 2387 (us->suspend_resume_hook)(us, US_RESUME); 2388 2389 mutex_unlock(&us->dev_mutex); 2390 2391 info->Power_IsResum = true; 2392 /*info->SD_Status.Ready = 0; */ 2393 info->SD_Status = *(struct SD_STATUS *)&tmp; 2394 info->MS_Status = *(struct MS_STATUS *)&tmp; 2395 info->SM_Status = *(struct SM_STATUS *)&tmp; 2396 2397 return 0; 2398 } 2399 2400 static int ene_ub6250_reset_resume(struct usb_interface *iface) 2401 { 2402 u8 tmp = 0; 2403 struct us_data *us = usb_get_intfdata(iface); 2404 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra); 2405 2406 /* Report the reset to the SCSI core */ 2407 usb_stor_reset_resume(iface); 2408 2409 /* 2410 * FIXME: Notify the subdrivers that they need to reinitialize 2411 * the device 2412 */ 2413 info->Power_IsResum = true; 2414 /*info->SD_Status.Ready = 0; */ 2415 info->SD_Status = *(struct SD_STATUS *)&tmp; 2416 info->MS_Status = *(struct MS_STATUS *)&tmp; 2417 info->SM_Status = *(struct SM_STATUS *)&tmp; 2418 2419 return 0; 2420 } 2421 2422 #else 2423 2424 #define ene_ub6250_resume NULL 2425 #define ene_ub6250_reset_resume NULL 2426 2427 #endif 2428 2429 static struct usb_driver ene_ub6250_driver = { 2430 .name = DRV_NAME, 2431 .probe = ene_ub6250_probe, 2432 .disconnect = usb_stor_disconnect, 2433 .suspend = usb_stor_suspend, 2434 .resume = ene_ub6250_resume, 2435 .reset_resume = ene_ub6250_reset_resume, 2436 .pre_reset = usb_stor_pre_reset, 2437 .post_reset = usb_stor_post_reset, 2438 .id_table = ene_ub6250_usb_ids, 2439 .soft_unbind = 1, 2440 .no_dynamic_id = 1, 2441 }; 2442 2443 module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME); 2444