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