1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
// Code for handling USB Mass Storage Controller devices.
//
// Copyright (C) 2010 Kevin O'Connor <kevin@koconnor.net>
//
// This file may be distributed under the terms of the GNU LGPLv3 license.
#include "util.h" // dprintf
#include "config.h" // CONFIG_USB_MSC
#include "usb-msc.h" // usb_msc_init
#include "usb.h" // struct usb_s
#include "biosvar.h" // GET_GLOBAL
#include "blockcmd.h" // cdb_read
#include "disk.h" // DTYPE_USB
#include "boot.h" // boot_add_hd
struct usbdrive_s {
struct drive_s drive;
struct usb_pipe *bulkin, *bulkout;
};
/****************************************************************
* Bulk-only drive command processing
****************************************************************/
#define USB_CDB_SIZE 12
#define CBW_SIGNATURE 0x43425355 // USBC
struct cbw_s {
u32 dCBWSignature;
u32 dCBWTag;
u32 dCBWDataTransferLength;
u8 bmCBWFlags;
u8 bCBWLUN;
u8 bCBWCBLength;
u8 CBWCB[16];
} PACKED;
#define CSW_SIGNATURE 0x53425355 // USBS
struct csw_s {
u32 dCSWSignature;
u32 dCSWTag;
u32 dCSWDataResidue;
u8 bCSWStatus;
} PACKED;
// Low-level usb command transmit function.
int
usb_cmd_data(struct disk_op_s *op, void *cdbcmd, u16 blocksize)
{
if (!CONFIG_USB_MSC)
return 0;
dprintf(16, "usb_cmd_data id=%p write=%d count=%d bs=%d buf=%p\n"
, op->drive_g, 0, op->count, blocksize, op->buf_fl);
struct usbdrive_s *udrive_g = container_of(
op->drive_g, struct usbdrive_s, drive);
struct usb_pipe *bulkin = GET_GLOBAL(udrive_g->bulkin);
struct usb_pipe *bulkout = GET_GLOBAL(udrive_g->bulkout);
// Setup command block wrapper.
u32 bytes = blocksize * op->count;
struct cbw_s cbw;
memset(&cbw, 0, sizeof(cbw));
cbw.dCBWSignature = CBW_SIGNATURE;
cbw.dCBWTag = 999; // XXX
cbw.dCBWDataTransferLength = bytes;
cbw.bmCBWFlags = USB_DIR_IN; // XXX
cbw.bCBWLUN = 0; // XXX
cbw.bCBWCBLength = USB_CDB_SIZE;
memcpy(cbw.CBWCB, cdbcmd, USB_CDB_SIZE);
// Transfer cbw to device.
int ret = usb_send_bulk(bulkout, USB_DIR_OUT
, MAKE_FLATPTR(GET_SEG(SS), &cbw), sizeof(cbw));
if (ret)
goto fail;
// Transfer data from device.
ret = usb_send_bulk(bulkin, USB_DIR_IN, op->buf_fl, bytes);
if (ret)
goto fail;
// Transfer csw info.
struct csw_s csw;
ret = usb_send_bulk(bulkin, USB_DIR_IN
, MAKE_FLATPTR(GET_SEG(SS), &csw), sizeof(csw));
if (ret)
goto fail;
if (!csw.bCSWStatus)
return DISK_RET_SUCCESS;
if (csw.bCSWStatus == 2)
goto fail;
op->count -= csw.dCSWDataResidue / blocksize;
return DISK_RET_EBADTRACK;
fail:
// XXX - reset connection
dprintf(1, "USB transmission failed\n");
op->count = 0;
return DISK_RET_EBADTRACK;
}
/****************************************************************
* Drive ops
****************************************************************/
// 16bit command demuxer for ATAPI cdroms.
int
process_usb_op(struct disk_op_s *op)
{
if (!CONFIG_USB_MSC)
return 0;
switch (op->command) {
case CMD_READ:
return cdb_read(op);
case CMD_FORMAT:
case CMD_WRITE:
return DISK_RET_EWRITEPROTECT;
case CMD_RESET:
case CMD_ISREADY:
case CMD_VERIFY:
case CMD_SEEK:
return DISK_RET_SUCCESS;
default:
op->count = 0;
return DISK_RET_EPARAM;
}
}
/****************************************************************
* Setup
****************************************************************/
static int
setup_drive_cdrom(struct disk_op_s *op, char *desc)
{
op->drive_g->blksize = CDROM_SECTOR_SIZE;
op->drive_g->sectors = (u64)-1;
boot_add_cd(op->drive_g, desc, -1);
return 0;
}
static int
setup_drive_hd(struct disk_op_s *op, char *desc)
{
struct cdbres_read_capacity info;
int ret = cdb_read_capacity(op, &info);
if (ret)
return ret;
// XXX - retry for some timeout?
u32 blksize = ntohl(info.blksize), sectors = ntohl(info.sectors);
if (blksize != DISK_SECTOR_SIZE) {
if (blksize == CDROM_SECTOR_SIZE)
return setup_drive_cdrom(op, desc);
dprintf(1, "Unsupported USB MSC block size %d\n", blksize);
return -1;
}
op->drive_g->blksize = blksize;
op->drive_g->sectors = sectors;
dprintf(1, "USB MSC blksize=%d sectors=%d\n", blksize, sectors);
// Register with bcv system.
boot_add_hd(op->drive_g, desc, -1);
return 0;
}
// Configure a usb msc device.
int
usb_msc_init(struct usb_pipe *pipe
, struct usb_interface_descriptor *iface, int imax)
{
if (!CONFIG_USB_MSC)
return -1;
// Verify right kind of device
if ((iface->bInterfaceSubClass != US_SC_SCSI &&
iface->bInterfaceSubClass != US_SC_ATAPI_8070 &&
iface->bInterfaceSubClass != US_SC_ATAPI_8020)
|| iface->bInterfaceProtocol != US_PR_BULK) {
dprintf(1, "Unsupported MSC USB device (subclass=%02x proto=%02x)\n"
, iface->bInterfaceSubClass, iface->bInterfaceProtocol);
return -1;
}
// Allocate drive structure.
struct usbdrive_s *udrive_g = malloc_fseg(sizeof(*udrive_g));
if (!udrive_g) {
warn_noalloc();
goto fail;
}
memset(udrive_g, 0, sizeof(*udrive_g));
udrive_g->drive.type = DTYPE_USB;
// Find bulk in and bulk out endpoints.
struct usb_endpoint_descriptor *indesc = findEndPointDesc(
iface, imax, USB_ENDPOINT_XFER_BULK, USB_DIR_IN);
struct usb_endpoint_descriptor *outdesc = findEndPointDesc(
iface, imax, USB_ENDPOINT_XFER_BULK, USB_DIR_OUT);
if (!indesc || !outdesc)
goto fail;
udrive_g->bulkin = alloc_bulk_pipe(pipe, indesc);
udrive_g->bulkout = alloc_bulk_pipe(pipe, outdesc);
if (!udrive_g->bulkin || !udrive_g->bulkout)
goto fail;
// Validate drive and find block size and sector count.
struct disk_op_s dop;
memset(&dop, 0, sizeof(dop));
dop.drive_g = &udrive_g->drive;
struct cdbres_inquiry data;
int ret = cdb_get_inquiry(&dop, &data);
if (ret)
goto fail;
char vendor[sizeof(data.vendor)+1], product[sizeof(data.product)+1];
char rev[sizeof(data.rev)+1];
int pdt = data.pdt & 0x1f;
int removable = !!(data.removable & 0x80);
dprintf(1, "USB MSC vendor='%s' product='%s' rev='%s'"
" type=%d removable=%d\n"
, strtcpy(vendor, data.vendor, sizeof(vendor))
, strtcpy(product, data.product, sizeof(product))
, strtcpy(rev, data.rev, sizeof(rev))
, pdt, removable);
udrive_g->drive.removable = removable;
if (pdt == USB_MSC_TYPE_CDROM) {
char *desc = znprintf(MAXDESCSIZE, "DVD/CD [USB Drive %s %s %s]"
, vendor, product, rev);
ret = setup_drive_cdrom(&dop, desc);
} else {
char *desc = znprintf(MAXDESCSIZE, "USB Drive %s %s %s"
, vendor, product, rev);
ret = setup_drive_hd(&dop, desc);
}
if (ret)
goto fail;
return 0;
fail:
dprintf(1, "Unable to configure USB MSC device.\n");
free(udrive_g);
return -1;
}
|
