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