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