← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise

« back to all changes in this revision

Viewing changes to drivers/staging/keucr/msscsi.c

  • Committer: Bazaar Package Importer
  • Author(s): Paolo Pisati
  • Date: 2011-06-29 15:23:51 UTC
  • mfrom: (26.1.1 natty-proposed)
  • Revision ID: james.westby@ubuntu.com-20110629152351-xs96tm303d95rpbk
Tags: 3.0.0-1200.2
* Rebased against 3.0.0-6.7
* BSP from TI based on 3.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/keucr/msscsi.c
 
1
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
2
 
1
3
#include <linux/sched.h>
2
4
#include <linux/errno.h>
3
5
#include <linux/slab.h>
10
12
#include "scsiglue.h"
11
13
#include "transport.h"
12
14
 
13
 
int MS_SCSI_Test_Unit_Ready (struct us_data *us, struct scsi_cmnd *srb);
14
 
int MS_SCSI_Inquiry         (struct us_data *us, struct scsi_cmnd *srb);
15
 
int MS_SCSI_Mode_Sense      (struct us_data *us, struct scsi_cmnd *srb);
16
 
int MS_SCSI_Start_Stop      (struct us_data *us, struct scsi_cmnd *srb);
17
 
int MS_SCSI_Read_Capacity   (struct us_data *us, struct scsi_cmnd *srb);
18
 
int MS_SCSI_Read            (struct us_data *us, struct scsi_cmnd *srb);
19
 
int MS_SCSI_Write           (struct us_data *us, struct scsi_cmnd *srb);
20
 
 
21
 
//----- MS_SCSIIrp() --------------------------------------------------
22
 
int MS_SCSIIrp(struct us_data *us, struct scsi_cmnd *srb)
23
 
{
24
 
        int    result;
25
 
 
26
 
        us->SrbStatus = SS_SUCCESS;
27
 
        switch (srb->cmnd[0])
28
 
        {
29
 
                case TEST_UNIT_READY :  result = MS_SCSI_Test_Unit_Ready (us, srb);  break; //0x00
30
 
                case INQUIRY         :  result = MS_SCSI_Inquiry         (us, srb);  break; //0x12
31
 
                case MODE_SENSE      :  result = MS_SCSI_Mode_Sense      (us, srb);  break; //0x1A
32
 
                case READ_CAPACITY   :  result = MS_SCSI_Read_Capacity   (us, srb);  break; //0x25
33
 
                case READ_10         :  result = MS_SCSI_Read            (us, srb);  break; //0x28
34
 
                case WRITE_10        :  result = MS_SCSI_Write           (us, srb);  break; //0x2A
35
 
 
36
 
                default:
37
 
                        us->SrbStatus = SS_ILLEGAL_REQUEST;
38
 
                        result = USB_STOR_TRANSPORT_FAILED;
39
 
                        break;
40
 
        }
41
 
        return result;
42
 
}
43
 
 
44
 
//----- MS_SCSI_Test_Unit_Ready() --------------------------------------------------
 
15
/*
 
16
 * MS_SCSI_Test_Unit_Ready()
 
17
 */
