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