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