]>
Commit | Line | Data |
---|---|---|
d52affa7 | 1 | #include "hw.h" |
2f792016 | 2 | #include "qemu-error.h" |
43b443b6 | 3 | #include "scsi.h" |
2ec749cb | 4 | #include "scsi-defs.h" |
d52affa7 GH |
5 | #include "qdev.h" |
6 | ||
7 | static struct BusInfo scsi_bus_info = { | |
8 | .name = "SCSI", | |
9 | .size = sizeof(SCSIBus), | |
10 | .props = (Property[]) { | |
11 | DEFINE_PROP_UINT32("scsi-id", SCSIDevice, id, -1), | |
12 | DEFINE_PROP_END_OF_LIST(), | |
13 | }, | |
14 | }; | |
15 | static int next_scsi_bus; | |
16 | ||
17 | /* Create a scsi bus, and attach devices to it. */ | |
ca9c39fa GH |
18 | void scsi_bus_new(SCSIBus *bus, DeviceState *host, int tcq, int ndev, |
19 | scsi_completionfn complete) | |
d52affa7 | 20 | { |
ca9c39fa | 21 | qbus_create_inplace(&bus->qbus, &scsi_bus_info, host, NULL); |
d52affa7 GH |
22 | bus->busnr = next_scsi_bus++; |
23 | bus->tcq = tcq; | |
24 | bus->ndev = ndev; | |
25 | bus->complete = complete; | |
cb23117b | 26 | bus->qbus.allow_hotplug = 1; |
d52affa7 GH |
27 | } |
28 | ||
29 | static int scsi_qdev_init(DeviceState *qdev, DeviceInfo *base) | |
30 | { | |
31 | SCSIDevice *dev = DO_UPCAST(SCSIDevice, qdev, qdev); | |
32 | SCSIDeviceInfo *info = DO_UPCAST(SCSIDeviceInfo, qdev, base); | |
33 | SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus); | |
01985dcf | 34 | int rc = -1; |
d52affa7 GH |
35 | |
36 | if (dev->id == -1) { | |
37 | for (dev->id = 0; dev->id < bus->ndev; dev->id++) { | |
38 | if (bus->devs[dev->id] == NULL) | |
39 | break; | |
40 | } | |
41 | } | |
42 | if (dev->id >= bus->ndev) { | |
1ecda02b | 43 | error_report("bad scsi device id: %d", dev->id); |
d52affa7 GH |
44 | goto err; |
45 | } | |
46 | ||
47 | if (bus->devs[dev->id]) { | |
01985dcf | 48 | qdev_free(&bus->devs[dev->id]->qdev); |
d52affa7 GH |
49 | } |
50 | bus->devs[dev->id] = dev; | |
51 | ||
52 | dev->info = info; | |
9af99d98 | 53 | QTAILQ_INIT(&dev->requests); |
01985dcf GH |
54 | rc = dev->info->init(dev); |
55 | if (rc != 0) { | |
56 | bus->devs[dev->id] = NULL; | |
57 | } | |
d52affa7 GH |
58 | |
59 | err: | |
01985dcf GH |
60 | return rc; |
61 | } | |
62 | ||
63 | static int scsi_qdev_exit(DeviceState *qdev) | |
64 | { | |
65 | SCSIDevice *dev = DO_UPCAST(SCSIDevice, qdev, qdev); | |
66 | SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus); | |
67 | ||
68 | assert(bus->devs[dev->id] != NULL); | |
69 | if (bus->devs[dev->id]->info->destroy) { | |
70 | bus->devs[dev->id]->info->destroy(bus->devs[dev->id]); | |
71 | } | |
72 | bus->devs[dev->id] = NULL; | |
73 | return 0; | |
d52affa7 GH |
74 | } |
75 | ||
76 | void scsi_qdev_register(SCSIDeviceInfo *info) | |
77 | { | |
78 | info->qdev.bus_info = &scsi_bus_info; | |
79 | info->qdev.init = scsi_qdev_init; | |
cb23117b | 80 | info->qdev.unplug = qdev_simple_unplug_cb; |
01985dcf | 81 | info->qdev.exit = scsi_qdev_exit; |
d52affa7 GH |
82 | qdev_register(&info->qdev); |
83 | } | |
84 | ||
85 | /* handle legacy '-drive if=scsi,...' cmd line args */ | |
86 | SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, DriveInfo *dinfo, int unit) | |
87 | { | |
88 | const char *driver; | |
89 | DeviceState *dev; | |
90 | ||
91 | driver = bdrv_is_sg(dinfo->bdrv) ? "scsi-generic" : "scsi-disk"; | |
92 | dev = qdev_create(&bus->qbus, driver); | |
93 | qdev_prop_set_uint32(dev, "scsi-id", unit); | |
94 | qdev_prop_set_drive(dev, "drive", dinfo); | |
33e66b86 MA |
95 | if (qdev_init(dev) < 0) |
96 | return NULL; | |
d52affa7 GH |
97 | return DO_UPCAST(SCSIDevice, qdev, dev); |
98 | } | |
99 | ||
fa66b909 | 100 | int scsi_bus_legacy_handle_cmdline(SCSIBus *bus) |
d52affa7 GH |
101 | { |
102 | DriveInfo *dinfo; | |
fa66b909 | 103 | int res = 0, unit; |
d52affa7 GH |
104 | |
105 | for (unit = 0; unit < MAX_SCSI_DEVS; unit++) { | |
106 | dinfo = drive_get(IF_SCSI, bus->busnr, unit); | |
107 | if (dinfo == NULL) { | |
108 | continue; | |
109 | } | |
fa66b909 MA |
110 | if (!scsi_bus_legacy_add_drive(bus, dinfo, unit)) { |
111 | res = -1; | |
112 | break; | |
113 | } | |
d52affa7 | 114 | } |
fa66b909 | 115 | return res; |
d52affa7 | 116 | } |
89b08ae1 | 117 | |
37659e51 GH |
118 | void scsi_dev_clear_sense(SCSIDevice *dev) |
119 | { | |
120 | memset(&dev->sense, 0, sizeof(dev->sense)); | |
121 | } | |
122 | ||
123 | void scsi_dev_set_sense(SCSIDevice *dev, uint8_t key) | |
124 | { | |
125 | dev->sense.key = key; | |
126 | } | |
127 | ||
89b08ae1 GH |
128 | SCSIRequest *scsi_req_alloc(size_t size, SCSIDevice *d, uint32_t tag, uint32_t lun) |
129 | { | |
130 | SCSIRequest *req; | |
131 | ||
132 | req = qemu_mallocz(size); | |
133 | req->bus = scsi_bus_from_device(d); | |
134 | req->dev = d; | |
135 | req->tag = tag; | |
136 | req->lun = lun; | |
ed3a34a3 | 137 | req->status = -1; |
89b08ae1 GH |
138 | QTAILQ_INSERT_TAIL(&d->requests, req, next); |
139 | return req; | |
140 | } | |
141 | ||
142 | SCSIRequest *scsi_req_find(SCSIDevice *d, uint32_t tag) | |
143 | { | |
144 | SCSIRequest *req; | |
145 | ||
146 | QTAILQ_FOREACH(req, &d->requests, next) { | |
147 | if (req->tag == tag) { | |
148 | return req; | |
149 | } | |
150 | } | |
151 | return NULL; | |
152 | } | |
153 | ||
154 | void scsi_req_free(SCSIRequest *req) | |
155 | { | |
156 | QTAILQ_REMOVE(&req->dev->requests, req, next); | |
157 | qemu_free(req); | |
158 | } | |
2ec749cb GH |
159 | |
160 | static int scsi_req_length(SCSIRequest *req, uint8_t *cmd) | |
161 | { | |
162 | switch (cmd[0] >> 5) { | |
163 | case 0: | |
164 | req->cmd.xfer = cmd[4]; | |
165 | req->cmd.len = 6; | |
166 | /* length 0 means 256 blocks */ | |
167 | if (req->cmd.xfer == 0) | |
168 | req->cmd.xfer = 256; | |
169 | break; | |
170 | case 1: | |
171 | case 2: | |
172 | req->cmd.xfer = cmd[8] | (cmd[7] << 8); | |
173 | req->cmd.len = 10; | |
174 | break; | |
175 | case 4: | |
176 | req->cmd.xfer = cmd[13] | (cmd[12] << 8) | (cmd[11] << 16) | (cmd[10] << 24); | |
177 | req->cmd.len = 16; | |
178 | break; | |
179 | case 5: | |
180 | req->cmd.xfer = cmd[9] | (cmd[8] << 8) | (cmd[7] << 16) | (cmd[6] << 24); | |
181 | req->cmd.len = 12; | |
182 | break; | |
183 | default: | |
184 | return -1; | |
185 | } | |
186 | ||
187 | switch(cmd[0]) { | |
188 | case TEST_UNIT_READY: | |
189 | case REZERO_UNIT: | |
190 | case START_STOP: | |
191 | case SEEK_6: | |
192 | case WRITE_FILEMARKS: | |
193 | case SPACE: | |
194 | case ERASE: | |
195 | case ALLOW_MEDIUM_REMOVAL: | |
196 | case VERIFY: | |
197 | case SEEK_10: | |
198 | case SYNCHRONIZE_CACHE: | |
199 | case LOCK_UNLOCK_CACHE: | |
200 | case LOAD_UNLOAD: | |
201 | case SET_CD_SPEED: | |
202 | case SET_LIMITS: | |
203 | case WRITE_LONG: | |
204 | case MOVE_MEDIUM: | |
205 | case UPDATE_BLOCK: | |
206 | req->cmd.xfer = 0; | |
207 | break; | |
208 | case MODE_SENSE: | |
209 | break; | |
210 | case WRITE_SAME: | |
211 | req->cmd.xfer = 1; | |
212 | break; | |
213 | case READ_CAPACITY: | |
214 | req->cmd.xfer = 8; | |
215 | break; | |
216 | case READ_BLOCK_LIMITS: | |
217 | req->cmd.xfer = 6; | |
218 | break; | |
219 | case READ_POSITION: | |
220 | req->cmd.xfer = 20; | |
221 | break; | |
222 | case SEND_VOLUME_TAG: | |
223 | req->cmd.xfer *= 40; | |
224 | break; | |
225 | case MEDIUM_SCAN: | |
226 | req->cmd.xfer *= 8; | |
227 | break; | |
228 | case WRITE_10: | |
229 | case WRITE_VERIFY: | |
230 | case WRITE_6: | |
231 | case WRITE_12: | |
232 | case WRITE_VERIFY_12: | |
bd536cf3 GH |
233 | case WRITE_16: |
234 | case WRITE_VERIFY_16: | |
2ec749cb GH |
235 | req->cmd.xfer *= req->dev->blocksize; |
236 | break; | |
237 | case READ_10: | |
238 | case READ_6: | |
239 | case READ_REVERSE: | |
240 | case RECOVER_BUFFERED_DATA: | |
241 | case READ_12: | |
bd536cf3 | 242 | case READ_16: |
2ec749cb GH |
243 | req->cmd.xfer *= req->dev->blocksize; |
244 | break; | |
245 | case INQUIRY: | |
246 | req->cmd.xfer = cmd[4] | (cmd[3] << 8); | |
247 | break; | |
c7126d5b NB |
248 | case MAINTENANCE_OUT: |
249 | case MAINTENANCE_IN: | |
250 | if (req->dev->type == TYPE_ROM) { | |
251 | /* GPCMD_REPORT_KEY and GPCMD_SEND_KEY from multi media commands */ | |
252 | req->cmd.xfer = cmd[9] | (cmd[8] << 8); | |
253 | } | |
254 | break; | |
2ec749cb GH |
255 | } |
256 | return 0; | |
257 | } | |
258 | ||
259 | static int scsi_req_stream_length(SCSIRequest *req, uint8_t *cmd) | |
260 | { | |
261 | switch(cmd[0]) { | |
262 | /* stream commands */ | |
263 | case READ_6: | |
264 | case READ_REVERSE: | |
265 | case RECOVER_BUFFERED_DATA: | |
266 | case WRITE_6: | |
267 | req->cmd.len = 6; | |
268 | req->cmd.xfer = cmd[4] | (cmd[3] << 8) | (cmd[2] << 16); | |
269 | if (cmd[1] & 0x01) /* fixed */ | |
270 | req->cmd.xfer *= req->dev->blocksize; | |
271 | break; | |
272 | case REWIND: | |
273 | case START_STOP: | |
274 | req->cmd.len = 6; | |
275 | req->cmd.xfer = 0; | |
276 | break; | |
277 | /* generic commands */ | |
278 | default: | |
279 | return scsi_req_length(req, cmd); | |
280 | } | |
281 | return 0; | |
282 | } | |
283 | ||
97a06435 GH |
284 | static void scsi_req_xfer_mode(SCSIRequest *req) |
285 | { | |
286 | switch (req->cmd.buf[0]) { | |
287 | case WRITE_6: | |
288 | case WRITE_10: | |
289 | case WRITE_VERIFY: | |
290 | case WRITE_12: | |
291 | case WRITE_VERIFY_12: | |
bd536cf3 GH |
292 | case WRITE_16: |
293 | case WRITE_VERIFY_16: | |
97a06435 GH |
294 | case COPY: |
295 | case COPY_VERIFY: | |
296 | case COMPARE: | |
297 | case CHANGE_DEFINITION: | |
298 | case LOG_SELECT: | |
299 | case MODE_SELECT: | |
300 | case MODE_SELECT_10: | |
301 | case SEND_DIAGNOSTIC: | |
302 | case WRITE_BUFFER: | |
303 | case FORMAT_UNIT: | |
304 | case REASSIGN_BLOCKS: | |
305 | case RESERVE: | |
306 | case SEARCH_EQUAL: | |
307 | case SEARCH_HIGH: | |
308 | case SEARCH_LOW: | |
309 | case UPDATE_BLOCK: | |
310 | case WRITE_LONG: | |
311 | case WRITE_SAME: | |
312 | case SEARCH_HIGH_12: | |
313 | case SEARCH_EQUAL_12: | |
314 | case SEARCH_LOW_12: | |
315 | case SET_WINDOW: | |
316 | case MEDIUM_SCAN: | |
317 | case SEND_VOLUME_TAG: | |
318 | case WRITE_LONG_2: | |
01bedeba | 319 | case PERSISTENT_RESERVE_OUT: |
c7126d5b | 320 | case MAINTENANCE_OUT: |
97a06435 GH |
321 | req->cmd.mode = SCSI_XFER_TO_DEV; |
322 | break; | |
323 | default: | |
324 | if (req->cmd.xfer) | |
325 | req->cmd.mode = SCSI_XFER_FROM_DEV; | |
326 | else { | |
327 | req->cmd.mode = SCSI_XFER_NONE; | |
328 | } | |
329 | break; | |
330 | } | |
331 | } | |
332 | ||
2ec749cb GH |
333 | static uint64_t scsi_req_lba(SCSIRequest *req) |
334 | { | |
335 | uint8_t *buf = req->cmd.buf; | |
336 | uint64_t lba; | |
337 | ||
338 | switch (buf[0] >> 5) { | |
339 | case 0: | |
340 | lba = (uint64_t) buf[3] | ((uint64_t) buf[2] << 8) | | |
341 | (((uint64_t) buf[1] & 0x1f) << 16); | |
342 | break; | |
343 | case 1: | |
344 | case 2: | |
345 | lba = (uint64_t) buf[5] | ((uint64_t) buf[4] << 8) | | |
346 | ((uint64_t) buf[3] << 16) | ((uint64_t) buf[2] << 24); | |
347 | break; | |
348 | case 4: | |
349 | lba = (uint64_t) buf[9] | ((uint64_t) buf[8] << 8) | | |
350 | ((uint64_t) buf[7] << 16) | ((uint64_t) buf[6] << 24) | | |
351 | ((uint64_t) buf[5] << 32) | ((uint64_t) buf[4] << 40) | | |
352 | ((uint64_t) buf[3] << 48) | ((uint64_t) buf[2] << 56); | |
353 | break; | |
354 | case 5: | |
355 | lba = (uint64_t) buf[5] | ((uint64_t) buf[4] << 8) | | |
356 | ((uint64_t) buf[3] << 16) | ((uint64_t) buf[2] << 24); | |
357 | break; | |
358 | default: | |
359 | lba = -1; | |
360 | ||
361 | } | |
362 | return lba; | |
363 | } | |
364 | ||
365 | int scsi_req_parse(SCSIRequest *req, uint8_t *buf) | |
366 | { | |
367 | int rc; | |
368 | ||
369 | if (req->dev->type == TYPE_TAPE) { | |
370 | rc = scsi_req_stream_length(req, buf); | |
371 | } else { | |
372 | rc = scsi_req_length(req, buf); | |
373 | } | |
374 | if (rc != 0) | |
375 | return rc; | |
376 | ||
377 | memcpy(req->cmd.buf, buf, req->cmd.len); | |
97a06435 | 378 | scsi_req_xfer_mode(req); |
2ec749cb GH |
379 | req->cmd.lba = scsi_req_lba(req); |
380 | return 0; | |
381 | } | |
ed3a34a3 | 382 | |
ec766865 GH |
383 | static const char *scsi_command_name(uint8_t cmd) |
384 | { | |
385 | static const char *names[] = { | |
386 | [ TEST_UNIT_READY ] = "TEST_UNIT_READY", | |
387 | [ REZERO_UNIT ] = "REZERO_UNIT", | |
545557d4 | 388 | /* REWIND and REZERO_UNIT use the same operation code */ |
ec766865 GH |
389 | [ REQUEST_SENSE ] = "REQUEST_SENSE", |
390 | [ FORMAT_UNIT ] = "FORMAT_UNIT", | |
391 | [ READ_BLOCK_LIMITS ] = "READ_BLOCK_LIMITS", | |
392 | [ REASSIGN_BLOCKS ] = "REASSIGN_BLOCKS", | |
393 | [ READ_6 ] = "READ_6", | |
394 | [ WRITE_6 ] = "WRITE_6", | |
395 | [ SEEK_6 ] = "SEEK_6", | |
396 | [ READ_REVERSE ] = "READ_REVERSE", | |
397 | [ WRITE_FILEMARKS ] = "WRITE_FILEMARKS", | |
398 | [ SPACE ] = "SPACE", | |
399 | [ INQUIRY ] = "INQUIRY", | |
400 | [ RECOVER_BUFFERED_DATA ] = "RECOVER_BUFFERED_DATA", | |
c7126d5b NB |
401 | [ MAINTENANCE_IN ] = "MAINTENANCE_IN", |
402 | [ MAINTENANCE_OUT ] = "MAINTENANCE_OUT", | |
ec766865 GH |
403 | [ MODE_SELECT ] = "MODE_SELECT", |
404 | [ RESERVE ] = "RESERVE", | |
405 | [ RELEASE ] = "RELEASE", | |
406 | [ COPY ] = "COPY", | |
407 | [ ERASE ] = "ERASE", | |
408 | [ MODE_SENSE ] = "MODE_SENSE", | |
409 | [ START_STOP ] = "START_STOP", | |
410 | [ RECEIVE_DIAGNOSTIC ] = "RECEIVE_DIAGNOSTIC", | |
411 | [ SEND_DIAGNOSTIC ] = "SEND_DIAGNOSTIC", | |
412 | [ ALLOW_MEDIUM_REMOVAL ] = "ALLOW_MEDIUM_REMOVAL", | |
413 | ||
414 | [ SET_WINDOW ] = "SET_WINDOW", | |
415 | [ READ_CAPACITY ] = "READ_CAPACITY", | |
416 | [ READ_10 ] = "READ_10", | |
417 | [ WRITE_10 ] = "WRITE_10", | |
418 | [ SEEK_10 ] = "SEEK_10", | |
419 | [ WRITE_VERIFY ] = "WRITE_VERIFY", | |
420 | [ VERIFY ] = "VERIFY", | |
421 | [ SEARCH_HIGH ] = "SEARCH_HIGH", | |
422 | [ SEARCH_EQUAL ] = "SEARCH_EQUAL", | |
423 | [ SEARCH_LOW ] = "SEARCH_LOW", | |
424 | [ SET_LIMITS ] = "SET_LIMITS", | |
425 | [ PRE_FETCH ] = "PRE_FETCH", | |
545557d4 | 426 | /* READ_POSITION and PRE_FETCH use the same operation code */ |
ec766865 GH |
427 | [ SYNCHRONIZE_CACHE ] = "SYNCHRONIZE_CACHE", |
428 | [ LOCK_UNLOCK_CACHE ] = "LOCK_UNLOCK_CACHE", | |
429 | [ READ_DEFECT_DATA ] = "READ_DEFECT_DATA", | |
430 | [ MEDIUM_SCAN ] = "MEDIUM_SCAN", | |
431 | [ COMPARE ] = "COMPARE", | |
432 | [ COPY_VERIFY ] = "COPY_VERIFY", | |
433 | [ WRITE_BUFFER ] = "WRITE_BUFFER", | |
434 | [ READ_BUFFER ] = "READ_BUFFER", | |
435 | [ UPDATE_BLOCK ] = "UPDATE_BLOCK", | |
436 | [ READ_LONG ] = "READ_LONG", | |
437 | [ WRITE_LONG ] = "WRITE_LONG", | |
438 | [ CHANGE_DEFINITION ] = "CHANGE_DEFINITION", | |
439 | [ WRITE_SAME ] = "WRITE_SAME", | |
440 | [ READ_TOC ] = "READ_TOC", | |
441 | [ LOG_SELECT ] = "LOG_SELECT", | |
442 | [ LOG_SENSE ] = "LOG_SENSE", | |
443 | [ MODE_SELECT_10 ] = "MODE_SELECT_10", | |
444 | [ RESERVE_10 ] = "RESERVE_10", | |
445 | [ RELEASE_10 ] = "RELEASE_10", | |
446 | [ MODE_SENSE_10 ] = "MODE_SENSE_10", | |
447 | [ PERSISTENT_RESERVE_IN ] = "PERSISTENT_RESERVE_IN", | |
448 | [ PERSISTENT_RESERVE_OUT ] = "PERSISTENT_RESERVE_OUT", | |
449 | [ MOVE_MEDIUM ] = "MOVE_MEDIUM", | |
450 | [ READ_12 ] = "READ_12", | |
451 | [ WRITE_12 ] = "WRITE_12", | |
452 | [ WRITE_VERIFY_12 ] = "WRITE_VERIFY_12", | |
453 | [ SEARCH_HIGH_12 ] = "SEARCH_HIGH_12", | |
454 | [ SEARCH_EQUAL_12 ] = "SEARCH_EQUAL_12", | |
455 | [ SEARCH_LOW_12 ] = "SEARCH_LOW_12", | |
456 | [ READ_ELEMENT_STATUS ] = "READ_ELEMENT_STATUS", | |
457 | [ SEND_VOLUME_TAG ] = "SEND_VOLUME_TAG", | |
458 | [ WRITE_LONG_2 ] = "WRITE_LONG_2", | |
459 | ||
ec766865 | 460 | [ REPORT_DENSITY_SUPPORT ] = "REPORT_DENSITY_SUPPORT", |
38215553 | 461 | [ GET_CONFIGURATION ] = "GET_CONFIGURATION", |
bd536cf3 GH |
462 | [ READ_16 ] = "READ_16", |
463 | [ WRITE_16 ] = "WRITE_16", | |
464 | [ WRITE_VERIFY_16 ] = "WRITE_VERIFY_16", | |
5dd90e2a | 465 | [ SERVICE_ACTION_IN ] = "SERVICE_ACTION_IN", |
39ec9a50 | 466 | [ REPORT_LUNS ] = "REPORT_LUNS", |
ec766865 GH |
467 | [ LOAD_UNLOAD ] = "LOAD_UNLOAD", |
468 | [ SET_CD_SPEED ] = "SET_CD_SPEED", | |
469 | [ BLANK ] = "BLANK", | |
470 | }; | |
471 | ||
472 | if (cmd >= ARRAY_SIZE(names) || names[cmd] == NULL) | |
473 | return "*UNKNOWN*"; | |
474 | return names[cmd]; | |
475 | } | |
476 | ||
477 | void scsi_req_print(SCSIRequest *req) | |
478 | { | |
479 | FILE *fp = stderr; | |
480 | int i; | |
481 | ||
482 | fprintf(fp, "[%s id=%d] %s", | |
483 | req->dev->qdev.parent_bus->name, | |
484 | req->dev->id, | |
485 | scsi_command_name(req->cmd.buf[0])); | |
486 | for (i = 1; i < req->cmd.len; i++) { | |
487 | fprintf(fp, " 0x%02x", req->cmd.buf[i]); | |
488 | } | |
489 | switch (req->cmd.mode) { | |
490 | case SCSI_XFER_NONE: | |
491 | fprintf(fp, " - none\n"); | |
492 | break; | |
493 | case SCSI_XFER_FROM_DEV: | |
494 | fprintf(fp, " - from-dev len=%zd\n", req->cmd.xfer); | |
495 | break; | |
496 | case SCSI_XFER_TO_DEV: | |
497 | fprintf(fp, " - to-dev len=%zd\n", req->cmd.xfer); | |
498 | break; | |
499 | default: | |
500 | fprintf(fp, " - Oops\n"); | |
501 | break; | |
502 | } | |
503 | } | |
504 | ||
ed3a34a3 GH |
505 | void scsi_req_complete(SCSIRequest *req) |
506 | { | |
507 | assert(req->status != -1); | |
508 | req->bus->complete(req->bus, SCSI_REASON_DONE, | |
509 | req->tag, | |
510 | req->status); | |
511 | } |