tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 return USB_STOR_TRANSPORT_ERROR;
35 }
36 }
37
38 }
39 return result;
40}
41
42/*
43 * ENE_Read_BYTE() :
44 */
45int ENE_Read_BYTE(struct us_data *us, WORD index, void *buf)
46{
47 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
48 int result;
49
50 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
51 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
52 bcb->DataTransferLength = 0x01;
53 bcb->Flags = 0x80;
54 bcb->CDB[0] = 0xED;
55 bcb->CDB[2] = (BYTE)(index>>8);
56 bcb->CDB[3] = (BYTE)index;
57
58 result = ENE_SendScsiCmd(us, FDIR_READ, buf, 0);
59 return result;
60}
61
62/*
63 *ENE_SMInit()
64 */
65int ENE_SMInit(struct us_data *us)
66{
67 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
68 int result;
69 BYTE buf[0x200];
70
71 printk(KERN_INFO "transport --- ENE_SMInit\n");
72
73 result = ENE_LoadBinCode(us, SM_INIT_PATTERN);
74 if (result != USB_STOR_XFER_GOOD) {
75 printk(KERN_INFO "Load SM Init Code Fail !!\n");
76 return USB_STOR_TRANSPORT_ERROR;
77 }
78
79 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
80 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
81 bcb->DataTransferLength = 0x200;
82 bcb->Flags = 0x80;
83 bcb->CDB[0] = 0xF1;
84 bcb->CDB[1] = 0x01;
85
86 result = ENE_SendScsiCmd(us, FDIR_READ, &buf, 0);
87 if (result != USB_STOR_XFER_GOOD) {
88 printk(KERN_ERR
89 "Execution SM Init Code Fail !! result = %x\n", result);
90 return USB_STOR_TRANSPORT_ERROR;
91 }
92
93 us->SM_Status = *(PSM_STATUS)&buf[0];
94
95 us->SM_DeviceID = buf[1];
96 us->SM_CardID = buf[2];
97
98 if (us->SM_Status.Insert && us->SM_Status.Ready) {
99 printk(KERN_INFO "Insert = %x\n", us->SM_Status.Insert);
100 printk(KERN_INFO "Ready = %x\n", us->SM_Status.Ready);
101 printk(KERN_INFO "WtP = %x\n", us->SM_Status.WtP);
102 printk(KERN_INFO "DeviceID = %x\n", us->SM_DeviceID);
103 printk(KERN_INFO "CardID = %x\n", us->SM_CardID);
104 MediaChange = 1;
105 Check_D_MediaFmt(us);
106 } else {
107 printk(KERN_ERR "SM Card Not Ready --- %x\n", buf[0]);
108 return USB_STOR_TRANSPORT_ERROR;
109 }
110
111 return USB_STOR_TRANSPORT_GOOD;
112}
113
114/*
115 * ENE_LoadBinCode()
116 */
117int ENE_LoadBinCode(struct us_data *us, BYTE flag)
118{
119 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
120 int result;
121 /* void *buf; */
122 PBYTE buf;
123
124 /* printk(KERN_INFO "transport --- ENE_LoadBinCode\n"); */
125 if (us->BIN_FLAG == flag)
126 return USB_STOR_TRANSPORT_GOOD;
127
128 buf = kmalloc(0x800, GFP_KERNEL);
129 if (buf == NULL)
130 return USB_STOR_TRANSPORT_ERROR;
131 switch (flag) {
132 /* For SS */
133 case SM_INIT_PATTERN:
134 printk(KERN_INFO "SM_INIT_PATTERN\n");
135 memcpy(buf, SM_Init, 0x800);
136 break;
137 case SM_RW_PATTERN:
138 printk(KERN_INFO "SM_RW_PATTERN\n");
139 memcpy(buf, SM_Rdwr, 0x800);
140 break;
141 }
142
143 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
144 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
145 bcb->DataTransferLength = 0x800;
146 bcb->Flags = 0x00;
147 bcb->CDB[0] = 0xEF;
148
149 result = ENE_SendScsiCmd(us, FDIR_WRITE, buf, 0);
150
151 kfree(buf);
152 us->BIN_FLAG = flag;
153 return result;
154}
155
156/*
157 * ENE_SendScsiCmd():
158 */
159int ENE_SendScsiCmd(struct us_data *us, BYTE fDir, void *buf, int use_sg)
160{
161 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
162 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
163
164 int result;
165 unsigned int transfer_length = bcb->DataTransferLength,
166 cswlen = 0, partial = 0;
167 unsigned int residue;
168
169 /* printk(KERN_INFO "transport --- ENE_SendScsiCmd\n"); */
170 /* send cmd to out endpoint */
171 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
172 bcb, US_BULK_CB_WRAP_LEN, NULL);
173 if (result != USB_STOR_XFER_GOOD) {
174 printk(KERN_ERR "send cmd to out endpoint fail ---\n");
175 return USB_STOR_TRANSPORT_ERROR;
176 }
177
178 if (buf) {
179 unsigned int pipe = fDir;
180
181 if (fDir == FDIR_READ)
182 pipe = us->recv_bulk_pipe;
183 else
184 pipe = us->send_bulk_pipe;
185
186 /* Bulk */
187 if (use_sg)
188 result = usb_stor_bulk_srb(us, pipe, us->srb);
189 else
190 result = usb_stor_bulk_transfer_sg(us, pipe, buf,
191 transfer_length, 0, &partial);
192 if (result != USB_STOR_XFER_GOOD) {
193 printk(KERN_ERR "data transfer fail ---\n");
194 return USB_STOR_TRANSPORT_ERROR;
195 }
196 }
197
198 /* Get CSW for device status */
199 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
200 US_BULK_CS_WRAP_LEN, &cswlen);
201
202 if (result == USB_STOR_XFER_SHORT && cswlen == 0) {
203 printk(KERN_WARNING "Received 0-length CSW; retrying...\n");
204 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
205 bcs, US_BULK_CS_WRAP_LEN, &cswlen);
206 }
207
208 if (result == USB_STOR_XFER_STALLED) {
209 /* get the status again */
210 printk(KERN_WARNING "Attempting to get CSW (2nd try)...\n");
211 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
212 bcs, US_BULK_CS_WRAP_LEN, NULL);
213 }
214
215 if (result != USB_STOR_XFER_GOOD)
216 return USB_STOR_TRANSPORT_ERROR;
217
218 /* check bulk status */
219 residue = le32_to_cpu(bcs->Residue);
220
221 /*
222 * try to compute the actual residue, based on how much data
223 * was really transferred and what the device tells us
224 */
225 if (residue && !(us->fflags & US_FL_IGNORE_RESIDUE)) {
226 residue = min(residue, transfer_length);
227 if (us->srb)
228 scsi_set_resid(us->srb, max(scsi_get_resid(us->srb),
229 (int) residue));
230 }
231
232 if (bcs->Status != US_BULK_STAT_OK)
233 return USB_STOR_TRANSPORT_ERROR;
234
235 return USB_STOR_TRANSPORT_GOOD;
236}
237
238/*
239 * ENE_Read_Data()
240 */
241int ENE_Read_Data(struct us_data *us, void *buf, unsigned int length)
242{
243 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
244 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
245 int result;
246
247 /* printk(KERN_INFO "transport --- ENE_Read_Data\n"); */
248 /* set up the command wrapper */
249 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
250 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
251 bcb->DataTransferLength = length;
252 bcb->Flags = 0x80;
253 bcb->CDB[0] = 0xED;
254 bcb->CDB[2] = 0xFF;
255 bcb->CDB[3] = 0x81;
256
257 /* send cmd to out endpoint */
258 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
259 US_BULK_CB_WRAP_LEN, NULL);
260 if (result != USB_STOR_XFER_GOOD)
261 return USB_STOR_TRANSPORT_ERROR;
262
263 /* R/W data */
264 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe,
265 buf, length, NULL);
266 if (result != USB_STOR_XFER_GOOD)
267 return USB_STOR_TRANSPORT_ERROR;
268
269 /* Get CSW for device status */
270 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
271 US_BULK_CS_WRAP_LEN, NULL);
272 if (result != USB_STOR_XFER_GOOD)
273 return USB_STOR_TRANSPORT_ERROR;
274 if (bcs->Status != US_BULK_STAT_OK)
275 return USB_STOR_TRANSPORT_ERROR;
276
277 return USB_STOR_TRANSPORT_GOOD;
278}
279
280/*
281 * ENE_Write_Data():
282 */
283int ENE_Write_Data(struct us_data *us, void *buf, unsigned int length)
284{
285 struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
286 struct bulk_cs_wrap *bcs = (struct bulk_cs_wrap *) us->iobuf;
287 int result;
288
289 /* printk("transport --- ENE_Write_Data\n"); */
290 /* set up the command wrapper */
291 memset(bcb, 0, sizeof(struct bulk_cb_wrap));
292 bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
293 bcb->DataTransferLength = length;
294 bcb->Flags = 0x00;
295 bcb->CDB[0] = 0xEE;
296 bcb->CDB[2] = 0xFF;
297 bcb->CDB[3] = 0x81;
298
299 /* send cmd to out endpoint */
300 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe, bcb,
301 US_BULK_CB_WRAP_LEN, NULL);
302 if (result != USB_STOR_XFER_GOOD)
303 return USB_STOR_TRANSPORT_ERROR;
304
305 /* R/W data */
306 result = usb_stor_bulk_transfer_buf(us, us->send_bulk_pipe,
307 buf, length, NULL);
308 if (result != USB_STOR_XFER_GOOD)
309 return USB_STOR_TRANSPORT_ERROR;
310
311 /* Get CSW for device status */
312 result = usb_stor_bulk_transfer_buf(us, us->recv_bulk_pipe, bcs,
313 US_BULK_CS_WRAP_LEN, NULL);
314 if (result != USB_STOR_XFER_GOOD)
315 return USB_STOR_TRANSPORT_ERROR;
316 if (bcs->Status != US_BULK_STAT_OK)
317 return USB_STOR_TRANSPORT_ERROR;
318
319 return USB_STOR_TRANSPORT_GOOD;
320}
321
322/*
323 * usb_stor_print_cmd():
324 */
325void usb_stor_print_cmd(struct scsi_cmnd *srb)
326{
327 PBYTE Cdb = srb->cmnd;
328 DWORD cmd = Cdb[0];
329 DWORD bn = ((Cdb[2] << 24) & 0xff000000) |
330 ((Cdb[3] << 16) & 0x00ff0000) |
331 ((Cdb[4] << 8) & 0x0000ff00) |
332 ((Cdb[5] << 0) & 0x000000ff);
333 WORD blen = ((Cdb[7] << 8) & 0xff00) | ((Cdb[8] << 0) & 0x00ff);
334
335 switch (cmd) {
336 case TEST_UNIT_READY:
337 /* printk(KERN_INFO
338 "scsi cmd %X --- SCSIOP_TEST_UNIT_READY\n", cmd); */
339 break;
340 case INQUIRY:
341 printk(KERN_INFO "scsi cmd %X --- SCSIOP_INQUIRY\n", cmd);
342 break;
343 case MODE_SENSE:
344 printk(KERN_INFO "scsi cmd %X --- SCSIOP_MODE_SENSE\n", cmd);
345 break;
346 case START_STOP:
347 printk(KERN_INFO "scsi cmd %X --- SCSIOP_START_STOP\n", cmd);
348 break;
349 case READ_CAPACITY:
350 printk(KERN_INFO "scsi cmd %X --- SCSIOP_READ_CAPACITY\n", cmd);
351 break;
352 case READ_10:
353 /* printk(KERN_INFO
354 "scsi cmd %X --- SCSIOP_READ,bn = %X, blen = %X\n"
355 ,cmd, bn, blen); */
356 break;
357 case WRITE_10:
358 /* printk(KERN_INFO
359 "scsi cmd %X --- SCSIOP_WRITE,
360 bn = %X, blen = %X\n" , cmd, bn, blen); */
361 break;
362 case ALLOW_MEDIUM_REMOVAL:
363 printk(KERN_INFO
364 "scsi cmd %X --- SCSIOP_ALLOW_MEDIUM_REMOVAL\n", cmd);
365 break;
366 default:
367 printk(KERN_INFO "scsi cmd %X --- Other cmd\n", cmd);
368 break;
369 }
370 bn = 0;
371 blen = 0;
372}
373