45
18
int MS_SCSI_Test_Unit_Ready(struct us_data *us, struct scsi_cmnd *srb)
46
19
{
47
 
        //printk("MS_SCSI_Test_Unit_Ready\n");
 
20
        /* pr_info("MS_SCSI_Test_Unit_Ready\n"); */
48
21
        if (us->MS_Status.Insert && us->MS_Status.Ready)
49
22
                return USB_STOR_TRANSPORT_GOOD;
50
 
        else
51
 
        {
 
23
        else {
52
24
                ENE_MSInit(us);
53
25
                return USB_STOR_TRANSPORT_GOOD;
54
26
        }
55
 
                
 
27
 
56
28
        return USB_STOR_TRANSPORT_GOOD;
57
29
}
58
30
 
59
 
//----- MS_SCSI_Inquiry() --------------------------------------------------
 
31
/*
 
32
 * MS_SCSI_Inquiry()
 
33
 */
60
34
int MS_SCSI_Inquiry(struct us_data *us, struct scsi_cmnd *srb)
61
35
{
62
 
        //printk("MS_SCSI_Inquiry\n");
63
 
        BYTE data_ptr[36] = {0x00, 0x80, 0x02, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x55, 0x53, 0x42, 0x32, 0x2E, 0x30, 0x20, 0x20, 0x43, 0x61, 0x72, 0x64, 0x52, 0x65, 0x61, 0x64, 0x65, 0x72, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
 
36
        /* pr_info("MS_SCSI_Inquiry\n"); */
 
37
        BYTE data_ptr[36] = {0x00, 0x80, 0x02, 0x00, 0x1F, 0x00,
 
38
                                0x00, 0x00, 0x55, 0x53, 0x42, 0x32,
 
39
                                0x2E, 0x30, 0x20, 0x20, 0x43, 0x61,
 
40
                                0x72, 0x64, 0x52, 0x65, 0x61, 0x64,
 
41
                                0x65, 0x72, 0x20, 0x20, 0x20, 0x20,
 
42
                                0x20, 0x20, 0x30, 0x31, 0x30, 0x30};
64
43
 
65
44
        usb_stor_set_xfer_buf(us, data_ptr, 36, srb, TO_XFER_BUF);
66
45
        return USB_STOR_TRANSPORT_GOOD;
67
46
}
68
47
 
69
 
 
70
 
//----- MS_SCSI_Mode_Sense() --------------------------------------------------
 
48
/*
 
49
 * MS_SCSI_Mode_Sense()
 
50
 */
71
51
int MS_SCSI_Mode_Sense(struct us_data *us, struct scsi_cmnd *srb)
72
52
{
73
 
        BYTE    mediaNoWP[12] = {0x0b,0x00,0x00,0x08,0x00,0x00,0x71,0xc0,0x00,0x00,0x02,0x00};
74
 
        BYTE    mediaWP[12]   = {0x0b,0x00,0x80,0x08,0x00,0x00,0x71,0xc0,0x00,0x00,0x02,0x00};
 
53
        BYTE    mediaNoWP[12] = {0x0b, 0x00, 0x00, 0x08, 0x00, 0x00,
 
54
                                        0x71, 0xc0, 0x00, 0x00, 0x02, 0x00};
 
55
        BYTE    mediaWP[12]   = {0x0b, 0x00, 0x80, 0x08, 0x00, 0x00,
 
56
                                        0x71, 0xc0, 0x00, 0x00, 0x02, 0x00};
75
57
 
76
58
        if (us->MS_Status.WtP)
77
59
                usb_stor_set_xfer_buf(us, mediaWP, 12, srb, TO_XFER_BUF);
82
64
        return USB_STOR_TRANSPORT_GOOD;
83
65
}
84
66
 
85
 
//----- MS_SCSI_Read_Capacity() --------------------------------------------------
 
67
/*
 
68
 * MS_SCSI_Read_Capacity()
 
69
 */
86
70
int MS_SCSI_Read_Capacity(struct us_data *us, struct scsi_cmnd *srb)
87
71
{
88
72
        unsigned int offset = 0;
91
75
        WORD    bl_len;
92
76
        BYTE    buf[8];
93
77
 
94
 
        printk("MS_SCSI_Read_Capacity\n");
 
78
        pr_info("MS_SCSI_Read_Capacity\n");
95
79
 
96
80
        bl_len = 0x200;
97
 
        if ( us->MS_Status.IsMSPro )
 
81
        if (us->MS_Status.IsMSPro)
98
82
                bl_num = us->MSP_TotalBlock - 1;
99
83
        else
100
 
                bl_num = us->MS_Lib.NumberOfLogBlock * us->MS_Lib.blockSize * 2 - 1;
 
84
                bl_num = us->MS_Lib.NumberOfLogBlock *
 
85
                                us->MS_Lib.blockSize * 2 - 1;
101
86
 
102
87
        us->bl_num = bl_num;
103
 
        printk("bl_len = %x\n", bl_len);
104
 
        printk("bl_num = %x\n", bl_num);
105
 
 
106
 
        //srb->request_bufflen = 8;
107
 
        buf[0] = (bl_num>>24) & 0xff;
108
 
        buf[1] = (bl_num>>16) & 0xff;
109
 
        buf[2] = (bl_num>> 8) & 0xff;
110
 
        buf[3] = (bl_num>> 0) & 0xff;
111
 
        buf[4] = (bl_len>>24) & 0xff;
112
 
        buf[5] = (bl_len>>16) & 0xff;
113
 
        buf[6] = (bl_len>> 8) & 0xff;
114
 
        buf[7] = (bl_len>> 0) & 0xff;
115
 
        
 
88
        pr_info("bl_len = %x\n", bl_len);
 
89
        pr_info("bl_num = %x\n", bl_num);
 
90
 
 
91
        /* srb->request_bufflen = 8; */
 
92
        buf[0] = (bl_num >> 24) & 0xff;
 
93
        buf[1] = (bl_num >> 16) & 0xff;
 
94
        buf[2] = (bl_num >> 8) & 0xff;
 
95
        buf[3] = (bl_num >> 0) & 0xff;
 
96
        buf[4] = (bl_len >> 24) & 0xff;
 
97
        buf[5] = (bl_len >> 16) & 0xff;
 
98
        buf[6] = (bl_len >> 8) & 0xff;
 
99
        buf[7] = (bl_len >> 0) & 0xff;
 
100
 
116
101
        usb_stor_access_xfer_buf(us, buf, 8, srb, &sg, &offset, TO_XFER_BUF);
117
 
        //usb_stor_set_xfer_buf(us, buf, srb->request_bufflen, srb, TO_XFER_BUF);
 
102
        /* usb_stor_set_xfer_buf(us, buf, srb->request_bufflen,
 
103
                                                srb, TO_XFER_BUF); */
118
104
 
119
105
        return USB_STOR_TRANSPORT_GOOD;
120
106
}
121
107
 
122
 
//----- MS_SCSI_Read() --------------------------------------------------
 
108
/*
 
109
 * MS_SCSI_Read()
 
110
 */
123
111
int MS_SCSI_Read(struct us_data *us, struct scsi_cmnd *srb)
124
112
{
125
113
        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
126
 
        int result=0;
 
114
        int result = 0;
127
115
        PBYTE   Cdb = srb->cmnd;
128
 
        DWORD bn  =  ((Cdb[2]<<24) & 0xff000000) | ((Cdb[3]<<16) & 0x00ff0000) |
129
 
                   ((Cdb[4]<< 8) & 0x0000ff00) | ((Cdb[5]<< 0) & 0x000000ff);
130
 
        WORD  blen = ((Cdb[7]<< 8) & 0xff00)     | ((Cdb[8]<< 0) & 0x00ff);
 
116
        DWORD bn  =  ((Cdb[2] << 24) & 0xff000000) |
 
117
                        ((Cdb[3] << 16) & 0x00ff0000) |
 
118
                        ((Cdb[4] << 8) & 0x0000ff00) |
 
119
                        ((Cdb[5] << 0) & 0x000000ff);
 
120
        WORD  blen = ((Cdb[7] << 8) & 0xff00) | ((Cdb[8] << 0) & 0x00ff);
131
121
        DWORD   blenByte = blen * 0x200;
132
122
 
133
 
        //printk("SCSIOP_READ --- bn = %X, blen = %X, srb->use_sg = %X\n", bn, blen, srb->use_sg);
134
 
        
 
123
        /* pr_info("SCSIOP_READ --- bn = %X, blen = %X, srb->use_sg = %X\n",
 
124
                                                bn, blen, srb->use_sg); */
 
125
 
135
126
        if (bn > us->bl_num)
136
127
                return USB_STOR_TRANSPORT_ERROR;
137
128
 
138
 
        if (us->MS_Status.IsMSPro)
139
 
        {
 
129
        if (us->MS_Status.IsMSPro) {
140
130
                result = ENE_LoadBinCode(us, MSP_RW_PATTERN);
141
 
                if (result != USB_STOR_XFER_GOOD)
142
 
                {
143
 
                        printk("Load MSP RW pattern Fail !!\n");
 
131
                if (result != USB_STOR_XFER_GOOD) {
 
132
                        pr_info("Load MSP RW pattern Fail !!\n");
144
133
                        return USB_STOR_TRANSPORT_ERROR;
145
134
                }
146
135
 
147
 
                // set up the command wrapper
 
136
                /*  set up the command wrapper */
148
137
                memset(bcb, 0, sizeof(struct bulk_cb_wrap));
149
138
                bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
150
139
                bcb->DataTransferLength = blenByte;
157
146
                bcb->CDB[2] = (BYTE)(bn>>24);
158
147
 
159
148
                result = ENE_SendScsiCmd(us, FDIR_READ, scsi_sglist(srb), 1);
160
 
        }
161
 
        else
162
 
        {
 
149
        } else {
163
150
                void    *buf;
164
 
                int     offset=0;
 
151
                int     offset = 0;
165
152
                WORD    phyblk, logblk;
166
153
                BYTE    PageNum;
167
154
                WORD    len;
172
159
                        return USB_STOR_TRANSPORT_ERROR;
173
160
 
174
161
                result = ENE_LoadBinCode(us, MS_RW_PATTERN);
175
 
                if (result != USB_STOR_XFER_GOOD)
176
 
                {
177
 
                        printk("Load MS RW pattern Fail !!\n");
 
162
                if (result != USB_STOR_XFER_GOOD) {
 
163
                        pr_info("Load MS RW pattern Fail !!\n");
178
164
                        result = USB_STOR_TRANSPORT_ERROR;
179
165
                        goto exit;
180
166
                }
182
168
                logblk  = (WORD)(bn / us->MS_Lib.PagesPerBlock);
183
169
                PageNum = (BYTE)(bn % us->MS_Lib.PagesPerBlock);
184
170
 
185
 
                while(1)
186
 
                {
187
 
                        if (blen > (us->MS_Lib.PagesPerBlock-PageNum) )
 
171
                while (1) {
 
172
                        if (blen > (us->MS_Lib.PagesPerBlock-PageNum))
188
173
                                len = us->MS_Lib.PagesPerBlock-PageNum;
189
174
                        else
190
175
                                len = blen;
192
177
                        phyblk = MS_LibConv2Physical(us, logblk);
193
178
                        blkno  = phyblk * 0x20 + PageNum;
194
179
 
195
 
                        // set up the command wrapper
 
180
                        /* set up the command wrapper */
196
181
                        memset(bcb, 0, sizeof(struct bulk_cb_wrap));
197
182
                        bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
198
183
                        bcb->DataTransferLength = 0x200 * len;
205
190
                        bcb->CDB[2] = (BYTE)(blkno>>24);
206
191
 
207
192
                        result = ENE_SendScsiCmd(us, FDIR_READ, buf+offset, 0);
208
 
                        if (result != USB_STOR_XFER_GOOD)
209
 
                        {
210
 
                                printk("MS_SCSI_Read --- result = %x\n", result);
 
193
                        if (result != USB_STOR_XFER_GOOD) {
 
194
                                pr_info("MS_SCSI_Read --- result = %x\n",
 
195
                                                                result);
211
196
                                result =  USB_STOR_TRANSPORT_ERROR;
212
197
                                goto exit;
213
198
                        }
214
199
 
215
200
                        blen -= len;
216
 
                        if (blen<=0)
 
201
                        if (blen <= 0)
217
202
                                break;
218
203
                        logblk++;
219
204
                        PageNum = 0;
226
211
        return result;
227
212
}
228
213
 
229
 
//----- MS_SCSI_Write() --------------------------------------------------
 
214
/*
 
215
 * MS_SCSI_Write()
 
216
 */
230
217
int MS_SCSI_Write(struct us_data *us, struct scsi_cmnd *srb)
231
218
{
232
219
        struct bulk_cb_wrap *bcb = (struct bulk_cb_wrap *) us->iobuf;
233
 
        int result=0;
 
220
        int result = 0;
234
221
        PBYTE   Cdb = srb->cmnd;
235
 
        DWORD bn  =  ((Cdb[2]<<24) & 0xff000000) | ((Cdb[3]<<16) & 0x00ff0000) |
236
 
                   ((Cdb[4]<< 8) & 0x0000ff00) | ((Cdb[5]<< 0) & 0x000000ff);
237
 
        WORD  blen = ((Cdb[7]<< 8) & 0xff00)     | ((Cdb[8]<< 0) & 0x00ff);
 
222
        DWORD bn  = ((Cdb[2] << 24) & 0xff000000) |
 
223
                        ((Cdb[3] << 16) & 0x00ff0000) |
 
224
                        ((Cdb[4] << 8) & 0x0000ff00) |
 
225
                        ((Cdb[5] << 0) & 0x000000ff);
 
226
        WORD  blen = ((Cdb[7] << 8) & 0xff00)     | ((Cdb[8] << 0) & 0x00ff);
238
227
        DWORD   blenByte = blen * 0x200;
239
228
 
240
229
        if (bn > us->bl_num)
241
230
                return USB_STOR_TRANSPORT_ERROR;
242
231
 
243
 
        if (us->MS_Status.IsMSPro)
244
 
        {
 
232
        if (us->MS_Status.IsMSPro) {
245
233
                result = ENE_LoadBinCode(us, MSP_RW_PATTERN);
246
 
                if (result != USB_STOR_XFER_GOOD)
247
 
                {
248
 
                        printk("Load MSP RW pattern Fail !!\n");
 
234
                if (result != USB_STOR_XFER_GOOD) {
 
235
                        pr_info("Load MSP RW pattern Fail !!\n");
249
236
                        return USB_STOR_TRANSPORT_ERROR;
250
237
                }
251
238
 
252
 
                // set up the command wrapper
 
239
                /* set up the command wrapper */
253
240
                memset(bcb, 0, sizeof(struct bulk_cb_wrap));
254
241
                bcb->Signature = cpu_to_le32(US_BULK_CB_SIGN);
255
242
                bcb->DataTransferLength = blenByte;
262
249
                bcb->CDB[2] = (BYTE)(bn>>24);
263
250
 
264
251
                result = ENE_SendScsiCmd(us, FDIR_WRITE, scsi_sglist(srb), 1);
265
 
        }
266
 
        else
267
 
        {
 
252
        } else {
268
253
                void    *buf;
269
 
                int     offset=0;
 
254
                int     offset = 0;
270
255
                WORD    PhyBlockAddr;
271
256
                BYTE    PageNum;
272
257
                DWORD   result;
278
263
                usb_stor_set_xfer_buf(us, buf, blenByte, srb, FROM_XFER_BUF);
279
264
 
280
265
                result = ENE_LoadBinCode(us, MS_RW_PATTERN);
281
 
                if (result != USB_STOR_XFER_GOOD)
282
 
                {
283
 
                        printk("Load MS RW pattern Fail !!\n");
 
266
                if (result != USB_STOR_XFER_GOOD) {
 
267
                        pr_info("Load MS RW pattern Fail !!\n");
284
268
                        result = USB_STOR_TRANSPORT_ERROR;
285
269
                        goto exit;
286
270
                }
288
272
                PhyBlockAddr = (WORD)(bn / us->MS_Lib.PagesPerBlock);
289
273
                PageNum      = (BYTE)(bn % us->MS_Lib.PagesPerBlock);
290
274
 
291
 
                while(1)
292
 
                {
293
 
                        if (blen > (us->MS_Lib.PagesPerBlock-PageNum) )
 
275
                while (1) {
 
276
                        if (blen > (us->MS_Lib.PagesPerBlock-PageNum))
294
277
                                len = us->MS_Lib.PagesPerBlock-PageNum;
295
278
                        else
296
279
                                len = blen;
298
281
                        oldphy = MS_LibConv2Physical(us, PhyBlockAddr);
299
282
                        newphy = MS_LibSearchBlockFromLogical(us, PhyBlockAddr);
300
283
 
301
 
                        result = MS_ReaderCopyBlock(us, oldphy, newphy, PhyBlockAddr, PageNum, buf+offset, len);
302
 
                        if (result != USB_STOR_XFER_GOOD)
303
 
                        {
304
 
                                printk("MS_SCSI_Write --- result = %x\n", result);
 
284
                        result = MS_ReaderCopyBlock(us, oldphy, newphy,
 
285
                                                        PhyBlockAddr, PageNum,
 
286
                                                        buf+offset, len);
 
287
                        if (result != USB_STOR_XFER_GOOD) {
 
288
                                pr_info("MS_SCSI_Write --- result = %x\n",
 
289
                                                                result);
305
290
                                result =  USB_STOR_TRANSPORT_ERROR;
306
291
                                goto exit;
307
292
                        }
310
295
                        MS_LibForceSetLogicalPair(us, PhyBlockAddr, newphy);
311
296
 
312
297
                        blen -= len;
313
 
                        if (blen<=0)
 
298
                        if (blen <= 0)
314
299
                                break;
315
300
                        PhyBlockAddr++;
316
301
                        PageNum = 0;
322
307
        return result;
323
308
}
324
309
 
 
310
/*
 
311
 * MS_SCSIIrp()
 
312
 */
 
313
int MS_SCSIIrp(struct us_data *us, struct scsi_cmnd *srb)
 
314
{
 
315
        int    result;
 
316
 
 
317
        us->SrbStatus = SS_SUCCESS;
 
318
        switch (srb->cmnd[0]) {
 
319
        case TEST_UNIT_READY:
 
320
                result = MS_SCSI_Test_Unit_Ready(us, srb);
 
321
                break; /* 0x00 */
 
322
        case INQUIRY:
 
323
                result = MS_SCSI_Inquiry(us, srb);
 
324
                break; /* 0x12 */
 
325
        case MODE_SENSE:
 
326
                result = MS_SCSI_Mode_Sense(us, srb);
 
327
                break; /* 0x1A */
 
328
        case READ_CAPACITY:
 
329
                result = MS_SCSI_Read_Capacity(us, srb);
 
330
                break; /* 0x25 */
 
331
        case READ_10:
 
332
                result = MS_SCSI_Read(us, srb);
 
333
                break; /* 0x28 */
 
334
        case WRITE_10:
 
335
                result = MS_SCSI_Write(us, srb);
 
336
                break;  /* 0x2A */
 
337
        default:
 
338
                us->SrbStatus = SS_ILLEGAL_REQUEST;
 
339
                result = USB_STOR_TRANSPORT_FAILED;
 
340
                break;
 
341
        }
 
342
        return result;
 
343
}
 
344