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