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