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
27MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
28MODULE_LICENSE("GPL");
29MODULE_IMPORT_NS(USB_STORAGE);
30MODULE_FIRMWARE(SD_INIT1_FIRMWARE);
31MODULE_FIRMWARE(SD_INIT2_FIRMWARE);
32MODULE_FIRMWARE(SD_RW_FIRMWARE);
33MODULE_FIRMWARE(MS_INIT_FIRMWARE);
34MODULE_FIRMWARE(MSP_RW_FIRMWARE);
35MODULE_FIRMWARE(MS_RW_FIRMWARE);
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
46static struct usb_device_id ene_ub6250_usb_ids[] = {
47# include "unusual_ene_ub6250.h"
48 { }
49};
50MODULE_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
68static 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
240struct 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
251struct 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
262struct 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
271struct 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
292struct 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
326struct ms_bootblock_sysent_rec {
327 u32 dwStart;
328 u32 dwSize;
329 u8 bType;
330 u8 bReserved[3];
331};
332
333struct ms_bootblock_sysent {
334 struct ms_bootblock_sysent_rec entry[MS_NUMBER_OF_SYSTEM_ENTRY];
335};
336
337struct 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
371struct ms_bootblock_header {
372 u16 wBlockID;
373 u16 wFormatVersion;
374 u8 bReserved1[184];
375 u8 bNumberOfDataEntry;
376 u8 bReserved2[179];
377};
378
379struct ms_bootblock_page0 {
380 struct ms_bootblock_header header;
381 struct ms_bootblock_sysent sysent;
382 struct ms_bootblock_sysinf sysinf;
383};
384
385struct 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
399struct 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
409struct 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
434struct 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
480static int ene_sd_init(struct us_data *us);
481static int ene_ms_init(struct us_data *us);
482static int ene_load_bincode(struct us_data *us, unsigned char flag);
483
484static 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
493static 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 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
573static 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
589static 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
601static 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
615static 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
634static 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
674static 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
714static 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
758static 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
771static 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
783static 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
788static 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
793static 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
806static 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
832static 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
853static 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 break;
865 default:
866 break;
867 }
868 }
869
870 return Count;
871}
872
873static int ms_read_readpage(struct us_data *us, u32 PhyBlockAddr,
874 u8 PageNum, u32 *PageBuf, struct ms_lib_type_extdat *ExtraDat)
875{
876 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
877 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
878 u8 *bbuf = info->bbuf;
879 int result;
880 u32 bn = PhyBlockAddr * 0x20 + PageNum;
881
882 result = ene_load_bincode(us, MS_RW_PATTERN);
883 if (result != USB_STOR_XFER_GOOD)
884 return USB_STOR_TRANSPORT_ERROR;
885
886
887 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
888 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
889 bcb->DataTransferLength = 0x200;
890 bcb->Flags = US_BULK_FLAG_IN;
891 bcb->CDB[0] = 0xF1;
892
893 bcb->CDB[1] = 0x02;
894
895 bcb->CDB[5] = (unsigned char)(bn);
896 bcb->CDB[4] = (unsigned char)(bn>>8);
897 bcb->CDB[3] = (unsigned char)(bn>>16);
898 bcb->CDB[2] = (unsigned char)(bn>>24);
899
900 result = ene_send_scsi_cmd(us, FDIR_READ, PageBuf, 0);
901 if (result != USB_STOR_XFER_GOOD)
902 return USB_STOR_TRANSPORT_ERROR;
903
904
905
906 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
907 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
908 bcb->DataTransferLength = 0x4;
909 bcb->Flags = US_BULK_FLAG_IN;
910 bcb->CDB[0] = 0xF1;
911 bcb->CDB[1] = 0x03;
912
913 bcb->CDB[5] = (unsigned char)(PageNum);
914 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
915 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
916 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
917 bcb->CDB[6] = 0x01;
918
919 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
920 if (result != USB_STOR_XFER_GOOD)
921 return USB_STOR_TRANSPORT_ERROR;
922
923 ExtraDat->reserved = 0;
924 ExtraDat->intr = 0x80;
925 ExtraDat->status0 = 0x10;
926
927 ExtraDat->status1 = 0x00;
928 ExtraDat->ovrflg = bbuf[0];
929 ExtraDat->mngflg = bbuf[1];
930 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
931
932 return USB_STOR_TRANSPORT_GOOD;
933}
934
935static int ms_lib_process_bootblock(struct us_data *us, u16 PhyBlock, u8 *PageData)
936{
937 struct ms_bootblock_sysent *SysEntry;
938 struct ms_bootblock_sysinf *SysInfo;
939 u32 i, result;
940 u8 PageNumber;
941 u8 *PageBuffer;
942 struct ms_lib_type_extdat ExtraData;
943 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
944
945 PageBuffer = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
946 if (PageBuffer == NULL)
947 return (u32)-1;
948
949 result = (u32)-1;
950
951 SysInfo = &(((struct ms_bootblock_page0 *)PageData)->sysinf);
952
953 if ((SysInfo->bMsClass != MS_SYSINF_MSCLASS_TYPE_1) ||
954 (be16_to_cpu(SysInfo->wPageSize) != MS_SYSINF_PAGE_SIZE) ||
955 ((SysInfo->bSecuritySupport & MS_SYSINF_SECURITY) == MS_SYSINF_SECURITY_SUPPORT) ||
956 (SysInfo->bReserved1 != MS_SYSINF_RESERVED1) ||
957 (SysInfo->bReserved2 != MS_SYSINF_RESERVED2) ||
958 (SysInfo->bFormatType != MS_SYSINF_FORMAT_FAT) ||
959 (SysInfo->bUsage != MS_SYSINF_USAGE_GENERAL))
960 goto exit;
961
962 switch (info->MS_Lib.cardType = SysInfo->bCardType) {
963 case MS_SYSINF_CARDTYPE_RDONLY:
964 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
965 break;
966 case MS_SYSINF_CARDTYPE_RDWR:
967 ms_lib_ctrl_reset(info, MS_LIB_CTRL_RDONLY);
968 break;
969 case MS_SYSINF_CARDTYPE_HYBRID:
970 default:
971 goto exit;
972 }
973
974 info->MS_Lib.blockSize = be16_to_cpu(SysInfo->wBlockSize);
975 info->MS_Lib.NumberOfPhyBlock = be16_to_cpu(SysInfo->wBlockNumber);
976 info->MS_Lib.NumberOfLogBlock = be16_to_cpu(SysInfo->wTotalBlockNumber)-2;
977 info->MS_Lib.PagesPerBlock = info->MS_Lib.blockSize * SIZE_OF_KIRO / MS_BYTES_PER_PAGE;
978 info->MS_Lib.NumberOfSegment = info->MS_Lib.NumberOfPhyBlock / MS_PHYSICAL_BLOCKS_PER_SEGMENT;
979 info->MS_Model = be16_to_cpu(SysInfo->wMemorySize);
980
981
982 if (ms_lib_alloc_logicalmap(us))
983 goto exit;
984
985
986 ms_lib_set_bootblockmark(us, PhyBlock);
987
988 SysEntry = &(((struct ms_bootblock_page0 *)PageData)->sysent);
989
990 for (i = 0; i < MS_NUMBER_OF_SYSTEM_ENTRY; i++) {
991 u32 EntryOffset, EntrySize;
992
993 EntryOffset = be32_to_cpu(SysEntry->entry[i].dwStart);
994
995 if (EntryOffset == 0xffffff)
996 continue;
997 EntrySize = be32_to_cpu(SysEntry->entry[i].dwSize);
998
999 if (EntrySize == 0)
1000 continue;
1001
1002 if (EntryOffset + MS_BYTES_PER_PAGE + EntrySize > info->MS_Lib.blockSize * (u32)SIZE_OF_KIRO)
1003 continue;
1004
1005 if (i == 0) {
1006 u8 PrevPageNumber = 0;
1007 u16 phyblk;
1008
1009 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_INVALID_BLOCK)
1010 goto exit;
1011
1012 while (EntrySize > 0) {
1013
1014 PageNumber = (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1);
1015 if (PageNumber != PrevPageNumber) {
1016 switch (ms_read_readpage(us, PhyBlock, PageNumber, (u32 *)PageBuffer, &ExtraData)) {
1017 case MS_STATUS_SUCCESS:
1018 break;
1019 case MS_STATUS_WRITE_PROTECT:
1020 case MS_ERROR_FLASH_READ:
1021 case MS_STATUS_ERROR:
1022 default:
1023 goto exit;
1024 }
1025
1026 PrevPageNumber = PageNumber;
1027 }
1028
1029 phyblk = be16_to_cpu(*(u16 *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)));
1030 if (phyblk < 0x0fff)
1031 ms_lib_set_initialerrorblock(us, phyblk);
1032
1033 EntryOffset += 2;
1034 EntrySize -= 2;
1035 }
1036 } else if (i == 1) {
1037 struct ms_bootblock_idi *idi;
1038
1039 if (SysEntry->entry[i].bType != MS_SYSENT_TYPE_CIS_IDI)
1040 goto exit;
1041
1042 switch (ms_read_readpage(us, PhyBlock, (u8)(EntryOffset / MS_BYTES_PER_PAGE + 1), (u32 *)PageBuffer, &ExtraData)) {
1043 case MS_STATUS_SUCCESS:
1044 break;
1045 case MS_STATUS_WRITE_PROTECT:
1046 case MS_ERROR_FLASH_READ:
1047 case MS_STATUS_ERROR:
1048 default:
1049 goto exit;
1050 }
1051
1052 idi = &((struct ms_bootblock_cis_idi *)(PageBuffer + (EntryOffset % MS_BYTES_PER_PAGE)))->idi.idi;
1053 if (le16_to_cpu(idi->wIDIgeneralConfiguration) != MS_IDI_GENERAL_CONF)
1054 goto exit;
1055
1056 info->MS_Lib.BytesPerSector = le16_to_cpu(idi->wIDIbytesPerSector);
1057 if (info->MS_Lib.BytesPerSector != MS_BYTES_PER_PAGE)
1058 goto exit;
1059 }
1060 }
1061
1062 result = 0;
1063
1064exit:
1065 if (result)
1066 ms_lib_free_logicalmap(us);
1067
1068 kfree(PageBuffer);
1069
1070 result = 0;
1071 return result;
1072}
1073
1074static void ms_lib_free_writebuf(struct us_data *us)
1075{
1076 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1077 info->MS_Lib.wrtblk = (u16)-1;
1078
1079
1080
1081 ms_lib_clear_pagemap(info);
1082
1083 if (info->MS_Lib.blkpag) {
1084 kfree(info->MS_Lib.blkpag);
1085 info->MS_Lib.blkpag = NULL;
1086 }
1087
1088 if (info->MS_Lib.blkext) {
1089 kfree(info->MS_Lib.blkext);
1090 info->MS_Lib.blkext = NULL;
1091 }
1092}
1093
1094
1095static void ms_lib_free_allocatedarea(struct us_data *us)
1096{
1097 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1098
1099 ms_lib_free_writebuf(us);
1100 ms_lib_free_logicalmap(us);
1101
1102
1103 info->MS_Lib.flags = 0;
1104 info->MS_Lib.BytesPerSector = 0;
1105 info->MS_Lib.SectorsPerCylinder = 0;
1106
1107 info->MS_Lib.cardType = 0;
1108 info->MS_Lib.blockSize = 0;
1109 info->MS_Lib.PagesPerBlock = 0;
1110
1111 info->MS_Lib.NumberOfPhyBlock = 0;
1112 info->MS_Lib.NumberOfLogBlock = 0;
1113}
1114
1115
1116static int ms_lib_alloc_writebuf(struct us_data *us)
1117{
1118 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1119
1120 info->MS_Lib.wrtblk = (u16)-1;
1121
1122 info->MS_Lib.blkpag = kmalloc_array(info->MS_Lib.PagesPerBlock,
1123 info->MS_Lib.BytesPerSector,
1124 GFP_KERNEL);
1125 info->MS_Lib.blkext = kmalloc_array(info->MS_Lib.PagesPerBlock,
1126 sizeof(struct ms_lib_type_extdat),
1127 GFP_KERNEL);
1128
1129 if ((info->MS_Lib.blkpag == NULL) || (info->MS_Lib.blkext == NULL)) {
1130 ms_lib_free_writebuf(us);
1131 return (u32)-1;
1132 }
1133
1134 ms_lib_clear_writebuf(us);
1135
1136 return 0;
1137}
1138
1139static int ms_lib_force_setlogical_pair(struct us_data *us, u16 logblk, u16 phyblk)
1140{
1141 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1142
1143 if (logblk == MS_LB_NOT_USED)
1144 return 0;
1145
1146 if ((logblk >= info->MS_Lib.NumberOfLogBlock) ||
1147 (phyblk >= info->MS_Lib.NumberOfPhyBlock))
1148 return (u32)-1;
1149
1150 info->MS_Lib.Phy2LogMap[phyblk] = logblk;
1151 info->MS_Lib.Log2PhyMap[logblk] = phyblk;
1152
1153 return 0;
1154}
1155
1156static int ms_read_copyblock(struct us_data *us, u16 oldphy, u16 newphy,
1157 u16 PhyBlockAddr, u8 PageNum, unsigned char *buf, u16 len)
1158{
1159 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1160 int result;
1161
1162 result = ene_load_bincode(us, MS_RW_PATTERN);
1163 if (result != USB_STOR_XFER_GOOD)
1164 return USB_STOR_TRANSPORT_ERROR;
1165
1166 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1167 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1168 bcb->DataTransferLength = 0x200*len;
1169 bcb->Flags = 0x00;
1170 bcb->CDB[0] = 0xF0;
1171 bcb->CDB[1] = 0x08;
1172 bcb->CDB[4] = (unsigned char)(oldphy);
1173 bcb->CDB[3] = (unsigned char)(oldphy>>8);
1174 bcb->CDB[2] = 0;
1175 bcb->CDB[7] = (unsigned char)(newphy);
1176 bcb->CDB[6] = (unsigned char)(newphy>>8);
1177 bcb->CDB[5] = 0;
1178 bcb->CDB[9] = (unsigned char)(PhyBlockAddr);
1179 bcb->CDB[8] = (unsigned char)(PhyBlockAddr>>8);
1180 bcb->CDB[10] = PageNum;
1181
1182 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1183 if (result != USB_STOR_XFER_GOOD)
1184 return USB_STOR_TRANSPORT_ERROR;
1185
1186 return USB_STOR_TRANSPORT_GOOD;
1187}
1188
1189static int ms_read_eraseblock(struct us_data *us, u32 PhyBlockAddr)
1190{
1191 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1192 int result;
1193 u32 bn = PhyBlockAddr;
1194
1195 result = ene_load_bincode(us, MS_RW_PATTERN);
1196 if (result != USB_STOR_XFER_GOOD)
1197 return USB_STOR_TRANSPORT_ERROR;
1198
1199 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1200 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1201 bcb->DataTransferLength = 0x200;
1202 bcb->Flags = US_BULK_FLAG_IN;
1203 bcb->CDB[0] = 0xF2;
1204 bcb->CDB[1] = 0x06;
1205 bcb->CDB[4] = (unsigned char)(bn);
1206 bcb->CDB[3] = (unsigned char)(bn>>8);
1207 bcb->CDB[2] = (unsigned char)(bn>>16);
1208
1209 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1210 if (result != USB_STOR_XFER_GOOD)
1211 return USB_STOR_TRANSPORT_ERROR;
1212
1213 return USB_STOR_TRANSPORT_GOOD;
1214}
1215
1216static int ms_lib_check_disableblock(struct us_data *us, u16 PhyBlock)
1217{
1218 unsigned char *PageBuf = NULL;
1219 u16 result = MS_STATUS_SUCCESS;
1220 u16 blk, index = 0;
1221 struct ms_lib_type_extdat extdat;
1222 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1223
1224 PageBuf = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1225 if (PageBuf == NULL) {
1226 result = MS_NO_MEMORY_ERROR;
1227 goto exit;
1228 }
1229
1230 ms_read_readpage(us, PhyBlock, 1, (u32 *)PageBuf, &extdat);
1231 do {
1232 blk = be16_to_cpu(PageBuf[index]);
1233 if (blk == MS_LB_NOT_USED)
1234 break;
1235 if (blk == info->MS_Lib.Log2PhyMap[0]) {
1236 result = MS_ERROR_FLASH_READ;
1237 break;
1238 }
1239 index++;
1240 } while (1);
1241
1242exit:
1243 kfree(PageBuf);
1244 return result;
1245}
1246
1247static int ms_lib_setacquired_errorblock(struct us_data *us, u16 phyblk)
1248{
1249 u16 log;
1250 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1251
1252 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1253 return (u32)-1;
1254
1255 log = info->MS_Lib.Phy2LogMap[phyblk];
1256
1257 if (log < info->MS_Lib.NumberOfLogBlock)
1258 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1259
1260 if (info->MS_Lib.Phy2LogMap[phyblk] != MS_LB_INITIAL_ERROR)
1261 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_ACQUIRED_ERROR;
1262
1263 return 0;
1264}
1265
1266static int ms_lib_overwrite_extra(struct us_data *us, u32 PhyBlockAddr,
1267 u8 PageNum, u8 OverwriteFlag)
1268{
1269 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1270 int result;
1271
1272 result = ene_load_bincode(us, MS_RW_PATTERN);
1273 if (result != USB_STOR_XFER_GOOD)
1274 return USB_STOR_TRANSPORT_ERROR;
1275
1276 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1277 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1278 bcb->DataTransferLength = 0x4;
1279 bcb->Flags = US_BULK_FLAG_IN;
1280 bcb->CDB[0] = 0xF2;
1281 bcb->CDB[1] = 0x05;
1282 bcb->CDB[5] = (unsigned char)(PageNum);
1283 bcb->CDB[4] = (unsigned char)(PhyBlockAddr);
1284 bcb->CDB[3] = (unsigned char)(PhyBlockAddr>>8);
1285 bcb->CDB[2] = (unsigned char)(PhyBlockAddr>>16);
1286 bcb->CDB[6] = OverwriteFlag;
1287 bcb->CDB[7] = 0xFF;
1288 bcb->CDB[8] = 0xFF;
1289 bcb->CDB[9] = 0xFF;
1290
1291 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
1292 if (result != USB_STOR_XFER_GOOD)
1293 return USB_STOR_TRANSPORT_ERROR;
1294
1295 return USB_STOR_TRANSPORT_GOOD;
1296}
1297
1298static int ms_lib_error_phyblock(struct us_data *us, u16 phyblk)
1299{
1300 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1301
1302 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1303 return MS_STATUS_ERROR;
1304
1305 ms_lib_setacquired_errorblock(us, phyblk);
1306
1307 if (ms_lib_iswritable(info))
1308 return ms_lib_overwrite_extra(us, phyblk, 0, (u8)(~MS_REG_OVR_BKST & BYTE_MASK));
1309
1310 return MS_STATUS_SUCCESS;
1311}
1312
1313static int ms_lib_erase_phyblock(struct us_data *us, u16 phyblk)
1314{
1315 u16 log;
1316 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1317
1318 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1319 return MS_STATUS_ERROR;
1320
1321 log = info->MS_Lib.Phy2LogMap[phyblk];
1322
1323 if (log < info->MS_Lib.NumberOfLogBlock)
1324 info->MS_Lib.Log2PhyMap[log] = MS_LB_NOT_USED;
1325
1326 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED;
1327
1328 if (ms_lib_iswritable(info)) {
1329 switch (ms_read_eraseblock(us, phyblk)) {
1330 case MS_STATUS_SUCCESS:
1331 info->MS_Lib.Phy2LogMap[phyblk] = MS_LB_NOT_USED_ERASED;
1332 return MS_STATUS_SUCCESS;
1333 case MS_ERROR_FLASH_ERASE:
1334 case MS_STATUS_INT_ERROR:
1335 ms_lib_error_phyblock(us, phyblk);
1336 return MS_ERROR_FLASH_ERASE;
1337 case MS_STATUS_ERROR:
1338 default:
1339 ms_lib_ctrl_set(info, MS_LIB_CTRL_RDONLY);
1340 ms_lib_setacquired_errorblock(us, phyblk);
1341 return MS_STATUS_ERROR;
1342 }
1343 }
1344
1345 ms_lib_setacquired_errorblock(us, phyblk);
1346
1347 return MS_STATUS_SUCCESS;
1348}
1349
1350static int ms_lib_read_extra(struct us_data *us, u32 PhyBlock,
1351 u8 PageNum, struct ms_lib_type_extdat *ExtraDat)
1352{
1353 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1354 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1355 u8 *bbuf = info->bbuf;
1356 int result;
1357
1358 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1359 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1360 bcb->DataTransferLength = 0x4;
1361 bcb->Flags = US_BULK_FLAG_IN;
1362 bcb->CDB[0] = 0xF1;
1363 bcb->CDB[1] = 0x03;
1364 bcb->CDB[5] = (unsigned char)(PageNum);
1365 bcb->CDB[4] = (unsigned char)(PhyBlock);
1366 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1367 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1368 bcb->CDB[6] = 0x01;
1369
1370 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
1371 if (result != USB_STOR_XFER_GOOD)
1372 return USB_STOR_TRANSPORT_ERROR;
1373
1374 ExtraDat->reserved = 0;
1375 ExtraDat->intr = 0x80;
1376 ExtraDat->status0 = 0x10;
1377 ExtraDat->status1 = 0x00;
1378 ExtraDat->ovrflg = bbuf[0];
1379 ExtraDat->mngflg = bbuf[1];
1380 ExtraDat->logadr = memstick_logaddr(bbuf[2], bbuf[3]);
1381
1382 return USB_STOR_TRANSPORT_GOOD;
1383}
1384
1385static int ms_libsearch_block_from_physical(struct us_data *us, u16 phyblk)
1386{
1387 u16 blk;
1388 struct ms_lib_type_extdat extdat;
1389 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1390
1391
1392 if (phyblk >= info->MS_Lib.NumberOfPhyBlock)
1393 return MS_LB_ERROR;
1394
1395 for (blk = phyblk + 1; blk != phyblk; blk++) {
1396 if ((blk & MS_PHYSICAL_BLOCKS_PER_SEGMENT_MASK) == 0)
1397 blk -= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1398
1399 if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED_ERASED) {
1400 return blk;
1401 } else if (info->MS_Lib.Phy2LogMap[blk] == MS_LB_NOT_USED) {
1402 switch (ms_lib_read_extra(us, blk, 0, &extdat)) {
1403 case MS_STATUS_SUCCESS:
1404 case MS_STATUS_SUCCESS_WITH_ECC:
1405 break;
1406 case MS_NOCARD_ERROR:
1407 return MS_NOCARD_ERROR;
1408 case MS_STATUS_INT_ERROR:
1409 return MS_LB_ERROR;
1410 case MS_ERROR_FLASH_READ:
1411 default:
1412 ms_lib_setacquired_errorblock(us, blk);
1413 continue;
1414 }
1415
1416 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1417 ms_lib_setacquired_errorblock(us, blk);
1418 continue;
1419 }
1420
1421 switch (ms_lib_erase_phyblock(us, blk)) {
1422 case MS_STATUS_SUCCESS:
1423 return blk;
1424 case MS_STATUS_ERROR:
1425 return MS_LB_ERROR;
1426 case MS_ERROR_FLASH_ERASE:
1427 default:
1428 ms_lib_error_phyblock(us, blk);
1429 break;
1430 }
1431 }
1432 }
1433
1434 return MS_LB_ERROR;
1435}
1436static int ms_libsearch_block_from_logical(struct us_data *us, u16 logblk)
1437{
1438 u16 phyblk;
1439 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1440
1441 phyblk = ms_libconv_to_physical(info, logblk);
1442 if (phyblk >= MS_LB_ERROR) {
1443 if (logblk >= info->MS_Lib.NumberOfLogBlock)
1444 return MS_LB_ERROR;
1445
1446 phyblk = (logblk + MS_NUMBER_OF_BOOT_BLOCK) / MS_LOGICAL_BLOCKS_PER_SEGMENT;
1447 phyblk *= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1448 phyblk += MS_PHYSICAL_BLOCKS_PER_SEGMENT - 1;
1449 }
1450
1451 return ms_libsearch_block_from_physical(us, phyblk);
1452}
1453
1454static int ms_scsi_test_unit_ready(struct us_data *us, struct scsi_cmnd *srb)
1455{
1456 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
1457
1458
1459 if (info->MS_Status.Insert && info->MS_Status.Ready) {
1460 return USB_STOR_TRANSPORT_GOOD;
1461 } else {
1462 ene_ms_init(us);
1463 return USB_STOR_TRANSPORT_GOOD;
1464 }
1465
1466 return USB_STOR_TRANSPORT_GOOD;
1467}
1468
1469static int ms_scsi_mode_sense(struct us_data *us, struct scsi_cmnd *srb)
1470{
1471 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1472 unsigned char mediaNoWP[12] = {
1473 0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
1474 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1475 unsigned char mediaWP[12] = {
1476 0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
1477 0x71, 0xc0, 0x00, 0x00, 0x02, 0x00 };
1478
1479 if (info->MS_Status.WtP)
1480 usb_stor_set_xfer_buf(mediaWP, 12, srb);
1481 else
1482 usb_stor_set_xfer_buf(mediaNoWP, 12, srb);
1483
1484 return USB_STOR_TRANSPORT_GOOD;
1485}
1486
1487static int ms_scsi_read_capacity(struct us_data *us, struct scsi_cmnd *srb)
1488{
1489 u32 bl_num;
1490 u16 bl_len;
1491 unsigned int offset = 0;
1492 unsigned char buf[8];
1493 struct scatterlist *sg = NULL;
1494 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1495
1496 usb_stor_dbg(us, "ms_scsi_read_capacity\n");
1497 bl_len = 0x200;
1498 if (info->MS_Status.IsMSPro)
1499 bl_num = info->MSP_TotalBlock - 1;
1500 else
1501 bl_num = info->MS_Lib.NumberOfLogBlock * info->MS_Lib.blockSize * 2 - 1;
1502
1503 info->bl_num = bl_num;
1504 usb_stor_dbg(us, "bl_len = %x\n", bl_len);
1505 usb_stor_dbg(us, "bl_num = %x\n", bl_num);
1506
1507
1508 buf[0] = (bl_num >> 24) & 0xff;
1509 buf[1] = (bl_num >> 16) & 0xff;
1510 buf[2] = (bl_num >> 8) & 0xff;
1511 buf[3] = (bl_num >> 0) & 0xff;
1512 buf[4] = (bl_len >> 24) & 0xff;
1513 buf[5] = (bl_len >> 16) & 0xff;
1514 buf[6] = (bl_len >> 8) & 0xff;
1515 buf[7] = (bl_len >> 0) & 0xff;
1516
1517 usb_stor_access_xfer_buf(buf, 8, srb, &sg, &offset, TO_XFER_BUF);
1518
1519 return USB_STOR_TRANSPORT_GOOD;
1520}
1521
1522static void ms_lib_phy_to_log_range(u16 PhyBlock, u16 *LogStart, u16 *LogEnde)
1523{
1524 PhyBlock /= MS_PHYSICAL_BLOCKS_PER_SEGMENT;
1525
1526 if (PhyBlock) {
1527 *LogStart = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT + (PhyBlock - 1) * MS_LOGICAL_BLOCKS_PER_SEGMENT;
1528 *LogEnde = *LogStart + MS_LOGICAL_BLOCKS_PER_SEGMENT;
1529 } else {
1530 *LogStart = 0;
1531 *LogEnde = MS_LOGICAL_BLOCKS_IN_1ST_SEGMENT;
1532 }
1533}
1534
1535static int ms_lib_read_extrablock(struct us_data *us, u32 PhyBlock,
1536 u8 PageNum, u8 blen, void *buf)
1537{
1538 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1539 int result;
1540
1541
1542 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1543 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1544 bcb->DataTransferLength = 0x4 * blen;
1545 bcb->Flags = US_BULK_FLAG_IN;
1546 bcb->CDB[0] = 0xF1;
1547 bcb->CDB[1] = 0x03;
1548 bcb->CDB[5] = (unsigned char)(PageNum);
1549 bcb->CDB[4] = (unsigned char)(PhyBlock);
1550 bcb->CDB[3] = (unsigned char)(PhyBlock>>8);
1551 bcb->CDB[2] = (unsigned char)(PhyBlock>>16);
1552 bcb->CDB[6] = blen;
1553
1554 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1555 if (result != USB_STOR_XFER_GOOD)
1556 return USB_STOR_TRANSPORT_ERROR;
1557
1558 return USB_STOR_TRANSPORT_GOOD;
1559}
1560
1561static int ms_lib_scan_logicalblocknumber(struct us_data *us, u16 btBlk1st)
1562{
1563 u16 PhyBlock, newblk, i;
1564 u16 LogStart, LogEnde;
1565 struct ms_lib_type_extdat extdat;
1566 u32 count = 0, index = 0;
1567 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1568 u8 *bbuf = info->bbuf;
1569
1570 for (PhyBlock = 0; PhyBlock < info->MS_Lib.NumberOfPhyBlock;) {
1571 ms_lib_phy_to_log_range(PhyBlock, &LogStart, &LogEnde);
1572
1573 for (i = 0; i < MS_PHYSICAL_BLOCKS_PER_SEGMENT; i++, PhyBlock++) {
1574 switch (ms_libconv_to_logical(info, PhyBlock)) {
1575 case MS_STATUS_ERROR:
1576 continue;
1577 default:
1578 break;
1579 }
1580
1581 if (count == PhyBlock) {
1582 ms_lib_read_extrablock(us, PhyBlock, 0, 0x80,
1583 bbuf);
1584 count += 0x80;
1585 }
1586 index = (PhyBlock % 0x80) * 4;
1587
1588 extdat.ovrflg = bbuf[index];
1589 extdat.mngflg = bbuf[index+1];
1590 extdat.logadr = memstick_logaddr(bbuf[index+2],
1591 bbuf[index+3]);
1592
1593 if ((extdat.ovrflg & MS_REG_OVR_BKST) != MS_REG_OVR_BKST_OK) {
1594 ms_lib_setacquired_errorblock(us, PhyBlock);
1595 continue;
1596 }
1597
1598 if ((extdat.mngflg & MS_REG_MNG_ATFLG) == MS_REG_MNG_ATFLG_ATTBL) {
1599 ms_lib_erase_phyblock(us, PhyBlock);
1600 continue;
1601 }
1602
1603 if (extdat.logadr != MS_LB_NOT_USED) {
1604 if ((extdat.logadr < LogStart) || (LogEnde <= extdat.logadr)) {
1605 ms_lib_erase_phyblock(us, PhyBlock);
1606 continue;
1607 }
1608
1609 newblk = ms_libconv_to_physical(info, extdat.logadr);
1610
1611 if (newblk != MS_LB_NOT_USED) {
1612 if (extdat.logadr == 0) {
1613 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1614 if (ms_lib_check_disableblock(us, btBlk1st)) {
1615 ms_lib_set_logicalpair(us, extdat.logadr, newblk);
1616 continue;
1617 }
1618 }
1619
1620 ms_lib_read_extra(us, newblk, 0, &extdat);
1621 if ((extdat.ovrflg & MS_REG_OVR_UDST) == MS_REG_OVR_UDST_UPDATING) {
1622 ms_lib_erase_phyblock(us, PhyBlock);
1623 continue;
1624 } else {
1625 ms_lib_erase_phyblock(us, newblk);
1626 }
1627 }
1628
1629 ms_lib_set_logicalpair(us, extdat.logadr, PhyBlock);
1630 }
1631 }
1632 }
1633
1634 return MS_STATUS_SUCCESS;
1635}
1636
1637
1638static int ms_scsi_read(struct us_data *us, struct scsi_cmnd *srb)
1639{
1640 int result;
1641 unsigned char *cdb = srb->cmnd;
1642 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1643 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1644
1645 u32 bn = ((cdb[2] << 24) & 0xff000000) | ((cdb[3] << 16) & 0x00ff0000) |
1646 ((cdb[4] << 8) & 0x0000ff00) | ((cdb[5] << 0) & 0x000000ff);
1647 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1648 u32 blenByte = blen * 0x200;
1649
1650 if (bn > info->bl_num)
1651 return USB_STOR_TRANSPORT_ERROR;
1652
1653 if (info->MS_Status.IsMSPro) {
1654 result = ene_load_bincode(us, MSP_RW_PATTERN);
1655 if (result != USB_STOR_XFER_GOOD) {
1656 usb_stor_dbg(us, "Load MPS RW pattern Fail !!\n");
1657 return USB_STOR_TRANSPORT_ERROR;
1658 }
1659
1660
1661 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1662 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1663 bcb->DataTransferLength = blenByte;
1664 bcb->Flags = US_BULK_FLAG_IN;
1665 bcb->CDB[0] = 0xF1;
1666 bcb->CDB[1] = 0x02;
1667 bcb->CDB[5] = (unsigned char)(bn);
1668 bcb->CDB[4] = (unsigned char)(bn>>8);
1669 bcb->CDB[3] = (unsigned char)(bn>>16);
1670 bcb->CDB[2] = (unsigned char)(bn>>24);
1671
1672 result = ene_send_scsi_cmd(us, FDIR_READ, scsi_sglist(srb), 1);
1673 } else {
1674 void *buf;
1675 int offset = 0;
1676 u16 phyblk, logblk;
1677 u8 PageNum;
1678 u16 len;
1679 u32 blkno;
1680
1681 buf = kmalloc(blenByte, GFP_KERNEL);
1682 if (buf == NULL)
1683 return USB_STOR_TRANSPORT_ERROR;
1684
1685 result = ene_load_bincode(us, MS_RW_PATTERN);
1686 if (result != USB_STOR_XFER_GOOD) {
1687 pr_info("Load MS RW pattern Fail !!\n");
1688 result = USB_STOR_TRANSPORT_ERROR;
1689 goto exit;
1690 }
1691
1692 logblk = (u16)(bn / info->MS_Lib.PagesPerBlock);
1693 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1694
1695 while (1) {
1696 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1697 len = info->MS_Lib.PagesPerBlock-PageNum;
1698 else
1699 len = blen;
1700
1701 phyblk = ms_libconv_to_physical(info, logblk);
1702 blkno = phyblk * 0x20 + PageNum;
1703
1704
1705 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1706 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1707 bcb->DataTransferLength = 0x200 * len;
1708 bcb->Flags = US_BULK_FLAG_IN;
1709 bcb->CDB[0] = 0xF1;
1710 bcb->CDB[1] = 0x02;
1711 bcb->CDB[5] = (unsigned char)(blkno);
1712 bcb->CDB[4] = (unsigned char)(blkno>>8);
1713 bcb->CDB[3] = (unsigned char)(blkno>>16);
1714 bcb->CDB[2] = (unsigned char)(blkno>>24);
1715
1716 result = ene_send_scsi_cmd(us, FDIR_READ, buf+offset, 0);
1717 if (result != USB_STOR_XFER_GOOD) {
1718 pr_info("MS_SCSI_Read --- result = %x\n", result);
1719 result = USB_STOR_TRANSPORT_ERROR;
1720 goto exit;
1721 }
1722
1723 blen -= len;
1724 if (blen <= 0)
1725 break;
1726 logblk++;
1727 PageNum = 0;
1728 offset += MS_BYTES_PER_PAGE*len;
1729 }
1730 usb_stor_set_xfer_buf(buf, blenByte, srb);
1731exit:
1732 kfree(buf);
1733 }
1734 return result;
1735}
1736
1737static int ms_scsi_write(struct us_data *us, struct scsi_cmnd *srb)
1738{
1739 int result;
1740 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1741 unsigned char *cdb = srb->cmnd;
1742 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1743
1744 u32 bn = ((cdb[2] << 24) & 0xff000000) |
1745 ((cdb[3] << 16) & 0x00ff0000) |
1746 ((cdb[4] << 8) & 0x0000ff00) |
1747 ((cdb[5] << 0) & 0x000000ff);
1748 u16 blen = ((cdb[7] << 8) & 0xff00) | ((cdb[8] << 0) & 0x00ff);
1749 u32 blenByte = blen * 0x200;
1750
1751 if (bn > info->bl_num)
1752 return USB_STOR_TRANSPORT_ERROR;
1753
1754 if (info->MS_Status.IsMSPro) {
1755 result = ene_load_bincode(us, MSP_RW_PATTERN);
1756 if (result != USB_STOR_XFER_GOOD) {
1757 pr_info("Load MSP RW pattern Fail !!\n");
1758 return USB_STOR_TRANSPORT_ERROR;
1759 }
1760
1761
1762 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1763 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1764 bcb->DataTransferLength = blenByte;
1765 bcb->Flags = 0x00;
1766 bcb->CDB[0] = 0xF0;
1767 bcb->CDB[1] = 0x04;
1768 bcb->CDB[5] = (unsigned char)(bn);
1769 bcb->CDB[4] = (unsigned char)(bn>>8);
1770 bcb->CDB[3] = (unsigned char)(bn>>16);
1771 bcb->CDB[2] = (unsigned char)(bn>>24);
1772
1773 result = ene_send_scsi_cmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
1774 } else {
1775 void *buf;
1776 int offset = 0;
1777 u16 PhyBlockAddr;
1778 u8 PageNum;
1779 u16 len, oldphy, newphy;
1780
1781 buf = kmalloc(blenByte, GFP_KERNEL);
1782 if (buf == NULL)
1783 return USB_STOR_TRANSPORT_ERROR;
1784 usb_stor_set_xfer_buf(buf, blenByte, srb);
1785
1786 result = ene_load_bincode(us, MS_RW_PATTERN);
1787 if (result != USB_STOR_XFER_GOOD) {
1788 pr_info("Load MS RW pattern Fail !!\n");
1789 result = USB_STOR_TRANSPORT_ERROR;
1790 goto exit;
1791 }
1792
1793 PhyBlockAddr = (u16)(bn / info->MS_Lib.PagesPerBlock);
1794 PageNum = (u8)(bn % info->MS_Lib.PagesPerBlock);
1795
1796 while (1) {
1797 if (blen > (info->MS_Lib.PagesPerBlock-PageNum))
1798 len = info->MS_Lib.PagesPerBlock-PageNum;
1799 else
1800 len = blen;
1801
1802 oldphy = ms_libconv_to_physical(info, PhyBlockAddr);
1803 newphy = ms_libsearch_block_from_logical(us, PhyBlockAddr);
1804
1805 result = ms_read_copyblock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
1806
1807 if (result != USB_STOR_XFER_GOOD) {
1808 pr_info("MS_SCSI_Write --- result = %x\n", result);
1809 result = USB_STOR_TRANSPORT_ERROR;
1810 goto exit;
1811 }
1812
1813 info->MS_Lib.Phy2LogMap[oldphy] = MS_LB_NOT_USED_ERASED;
1814 ms_lib_force_setlogical_pair(us, PhyBlockAddr, newphy);
1815
1816 blen -= len;
1817 if (blen <= 0)
1818 break;
1819 PhyBlockAddr++;
1820 PageNum = 0;
1821 offset += MS_BYTES_PER_PAGE*len;
1822 }
1823exit:
1824 kfree(buf);
1825 }
1826 return result;
1827}
1828
1829
1830
1831
1832
1833static int ene_get_card_type(struct us_data *us, u16 index, void *buf)
1834{
1835 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1836 int result;
1837
1838 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1839 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1840 bcb->DataTransferLength = 0x01;
1841 bcb->Flags = US_BULK_FLAG_IN;
1842 bcb->CDB[0] = 0xED;
1843 bcb->CDB[2] = (unsigned char)(index>>8);
1844 bcb->CDB[3] = (unsigned char)index;
1845
1846 result = ene_send_scsi_cmd(us, FDIR_READ, buf, 0);
1847 return result;
1848}
1849
1850static int ene_get_card_status(struct us_data *us, u8 *buf)
1851{
1852 u16 tmpreg;
1853 u32 reg4b;
1854 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1855
1856
1857 reg4b = *(u32 *)&buf[0x18];
1858 info->SD_READ_BL_LEN = (u8)((reg4b >> 8) & 0x0f);
1859
1860 tmpreg = (u16) reg4b;
1861 reg4b = *(u32 *)(&buf[0x14]);
1862 if (info->SD_Status.HiCapacity && !info->SD_Status.IsMMC)
1863 info->HC_C_SIZE = (reg4b >> 8) & 0x3fffff;
1864
1865 info->SD_C_SIZE = ((tmpreg & 0x03) << 10) | (u16)(reg4b >> 22);
1866 info->SD_C_SIZE_MULT = (u8)(reg4b >> 7) & 0x07;
1867 if (info->SD_Status.HiCapacity && info->SD_Status.IsMMC)
1868 info->HC_C_SIZE = *(u32 *)(&buf[0x100]);
1869
1870 if (info->SD_READ_BL_LEN > SD_BLOCK_LEN) {
1871 info->SD_Block_Mult = 1 << (info->SD_READ_BL_LEN-SD_BLOCK_LEN);
1872 info->SD_READ_BL_LEN = SD_BLOCK_LEN;
1873 } else {
1874 info->SD_Block_Mult = 1;
1875 }
1876
1877 return USB_STOR_TRANSPORT_GOOD;
1878}
1879
1880static int ene_load_bincode(struct us_data *us, unsigned char flag)
1881{
1882 int err;
1883 char *fw_name = NULL;
1884 unsigned char *buf = NULL;
1885 const struct firmware *sd_fw = NULL;
1886 int result = USB_STOR_TRANSPORT_ERROR;
1887 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
1888 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1889
1890 if (info->BIN_FLAG == flag)
1891 return USB_STOR_TRANSPORT_GOOD;
1892
1893 switch (flag) {
1894
1895 case SD_INIT1_PATTERN:
1896 usb_stor_dbg(us, "SD_INIT1_PATTERN\n");
1897 fw_name = SD_INIT1_FIRMWARE;
1898 break;
1899 case SD_INIT2_PATTERN:
1900 usb_stor_dbg(us, "SD_INIT2_PATTERN\n");
1901 fw_name = SD_INIT2_FIRMWARE;
1902 break;
1903 case SD_RW_PATTERN:
1904 usb_stor_dbg(us, "SD_RW_PATTERN\n");
1905 fw_name = SD_RW_FIRMWARE;
1906 break;
1907
1908 case MS_INIT_PATTERN:
1909 usb_stor_dbg(us, "MS_INIT_PATTERN\n");
1910 fw_name = MS_INIT_FIRMWARE;
1911 break;
1912 case MSP_RW_PATTERN:
1913 usb_stor_dbg(us, "MSP_RW_PATTERN\n");
1914 fw_name = MSP_RW_FIRMWARE;
1915 break;
1916 case MS_RW_PATTERN:
1917 usb_stor_dbg(us, "MS_RW_PATTERN\n");
1918 fw_name = MS_RW_FIRMWARE;
1919 break;
1920 default:
1921 usb_stor_dbg(us, "----------- Unknown PATTERN ----------\n");
1922 goto nofw;
1923 }
1924
1925 err = request_firmware(&sd_fw, fw_name, &us->pusb_dev->dev);
1926 if (err) {
1927 usb_stor_dbg(us, "load firmware %s failed\n", fw_name);
1928 goto nofw;
1929 }
1930 buf = kmemdup(sd_fw->data, sd_fw->size, GFP_KERNEL);
1931 if (buf == NULL)
1932 goto nofw;
1933
1934 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
1935 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
1936 bcb->DataTransferLength = sd_fw->size;
1937 bcb->Flags = 0x00;
1938 bcb->CDB[0] = 0xEF;
1939
1940 result = ene_send_scsi_cmd(us, FDIR_WRITE, buf, 0);
1941 if (us->srb != NULL)
1942 scsi_set_resid(us->srb, 0);
1943 info->BIN_FLAG = flag;
1944 kfree(buf);
1945
1946nofw:
1947 release_firmware(sd_fw);
1948 return result;
1949}
1950
1951static int ms_card_init(struct us_data *us)
1952{
1953 u32 result;
1954 u16 TmpBlock;
1955 unsigned char *PageBuffer0 = NULL, *PageBuffer1 = NULL;
1956 struct ms_lib_type_extdat extdat;
1957 u16 btBlk1st, btBlk2nd;
1958 u32 btBlk1stErred;
1959 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
1960
1961 printk(KERN_INFO "MS_CardInit start\n");
1962
1963 ms_lib_free_allocatedarea(us);
1964
1965
1966 PageBuffer0 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1967 PageBuffer1 = kmalloc(MS_BYTES_PER_PAGE, GFP_KERNEL);
1968 if ((PageBuffer0 == NULL) || (PageBuffer1 == NULL)) {
1969 result = MS_NO_MEMORY_ERROR;
1970 goto exit;
1971 }
1972
1973 btBlk1st = btBlk2nd = MS_LB_NOT_USED;
1974 btBlk1stErred = 0;
1975
1976 for (TmpBlock = 0; TmpBlock < MS_MAX_INITIAL_ERROR_BLOCKS+2; TmpBlock++) {
1977
1978 switch (ms_read_readpage(us, TmpBlock, 0, (u32 *)PageBuffer0, &extdat)) {
1979 case MS_STATUS_SUCCESS:
1980 break;
1981 case MS_STATUS_INT_ERROR:
1982 break;
1983 case MS_STATUS_ERROR:
1984 default:
1985 continue;
1986 }
1987
1988 if ((extdat.ovrflg & MS_REG_OVR_BKST) == MS_REG_OVR_BKST_NG)
1989 continue;
1990
1991 if (((extdat.mngflg & MS_REG_MNG_SYSFLG) == MS_REG_MNG_SYSFLG_USER) ||
1992 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wBlockID) != MS_BOOT_BLOCK_ID) ||
1993 (be16_to_cpu(((struct ms_bootblock_page0 *)PageBuffer0)->header.wFormatVersion) != MS_BOOT_BLOCK_FORMAT_VERSION) ||
1994 (((struct ms_bootblock_page0 *)PageBuffer0)->header.bNumberOfDataEntry != MS_BOOT_BLOCK_DATA_ENTRIES))
1995 continue;
1996
1997 if (btBlk1st != MS_LB_NOT_USED) {
1998 btBlk2nd = TmpBlock;
1999 break;
2000 }
2001
2002 btBlk1st = TmpBlock;
2003 memcpy(PageBuffer1, PageBuffer0, MS_BYTES_PER_PAGE);
2004 if (extdat.status1 & (MS_REG_ST1_DTER | MS_REG_ST1_EXER | MS_REG_ST1_FGER))
2005 btBlk1stErred = 1;
2006 }
2007
2008 if (btBlk1st == MS_LB_NOT_USED) {
2009 result = MS_STATUS_ERROR;
2010 goto exit;
2011 }
2012
2013
2014 if ((extdat.status0 & MS_REG_ST0_WP) == MS_REG_ST0_WP_ON)
2015 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2016
2017 result = MS_STATUS_ERROR;
2018
2019 if (btBlk1stErred == 0)
2020 result = ms_lib_process_bootblock(us, btBlk1st, PageBuffer1);
2021
2022
2023 if (result && (btBlk2nd != MS_LB_NOT_USED))
2024 result = ms_lib_process_bootblock(us, btBlk2nd, PageBuffer0);
2025
2026 if (result) {
2027 result = MS_STATUS_ERROR;
2028 goto exit;
2029 }
2030
2031 for (TmpBlock = 0; TmpBlock < btBlk1st; TmpBlock++)
2032 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2033
2034 info->MS_Lib.Phy2LogMap[btBlk1st] = MS_LB_BOOT_BLOCK;
2035
2036 if (btBlk2nd != MS_LB_NOT_USED) {
2037 for (TmpBlock = btBlk1st + 1; TmpBlock < btBlk2nd; TmpBlock++)
2038 info->MS_Lib.Phy2LogMap[TmpBlock] = MS_LB_INITIAL_ERROR;
2039
2040 info->MS_Lib.Phy2LogMap[btBlk2nd] = MS_LB_BOOT_BLOCK;
2041 }
2042
2043 result = ms_lib_scan_logicalblocknumber(us, btBlk1st);
2044 if (result)
2045 goto exit;
2046
2047 for (TmpBlock = MS_PHYSICAL_BLOCKS_PER_SEGMENT;
2048 TmpBlock < info->MS_Lib.NumberOfPhyBlock;
2049 TmpBlock += MS_PHYSICAL_BLOCKS_PER_SEGMENT) {
2050 if (ms_count_freeblock(us, TmpBlock) == 0) {
2051 ms_lib_ctrl_set(info, MS_LIB_CTRL_WRPROTECT);
2052 break;
2053 }
2054 }
2055
2056
2057 if (ms_lib_alloc_writebuf(us)) {
2058 result = MS_NO_MEMORY_ERROR;
2059 goto exit;
2060 }
2061
2062 result = MS_STATUS_SUCCESS;
2063
2064exit:
2065 kfree(PageBuffer1);
2066 kfree(PageBuffer0);
2067
2068 printk(KERN_INFO "MS_CardInit end\n");
2069 return result;
2070}
2071
2072static int ene_ms_init(struct us_data *us)
2073{
2074 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2075 int result;
2076 u16 MSP_BlockSize, MSP_UserAreaBlocks;
2077 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2078 u8 *bbuf = info->bbuf;
2079
2080 printk(KERN_INFO "transport --- ENE_MSInit\n");
2081
2082
2083
2084 result = ene_load_bincode(us, MS_INIT_PATTERN);
2085 if (result != USB_STOR_XFER_GOOD) {
2086 printk(KERN_ERR "Load MS Init Code Fail !!\n");
2087 return USB_STOR_TRANSPORT_ERROR;
2088 }
2089
2090 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2091 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2092 bcb->DataTransferLength = 0x200;
2093 bcb->Flags = US_BULK_FLAG_IN;
2094 bcb->CDB[0] = 0xF1;
2095 bcb->CDB[1] = 0x01;
2096
2097 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2098 if (result != USB_STOR_XFER_GOOD) {
2099 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
2100 return USB_STOR_TRANSPORT_ERROR;
2101 }
2102
2103 info->MS_Status = *(struct MS_STATUS *) bbuf;
2104
2105 if (info->MS_Status.Insert && info->MS_Status.Ready) {
2106 printk(KERN_INFO "Insert = %x\n", info->MS_Status.Insert);
2107 printk(KERN_INFO "Ready = %x\n", info->MS_Status.Ready);
2108 printk(KERN_INFO "IsMSPro = %x\n", info->MS_Status.IsMSPro);
2109 printk(KERN_INFO "IsMSPHG = %x\n", info->MS_Status.IsMSPHG);
2110 printk(KERN_INFO "WtP= %x\n", info->MS_Status.WtP);
2111 if (info->MS_Status.IsMSPro) {
2112 MSP_BlockSize = (bbuf[6] << 8) | bbuf[7];
2113 MSP_UserAreaBlocks = (bbuf[10] << 8) | bbuf[11];
2114 info->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
2115 } else {
2116 ms_card_init(us);
2117 }
2118 usb_stor_dbg(us, "MS Init Code OK !!\n");
2119 } else {
2120 usb_stor_dbg(us, "MS Card Not Ready --- %x\n", bbuf[0]);
2121 return USB_STOR_TRANSPORT_ERROR;
2122 }
2123
2124 return USB_STOR_TRANSPORT_GOOD;
2125}
2126
2127static int ene_sd_init(struct us_data *us)
2128{
2129 int result;
2130 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
2131 struct ene_ub6250_info *info = (struct ene_ub6250_info *) us->extra;
2132 u8 *bbuf = info->bbuf;
2133
2134 usb_stor_dbg(us, "transport --- ENE_SDInit\n");
2135
2136 result = ene_load_bincode(us, SD_INIT1_PATTERN);
2137 if (result != USB_STOR_XFER_GOOD) {
2138 usb_stor_dbg(us, "Load SD Init Code Part-1 Fail !!\n");
2139 return USB_STOR_TRANSPORT_ERROR;
2140 }
2141
2142 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2143 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2144 bcb->Flags = US_BULK_FLAG_IN;
2145 bcb->CDB[0] = 0xF2;
2146
2147 result = ene_send_scsi_cmd(us, FDIR_READ, NULL, 0);
2148 if (result != USB_STOR_XFER_GOOD) {
2149 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2150 return USB_STOR_TRANSPORT_ERROR;
2151 }
2152
2153
2154 result = ene_load_bincode(us, SD_INIT2_PATTERN);
2155 if (result != USB_STOR_XFER_GOOD) {
2156 usb_stor_dbg(us, "Load SD Init Code Part-2 Fail !!\n");
2157 return USB_STOR_TRANSPORT_ERROR;
2158 }
2159
2160 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
2161 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
2162 bcb->DataTransferLength = 0x200;
2163 bcb->Flags = US_BULK_FLAG_IN;
2164 bcb->CDB[0] = 0xF1;
2165
2166 result = ene_send_scsi_cmd(us, FDIR_READ, bbuf, 0);
2167 if (result != USB_STOR_XFER_GOOD) {
2168 usb_stor_dbg(us, "Execution SD Init Code Fail !!\n");
2169 return USB_STOR_TRANSPORT_ERROR;
2170 }
2171
2172 info->SD_Status = *(struct SD_STATUS *) bbuf;
2173 if (info->SD_Status.Insert && info->SD_Status.Ready) {
2174 struct SD_STATUS *s = &info->SD_Status;
2175
2176 ene_get_card_status(us, bbuf);
2177 usb_stor_dbg(us, "Insert = %x\n", s->Insert);
2178 usb_stor_dbg(us, "Ready = %x\n", s->Ready);
2179 usb_stor_dbg(us, "IsMMC = %x\n", s->IsMMC);
2180 usb_stor_dbg(us, "HiCapacity = %x\n", s->HiCapacity);
2181 usb_stor_dbg(us, "HiSpeed = %x\n", s->HiSpeed);
2182 usb_stor_dbg(us, "WtP = %x\n", s->WtP);
2183 } else {
2184 usb_stor_dbg(us, "SD Card Not Ready --- %x\n", bbuf[0]);
2185 return USB_STOR_TRANSPORT_ERROR;
2186 }
2187 return USB_STOR_TRANSPORT_GOOD;
2188}
2189
2190
2191static int ene_init(struct us_data *us)
2192{
2193 int result;
2194 u8 misc_reg03;
2195 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2196 u8 *bbuf = info->bbuf;
2197
2198 result = ene_get_card_type(us, REG_CARD_STATUS, bbuf);
2199 if (result != USB_STOR_XFER_GOOD)
2200 return USB_STOR_TRANSPORT_ERROR;
2201
2202 misc_reg03 = bbuf[0];
2203 if (misc_reg03 & 0x01) {
2204 if (!info->SD_Status.Ready) {
2205 result = ene_sd_init(us);
2206 if (result != USB_STOR_XFER_GOOD)
2207 return USB_STOR_TRANSPORT_ERROR;
2208 }
2209 }
2210 if (misc_reg03 & 0x02) {
2211 if (!info->MS_Status.Ready) {
2212 result = ene_ms_init(us);
2213 if (result != USB_STOR_XFER_GOOD)
2214 return USB_STOR_TRANSPORT_ERROR;
2215 }
2216 }
2217 return result;
2218}
2219
2220
2221static int sd_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2222{
2223 int result;
2224 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2225
2226 switch (srb->cmnd[0]) {
2227 case TEST_UNIT_READY:
2228 result = sd_scsi_test_unit_ready(us, srb);
2229 break;
2230 case REQUEST_SENSE:
2231 result = do_scsi_request_sense(us, srb);
2232 break;
2233 case INQUIRY:
2234 result = do_scsi_inquiry(us, srb);
2235 break;
2236 case MODE_SENSE:
2237 result = sd_scsi_mode_sense(us, srb);
2238 break;
2239
2240
2241
2242
2243
2244 case READ_CAPACITY:
2245 result = sd_scsi_read_capacity(us, srb);
2246 break;
2247 case READ_10:
2248 result = sd_scsi_read(us, srb);
2249 break;
2250 case WRITE_10:
2251 result = sd_scsi_write(us, srb);
2252 break;
2253 default:
2254 info->SrbStatus = SS_ILLEGAL_REQUEST;
2255 result = USB_STOR_TRANSPORT_FAILED;
2256 break;
2257 }
2258 if (result == USB_STOR_TRANSPORT_GOOD)
2259 info->SrbStatus = SS_SUCCESS;
2260 return result;
2261}
2262
2263
2264
2265
2266static int ms_scsi_irp(struct us_data *us, struct scsi_cmnd *srb)
2267{
2268 int result;
2269 struct ene_ub6250_info *info = (struct ene_ub6250_info *)us->extra;
2270
2271 switch (srb->cmnd[0]) {
2272 case TEST_UNIT_READY:
2273 result = ms_scsi_test_unit_ready(us, srb);
2274 break;
2275 case REQUEST_SENSE:
2276 result = do_scsi_request_sense(us, srb);
2277 break;
2278 case INQUIRY:
2279 result = do_scsi_inquiry(us, srb);
2280 break;
2281 case MODE_SENSE:
2282 result = ms_scsi_mode_sense(us, srb);
2283 break;
2284 case READ_CAPACITY:
2285 result = ms_scsi_read_capacity(us, srb);
2286 break;
2287 case READ_10:
2288 result = ms_scsi_read(us, srb);
2289 break;
2290 case WRITE_10:
2291 result = ms_scsi_write(us, srb);
2292 break;
2293 default:
2294 info->SrbStatus = SS_ILLEGAL_REQUEST;
2295 result = USB_STOR_TRANSPORT_FAILED;
2296 break;
2297 }
2298 if (result == USB_STOR_TRANSPORT_GOOD)
2299 info->SrbStatus = SS_SUCCESS;
2300 return result;
2301}
2302
2303static int ene_transport(struct scsi_cmnd *srb, struct us_data *us)
2304{
2305 int result = USB_STOR_XFER_GOOD;
2306 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2307
2308
2309 scsi_set_resid(srb, 0);
2310 if (unlikely(!(info->SD_Status.Ready || info->MS_Status.Ready)))
2311 result = ene_init(us);
2312 if (result == USB_STOR_XFER_GOOD) {
2313 result = USB_STOR_TRANSPORT_ERROR;
2314 if (info->SD_Status.Ready)
2315 result = sd_scsi_irp(us, srb);
2316
2317 if (info->MS_Status.Ready)
2318 result = ms_scsi_irp(us, srb);
2319 }
2320 return result;
2321}
2322
2323static struct scsi_host_template ene_ub6250_host_template;
2324
2325static int ene_ub6250_probe(struct usb_interface *intf,
2326 const struct usb_device_id *id)
2327{
2328 int result;
2329 u8 misc_reg03;
2330 struct us_data *us;
2331 struct ene_ub6250_info *info;
2332
2333 result = usb_stor_probe1(&us, intf, id,
2334 (id - ene_ub6250_usb_ids) + ene_ub6250_unusual_dev_list,
2335 &ene_ub6250_host_template);
2336 if (result)
2337 return result;
2338
2339
2340 us->extra = kzalloc(sizeof(struct ene_ub6250_info), GFP_KERNEL);
2341 if (!us->extra)
2342 return -ENOMEM;
2343 us->extra_destructor = ene_ub6250_info_destructor;
2344
2345 info = (struct ene_ub6250_info *)(us->extra);
2346 info->bbuf = kmalloc(512, GFP_KERNEL);
2347 if (!info->bbuf) {
2348 kfree(us->extra);
2349 return -ENOMEM;
2350 }
2351
2352 us->transport_name = "ene_ub6250";
2353 us->transport = ene_transport;
2354 us->max_lun = 0;
2355
2356 result = usb_stor_probe2(us);
2357 if (result)
2358 return result;
2359
2360
2361 result = ene_get_card_type(us, REG_CARD_STATUS, info->bbuf);
2362 if (result != USB_STOR_XFER_GOOD) {
2363 usb_stor_disconnect(intf);
2364 return USB_STOR_TRANSPORT_ERROR;
2365 }
2366
2367 misc_reg03 = info->bbuf[0];
2368 if (!(misc_reg03 & 0x01)) {
2369 pr_info("ums_eneub6250: This driver only supports SD/MS cards. "
2370 "It does not support SM cards.\n");
2371 }
2372
2373 return result;
2374}
2375
2376
2377#ifdef CONFIG_PM
2378
2379static int ene_ub6250_resume(struct usb_interface *iface)
2380{
2381 u8 tmp = 0;
2382 struct us_data *us = usb_get_intfdata(iface);
2383 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2384
2385 mutex_lock(&us->dev_mutex);
2386
2387 if (us->suspend_resume_hook)
2388 (us->suspend_resume_hook)(us, US_RESUME);
2389
2390 mutex_unlock(&us->dev_mutex);
2391
2392 info->Power_IsResum = true;
2393
2394 info->SD_Status = *(struct SD_STATUS *)&tmp;
2395 info->MS_Status = *(struct MS_STATUS *)&tmp;
2396 info->SM_Status = *(struct SM_STATUS *)&tmp;
2397
2398 return 0;
2399}
2400
2401static int ene_ub6250_reset_resume(struct usb_interface *iface)
2402{
2403 u8 tmp = 0;
2404 struct us_data *us = usb_get_intfdata(iface);
2405 struct ene_ub6250_info *info = (struct ene_ub6250_info *)(us->extra);
2406
2407
2408 usb_stor_reset_resume(iface);
2409
2410
2411
2412
2413
2414 info->Power_IsResum = true;
2415
2416 info->SD_Status = *(struct SD_STATUS *)&tmp;
2417 info->MS_Status = *(struct MS_STATUS *)&tmp;
2418 info->SM_Status = *(struct SM_STATUS *)&tmp;
2419
2420 return 0;
2421}
2422
2423#else
2424
2425#define ene_ub6250_resume NULL
2426#define ene_ub6250_reset_resume NULL
2427
2428#endif
2429
2430static struct usb_driver ene_ub6250_driver = {
2431 .name = DRV_NAME,
2432 .probe = ene_ub6250_probe,
2433 .disconnect = usb_stor_disconnect,
2434 .suspend = usb_stor_suspend,
2435 .resume = ene_ub6250_resume,
2436 .reset_resume = ene_ub6250_reset_resume,
2437 .pre_reset = usb_stor_pre_reset,
2438 .post_reset = usb_stor_post_reset,
2439 .id_table = ene_ub6250_usb_ids,
2440 .soft_unbind = 1,
2441 .no_dynamic_id = 1,
2442};
2443
2444module_usb_stor_driver(ene_ub6250_driver, ene_ub6250_host_template, DRV_NAME);
2445
