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