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