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