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