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