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