/drivers/staging/keucr/init.c
C | 442 lines | 323 code | 60 blank | 59 comment | 68 complexity | 7fd564ded98da06c3c1fae37cf09b6c1 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0, AGPL-1.0
1#include <linux/sched.h>
2#include <linux/errno.h>
3#include <linux/slab.h>
4
5#include <scsi/scsi.h>
6#include <scsi/scsi_eh.h>
7#include <scsi/scsi_device.h>
8
9#include "usb.h"
10#include "scsiglue.h"
11#include "transport.h"
12#include "init.h"
13
14/*
15 * ENE_InitMedia():
16 */
17int ENE_InitMedia(struct us_data *us)
18{
19 int result;
20 BYTE MiscReg03 = 0;
21
22 printk(KERN_INFO "--- Init Media ---\n");
23 result = ENE_Read_BYTE(us, REG_CARD_STATUS, &MiscReg03);
24 if (result != USB_STOR_XFER_GOOD) {
25 printk(KERN_ERR "Read register fail !!\n");
26 return USB_STOR_TRANSPORT_ERROR;
27 }
28 printk(KERN_INFO "MiscReg03 = %x\n", MiscReg03);
29
30 if (MiscReg03 & 0x02) {
31 if (!us->SM_Status.Ready && !us->MS_Status.Ready) {
32 result = ENE_SMInit(us);
33 if (result != USB_STOR_XFER_GOOD) {
34 result = ENE_MSInit(us);
35 if (result != USB_STOR_XFER_GOOD)
36 return USB_STOR_TRANSPORT_ERROR;
37 }
38 }
39
40 }
41 return result;
42}
43
44/*
45 * ENE_Read_BYTE() :
46 */
47int ENE_Read_BYTE(struct us_data *us, WORD index, void *buf)
48{
49 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
50 int result;
51
52 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
53 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
54 bcb->DataTransferLength = 0x01;
55 bcb->Flags = 0x80;
56 bcb->CDB[0] = 0xED;
57 bcb->CDB[2] = (BYTE)(index>>8);
58 bcb->CDB[3] = (BYTE)index;
59
60 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
61 return result;
62}
63
64/*
65 * ENE_MSInit():
66 */
67int ENE_MSInit(struct us_data *us)
68{
69 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
70 int result;
71 BYTE buf[0x200];
72 WORD MSP_BlockSize, MSP_UserAreaBlocks;
73
74 printk(KERN_INFO "transport --- ENE_MSInit\n");
75 result = ENE_LoadBinCode(us, MS_INIT_PATTERN);
76 if (result != USB_STOR_XFER_GOOD) {
77 printk(KERN_ERR "Load MS Init Code Fail !!\n");
78 return USB_STOR_TRANSPORT_ERROR;
79 }
80
81 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
82 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
83 bcb->DataTransferLength = 0x200;
84 bcb->Flags = 0x80;
85 bcb->CDB[0] = 0xF1;
86 bcb->CDB[1] = 0x01;
87
88 result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
89 if (result != USB_STOR_XFER_GOOD) {
90 printk(KERN_ERR "Execution MS Init Code Fail !!\n");
91 return USB_STOR_TRANSPORT_ERROR;
92 }
93
94 us->MS_Status = *(PMS_STATUS)&buf[0];
95
96 if (us->MS_Status.Insert && us->MS_Status.Ready) {
97 printk(KERN_INFO "Insert = %x\n", us->MS_Status.Insert);
98 printk(KERN_INFO "Ready = %x\n", us->MS_Status.Ready);
99 printk(KERN_INFO "IsMSPro = %x\n", us->MS_Status.IsMSPro);
100 printk(KERN_INFO "IsMSPHG = %x\n", us->MS_Status.IsMSPHG);
101 printk(KERN_INFO "WtP = %x\n", us->MS_Status.WtP);
102 if (us->MS_Status.IsMSPro) {
103 MSP_BlockSize = (buf[6] << 8) | buf[7];
104 MSP_UserAreaBlocks = (buf[10] << 8) | buf[11];
105 us->MSP_TotalBlock = MSP_BlockSize * MSP_UserAreaBlocks;
106 } else {
107 MS_CardInit(us);
108 }
109 printk(KERN_INFO "MS Init Code OK !!\n");
110 } else {
111 printk(KERN_INFO "MS Card Not Ready --- %x\n", buf[0]);
112 return USB_STOR_TRANSPORT_ERROR;
113 }
114
115 return USB_STOR_TRANSPORT_GOOD;
116}
117
118/*
119 *ENE_SMInit()
120 */
121int ENE_SMInit(struct us_data *us)
122{
123 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
124 int result;
125 BYTE buf[0x200];
126
127 printk(KERN_INFO "transport --- ENE_SMInit\n");
128
129 result = ENE_LoadBinCode(us, SM_INIT_PATTERN);
130 if (result != USB_STOR_XFER_GOOD) {
131 printk(KERN_INFO "Load SM Init Code Fail !!\n");
132 return USB_STOR_TRANSPORT_ERROR;
133 }
134
135 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
136 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
137 bcb->DataTransferLength = 0x200;
138 bcb->Flags = 0x80;
139 bcb->CDB[0] = 0xF1;
140 bcb->CDB[1] = 0x01;
141
142 result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
143 if (result != USB_STOR_XFER_GOOD) {
144 printk(KERN_ERR
145 "Execution SM Init Code Fail !! result = %x\n", result);
146 return USB_STOR_TRANSPORT_ERROR;
147 }
148
149 us->SM_Status = *(PSM_STATUS)&buf[0];
150
151 us->SM_DeviceID = buf[1];
152 us->SM_CardID = buf[2];
153
154 if (us->SM_Status.Insert && us->SM_Status.Ready) {
155 printk(KERN_INFO "Insert = %x\n", us->SM_Status.Insert);
156 printk(KERN_INFO "Ready = %x\n", us->SM_Status.Ready);
157 printk(KERN_INFO "WtP = %x\n", us->SM_Status.WtP);
158 printk(KERN_INFO "DeviceID = %x\n", us->SM_DeviceID);
159 printk(KERN_INFO "CardID = %x\n", us->SM_CardID);
160 MediaChange = 1;
161 Check_D_MediaFmt(us);
162 } else {
163 printk(KERN_ERR "SM Card Not Ready --- %x\n", buf[0]);
164 return USB_STOR_TRANSPORT_ERROR;
165 }
166
167 return USB_STOR_TRANSPORT_GOOD;
168}
169
170/*
171 * ENE_LoadBinCode()
172 */
173int ENE_LoadBinCode(struct us_data *us, BYTE flag)
174{
175 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
176 int result;
177 /* void *buf; */
178 PBYTE buf;
179
180 /* printk(KERN_INFO "transport --- ENE_LoadBinCode\n"); */
181 if (us->BIN_FLAG == flag)
182 return USB_STOR_TRANSPORT_GOOD;
183
184 buf = kmalloc(0x800, GFP_KERNEL);
185 if (buf == NULL)
186 return USB_STOR_TRANSPORT_ERROR;
187 switch (flag) {
188 /* For MS */
189 case MS_INIT_PATTERN:
190 printk(KERN_INFO "MS_INIT_PATTERN\n");
191 memcpy(buf, MS_Init, 0x800);
192 break;
193 case MSP_RW_PATTERN:
194 printk(KERN_INFO "MSP_RW_PATTERN\n");
195 memcpy(buf, MSP_Rdwr, 0x800);
196 break;
197 case MS_RW_PATTERN:
198 printk(KERN_INFO "MS_RW_PATTERN\n");
199 memcpy(buf, MS_Rdwr, 0x800);
200 break;
201 /* For SS */
202 case SM_INIT_PATTERN:
203 printk(KERN_INFO "SM_INIT_PATTERN\n");
204 memcpy(buf, SM_Init, 0x800);
205 break;
206 case SM_RW_PATTERN:
207 printk(KERN_INFO "SM_RW_PATTERN\n");
208 memcpy(buf, SM_Rdwr, 0x800);
209 break;
210 }
211
212 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
213 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
214 bcb->DataTransferLength = 0x800;
215 bcb->Flags = 0x00;
216 bcb->CDB[0] = 0xEF;
217
218 result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
219
220 kfree(buf);
221 us->BIN_FLAG = flag;
222 return result;
223}
224
225/*
226 * ENE_SendScsiCmd():
227 */
228int ENE_SendScsiCmd(struct us_data *us, BYTE fDir, void *buf, int use_sg)
229{
230 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
231 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
232
233 int result;
234 unsigned int transfer_length = bcb->DataTransferLength,
235 cswlen = 0, partial = 0;
236 unsigned int residue;
237
238 /* printk(KERN_INFO "transport --- ENE_SendScsiCmd\n"); */
239 /* send cmd to out endpoint */
240 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
241 bcb, US_BULK_CB_WRAP_LEN, NULL);
242 if (result != USB_STOR_XFER_GOOD) {
243 printk(KERN_ERR "send cmd to out endpoint fail ---\n");
244 return USB_STOR_TRANSPORT_ERROR;
245 }
246
247 if (buf) {
248 unsigned int pipe = fDir;
249
250 if (fDir == FDIR_READ)
251 pipe = us->recv_bulk_pipe;
252 else
253 pipe = us->send_bulk_pipe;
254
255 /* Bulk */
256 if (use_sg)
257 result = usb_stor_bulk_srb(us, pipe, us->srb);
258 else
259 result = usb_stor_bulk_transfer_sg(us, pipe, buf,
260 transfer_length, 0, &partial);
261 if (result != USB_STOR_XFER_GOOD) {
262 printk(KERN_ERR "data transfer fail ---\n");
263 return USB_STOR_TRANSPORT_ERROR;
264 }
265 }
266
267 /* Get CSW for device status */
268 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
269 US_BULK_CS_WRAP_LEN, &cswlen);
270
271 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
272 printk(KERN_WARNING "Received 0-length CSW; retrying...\n");
273 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
274 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
275 }
276
277 if (result == USB_STOR_XFER_STALLED) {
278 /* get the status again */
279 printk(KERN_WARNING "Attempting to get CSW (2nd try)...\n");
280 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
281 bcs, US_BULK_CS_WRAP_LEN, NULL);
282 }
283
284 if (result != USB_STOR_XFER_GOOD)
285 return USB_STOR_TRANSPORT_ERROR;
286
287 /* check bulk status */
288 residue = le32_to_cpu(bcs->Residue);
289
290 /*
291 * try to compute the actual residue, based on how much data
292 * was really transferred and what the device tells us
293 */
294 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
295 residue = min(residue, transfer_length);
296 if (us->srb)
297 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
298 (int) residue));
299 }
300
301 if (bcs->Status != US_BULK_STAT_OK)
302 return USB_STOR_TRANSPORT_ERROR;
303
304 return USB_STOR_TRANSPORT_GOOD;
305}
306
307/*
308 * ENE_Read_Data()
309 */
310int ENE_Read_Data(struct us_data *us, void *buf, unsigned int length)
311{
312 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
313 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
314 int result;
315
316 /* printk(KERN_INFO "transport --- ENE_Read_Data\n"); */
317 /* set up the command wrapper */
318 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
319 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
320 bcb->DataTransferLength = length;
321 bcb->Flags = 0x80;
322 bcb->CDB[0] = 0xED;
323 bcb->CDB[2] = 0xFF;
324 bcb->CDB[3] = 0x81;
325
326 /* send cmd to out endpoint */
327 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
328 US_BULK_CB_WRAP_LEN, NULL);
329 if (result != USB_STOR_XFER_GOOD)
330 return USB_STOR_TRANSPORT_ERROR;
331
332 /* R/W data */
333 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
334 buf, length, NULL);
335 if (result != USB_STOR_XFER_GOOD)
336 return USB_STOR_TRANSPORT_ERROR;
337
338 /* Get CSW for device status */
339 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
340 US_BULK_CS_WRAP_LEN, NULL);
341 if (result != USB_STOR_XFER_GOOD)
342 return USB_STOR_TRANSPORT_ERROR;
343 if (bcs->Status != US_BULK_STAT_OK)
344 return USB_STOR_TRANSPORT_ERROR;
345
346 return USB_STOR_TRANSPORT_GOOD;
347}
348
349/*
350 * ENE_Write_Data():
351 */
352int ENE_Write_Data(struct us_data *us, void *buf, unsigned int length)
353{
354 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
355 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
356 int result;
357
358 /* printk("transport --- ENE_Write_Data\n"); */
359 /* set up the command wrapper */
360 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
361 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
362 bcb->DataTransferLength = length;
363 bcb->Flags = 0x00;
364 bcb->CDB[0] = 0xEE;
365 bcb->CDB[2] = 0xFF;
366 bcb->CDB[3] = 0x81;
367
368 /* send cmd to out endpoint */
369 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
370 US_BULK_CB_WRAP_LEN, NULL);
371 if (result != USB_STOR_XFER_GOOD)
372 return USB_STOR_TRANSPORT_ERROR;
373
374 /* R/W data */
375 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
376 buf, length, NULL);
377 if (result != USB_STOR_XFER_GOOD)
378 return USB_STOR_TRANSPORT_ERROR;
379
380 /* Get CSW for device status */
381 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
382 US_BULK_CS_WRAP_LEN, NULL);
383 if (result != USB_STOR_XFER_GOOD)
384 return USB_STOR_TRANSPORT_ERROR;
385 if (bcs->Status != US_BULK_STAT_OK)
386 return USB_STOR_TRANSPORT_ERROR;
387
388 return USB_STOR_TRANSPORT_GOOD;
389}
390
391/*
392 * usb_stor_print_cmd():
393 */
394void usb_stor_print_cmd(struct scsi_cmnd *srb)
395{
396 PBYTE Cdb = srb->cmnd;
397 DWORD cmd = Cdb[0];
398 DWORD bn = ((Cdb[2] << 24) & 0xff000000) |
399 ((Cdb[3] << 16) & 0x00ff0000) |
400 ((Cdb[4] << 8) & 0x0000ff00) |
401 ((Cdb[5] << 0) & 0x000000ff);
402 WORD blen = ((Cdb[7] << 8) & 0xff00) | ((Cdb[8] << 0) & 0x00ff);
403
404 switch (cmd) {
405 case TEST_UNIT_READY:
406 /* printk(KERN_INFO
407 "scsi cmd %X --- SCSIOP_TEST_UNIT_READY\n", cmd); */
408 break;
409 case INQUIRY:
410 printk(KERN_INFO "scsi cmd %X --- SCSIOP_INQUIRY\n", cmd);
411 break;
412 case MODE_SENSE:
413 printk(KERN_INFO "scsi cmd %X --- SCSIOP_MODE_SENSE\n", cmd);
414 break;
415 case START_STOP:
416 printk(KERN_INFO "scsi cmd %X --- SCSIOP_START_STOP\n", cmd);
417 break;
418 case READ_CAPACITY:
419 printk(KERN_INFO "scsi cmd %X --- SCSIOP_READ_CAPACITY\n", cmd);
420 break;
421 case READ_10:
422 /* printk(KERN_INFO
423 "scsi cmd %X --- SCSIOP_READ,bn = %X, blen = %X\n"
424 ,cmd, bn, blen); */
425 break;
426 case WRITE_10:
427 /* printk(KERN_INFO
428 "scsi cmd %X --- SCSIOP_WRITE,
429 bn = %X, blen = %X\n" , cmd, bn, blen); */
430 break;
431 case ALLOW_MEDIUM_REMOVAL:
432 printk(KERN_INFO
433 "scsi cmd %X --- SCSIOP_ALLOW_MEDIUM_REMOVAL\n", cmd);
434 break;
435 default:
436 printk(KERN_INFO "scsi cmd %X --- Other cmd\n", cmd);
437 break;
438 }
439 bn = 0;
440 blen = 0;
441}
442