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