2 * Generic SCSI Device support
4 * Copyright (c) 2007 Bull S.A.S.
5 * Based on code by Paul Brook
6 * Based on code by Fabrice Bellard
8 * Written by Laurent Vivier <Laurent.Vivier@bull.net>
10 * This code is licensed under the LGPL.
14 #include "qemu/osdep.h"
15 #include "qapi/error.h"
16 #include "qemu-common.h"
17 #include "qemu/error-report.h"
18 #include "hw/scsi/scsi.h"
19 #include "hw/scsi/emulation.h"
20 #include "sysemu/block-backend.h"
27 #define DPRINTF(fmt, ...) \
28 do { printf("scsi-generic: " fmt , ## __VA_ARGS__); } while (0)
30 #define DPRINTF(fmt, ...) do {} while(0)
33 #define BADF(fmt, ...) \
34 do { fprintf(stderr, "scsi-generic: " fmt , ## __VA_ARGS__); } while (0)
37 #include "scsi/constants.h"
40 #define MAX_UINT ((unsigned int)-1)
43 typedef struct SCSIGenericReq
{
48 sg_io_hdr_t io_header
;
51 static void scsi_generic_save_request(QEMUFile
*f
, SCSIRequest
*req
)
53 SCSIGenericReq
*r
= DO_UPCAST(SCSIGenericReq
, req
, req
);
55 qemu_put_sbe32s(f
, &r
->buflen
);
56 if (r
->buflen
&& r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
58 qemu_put_buffer(f
, r
->buf
, r
->req
.cmd
.xfer
);
62 static void scsi_generic_load_request(QEMUFile
*f
, SCSIRequest
*req
)
64 SCSIGenericReq
*r
= DO_UPCAST(SCSIGenericReq
, req
, req
);
66 qemu_get_sbe32s(f
, &r
->buflen
);
67 if (r
->buflen
&& r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
69 qemu_get_buffer(f
, r
->buf
, r
->req
.cmd
.xfer
);
73 static void scsi_free_request(SCSIRequest
*req
)
75 SCSIGenericReq
*r
= DO_UPCAST(SCSIGenericReq
, req
, req
);
80 /* Helper function for command completion. */
81 static void scsi_command_complete_noio(SCSIGenericReq
*r
, int ret
)
86 assert(r
->req
.aiocb
== NULL
);
88 if (r
->req
.io_canceled
) {
89 scsi_req_cancel_complete(&r
->req
);
92 status
= sg_io_sense_from_errno(-ret
, &r
->io_header
, &sense
);
93 if (status
== CHECK_CONDITION
) {
94 if (r
->io_header
.driver_status
& SG_ERR_DRIVER_SENSE
) {
95 r
->req
.sense_len
= r
->io_header
.sb_len_wr
;
97 scsi_req_build_sense(&r
->req
, sense
);
101 DPRINTF("Command complete 0x%p tag=0x%x status=%d\n",
102 r
, r
->req
.tag
, status
);
104 scsi_req_complete(&r
->req
, status
);
106 scsi_req_unref(&r
->req
);
109 static void scsi_command_complete(void *opaque
, int ret
)
111 SCSIGenericReq
*r
= (SCSIGenericReq
*)opaque
;
112 SCSIDevice
*s
= r
->req
.dev
;
114 assert(r
->req
.aiocb
!= NULL
);
117 aio_context_acquire(blk_get_aio_context(s
->conf
.blk
));
118 scsi_command_complete_noio(r
, ret
);
119 aio_context_release(blk_get_aio_context(s
->conf
.blk
));
122 static int execute_command(BlockBackend
*blk
,
123 SCSIGenericReq
*r
, int direction
,
124 BlockCompletionFunc
*complete
)
126 r
->io_header
.interface_id
= 'S';
127 r
->io_header
.dxfer_direction
= direction
;
128 r
->io_header
.dxferp
= r
->buf
;
129 r
->io_header
.dxfer_len
= r
->buflen
;
130 r
->io_header
.cmdp
= r
->req
.cmd
.buf
;
131 r
->io_header
.cmd_len
= r
->req
.cmd
.len
;
132 r
->io_header
.mx_sb_len
= sizeof(r
->req
.sense
);
133 r
->io_header
.sbp
= r
->req
.sense
;
134 r
->io_header
.timeout
= MAX_UINT
;
135 r
->io_header
.usr_ptr
= r
;
136 r
->io_header
.flags
|= SG_FLAG_DIRECT_IO
;
138 r
->req
.aiocb
= blk_aio_ioctl(blk
, SG_IO
, &r
->io_header
, complete
, r
);
139 if (r
->req
.aiocb
== NULL
) {
146 static void scsi_handle_inquiry_reply(SCSIGenericReq
*r
, SCSIDevice
*s
)
148 uint8_t page
, page_idx
;
151 * EVPD set to zero returns the standard INQUIRY data.
153 * Check if scsi_version is unset (-1) to avoid re-defining it
154 * each time an INQUIRY with standard data is received.
155 * scsi_version is initialized with -1 in scsi_generic_reset
156 * and scsi_disk_reset, making sure that we'll set the
157 * scsi_version after a reset. If the version field of the
158 * INQUIRY response somehow changes after a guest reboot,
159 * we'll be able to keep track of it.
161 * On SCSI-2 and older, first 3 bits of byte 2 is the
162 * ANSI-approved version, while on later versions the
163 * whole byte 2 contains the version. Check if we're dealing
164 * with a newer version and, in that case, assign the
167 if (s
->scsi_version
== -1 && !(r
->req
.cmd
.buf
[1] & 0x01)) {
168 s
->scsi_version
= r
->buf
[2] & 0x07;
169 if (s
->scsi_version
> 2) {
170 s
->scsi_version
= r
->buf
[2];
174 if (s
->type
== TYPE_DISK
&& (r
->req
.cmd
.buf
[1] & 0x01)) {
175 page
= r
->req
.cmd
.buf
[2];
177 uint32_t max_transfer
=
178 blk_get_max_transfer(s
->conf
.blk
) / s
->blocksize
;
180 assert(max_transfer
);
181 stl_be_p(&r
->buf
[8], max_transfer
);
182 /* Also take care of the opt xfer len. */
183 stl_be_p(&r
->buf
[12],
184 MIN_NON_ZERO(max_transfer
, ldl_be_p(&r
->buf
[12])));
185 } else if (s
->needs_vpd_bl_emulation
&& page
== 0x00) {
187 * Now we're capable of supplying the VPD Block Limits
188 * response if the hardware can't. Add it in the INQUIRY
189 * Supported VPD pages response in case we are using the
190 * emulation for this device.
192 * This way, the guest kernel will be aware of the support
193 * and will use it to proper setup the SCSI device.
195 * VPD page numbers must be sorted, so insert 0xb0 at the
196 * right place with an in-place insert. After the initialization
197 * part of the for loop is executed, the device response is
198 * at r[0] to r[page_idx - 1].
200 for (page_idx
= lduw_be_p(r
->buf
+ 2) + 4;
201 page_idx
> 4 && r
->buf
[page_idx
- 1] >= 0xb0;
203 if (page_idx
< r
->buflen
) {
204 r
->buf
[page_idx
] = r
->buf
[page_idx
- 1];
207 r
->buf
[page_idx
] = 0xb0;
208 stw_be_p(r
->buf
+ 2, lduw_be_p(r
->buf
+ 2) + 1);
213 static int scsi_generic_emulate_block_limits(SCSIGenericReq
*r
, SCSIDevice
*s
)
218 SCSIBlockLimits bl
= {
219 .max_io_sectors
= blk_get_max_transfer(s
->conf
.blk
) / s
->blocksize
222 memset(r
->buf
, 0, r
->buflen
);
224 stb_p(buf
+ 1, 0xb0);
225 len
= scsi_emulate_block_limits(buf
+ 4, &bl
);
226 assert(len
<= sizeof(buf
) - 4);
227 stw_be_p(buf
+ 2, len
);
229 memcpy(r
->buf
, buf
, MIN(r
->buflen
, len
+ 4));
231 r
->io_header
.sb_len_wr
= 0;
234 * We have valid contents in the reply buffer but the
235 * io_header can report a sense error coming from
236 * the hardware in scsi_command_complete_noio. Clean
237 * up the io_header to avoid reporting it.
239 r
->io_header
.driver_status
= 0;
240 r
->io_header
.status
= 0;
245 static void scsi_read_complete(void * opaque
, int ret
)
247 SCSIGenericReq
*r
= (SCSIGenericReq
*)opaque
;
248 SCSIDevice
*s
= r
->req
.dev
;
251 assert(r
->req
.aiocb
!= NULL
);
254 aio_context_acquire(blk_get_aio_context(s
->conf
.blk
));
256 if (ret
|| r
->req
.io_canceled
) {
257 scsi_command_complete_noio(r
, ret
);
261 len
= r
->io_header
.dxfer_len
- r
->io_header
.resid
;
262 DPRINTF("Data ready tag=0x%x len=%d\n", r
->req
.tag
, len
);
267 * Check if this is a VPD Block Limits request that
268 * resulted in sense error but would need emulation.
269 * In this case, emulate a valid VPD response.
271 if (s
->needs_vpd_bl_emulation
&& ret
== 0 &&
272 (r
->io_header
.driver_status
& SG_ERR_DRIVER_SENSE
) &&
273 r
->req
.cmd
.buf
[0] == INQUIRY
&&
274 (r
->req
.cmd
.buf
[1] & 0x01) &&
275 r
->req
.cmd
.buf
[2] == 0xb0) {
277 scsi_parse_sense_buf(r
->req
.sense
, r
->io_header
.sb_len_wr
);
278 if (sense
.key
== ILLEGAL_REQUEST
) {
279 len
= scsi_generic_emulate_block_limits(r
, s
);
281 * No need to let scsi_read_complete go on and handle an
282 * INQUIRY VPD BL request we created manually.
289 scsi_command_complete_noio(r
, 0);
293 /* Snoop READ CAPACITY output to set the blocksize. */
294 if (r
->req
.cmd
.buf
[0] == READ_CAPACITY_10
&&
295 (ldl_be_p(&r
->buf
[0]) != 0xffffffffU
|| s
->max_lba
== 0)) {
296 s
->blocksize
= ldl_be_p(&r
->buf
[4]);
297 s
->max_lba
= ldl_be_p(&r
->buf
[0]) & 0xffffffffULL
;
298 } else if (r
->req
.cmd
.buf
[0] == SERVICE_ACTION_IN_16
&&
299 (r
->req
.cmd
.buf
[1] & 31) == SAI_READ_CAPACITY_16
) {
300 s
->blocksize
= ldl_be_p(&r
->buf
[8]);
301 s
->max_lba
= ldq_be_p(&r
->buf
[0]);
303 blk_set_guest_block_size(s
->conf
.blk
, s
->blocksize
);
305 /* Patch MODE SENSE device specific parameters if the BDS is opened
308 if ((s
->type
== TYPE_DISK
|| s
->type
== TYPE_TAPE
) &&
309 blk_is_read_only(s
->conf
.blk
) &&
310 (r
->req
.cmd
.buf
[0] == MODE_SENSE
||
311 r
->req
.cmd
.buf
[0] == MODE_SENSE_10
) &&
312 (r
->req
.cmd
.buf
[1] & 0x8) == 0) {
313 if (r
->req
.cmd
.buf
[0] == MODE_SENSE
) {
319 if (r
->req
.cmd
.buf
[0] == INQUIRY
) {
320 scsi_handle_inquiry_reply(r
, s
);
324 scsi_req_data(&r
->req
, len
);
325 scsi_req_unref(&r
->req
);
328 aio_context_release(blk_get_aio_context(s
->conf
.blk
));
331 /* Read more data from scsi device into buffer. */
332 static void scsi_read_data(SCSIRequest
*req
)
334 SCSIGenericReq
*r
= DO_UPCAST(SCSIGenericReq
, req
, req
);
335 SCSIDevice
*s
= r
->req
.dev
;
338 DPRINTF("scsi_read_data tag=0x%x\n", req
->tag
);
340 /* The request is used as the AIO opaque value, so add a ref. */
341 scsi_req_ref(&r
->req
);
343 scsi_command_complete_noio(r
, 0);
347 ret
= execute_command(s
->conf
.blk
, r
, SG_DXFER_FROM_DEV
,
350 scsi_command_complete_noio(r
, ret
);
354 static void scsi_write_complete(void * opaque
, int ret
)
356 SCSIGenericReq
*r
= (SCSIGenericReq
*)opaque
;
357 SCSIDevice
*s
= r
->req
.dev
;
359 DPRINTF("scsi_write_complete() ret = %d\n", ret
);
361 assert(r
->req
.aiocb
!= NULL
);
364 aio_context_acquire(blk_get_aio_context(s
->conf
.blk
));
366 if (ret
|| r
->req
.io_canceled
) {
367 scsi_command_complete_noio(r
, ret
);
371 if (r
->req
.cmd
.buf
[0] == MODE_SELECT
&& r
->req
.cmd
.buf
[4] == 12 &&
372 s
->type
== TYPE_TAPE
) {
373 s
->blocksize
= (r
->buf
[9] << 16) | (r
->buf
[10] << 8) | r
->buf
[11];
374 DPRINTF("block size %d\n", s
->blocksize
);
377 scsi_command_complete_noio(r
, ret
);
380 aio_context_release(blk_get_aio_context(s
->conf
.blk
));
383 /* Write data to a scsi device. Returns nonzero on failure.
384 The transfer may complete asynchronously. */
385 static void scsi_write_data(SCSIRequest
*req
)
387 SCSIGenericReq
*r
= DO_UPCAST(SCSIGenericReq
, req
, req
);
388 SCSIDevice
*s
= r
->req
.dev
;
391 DPRINTF("scsi_write_data tag=0x%x\n", req
->tag
);
394 scsi_req_data(&r
->req
, r
->len
);
398 /* The request is used as the AIO opaque value, so add a ref. */
399 scsi_req_ref(&r
->req
);
400 ret
= execute_command(s
->conf
.blk
, r
, SG_DXFER_TO_DEV
, scsi_write_complete
);
402 scsi_command_complete_noio(r
, ret
);
406 /* Return a pointer to the data buffer. */
407 static uint8_t *scsi_get_buf(SCSIRequest
*req
)
409 SCSIGenericReq
*r
= DO_UPCAST(SCSIGenericReq
, req
, req
);
414 /* Execute a scsi command. Returns the length of the data expected by the
415 command. This will be Positive for data transfers from the device
416 (eg. disk reads), negative for transfers to the device (eg. disk writes),
417 and zero if the command does not transfer any data. */
419 static int32_t scsi_send_command(SCSIRequest
*req
, uint8_t *cmd
)
421 SCSIGenericReq
*r
= DO_UPCAST(SCSIGenericReq
, req
, req
);
422 SCSIDevice
*s
= r
->req
.dev
;
426 DPRINTF("Command: data=0x%02x", cmd
[0]);
429 for (i
= 1; i
< r
->req
.cmd
.len
; i
++) {
430 printf(" 0x%02x", cmd
[i
]);
436 if (r
->req
.cmd
.xfer
== 0) {
440 /* The request is used as the AIO opaque value, so add a ref. */
441 scsi_req_ref(&r
->req
);
442 ret
= execute_command(s
->conf
.blk
, r
, SG_DXFER_NONE
,
443 scsi_command_complete
);
445 scsi_command_complete_noio(r
, ret
);
451 if (r
->buflen
!= r
->req
.cmd
.xfer
) {
453 r
->buf
= g_malloc(r
->req
.cmd
.xfer
);
454 r
->buflen
= r
->req
.cmd
.xfer
;
457 memset(r
->buf
, 0, r
->buflen
);
458 r
->len
= r
->req
.cmd
.xfer
;
459 if (r
->req
.cmd
.mode
== SCSI_XFER_TO_DEV
) {
461 return -r
->req
.cmd
.xfer
;
463 return r
->req
.cmd
.xfer
;
467 static int read_naa_id(const uint8_t *p
, uint64_t *p_wwn
)
471 if ((p
[1] & 0xF) == 3) {
472 /* NAA designator type */
476 *p_wwn
= ldq_be_p(p
+ 4);
480 if ((p
[1] & 0xF) == 8) {
481 /* SCSI name string designator type */
482 if (p
[3] < 20 || memcmp(&p
[4], "naa.", 4)) {
485 if (p
[3] > 20 && p
[24] != ',') {
489 for (i
= 8; i
< 24; i
++) {
490 char c
= qemu_toupper(p
[i
]);
491 c
-= (c
>= '0' && c
<= '9' ? '0' : 'A' - 10);
492 *p_wwn
= (*p_wwn
<< 4) | c
;
500 int scsi_SG_IO_FROM_DEV(BlockBackend
*blk
, uint8_t *cmd
, uint8_t cmd_size
,
501 uint8_t *buf
, uint8_t buf_size
)
503 sg_io_hdr_t io_header
;
507 memset(&io_header
, 0, sizeof(io_header
));
508 io_header
.interface_id
= 'S';
509 io_header
.dxfer_direction
= SG_DXFER_FROM_DEV
;
510 io_header
.dxfer_len
= buf_size
;
511 io_header
.dxferp
= buf
;
512 io_header
.cmdp
= cmd
;
513 io_header
.cmd_len
= cmd_size
;
514 io_header
.mx_sb_len
= sizeof(sensebuf
);
515 io_header
.sbp
= sensebuf
;
516 io_header
.timeout
= 6000; /* XXX */
518 ret
= blk_ioctl(blk
, SG_IO
, &io_header
);
519 if (ret
< 0 || io_header
.driver_status
|| io_header
.host_status
) {
526 * Executes an INQUIRY request with EVPD set to retrieve the
527 * available VPD pages of the device. If the device does
528 * not support the Block Limits page (page 0xb0), set
529 * the needs_vpd_bl_emulation flag for future use.
531 static void scsi_generic_set_vpd_bl_emulation(SCSIDevice
*s
)
538 memset(cmd
, 0, sizeof(cmd
));
539 memset(buf
, 0, sizeof(buf
));
543 cmd
[4] = sizeof(buf
);
545 ret
= scsi_SG_IO_FROM_DEV(s
->conf
.blk
, cmd
, sizeof(cmd
),
549 * Do not assume anything if we can't retrieve the
550 * INQUIRY response to assert the VPD Block Limits
553 s
->needs_vpd_bl_emulation
= false;
558 for (i
= 4; i
< MIN(sizeof(buf
), page_len
+ 4); i
++) {
559 if (buf
[i
] == 0xb0) {
560 s
->needs_vpd_bl_emulation
= false;
564 s
->needs_vpd_bl_emulation
= true;
567 static void scsi_generic_read_device_identification(SCSIDevice
*s
)
574 memset(cmd
, 0, sizeof(cmd
));
575 memset(buf
, 0, sizeof(buf
));
579 cmd
[4] = sizeof(buf
);
581 ret
= scsi_SG_IO_FROM_DEV(s
->conf
.blk
, cmd
, sizeof(cmd
),
587 len
= MIN((buf
[2] << 8) | buf
[3], sizeof(buf
) - 4);
588 for (i
= 0; i
+ 3 <= len
; ) {
589 const uint8_t *p
= &buf
[i
+ 4];
592 if (i
+ (p
[3] + 4) > len
) {
596 if ((p
[1] & 0x10) == 0) {
597 /* Associated with the logical unit */
598 if (read_naa_id(p
, &wwn
) == 0) {
601 } else if ((p
[1] & 0x10) == 0x10) {
602 /* Associated with the target port */
603 if (read_naa_id(p
, &wwn
) == 0) {
612 void scsi_generic_read_device_inquiry(SCSIDevice
*s
)
614 scsi_generic_read_device_identification(s
);
615 if (s
->type
== TYPE_DISK
) {
616 scsi_generic_set_vpd_bl_emulation(s
);
618 s
->needs_vpd_bl_emulation
= false;
622 static int get_stream_blocksize(BlockBackend
*blk
)
628 memset(cmd
, 0, sizeof(cmd
));
629 memset(buf
, 0, sizeof(buf
));
631 cmd
[4] = sizeof(buf
);
633 ret
= scsi_SG_IO_FROM_DEV(blk
, cmd
, sizeof(cmd
), buf
, sizeof(buf
));
638 return (buf
[9] << 16) | (buf
[10] << 8) | buf
[11];
641 static void scsi_generic_reset(DeviceState
*dev
)
643 SCSIDevice
*s
= SCSI_DEVICE(dev
);
645 s
->scsi_version
= s
->default_scsi_version
;
646 scsi_device_purge_requests(s
, SENSE_CODE(RESET
));
649 static void scsi_generic_realize(SCSIDevice
*s
, Error
**errp
)
653 struct sg_scsi_id scsiid
;
656 error_setg(errp
, "drive property not set");
660 if (blk_get_on_error(s
->conf
.blk
, 0) != BLOCKDEV_ON_ERROR_ENOSPC
) {
661 error_setg(errp
, "Device doesn't support drive option werror");
664 if (blk_get_on_error(s
->conf
.blk
, 1) != BLOCKDEV_ON_ERROR_REPORT
) {
665 error_setg(errp
, "Device doesn't support drive option rerror");
669 /* check we are using a driver managing SG_IO (version 3 and after */
670 rc
= blk_ioctl(s
->conf
.blk
, SG_GET_VERSION_NUM
, &sg_version
);
672 error_setg_errno(errp
, -rc
, "cannot get SG_IO version number");
674 error_append_hint(errp
, "Is this a SCSI device?\n");
678 if (sg_version
< 30000) {
679 error_setg(errp
, "scsi generic interface too old");
683 /* get LUN of the /dev/sg? */
684 if (blk_ioctl(s
->conf
.blk
, SG_GET_SCSI_ID
, &scsiid
)) {
685 error_setg(errp
, "SG_GET_SCSI_ID ioctl failed");
688 if (!blkconf_apply_backend_options(&s
->conf
,
689 blk_is_read_only(s
->conf
.blk
),
694 /* define device state */
695 s
->type
= scsiid
.scsi_type
;
696 DPRINTF("device type %d\n", s
->type
);
700 s
->blocksize
= get_stream_blocksize(s
->conf
.blk
);
701 if (s
->blocksize
== -1) {
706 /* Make a guess for block devices, we'll fix it when the guest sends.
707 * READ CAPACITY. If they don't, they likely would assume these sizes
708 * anyway. (TODO: they could also send MODE SENSE).
719 DPRINTF("block size %d\n", s
->blocksize
);
721 /* Only used by scsi-block, but initialize it nevertheless to be clean. */
722 s
->default_scsi_version
= -1;
723 scsi_generic_read_device_inquiry(s
);
726 const SCSIReqOps scsi_generic_req_ops
= {
727 .size
= sizeof(SCSIGenericReq
),
728 .free_req
= scsi_free_request
,
729 .send_command
= scsi_send_command
,
730 .read_data
= scsi_read_data
,
731 .write_data
= scsi_write_data
,
732 .get_buf
= scsi_get_buf
,
733 .load_request
= scsi_generic_load_request
,
734 .save_request
= scsi_generic_save_request
,
737 static SCSIRequest
*scsi_new_request(SCSIDevice
*d
, uint32_t tag
, uint32_t lun
,
738 uint8_t *buf
, void *hba_private
)
740 return scsi_req_alloc(&scsi_generic_req_ops
, d
, tag
, lun
, hba_private
);
743 static Property scsi_generic_properties
[] = {
744 DEFINE_PROP_DRIVE("drive", SCSIDevice
, conf
.blk
),
745 DEFINE_PROP_BOOL("share-rw", SCSIDevice
, conf
.share_rw
, false),
746 DEFINE_PROP_END_OF_LIST(),
749 static int scsi_generic_parse_cdb(SCSIDevice
*dev
, SCSICommand
*cmd
,
750 uint8_t *buf
, void *hba_private
)
752 return scsi_bus_parse_cdb(dev
, cmd
, buf
, hba_private
);
755 static void scsi_generic_class_initfn(ObjectClass
*klass
, void *data
)
757 DeviceClass
*dc
= DEVICE_CLASS(klass
);
758 SCSIDeviceClass
*sc
= SCSI_DEVICE_CLASS(klass
);
760 sc
->realize
= scsi_generic_realize
;
761 sc
->alloc_req
= scsi_new_request
;
762 sc
->parse_cdb
= scsi_generic_parse_cdb
;
763 dc
->fw_name
= "disk";
764 dc
->desc
= "pass through generic scsi device (/dev/sg*)";
765 dc
->reset
= scsi_generic_reset
;
766 dc
->props
= scsi_generic_properties
;
767 dc
->vmsd
= &vmstate_scsi_device
;
770 static const TypeInfo scsi_generic_info
= {
771 .name
= "scsi-generic",
772 .parent
= TYPE_SCSI_DEVICE
,
773 .instance_size
= sizeof(SCSIDevice
),
774 .class_init
= scsi_generic_class_initfn
,
777 static void scsi_generic_register_types(void)
779 type_register_static(&scsi_generic_info
);
782 type_init(scsi_generic_register_types
)
784 #endif /* __linux__ */