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