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
,
477 static int virtscsi_tmf(struct virtio_scsi
*vscsi
, struct virtio_scsi_cmd
*cmd
)
479 DECLARE_COMPLETION_ONSTACK(comp
);
480 struct virtio_scsi_target_state
*tgt
= vscsi
->tgt
[cmd
->sc
->device
->id
];
484 if (virtscsi_kick_cmd(tgt
, &vscsi
->ctrl_vq
, cmd
,
485 sizeof cmd
->req
.tmf
, sizeof cmd
->resp
.tmf
,
489 wait_for_completion(&comp
);
490 if (cmd
->resp
.tmf
.response
== VIRTIO_SCSI_S_OK
||
491 cmd
->resp
.tmf
.response
== VIRTIO_SCSI_S_FUNCTION_SUCCEEDED
)
495 mempool_free(cmd
, virtscsi_cmd_pool
);
499 static int virtscsi_device_reset(struct scsi_cmnd
*sc
)
501 struct virtio_scsi
*vscsi
= shost_priv(sc
->device
->host
);
502 struct virtio_scsi_cmd
*cmd
;
504 sdev_printk(KERN_INFO
, sc
->device
, "device reset\n");
505 cmd
= mempool_alloc(virtscsi_cmd_pool
, GFP_NOIO
);
509 memset(cmd
, 0, sizeof(*cmd
));
511 cmd
->req
.tmf
= (struct virtio_scsi_ctrl_tmf_req
){
512 .type
= VIRTIO_SCSI_T_TMF
,
513 .subtype
= VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET
,
515 .lun
[1] = sc
->device
->id
,
516 .lun
[2] = (sc
->device
->lun
>> 8) | 0x40,
517 .lun
[3] = sc
->device
->lun
& 0xff,
519 return virtscsi_tmf(vscsi
, cmd
);
522 static int virtscsi_abort(struct scsi_cmnd
*sc
)
524 struct virtio_scsi
*vscsi
= shost_priv(sc
->device
->host
);
525 struct virtio_scsi_cmd
*cmd
;
527 scmd_printk(KERN_INFO
, sc
, "abort\n");
528 cmd
= mempool_alloc(virtscsi_cmd_pool
, GFP_NOIO
);
532 memset(cmd
, 0, sizeof(*cmd
));
534 cmd
->req
.tmf
= (struct virtio_scsi_ctrl_tmf_req
){
535 .type
= VIRTIO_SCSI_T_TMF
,
536 .subtype
= VIRTIO_SCSI_T_TMF_ABORT_TASK
,
538 .lun
[1] = sc
->device
->id
,
539 .lun
[2] = (sc
->device
->lun
>> 8) | 0x40,
540 .lun
[3] = sc
->device
->lun
& 0xff,
541 .tag
= (unsigned long)sc
,
543 return virtscsi_tmf(vscsi
, cmd
);
546 static struct scsi_host_template virtscsi_host_template
= {
547 .module
= THIS_MODULE
,
548 .name
= "Virtio SCSI HBA",
549 .proc_name
= "virtio_scsi",
550 .queuecommand
= virtscsi_queuecommand
,
552 .eh_abort_handler
= virtscsi_abort
,
553 .eh_device_reset_handler
= virtscsi_device_reset
,
556 .dma_boundary
= UINT_MAX
,
557 .use_clustering
= ENABLE_CLUSTERING
,
560 #define virtscsi_config_get(vdev, fld) \
562 typeof(((struct virtio_scsi_config *)0)->fld) __val; \
563 vdev->config->get(vdev, \
564 offsetof(struct virtio_scsi_config, fld), \
565 &__val, sizeof(__val)); \
569 #define virtscsi_config_set(vdev, fld, val) \
571 typeof(((struct virtio_scsi_config *)0)->fld) __val = (val); \
572 vdev->config->set(vdev, \
573 offsetof(struct virtio_scsi_config, fld), \
574 &__val, sizeof(__val)); \
577 static void virtscsi_init_vq(struct virtio_scsi_vq
*virtscsi_vq
,
578 struct virtqueue
*vq
)
580 spin_lock_init(&virtscsi_vq
->vq_lock
);
581 virtscsi_vq
->vq
= vq
;
584 static struct virtio_scsi_target_state
*virtscsi_alloc_tgt(
585 struct virtio_device
*vdev
, int sg_elems
)
587 struct virtio_scsi_target_state
*tgt
;
588 gfp_t gfp_mask
= GFP_KERNEL
;
590 /* We need extra sg elements at head and tail. */
591 tgt
= kmalloc(sizeof(*tgt
) + sizeof(tgt
->sg
[0]) * (sg_elems
+ 2),
597 spin_lock_init(&tgt
->tgt_lock
);
598 sg_init_table(tgt
->sg
, sg_elems
+ 2);
602 static void virtscsi_scan(struct virtio_device
*vdev
)
604 struct Scsi_Host
*shost
= (struct Scsi_Host
*)vdev
->priv
;
606 scsi_scan_host(shost
);
609 static void virtscsi_remove_vqs(struct virtio_device
*vdev
)
611 struct Scsi_Host
*sh
= virtio_scsi_host(vdev
);
612 struct virtio_scsi
*vscsi
= shost_priv(sh
);
615 /* Stop all the virtqueues. */
616 vdev
->config
->reset(vdev
);
618 num_targets
= sh
->max_id
;
619 for (i
= 0; i
< num_targets
; i
++) {
620 kfree(vscsi
->tgt
[i
]);
621 vscsi
->tgt
[i
] = NULL
;
624 vdev
->config
->del_vqs(vdev
);
627 static int virtscsi_init(struct virtio_device
*vdev
,
628 struct virtio_scsi
*vscsi
, int num_targets
)
631 struct virtqueue
*vqs
[3];
634 vq_callback_t
*callbacks
[] = {
639 const char *names
[] = {
645 /* Discover virtqueues and write information to configuration. */
646 err
= vdev
->config
->find_vqs(vdev
, 3, vqs
, callbacks
, names
);
650 virtscsi_init_vq(&vscsi
->ctrl_vq
, vqs
[0]);
651 virtscsi_init_vq(&vscsi
->event_vq
, vqs
[1]);
652 virtscsi_init_vq(&vscsi
->req_vq
, vqs
[2]);
654 virtscsi_config_set(vdev
, cdb_size
, VIRTIO_SCSI_CDB_SIZE
);
655 virtscsi_config_set(vdev
, sense_size
, VIRTIO_SCSI_SENSE_SIZE
);
657 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
))
658 virtscsi_kick_event_all(vscsi
);
660 /* We need to know how many segments before we allocate. */
661 sg_elems
= virtscsi_config_get(vdev
, seg_max
) ?: 1;
663 for (i
= 0; i
< num_targets
; i
++) {
664 vscsi
->tgt
[i
] = virtscsi_alloc_tgt(vdev
, sg_elems
);
665 if (!vscsi
->tgt
[i
]) {
674 virtscsi_remove_vqs(vdev
);
678 static int __devinit
virtscsi_probe(struct virtio_device
*vdev
)
680 struct Scsi_Host
*shost
;
681 struct virtio_scsi
*vscsi
;
683 u32 sg_elems
, num_targets
;
686 /* Allocate memory and link the structs together. */
687 num_targets
= virtscsi_config_get(vdev
, max_target
) + 1;
688 shost
= scsi_host_alloc(&virtscsi_host_template
,
690 + num_targets
* sizeof(struct virtio_scsi_target_state
));
695 sg_elems
= virtscsi_config_get(vdev
, seg_max
) ?: 1;
696 shost
->sg_tablesize
= sg_elems
;
697 vscsi
= shost_priv(shost
);
701 err
= virtscsi_init(vdev
, vscsi
, num_targets
);
703 goto virtscsi_init_failed
;
705 cmd_per_lun
= virtscsi_config_get(vdev
, cmd_per_lun
) ?: 1;
706 shost
->cmd_per_lun
= min_t(u32
, cmd_per_lun
, shost
->can_queue
);
707 shost
->max_sectors
= virtscsi_config_get(vdev
, max_sectors
) ?: 0xFFFF;
709 /* LUNs > 256 are reported with format 1, so they go in the range
712 shost
->max_lun
= virtscsi_config_get(vdev
, max_lun
) + 1 + 0x4000;
713 shost
->max_id
= num_targets
;
714 shost
->max_channel
= 0;
715 shost
->max_cmd_len
= VIRTIO_SCSI_CDB_SIZE
;
716 err
= scsi_add_host(shost
, &vdev
->dev
);
718 goto scsi_add_host_failed
;
720 * scsi_scan_host() happens in virtscsi_scan() via virtio_driver->scan()
721 * after VIRTIO_CONFIG_S_DRIVER_OK has been set..
725 scsi_add_host_failed
:
726 vdev
->config
->del_vqs(vdev
);
727 virtscsi_init_failed
:
728 scsi_host_put(shost
);
732 static void __devexit
virtscsi_remove(struct virtio_device
*vdev
)
734 struct Scsi_Host
*shost
= virtio_scsi_host(vdev
);
735 struct virtio_scsi
*vscsi
= shost_priv(shost
);
737 if (virtio_has_feature(vdev
, VIRTIO_SCSI_F_HOTPLUG
))
738 virtscsi_cancel_event_work(vscsi
);
740 scsi_remove_host(shost
);
742 virtscsi_remove_vqs(vdev
);
743 scsi_host_put(shost
);
747 static int virtscsi_freeze(struct virtio_device
*vdev
)
749 virtscsi_remove_vqs(vdev
);
753 static int virtscsi_restore(struct virtio_device
*vdev
)
755 struct Scsi_Host
*sh
= virtio_scsi_host(vdev
);
756 struct virtio_scsi
*vscsi
= shost_priv(sh
);
758 return virtscsi_init(vdev
, vscsi
, sh
->max_id
);
762 static struct virtio_device_id id_table
[] = {
763 { VIRTIO_ID_SCSI
, VIRTIO_DEV_ANY_ID
},
767 static unsigned int features
[] = {
768 VIRTIO_SCSI_F_HOTPLUG
,
769 VIRTIO_SCSI_F_CHANGE
,
772 static struct virtio_driver virtio_scsi_driver
= {
773 .feature_table
= features
,
774 .feature_table_size
= ARRAY_SIZE(features
),
775 .driver
.name
= KBUILD_MODNAME
,
776 .driver
.owner
= THIS_MODULE
,
777 .id_table
= id_table
,
778 .probe
= virtscsi_probe
,
779 .scan
= virtscsi_scan
,
781 .freeze
= virtscsi_freeze
,
782 .restore
= virtscsi_restore
,
784 .remove
= __devexit_p(virtscsi_remove
),
787 static int __init
init(void)
791 virtscsi_cmd_cache
= KMEM_CACHE(virtio_scsi_cmd
, 0);
792 if (!virtscsi_cmd_cache
) {
793 printk(KERN_ERR
"kmem_cache_create() for "
794 "virtscsi_cmd_cache failed\n");
800 mempool_create_slab_pool(VIRTIO_SCSI_MEMPOOL_SZ
,
802 if (!virtscsi_cmd_pool
) {
803 printk(KERN_ERR
"mempool_create() for"
804 "virtscsi_cmd_pool failed\n");
807 ret
= register_virtio_driver(&virtio_scsi_driver
);
814 if (virtscsi_cmd_pool
) {
815 mempool_destroy(virtscsi_cmd_pool
);
816 virtscsi_cmd_pool
= NULL
;
818 if (virtscsi_cmd_cache
) {
819 kmem_cache_destroy(virtscsi_cmd_cache
);
820 virtscsi_cmd_cache
= NULL
;
825 static void __exit
fini(void)
827 unregister_virtio_driver(&virtio_scsi_driver
);
828 mempool_destroy(virtscsi_cmd_pool
);
829 kmem_cache_destroy(virtscsi_cmd_cache
);
834 MODULE_DEVICE_TABLE(virtio
, id_table
);
835 MODULE_DESCRIPTION("Virtio SCSI HBA driver");
836 MODULE_LICENSE("GPL");