]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blame - drivers/usb/storage/ene_ub6250.c
projects / mirror_ubuntu-focal-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
UBUNTU: Ubuntu-5.4.0-117.132
[mirror_ubuntu-focal-kernel.git] / drivers / usb / storage / ene_ub6250.c
CommitLineData
5fd54ace 1// SPDX-License-Identifier: GPL-2.0+
41e568d1 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"
aa519be3 16#include "scsiglue.h"
41e568d1 17
595c8970
TG		 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
aa519be3
AM		 25#define DRV_NAME "ums_eneub6250"
26
41e568d1 27MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
28MODULE_LICENSE("GPL");
32bca2df 29MODULE_IMPORT_NS(USB_STORAGE);
595c8970
TG		 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);
41e568d1 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), \
f61870ee 44 .driver_info = (flags)}
41e568d1 45
36f3a14d 46static struct usb_device_id ene_ub6250_usb_ids[] = {
41e568d1 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 */
ce553bd1
AS		 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 */
41e568d1 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
33842ced
CYC		 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
41e568d1 239
a927e6bb
AS		 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)
41e568d1 267
33842ced
CYC		 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
41e568d1 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 {
628c2893
AS		 432
433 /* I/O bounce buffer */
434 u8 *bbuf;
435
41e568d1 436 /* for 6250 code */
a927e6bb
AS		 437 u8 SD_Status;
438 u8 MS_Status;
439 u8 SM_Status;
41e568d1 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;
33842ced 460 struct ms_lib_ctrl MS_Lib;
41e568d1 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);
33842ced 478static int ene_ms_init(struct us_data *us);
41e568d1 479static int ene_load_bincode(struct us_data *us, unsigned char flag);
480
481static void ene_ub6250_info_destructor(void *extra)
482{
628c2893
AS		 483 struct ene_ub6250_info *info = (struct ene_ub6250_info *) extra;
484
41e568d1 485 if (!extra)
486 return;
628c2893 487 kfree(info->bbuf);
41e568d1 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
191648d0 500 /* usb_stor_dbg(us, "transport --- ene_send_scsi_cmd\n"); */
41e568d1 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) {
191648d0 505 usb_stor_dbg(us, "send cmd to out endpoint fail ---\n");
41e568d1 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) {
191648d0 525 usb_stor_dbg(us, "data transfer fail ---\n");
41e568d1 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) {
191648d0 535 usb_stor_dbg(us, "Received 0-length CSW; retrying...\n");
41e568d1 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 */
191648d0 542 usb_stor_dbg(us, "Attempting to get CSW (2nd try)...\n");
41e568d1 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
f0183a33
FB		 553 /*
554 * try to compute the actual residue, based on how much data
555 * was really transferred and what the device tells us
556 */
41e568d1 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 (int)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
ce553bd1
AS		 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
f8efdabd
AS		 586static int do_scsi_inquiry(struct us_data *us, struct scsi_cmnd *srb)
587{
588 unsigned char data_ptr[36] = {
5fcf9379 589 0x00, 0x00, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55,
f8efdabd
AS		 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
41e568d1 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
a927e6bb 602 if ((info->SD_Status & SD_Insert) && (info->SD_Status & SD_Ready))
41e568d1 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
41e568d1 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
a927e6bb 622 if (info->SD_Status & SD_WtP)
41e568d1 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{
36f3a14d
FB		 633 u32 bl_num;
634 u32 bl_len;
41e568d1 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
191648d0 640 usb_stor_dbg(us, "sd_scsi_read_capacity\n");
a927e6bb 641 if (info->SD_Status & SD_HiCapacity) {
41e568d1 642 bl_len = 0x200;
a927e6bb 643 if (info->SD_Status & SD_IsMMC)
41e568d1 644 bl_num = info->HC_C_SIZE-1;
645 else
646 bl_num = (info->HC_C_SIZE + 1) * 1024 - 1;
647 } else {
36f3a14d 648 bl_len = 1 << (info->SD_READ_BL_LEN);
41e568d1 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;
191648d0
JP		 653 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
654 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
41e568d1 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) {
191648d0 689 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
41e568d1 690 return USB_STOR_TRANSPORT_ERROR;
691 }
692
a927e6bb 693 if (info->SD_Status & SD_HiCapacity)
41e568d1 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;
b8db6d64 700 bcb->Flags = US_BULK_FLAG_IN;
41e568d1 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) {
191648d0 729 usb_stor_dbg(us, "Load SD RW pattern Fail !!\n");
41e568d1 730 return USB_STOR_TRANSPORT_ERROR;
731 }
732
a927e6bb 733 if (info->SD_Status & SD_HiCapacity)
41e568d1 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
33842ced
CYC		 751/*
752 * ENE MS Card
753 */
754
755static int ms_lib_set_logicalpair(struct us_data *us, u16 logblk, u16 phyblk)
41e568d1 756{
33842ced 757 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
41e568d1 758
33842ced
CYC		 759 if ((logblk >= info->MS_Lib.NumberOfLogBlock) || (phyblk >= info->MS_Lib.NumberOfPhyBlock))
760 return (u32)-1;
41e568d1 761
33842ced
CYC		 762 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
763 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
764
765 return 0;
41e568d1 766}
767
33842ced 768static int ms_lib_set_logicalblockmark(struct us_data *us, u16 phyblk, u16 mark)
41e568d1 769{
41e568d1 770 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
771
33842ced
CYC		 772 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
773 return (u32)-1;
41e568d1 774
33842ced 775 info->MS_Lib.Phy2LogMap[phyblk] = mark;
41e568d1 776
33842ced
CYC		 777 return 0;
778}
41e568d1 779
33842ced
CYC		 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}
41e568d1 784
33842ced
CYC		 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);
41e568d1 788}
789
33842ced 790static int ms_lib_free_logicalmap(struct us_data *us)
41e568d1 791{
41e568d1 792 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
793
33842ced
CYC		 794 kfree(info->MS_Lib.Phy2LogMap);
795 info->MS_Lib.Phy2LogMap = NULL;
41e568d1 796
33842ced
CYC		 797 kfree(info->MS_Lib.Log2PhyMap);
798 info->MS_Lib.Log2PhyMap = NULL;
41e568d1 799
33842ced
CYC		 800 return 0;
801}
41e568d1 802
36f3a14d 803static int ms_lib_alloc_logicalmap(struct us_data *us)
33842ced
CYC		 804{
805 u32 i;
806 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
41e568d1 807
6da2ec56
KC		 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);
33842ced
CYC		 814
815 if ((info->MS_Lib.Phy2LogMap == NULL) || (info->MS_Lib.Log2PhyMap == NULL)) {
816 ms_lib_free_logicalmap(us);
817 return (u32)-1;
41e568d1 818 }
819
33842ced
CYC		 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;
41e568d1 827}
828
33842ced 829static void ms_lib_clear_writebuf(struct us_data *us)
41e568d1 830{
33842ced 831 int i;
41e568d1 832 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
833
33842ced
CYC		 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 }
41e568d1 847 }
33842ced 848}
41e568d1 849
33842ced
CYC		 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;
41e568d1 854
33842ced
CYC		 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 }
41e568d1 864 }
865
33842ced
CYC		 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;
628c2893
AS		 873 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
874 u8 *bbuf = info->bbuf;
33842ced 875 int result;
33842ced
CYC		 876 u32 bn = PhyBlockAddr * 0x20 + PageNum;
877
33842ced
CYC		 878 result = ene_load_bincode(us, MS_RW_PATTERN);
879 if (result != USB_STOR_XFER_GOOD)
41e568d1 880 return USB_STOR_TRANSPORT_ERROR;
41e568d1 881
33842ced 882 /* Read Page Data */
41e568d1 883 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
884 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
885 bcb->DataTransferLength = 0x200;
b8db6d64 886 bcb->Flags = US_BULK_FLAG_IN;
33842ced 887 bcb->CDB[0] = 0xF1;
41e568d1 888
33842ced 889 bcb->CDB[1] = 0x02; /* in init.c ENE_MSInit() is 0x01 */
41e568d1 890
33842ced
CYC		 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);
41e568d1 895
33842ced
CYC		 896 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
897 if (result != USB_STOR_XFER_GOOD)
898 return USB_STOR_TRANSPORT_ERROR;
41e568d1 899
41e568d1 900
33842ced
CYC		 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;
b8db6d64 905 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 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
628c2893 915 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
41e568d1 916 if (result != USB_STOR_XFER_GOOD)
917 return USB_STOR_TRANSPORT_ERROR;
918
33842ced
CYC		 919 ExtraDat->reserved = 0;
920 ExtraDat->intr = 0x80; /* Not yet,fireware support */
921 ExtraDat->status0 = 0x10; /* Not yet,fireware support */
41e568d1 922
33842ced 923 ExtraDat->status1 = 0x00; /* Not yet,fireware support */
628c2893
AS		 924 ExtraDat->ovrflg = bbuf[0];
925 ExtraDat->mngflg = bbuf[1];
926 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
33842ced
CYC		 927
928 return USB_STOR_TRANSPORT_GOOD;
41e568d1 929}
930
33842ced 931static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
41e568d1 932{
33842ced
CYC		 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;
41e568d1 940
33842ced
CYC		 941 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, 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);
41e568d1 964 break;
33842ced
CYC		 965 case MS_SYSINF_CARDTYPE_HYBRID:
966 default:
967 goto exit;
41e568d1 968 }
33842ced
CYC		 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;
41e568d1 1067 return result;
1068}
1069
33842ced 1070static void ms_lib_free_writebuf(struct us_data *us)
41e568d1 1071{
33842ced
CYC		 1072 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1073 info->MS_Lib.wrtblk = (u16)-1; /* set to -1 */
41e568d1 1074
33842ced 1075 /* memset((fdoExt)->MS_Lib.pagemap, 0, sizeof((fdoExt)->MS_Lib.pagemap)) */
41e568d1 1076
33842ced
CYC		 1077 ms_lib_clear_pagemap(info); /* (pdx)->MS_Lib.pagemap memset 0 in ms.h */
1078
1079 if (info->MS_Lib.blkpag) {
e6533e87 1080 kfree(info->MS_Lib.blkpag); /* Arnold test ... */
33842ced
CYC		 1081 info->MS_Lib.blkpag = NULL;
1082 }
1083
1084 if (info->MS_Lib.blkext) {
e6533e87 1085 kfree(info->MS_Lib.blkext); /* Arnold test ... */
33842ced
CYC		 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
6da2ec56
KC		 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);
33842ced
CYC		 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
18557fec 1132 return 0;
33842ced
CYC		 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
33842ced
CYC		 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
33842ced
CYC		 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;
b8db6d64 1198 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 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
33842ced
CYC		 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;
b8db6d64 1275 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 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;
628c2893
AS		 1350 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1351 u8 *bbuf = info->bbuf;
33842ced 1352 int result;
33842ced 1353
33842ced
CYC		 1354 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1355 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1356 bcb->DataTransferLength = 0x4;
b8db6d64 1357 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 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
628c2893 1366 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
33842ced
CYC		 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 */
628c2893
AS		 1374 ExtraDat->ovrflg = bbuf[0];
1375 ExtraDat->mngflg = bbuf[1];
1376 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
33842ced
CYC		 1377
1378 return USB_STOR_TRANSPORT_GOOD;
1379}
1380
1381static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1382{
33842ced
CYC		 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
33842ced
CYC		 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"); */
a927e6bb 1455 if ((info->MS_Status & MS_Insert) && (info->MS_Status & MS_Ready)) {
33842ced
CYC		 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
33842ced
CYC		 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
a927e6bb 1475 if (info->MS_Status & MS_WtP)
33842ced
CYC		 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
191648d0 1492 usb_stor_dbg(us, "ms_scsi_read_capacity\n");
33842ced 1493 bl_len = 0x200;
a927e6bb 1494 if (info->MS_Status & MS_IsMSPro)
33842ced
CYC		 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;
191648d0
JP		 1500 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1501 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
33842ced
CYC		 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
33842ced
CYC		 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;
b8db6d64 1541 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 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;
33842ced
CYC		 1562 u32 count = 0, index = 0;
1563 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
628c2893 1564 u8 *bbuf = info->bbuf;
33842ced
CYC		 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) {
628c2893
AS		 1578 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1579 bbuf);
33842ced
CYC		 1580 count += 0x80;
1581 }
1582 index = (PhyBlock % 0x80) * 4;
1583
628c2893
AS		 1584 extdat.ovrflg = bbuf[index];
1585 extdat.mngflg = bbuf[index+1];
1586 extdat.logadr = memstick_logaddr(bbuf[index+2],
1587 bbuf[index+3]);
33842ced
CYC		 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
a927e6bb 1649 if (info->MS_Status & MS_IsMSPro) {
33842ced
CYC		 1650 result = ene_load_bincode(us, MSP_RW_PATTERN);
1651 if (result != USB_STOR_XFER_GOOD) {
191648d0 1652 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
33842ced
CYC		 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;
b8db6d64 1660 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 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;
b8db6d64 1704 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 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
a927e6bb 1750 if (info->MS_Status & MS_IsMSPro) {
33842ced
CYC		 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;
bc985c10 1772 int offset = 0;
33842ced
CYC		 1773 u16 PhyBlockAddr;
1774 u8 PageNum;
33842ced
CYC		 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;
b8db6d64 1837 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 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
191648d0 1852 /*usb_stor_dbg(us, "transport --- ENE_ReadSDReg\n");*/
33842ced
CYC		 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]);
a927e6bb 1858 if ((info->SD_Status & SD_HiCapacity) && !(info->SD_Status & SD_IsMMC))
33842ced
CYC		 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;
a927e6bb 1863 if ((info->SD_Status & SD_HiCapacity) && (info->SD_Status & SD_IsMMC))
33842ced
CYC		 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:
191648d0 1892 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
595c8970 1893 fw_name = SD_INIT1_FIRMWARE;
33842ced
CYC		 1894 break;
1895 case SD_INIT2_PATTERN:
191648d0 1896 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
595c8970 1897 fw_name = SD_INIT2_FIRMWARE;
33842ced
CYC		 1898 break;
1899 case SD_RW_PATTERN:
191648d0 1900 usb_stor_dbg(us, "SD_RW_PATTERN\n");
595c8970 1901 fw_name = SD_RW_FIRMWARE;
33842ced
CYC		 1902 break;
1903 /* For MS */
1904 case MS_INIT_PATTERN:
191648d0 1905 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
595c8970 1906 fw_name = MS_INIT_FIRMWARE;
33842ced
CYC		 1907 break;
1908 case MSP_RW_PATTERN:
191648d0 1909 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
595c8970 1910 fw_name = MSP_RW_FIRMWARE;
33842ced
CYC		 1911 break;
1912 case MS_RW_PATTERN:
191648d0 1913 usb_stor_dbg(us, "MS_RW_PATTERN\n");
595c8970 1914 fw_name = MS_RW_FIRMWARE;
33842ced
CYC		 1915 break;
1916 default:
191648d0 1917 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
33842ced
CYC		 1918 goto nofw;
1919 }
1920
1921 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1922 if (err) {
191648d0 1923 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
33842ced
CYC		 1924 goto nofw;
1925 }
a328512d 1926 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
191648d0 1927 if (buf == NULL)
33842ced 1928 goto nofw;
191648d0 1929
33842ced
CYC		 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);
aa18c4b6
AS		 1937 if (us->srb != NULL)
1938 scsi_set_resid(us->srb, 0);
33842ced
CYC		 1939 info->BIN_FLAG = flag;
1940 kfree(buf);
1941
1942nofw:
e44fabbe 1943 release_firmware(sd_fw);
33842ced
CYC		 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;
33842ced
CYC		 2072 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2073 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
628c2893 2074 u8 *bbuf = info->bbuf;
a927e6bb 2075 unsigned int s;
33842ced
CYC		 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;
b8db6d64 2090 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 2091 bcb->CDB[0] = 0xF1;
2092 bcb->CDB[1] = 0x01;
2093
628c2893 2094 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
33842ced
CYC		 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 */
a927e6bb
AS		 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) {
628c2893
AS		 2110 MSP_BlockSize = (bbuf[6] << 8) | bbuf[7];
2111 MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11];
33842ced
CYC		 2112 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2113 } else {
2114 ms_card_init(us); /* Card is MS (to ms.c)*/
2115 }
191648d0 2116 usb_stor_dbg(us, "MS Init Code OK !!\n");
33842ced 2117 } else {
628c2893 2118 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]);
33842ced
CYC		 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;
33842ced
CYC		 2128 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2129 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
628c2893 2130 u8 *bbuf = info->bbuf;
33842ced 2131
191648d0 2132 usb_stor_dbg(us, "transport --- ENE_SDInit\n");
33842ced
CYC		 2133 /* SD Init Part-1 */
2134 result = ene_load_bincode(us, SD_INIT1_PATTERN);
2135 if (result != USB_STOR_XFER_GOOD) {
191648d0 2136 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
33842ced
CYC		 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);
b8db6d64 2142 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 2143 bcb->CDB[0] = 0xF2;
2144
2145 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2146 if (result != USB_STOR_XFER_GOOD) {
191648d0 2147 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
33842ced
CYC		 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) {
191648d0 2154 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
33842ced
CYC		 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;
b8db6d64 2161 bcb->Flags = US_BULK_FLAG_IN;
33842ced
CYC		 2162 bcb->CDB[0] = 0xF1;
2163
628c2893 2164 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
33842ced 2165 if (result != USB_STOR_XFER_GOOD) {
191648d0 2166 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
33842ced
CYC		 2167 return USB_STOR_TRANSPORT_ERROR;
2168 }
2169
a927e6bb
AS		 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;
191648d0 2173
628c2893 2174 ene_get_card_status(us, bbuf);
a927e6bb
AS		 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));
33842ced 2181 } else {
628c2893 2182 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]);
33842ced
CYC		 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;
628c2893 2192 u8 misc_reg03;
33842ced 2193 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
628c2893 2194 u8 *bbuf = info->bbuf;
33842ced 2195
628c2893 2196 result = ene_get_card_type(us, REG_CARD_STATUS, bbuf);
33842ced
CYC		 2197 if (result != USB_STOR_XFER_GOOD)
2198 return USB_STOR_TRANSPORT_ERROR;
2199
628c2893 2200 misc_reg03 = bbuf[0];
33842ced 2201 if (misc_reg03 & 0x01) {
a927e6bb 2202 if (!(info->SD_Status & SD_Ready)) {
33842ced
CYC		 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) {
a927e6bb 2209 if (!(info->MS_Status & MS_Ready)) {
33842ced
CYC		 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
33842ced
CYC		 2224 switch (srb->cmnd[0]) {
2225 case TEST_UNIT_READY:
2226 result = sd_scsi_test_unit_ready(us, srb);
2227 break; /* 0x00 */
ce553bd1
AS		 2228 case REQUEST_SENSE:
2229 result = do_scsi_request_sense(us, srb);
2230 break; /* 0x03 */
33842ced 2231 case INQUIRY:
f8efdabd 2232 result = do_scsi_inquiry(us, srb);
33842ced
CYC		 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 }
ce553bd1
AS		 2256 if (result == USB_STOR_TRANSPORT_GOOD)
2257 info->SrbStatus = SS_SUCCESS;
33842ced
CYC		 2258 return result;
2259}
2260
2261/*
2262 * ms_scsi_irp()
2263 */
36f3a14d 2264static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
33842ced
CYC		 2265{
2266 int result;
2267 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
ce553bd1 2268
33842ced
CYC		 2269 switch (srb->cmnd[0]) {
2270 case TEST_UNIT_READY:
2271 result = ms_scsi_test_unit_ready(us, srb);
2272 break; /* 0x00 */
ce553bd1
AS		 2273 case REQUEST_SENSE:
2274 result = do_scsi_request_sense(us, srb);
2275 break; /* 0x03 */
33842ced 2276 case INQUIRY:
f8efdabd 2277 result = do_scsi_inquiry(us, srb);
33842ced
CYC		 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 }
ce553bd1
AS		 2296 if (result == USB_STOR_TRANSPORT_GOOD)
2297 info->SrbStatus = SS_SUCCESS;
33842ced
CYC		 2298 return result;
2299}
2300
2301static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2302{
4b309f1c 2303 int result = USB_STOR_XFER_GOOD;
33842ced
CYC		 2304 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2305
191648d0 2306 /*US_DEBUG(usb_stor_show_command(us, srb)); */
33842ced 2307 scsi_set_resid(srb, 0);
a927e6bb 2308 if (unlikely(!(info->SD_Status & SD_Ready) || (info->MS_Status & MS_Ready)))
33842ced 2309 result = ene_init(us);
4b309f1c
AS		 2310 if (result == USB_STOR_XFER_GOOD) {
2311 result = USB_STOR_TRANSPORT_ERROR;
a927e6bb 2312 if (info->SD_Status & SD_Ready)
33842ced
CYC		 2313 result = sd_scsi_irp(us, srb);
2314
a927e6bb 2315 if (info->MS_Status & MS_Ready)
33842ced
CYC		 2316 result = ms_scsi_irp(us, srb);
2317 }
4b309f1c 2318 return result;
33842ced 2319}
41e568d1 2320
aa519be3 2321static struct scsi_host_template ene_ub6250_host_template;
41e568d1 2322
2323static int ene_ub6250_probe(struct usb_interface *intf,
2324 const struct usb_device_id *id)
2325{
2326 int result;
628c2893 2327 u8 misc_reg03;
41e568d1 2328 struct us_data *us;
628c2893 2329 struct ene_ub6250_info *info;
41e568d1 2330
2331 result = usb_stor_probe1(&us, intf, id,
aa519be3
AM		 2332 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2333 &ene_ub6250_host_template);
41e568d1 2334 if (result)
2335 return result;
2336
2337 /* FIXME: where should the code alloc extra buf ? */
628c2893
AS		 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;
41e568d1 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 */
628c2893 2359 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
41e568d1 2360 if (result != USB_STOR_XFER_GOOD) {
2361 usb_stor_disconnect(intf);
2362 return USB_STOR_TRANSPORT_ERROR;
2363 }
2364
628c2893 2365 misc_reg03 = info->bbuf[0];
41e568d1 2366 if (!(misc_reg03 & 0x01)) {
16fae052
KM		 2367 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2368 "It does not support SM cards.\n");
41e568d1 2369 }
2370
2371 return result;
2372}
2373
2374
2375#ifdef CONFIG_PM
2376
2377static int ene_ub6250_resume(struct usb_interface *iface)
2378{
41e568d1 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
41e568d1 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;
a927e6bb
AS		 2390 /* info->SD_Status &= ~SD_Ready; */
2391 info->SD_Status = 0;
2392 info->MS_Status = 0;
2393 info->SM_Status = 0;
41e568d1 2394
2395 return 0;
2396}
2397
2398static int ene_ub6250_reset_resume(struct usb_interface *iface)
2399{
41e568d1 2400 struct us_data *us = usb_get_intfdata(iface);
2401 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
191648d0 2402
41e568d1 2403 /* Report the reset to the SCSI core */
2404 usb_stor_reset_resume(iface);
2405
f0183a33
FB		 2406 /*
2407 * FIXME: Notify the subdrivers that they need to reinitialize
2408 * the device
2409 */
41e568d1 2410 info->Power_IsResum = true;
a927e6bb
AS		 2411 /* info->SD_Status &= ~SD_Ready; */
2412 info->SD_Status = 0;
2413 info->MS_Status = 0;
2414 info->SM_Status = 0;
41e568d1 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 = {
aa519be3 2427 .name = DRV_NAME,
41e568d1 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,
e73b2db6 2437 .no_dynamic_id = 1,
41e568d1 2438};
2439
aa519be3 2440module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);
Ubuntu Focal Linux kernel mirror