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