2 * Virtio SCSI HBA driver
4 * Copyright IBM Corp. 2010
5 * Copyright Red Hat, Inc. 2011
8 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com>
9 * Paolo Bonzini <pbonzini@redhat.com>
11 * This work is licensed under the terms of the GNU GPL, version 2 or later.
12 * See the COPYING file in the top-level directory.
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/mempool.h>
19 #include <linux/virtio.h>
20 #include <linux/virtio_ids.h>
21 #include <linux/virtio_config.h>
22 #include <linux/virtio_scsi.h>
23 #include <scsi/scsi_host.h>
24 #include <scsi/scsi_device.h>
25 #include <scsi/scsi_cmnd.h>
27 #define VIRTIO_SCSI_MEMPOOL_SZ 64
28 #define VIRTIO_SCSI_EVENT_LEN 8
30 /* Command queue element */
31 struct virtio_scsi_cmd
{
33 struct completion
*comp
;
35 struct virtio_scsi_cmd_req cmd
;
36 struct virtio_scsi_ctrl_tmf_req tmf
;
37 struct virtio_scsi_ctrl_an_req an
;
40 struct virtio_scsi_cmd_resp cmd
;
41 struct virtio_scsi_ctrl_tmf_resp tmf
;
42 struct virtio_scsi_ctrl_an_resp an
;
43 struct virtio_scsi_event evt
;
45 } ____cacheline_aligned_in_smp
;
47 struct virtio_scsi_event_node
{
48 struct virtio_scsi
*vscsi
;
49 struct virtio_scsi_event event
;
50 struct work_struct work
;
53 struct virtio_scsi_vq
{
60 /* Per-target queue state */
61 struct virtio_scsi_target_state
{
62 /* Protects sg. Lock hierarchy is tgt_lock -> vq_lock. */
65 /* For sglist construction when adding commands to the virtqueue. */
66 struct scatterlist sg
[];
69 /* Driver instance state */
71 struct virtio_device
*vdev
;
73 struct virtio_scsi_vq ctrl_vq
;
74 struct virtio_scsi_vq event_vq
;
75 struct virtio_scsi_vq req_vq
;
77 /* Get some buffers ready for event vq */
78 struct virtio_scsi_event_node event_list
[VIRTIO_SCSI_EVENT_LEN
];
80 struct virtio_scsi_target_state
*tgt
[];
83 static struct kmem_cache
*virtscsi_cmd_cache
;
84 static mempool_t
*virtscsi_cmd_pool
;
86 static inline struct Scsi_Host
*virtio_scsi_host(struct virtio_device
*vdev
)
91 static void virtscsi_compute_resid(struct scsi_cmnd
*sc
, u32 resid
)
96 if (!scsi_bidi_cmnd(sc
)) {
97 scsi_set_resid(sc
, resid
);
101 scsi_in(sc
)->resid
= min(resid
, scsi_in(sc
)->length
);
102 scsi_out(sc
)->resid
= resid
- scsi_in(sc
)->resid
;
106 * virtscsi_complete_cmd - finish a scsi_cmd and invoke scsi_done
108 * Called with vq_lock held.
110 static void virtscsi_complete_cmd(void *buf
)
112 struct virtio_scsi_cmd
*cmd
= buf
;
113 struct scsi_cmnd
*sc
= cmd
->sc
;
114 struct virtio_scsi_cmd_resp
*resp
= &cmd
->resp
.cmd
;
116 dev_dbg(&sc
->device
->sdev_gendev
,
117 "cmd %p response %u status %#02x sense_len %u\n",
118 sc
, resp
->response
, resp
->status
, resp
->sense_len
);
120 sc
->result
= resp
->status
;
121 virtscsi_compute_resid(sc
, resp
->resid
);
122 switch (resp
->response
) {
123 case VIRTIO_SCSI_S_OK
:
124 set_host_byte(sc
, DID_OK
);
126 case VIRTIO_SCSI_S_OVERRUN
:
127 set_host_byte(sc
, DID_ERROR
);
129 case VIRTIO_SCSI_S_ABORTED
:
130 set_host_byte(sc
, DID_ABORT
);
132 case VIRTIO_SCSI_S_BAD_TARGET
:
133 set_host_byte(sc
, DID_BAD_TARGET
);
135 case VIRTIO_SCSI_S_RESET
:
136 set_host_byte(sc
, DID_RESET
);
138 case VIRTIO_SCSI_S_BUSY
:
139 set_host_byte(sc
, DID_BUS_BUSY
);
141 case VIRTIO_SCSI_S_TRANSPORT_FAILURE
:
142 set_host_byte(sc
, DID_TRANSPORT_DISRUPTED
);
144 case VIRTIO_SCSI_S_TARGET_FAILURE
:
145 set_host_byte(sc
, DID_TARGET_FAILURE
);
147 case VIRTIO_SCSI_S_NEXUS_FAILURE
:
148 set_host_byte(sc
, DID_NEXUS_FAILURE
);
151 scmd_printk(KERN_WARNING
, sc
, "Unknown response %d",
154 case VIRTIO_SCSI_S_FAILURE
:
155 set_host_byte(sc
, DID_ERROR
);
159 WARN_ON(resp
->sense_len
> VIRTIO_SCSI_SENSE_SIZE
);
160 if (sc
->sense_buffer
) {
161 memcpy(sc
->sense_buffer
, resp
->sense
,
162 min_t(u32
, resp
->sense_len
, VIRTIO_SCSI_SENSE_SIZE
));
164 set_driver_byte(sc
, DRIVER_SENSE
);
167 mempool_free(cmd
, virtscsi_cmd_pool
);
171 static void virtscsi_vq_done(struct virtqueue
*vq
, void (*fn
)(void *buf
))
177 virtqueue_disable_cb(vq
);
178 while ((buf
= virtqueue_get_buf(vq
, &len
)) != NULL
)
180 } while (!virtqueue_enable_cb(vq
));
183 static void virtscsi_req_done(struct virtqueue
*vq
)
185 struct Scsi_Host
*sh
= virtio_scsi_host(vq
->vdev
);
186 struct virtio_scsi
*vscsi
= shost_priv(sh
);
189 spin_lock_irqsave(&vscsi
->req_vq
.vq_lock
, flags
);
190 virtscsi_vq_done(vq
, virtscsi_complete_cmd
);
191 spin_unlock_irqrestore(&vscsi
->req_vq
.vq_lock
, flags
);
194 static void virtscsi_complete_free(void *buf
)
196 struct virtio_scsi_cmd
*cmd
= buf
;
199 complete_all(cmd
->comp
);
201 mempool_free(cmd
, virtscsi_cmd_pool
);
204 static void virtscsi_ctrl_done(struct virtqueue
*vq
)
206 struct Scsi_Host
*sh
= virtio_scsi_host(vq
->vdev
);
207 struct virtio_scsi
*vscsi
= shost_priv(sh
);
210 spin_lock_irqsave(&vscsi
->ctrl_vq
.vq_lock
, flags
);
211 virtscsi_vq_done(vq
, virtscsi_complete_free
);
212 spin_unlock_irqrestore(&vscsi
->ctrl_vq
.vq_lock
, flags
);
215 static int virtscsi_kick_event(struct virtio_scsi
*vscsi
,
216 struct virtio_scsi_event_node
*event_node
)
219 struct scatterlist sg
;
222 sg_init_one(&sg
, &event_node
->event
, sizeof(struct virtio_scsi_event
));
224 spin_lock_irqsave(&vscsi
->event_vq
.vq_lock
, flags
);
226 ret
= virtqueue_add_buf(vscsi
->event_vq
.vq
, &sg
, 0, 1, event_node
, GFP_ATOMIC
);
228 virtqueue_kick(vscsi
->event_vq
.vq
);
230 spin_unlock_irqrestore(&vscsi
->event_vq
.vq_lock
, flags
);
235 static int virtscsi_kick_event_all(struct virtio_scsi
*vscsi
)
239 for (i
= 0; i
< VIRTIO_SCSI_EVENT_LEN
; i
++) {
240 vscsi
->event_list
[i
].vscsi
= vscsi
;
241 virtscsi_kick_event(vscsi
, &vscsi
->event_list
[i
]);
247 static void virtscsi_cancel_event_work(struct virtio_scsi
*vscsi
)
251 for (i
= 0; i
< VIRTIO_SCSI_EVENT_LEN
; i
++)
252 cancel_work_sync(&vscsi
->event_list
[i
].work
);
255 static void virtscsi_handle_transport_reset(struct virtio_scsi
*vscsi
,
256 struct virtio_scsi_event
*event
)
258 struct scsi_device
*sdev
;
259 struct Scsi_Host
*shost
= virtio_scsi_host(vscsi
->vdev
);
260 unsigned int target
= event
->lun
[1];
261 unsigned int lun
= (event
->lun
[2] << 8) | event
->lun
[3];
263 switch (event
->reason
) {
264 case VIRTIO_SCSI_EVT_RESET_RESCAN
:
265 scsi_add_device(shost
, 0, target
, lun
);
267 case VIRTIO_SCSI_EVT_RESET_REMOVED
:
268 sdev
= scsi_device_lookup(shost
, 0, target
, lun
);
270 scsi_remove_device(sdev
);
271 scsi_device_put(sdev
);
273 pr_err("SCSI device %d 0 %d %d not found\n",
274 shost
->host_no
, target
, lun
);
278 pr_info("Unsupport virtio scsi event reason %x\n", event
->reason
);
282 static void virtscsi_handle_param_change(struct virtio_scsi
*vscsi
,
283 struct virtio_scsi_event
*event
)
285 struct scsi_device
*sdev
;
286 struct Scsi_Host
*shost
= virtio_scsi_host(vscsi
->vdev
);
287 unsigned int target
= event
->lun
[1];
288 unsigned int lun
= (event
->lun
[2] << 8) | event
->lun
[3];
289 u8 asc
= event
->reason
& 255;
290 u8 ascq
= event
->reason
>> 8;
292 sdev
= scsi_device_lookup(shost
, 0, target
, lun
);
294 pr_err("SCSI device %d 0 %d %d not found\n",
295 shost
->host_no
, target
, lun
);
299 /* Handle "Parameters changed", "Mode parameters changed", and
300 "Capacity data has changed". */
301 if (asc
== 0x2a && (ascq
== 0x00 || ascq
== 0x01 || ascq
== 0x09))
302 scsi_rescan_device(&sdev
->sdev_gendev
);
304 scsi_device_put(sdev
);
307 static void virtscsi_handle_event(struct work_struct
*work
)
309 struct virtio_scsi_event_node
*event_node
=
310 container_of(work
, struct virtio_scsi_event_node
, work
);
311 struct virtio_scsi
*vscsi
= event_node
->vscsi
;
312 struct virtio_scsi_event
*event
= &event_node
->event
;
314 if (event
->event
& VIRTIO_SCSI_T_EVENTS_MISSED
) {
315 event
->event
&= ~VIRTIO_SCSI_T_EVENTS_MISSED
;
316 scsi_scan_host(virtio_scsi_host(vscsi
->vdev
));
319 switch (event
->event
) {
320 case VIRTIO_SCSI_T_NO_EVENT
:
322 case VIRTIO_SCSI_T_TRANSPORT_RESET
:
323 virtscsi_handle_transport_reset(vscsi
, event
);
325 case VIRTIO_SCSI_T_PARAM_CHANGE
:
326 virtscsi_handle_param_change(vscsi
, event
);
329 pr_err("Unsupport virtio scsi event %x\n", event
->event
);
331 virtscsi_kick_event(vscsi
, event_node
);
334 static void virtscsi_complete_event(void *buf
)
336 struct virtio_scsi_event_node
*event_node
= buf
;
338 INIT_WORK(&event_node
->work
, virtscsi_handle_event
);
339 schedule_work(&event_node
->work
);
342 static void virtscsi_event_done(struct virtqueue
*vq
)
344 struct Scsi_Host
*sh
= virtio_scsi_host(vq
->vdev
);
345 struct virtio_scsi
*vscsi
= shost_priv(sh
);
348 spin_lock_irqsave(&vscsi
->event_vq
.vq_lock
, flags
);
349 virtscsi_vq_done(vq
, virtscsi_complete_event
);
350 spin_unlock_irqrestore(&vscsi
->event_vq
.vq_lock
, flags
);
353 static void virtscsi_map_sgl(struct scatterlist
*sg
, unsigned int *p_idx
,
354 struct scsi_data_buffer
*sdb
)
356 struct sg_table
*table
= &sdb
->table
;
357 struct scatterlist
*sg_elem
;
358 unsigned int idx
= *p_idx
;
361 for_each_sg(table
->sgl
, sg_elem
, table
->nents
, i
)
362 sg
[idx
++] = *sg_elem
;
368 * virtscsi_map_cmd - map a scsi_cmd to a virtqueue scatterlist
369 * @vscsi : virtio_scsi state
370 * @cmd : command structure
371 * @out_num : number of read-only elements
372 * @in_num : number of write-only elements
373 * @req_size : size of the request buffer
374 * @resp_size : size of the response buffer
376 * Called with tgt_lock held.
378 static void virtscsi_map_cmd(struct virtio_scsi_target_state
*tgt
,
379 struct virtio_scsi_cmd
*cmd
,
380 unsigned *out_num
, unsigned *in_num
,
381 size_t req_size
, size_t resp_size
)
383 struct scsi_cmnd
*sc
= cmd
->sc
;
384 struct scatterlist
*sg
= tgt
->sg
;
385 unsigned int idx
= 0;
387 /* Request header. */
388 sg_set_buf(&sg
[idx
++], &cmd
->req
, req_size
);
390 /* Data-out buffer. */
391 if (sc
&& sc
->sc_data_direction
!= DMA_FROM_DEVICE
)
392 virtscsi_map_sgl(sg
, &idx
, scsi_out(sc
));
396 /* Response header. */
397 sg_set_buf(&sg
[idx
++], &cmd
->resp
, resp_size
);
400 if (sc
&& sc
->sc_data_direction
!= DMA_TO_DEVICE
)
401 virtscsi_map_sgl(sg
, &idx
, scsi_in(sc
));
403 *in_num
= idx
- *out_num
;
406 static int virtscsi_kick_cmd(struct virtio_scsi_target_state
*tgt
,
407 struct virtio_scsi_vq
*vq
,
408 struct virtio_scsi_cmd
*cmd
,
409 size_t req_size
, size_t resp_size
, gfp_t gfp
)
411 unsigned int out_num
, in_num
;
415 spin_lock_irqsave(&tgt
->tgt_lock
, flags
);
416 virtscsi_map_cmd(tgt
, cmd
, &out_num
, &in_num
, req_size
, resp_size
);
418 spin_lock(&vq
->vq_lock
);
419 ret
= virtqueue_add_buf(vq
->vq
, tgt
->sg
, out_num
, in_num
, cmd
, gfp
);
420 spin_unlock(&tgt
->tgt_lock
);
422 ret
= virtqueue_kick_prepare(vq
->vq
);
424 spin_unlock_irqrestore(&vq
->vq_lock
, flags
);
427 virtqueue_notify(vq
->vq
);
431 static int virtscsi_queuecommand(struct Scsi_Host
*sh
, struct scsi_cmnd
*sc
)
433 struct virtio_scsi
*vscsi
= shost_priv(sh
);
434 struct virtio_scsi_target_state
*tgt
= vscsi
->tgt
[sc
->device
->id
];
435 struct virtio_scsi_cmd
*cmd
;
438 struct Scsi_Host
*shost
= virtio_scsi_host(vscsi
->vdev
);
439 BUG_ON(scsi_sg_count(sc
) > shost
->sg_tablesize
);
441 /* TODO: check feature bit and fail if unsupported? */
442 BUG_ON(sc
->sc_data_direction
== DMA_BIDIRECTIONAL
);
444 dev_dbg(&sc
->device
->sdev_gendev
,
445 "cmd %p CDB: %#02x\n", sc
, sc
->cmnd
[0]);
447 ret
= SCSI_MLQUEUE_HOST_BUSY
;
448 cmd
= mempool_alloc(virtscsi_cmd_pool
, GFP_ATOMIC
);
452 memset(cmd
, 0, sizeof(*cmd
));
454 cmd
->req
.cmd
= (struct virtio_scsi_cmd_req
){
456 .lun
[1] = sc
->device
->id
,
457 .lun
[2] = (sc
->device
->lun
>> 8) | 0x40,
458 .lun
[3] = sc
->device
->lun
& 0xff,
459 .tag
= (unsigned long)sc
,
460 .task_attr
= VIRTIO_SCSI_S_SIMPLE
,
465 BUG_ON(sc
->cmd_len
> VIRTIO_SCSI_CDB_SIZE
);
466 memcpy(cmd
->req
.cmd
.cdb
, sc
->cmnd
, sc
->cmd_len
);
468 if (virtscsi_kick_cmd(tgt
, &vscsi
->req_vq
, cmd
,
469 sizeof cmd
->req
.cmd
, sizeof cmd
->resp
.cmd
,
473 mempool_free(cmd
, virtscsi_cmd_pool
);
479 static int virtscsi_tmf(struct virtio_scsi
*vscsi
, struct virtio_scsi_cmd
*cmd
)
481 DECLARE_COMPLETION_ONSTACK(comp
);
482 struct virtio_scsi_target_state
*tgt
= vscsi
->tgt
[cmd
->sc
->device
->id
];
486 if (virtscsi_kick_cmd(tgt
, &vscsi
->ctrl_vq
, cmd
,
487 sizeof cmd
->req
.tmf
, sizeof cmd
->resp
.tmf
,
491 wait_for_completion(&comp
);
492 if (cmd
->resp
.tmf
.response
== VIRTIO_SCSI_S_OK
||
493 cmd
->resp
.tmf
.response
== VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
)
497 mempool_free(cmd
, virtscsi_cmd_pool
);
501 static int virtscsi_device_reset(struct scsi_cmnd
*sc
)
503 struct virtio_scsi
*vscsi
= shost_priv(sc
->device
->host
);
504 struct virtio_scsi_cmd
*cmd
;
506 sdev_printk(KERN_INFO
, sc
->device
, "device reset\n");
507 cmd
= mempool_alloc(virtscsi_cmd_pool
, GFP_NOIO
);
511 memset(cmd
, 0, sizeof(*cmd
));
513 cmd
->req
.tmf
= (struct virtio_scsi_ctrl_tmf_req
){
514 .type
= VIRTIO_SCSI_T_TMF
,
515 .subtype
= VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
,
517 .lun
[1] = sc
->device
->id
,
518 .lun
[2] = (sc
->device
->lun
>> 8) | 0x40,
519 .lun
[3] = sc
->device
->lun
& 0xff,
521 return virtscsi_tmf(vscsi
, cmd
);
524 static int virtscsi_abort(struct scsi_cmnd
*sc
)
526 struct virtio_scsi
*vscsi
= shost_priv(sc
->device
->host
);
527 struct virtio_scsi_cmd
*cmd
;
529 scmd_printk(KERN_INFO
, sc
, "abort\n");
530 cmd
= mempool_alloc(virtscsi_cmd_pool
, GFP_NOIO
);
534 memset(cmd
, 0, sizeof(*cmd
));
536 cmd
->req
.tmf
= (struct virtio_scsi_ctrl_tmf_req
){
537 .type
= VIRTIO_SCSI_T_TMF
,
538 .subtype
= VIRTIO_SCSI_T_TMF_ABORT_TASK
,
540 .lun
[1] = sc
->device
->id
,
541 .lun
[2] = (sc
->device
->lun
>> 8) | 0x40,
542 .lun
[3] = sc
->device
->lun
& 0xff,
543 .tag
= (unsigned long)sc
,
545 return virtscsi_tmf(vscsi
, cmd
);
548 static struct scsi_host_template virtscsi_host_template
= {
549 .module
= THIS_MODULE
,
550 .name
= "Virtio SCSI HBA",
551 .proc_name
= "virtio_scsi",
552 .queuecommand
= virtscsi_queuecommand
,
554 .eh_abort_handler
= virtscsi_abort
,
555 .eh_device_reset_handler
= virtscsi_device_reset
,
558 .dma_boundary
= UINT_MAX
,
559 .use_clustering
= ENABLE_CLUSTERING
,
562 #define virtscsi_config_get(vdev, fld) \
564 typeof(((struct virtio_scsi_config *)0)->fld) __val; \
565 vdev->config->get(vdev, \
566 offsetof(struct virtio_scsi_config, fld), \
567 &__val, sizeof(__val)); \
571 #define virtscsi_config_set(vdev, fld, val) \
573 typeof(((struct virtio_scsi_config *)0)->fld) __val = (val); \
574 vdev->config->set(vdev, \
575 offsetof(struct virtio_scsi_config, fld), \
576 &__val, sizeof(__val)); \
579 static void virtscsi_init_vq(struct virtio_scsi_vq
*virtscsi_vq
,
580 struct virtqueue
*vq
)
582 spin_lock_init(&virtscsi_vq
->vq_lock
);
583 virtscsi_vq
->vq
= vq
;
586 static struct virtio_scsi_target_state
*virtscsi_alloc_tgt(
587 struct virtio_device
*vdev
, int sg_elems
)
589 struct virtio_scsi_target_state
*tgt
;
590 gfp_t gfp_mask
= GFP_KERNEL
;
592 /* We need extra sg elements at head and tail. */
593 tgt
= kmalloc(sizeof(*tgt
) + sizeof(tgt
->sg
[0]) * (sg_elems
+ 2),
599 spin_lock_init(&tgt
->tgt_lock
);
600 sg_init_table(tgt
->sg
, sg_elems
+ 2);
604 static void virtscsi_scan(struct virtio_device
*vdev
)
606 struct Scsi_Host
*shost
= (struct Scsi_Host
*)vdev
->priv
;
608 scsi_scan_host(shost
);
611 static void virtscsi_remove_vqs(struct virtio_device
*vdev
)
613 struct Scsi_Host
*sh
= virtio_scsi_host(vdev
);
614 struct virtio_scsi
*vscsi
= shost_priv(sh
);
617 /* Stop all the virtqueues. */
618 vdev
->config
->reset(vdev
);
620 num_targets
= sh
->max_id
;
621 for (i
= 0; i
< num_targets
; i
++) {
622 kfree(vscsi
->tgt
[i
]);
623 vscsi
->tgt
[i
] = NULL
;
626 vdev
->config
->del_vqs(vdev
);
629 static int virtscsi_init(struct virtio_device
*vdev
,
630 struct virtio_scsi
*vscsi
, int num_targets
)
633 struct virtqueue
*vqs
[3];
636 vq_callback_t
*callbacks
[] = {
641 const char *names
[] = {
647 /* Discover virtqueues and write information to configuration. */
648 err
= vdev
->config
->find_vqs(vdev
, 3, vqs
, callbacks
, names
);
652 virtscsi_init_vq(&vscsi
->ctrl_vq
, vqs
[0]);
653 virtscsi_init_vq(&vscsi
->event_vq
, vqs
[1]);
654 virtscsi_init_vq(&vscsi
->req_vq
, vqs
[2]);
656 virtscsi_config_set(vdev
, cdb_size
, VIRTIO_SCSI_CDB_SIZE
);
657 virtscsi_config_set(vdev
, sense_size
, VIRTIO_SCSI_SENSE_SIZE
);
659 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
))
660 virtscsi_kick_event_all(vscsi
);
662 /* We need to know how many segments before we allocate. */
663 sg_elems
= virtscsi_config_get(vdev
, seg_max
) ?: 1;
665 for (i
= 0; i
< num_targets
; i
++) {
666 vscsi
->tgt
[i
] = virtscsi_alloc_tgt(vdev
, sg_elems
);
667 if (!vscsi
->tgt
[i
]) {
676 virtscsi_remove_vqs(vdev
);
680 static int __devinit
virtscsi_probe(struct virtio_device
*vdev
)
682 struct Scsi_Host
*shost
;
683 struct virtio_scsi
*vscsi
;
685 u32 sg_elems
, num_targets
;
688 /* Allocate memory and link the structs together. */
689 num_targets
= virtscsi_config_get(vdev
, max_target
) + 1;
690 shost
= scsi_host_alloc(&virtscsi_host_template
,
692 + num_targets
* sizeof(struct virtio_scsi_target_state
));
697 sg_elems
= virtscsi_config_get(vdev
, seg_max
) ?: 1;
698 shost
->sg_tablesize
= sg_elems
;
699 vscsi
= shost_priv(shost
);
703 err
= virtscsi_init(vdev
, vscsi
, num_targets
);
705 goto virtscsi_init_failed
;
707 cmd_per_lun
= virtscsi_config_get(vdev
, cmd_per_lun
) ?: 1;
708 shost
->cmd_per_lun
= min_t(u32
, cmd_per_lun
, shost
->can_queue
);
709 shost
->max_sectors
= virtscsi_config_get(vdev
, max_sectors
) ?: 0xFFFF;
711 /* LUNs > 256 are reported with format 1, so they go in the range
714 shost
->max_lun
= virtscsi_config_get(vdev
, max_lun
) + 1 + 0x4000;
715 shost
->max_id
= num_targets
;
716 shost
->max_channel
= 0;
717 shost
->max_cmd_len
= VIRTIO_SCSI_CDB_SIZE
;
718 err
= scsi_add_host(shost
, &vdev
->dev
);
720 goto scsi_add_host_failed
;
722 * scsi_scan_host() happens in virtscsi_scan() via virtio_driver->scan()
723 * after VIRTIO_CONFIG_S_DRIVER_OK has been set..
727 scsi_add_host_failed
:
728 vdev
->config
->del_vqs(vdev
);
729 virtscsi_init_failed
:
730 scsi_host_put(shost
);
734 static void __devexit
virtscsi_remove(struct virtio_device
*vdev
)
736 struct Scsi_Host
*shost
= virtio_scsi_host(vdev
);
737 struct virtio_scsi
*vscsi
= shost_priv(shost
);
739 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
))
740 virtscsi_cancel_event_work(vscsi
);
742 scsi_remove_host(shost
);
744 virtscsi_remove_vqs(vdev
);
745 scsi_host_put(shost
);
749 static int virtscsi_freeze(struct virtio_device
*vdev
)
751 virtscsi_remove_vqs(vdev
);
755 static int virtscsi_restore(struct virtio_device
*vdev
)
757 struct Scsi_Host
*sh
= virtio_scsi_host(vdev
);
758 struct virtio_scsi
*vscsi
= shost_priv(sh
);
760 return virtscsi_init(vdev
, vscsi
, sh
->max_id
);
764 static struct virtio_device_id id_table
[] = {
765 { VIRTIO_ID_SCSI
, VIRTIO_DEV_ANY_ID
},
769 static unsigned int features
[] = {
770 VIRTIO_SCSI_F_HOTPLUG
,
771 VIRTIO_SCSI_F_CHANGE
,
774 static struct virtio_driver virtio_scsi_driver
= {
775 .feature_table
= features
,
776 .feature_table_size
= ARRAY_SIZE(features
),
777 .driver
.name
= KBUILD_MODNAME
,
778 .driver
.owner
= THIS_MODULE
,
779 .id_table
= id_table
,
780 .probe
= virtscsi_probe
,
781 .scan
= virtscsi_scan
,
783 .freeze
= virtscsi_freeze
,
784 .restore
= virtscsi_restore
,
786 .remove
= __devexit_p(virtscsi_remove
),
789 static int __init
init(void)
793 virtscsi_cmd_cache
= KMEM_CACHE(virtio_scsi_cmd
, 0);
794 if (!virtscsi_cmd_cache
) {
795 printk(KERN_ERR
"kmem_cache_create() for "
796 "virtscsi_cmd_cache failed\n");
802 mempool_create_slab_pool(VIRTIO_SCSI_MEMPOOL_SZ
,
804 if (!virtscsi_cmd_pool
) {
805 printk(KERN_ERR
"mempool_create() for"
806 "virtscsi_cmd_pool failed\n");
809 ret
= register_virtio_driver(&virtio_scsi_driver
);
816 if (virtscsi_cmd_pool
) {
817 mempool_destroy(virtscsi_cmd_pool
);
818 virtscsi_cmd_pool
= NULL
;
820 if (virtscsi_cmd_cache
) {
821 kmem_cache_destroy(virtscsi_cmd_cache
);
822 virtscsi_cmd_cache
= NULL
;
827 static void __exit
fini(void)
829 unregister_virtio_driver(&virtio_scsi_driver
);
830 mempool_destroy(virtscsi_cmd_pool
);
831 kmem_cache_destroy(virtscsi_cmd_cache
);
836 MODULE_DEVICE_TABLE(virtio
, id_table
);
837 MODULE_DESCRIPTION("Virtio SCSI HBA driver");
838 MODULE_LICENSE("GPL");