2 * ccw based virtio transport
4 * Copyright IBM Corp. 2012, 2014
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License (version 2 only)
8 * as published by the Free Software Foundation.
10 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
13 #include <linux/kernel_stat.h>
14 #include <linux/init.h>
15 #include <linux/bootmem.h>
16 #include <linux/err.h>
17 #include <linux/virtio.h>
18 #include <linux/virtio_config.h>
19 #include <linux/slab.h>
20 #include <linux/interrupt.h>
21 #include <linux/virtio_ring.h>
22 #include <linux/pfn.h>
23 #include <linux/async.h>
24 #include <linux/wait.h>
25 #include <linux/list.h>
26 #include <linux/bitops.h>
27 #include <linux/module.h>
29 #include <linux/kvm_para.h>
30 #include <linux/notifier.h>
31 #include <asm/setup.h>
34 #include <asm/ccwdev.h>
35 #include <asm/virtio-ccw.h>
40 * virtio related functions
43 struct vq_config_block
{
48 #define VIRTIO_CCW_CONFIG_SIZE 0x100
49 /* same as PCI config space size, should be enough for all drivers */
51 struct virtio_ccw_device
{
52 struct virtio_device vdev
;
54 __u8 config
[VIRTIO_CCW_CONFIG_SIZE
];
55 struct ccw_device
*cdev
;
58 wait_queue_head_t wait_q
;
60 struct list_head virtqueues
;
61 unsigned long indicators
;
62 unsigned long indicators2
;
63 struct vq_config_block
*config_block
;
70 struct vq_info_block
{
77 struct virtio_feature_desc
{
82 struct virtio_thinint_area
{
83 unsigned long summary_indicator
;
84 unsigned long indicator
;
89 struct virtio_ccw_vq_info
{
93 struct vq_info_block
*info_block
;
95 struct list_head node
;
99 #define VIRTIO_AIRQ_ISC IO_SCH_ISC /* inherit from subchannel */
101 #define VIRTIO_IV_BITS (L1_CACHE_BYTES * 8)
102 #define MAX_AIRQ_AREAS 20
104 static int virtio_ccw_use_airq
= 1;
108 u8 summary_indicator
;
109 struct airq_struct airq
;
112 static struct airq_info
*airq_areas
[MAX_AIRQ_AREAS
];
114 #define CCW_CMD_SET_VQ 0x13
115 #define CCW_CMD_VDEV_RESET 0x33
116 #define CCW_CMD_SET_IND 0x43
117 #define CCW_CMD_SET_CONF_IND 0x53
118 #define CCW_CMD_READ_FEAT 0x12
119 #define CCW_CMD_WRITE_FEAT 0x11
120 #define CCW_CMD_READ_CONF 0x22
121 #define CCW_CMD_WRITE_CONF 0x21
122 #define CCW_CMD_WRITE_STATUS 0x31
123 #define CCW_CMD_READ_VQ_CONF 0x32
124 #define CCW_CMD_SET_IND_ADAPTER 0x73
126 #define VIRTIO_CCW_DOING_SET_VQ 0x00010000
127 #define VIRTIO_CCW_DOING_RESET 0x00040000
128 #define VIRTIO_CCW_DOING_READ_FEAT 0x00080000
129 #define VIRTIO_CCW_DOING_WRITE_FEAT 0x00100000
130 #define VIRTIO_CCW_DOING_READ_CONFIG 0x00200000
131 #define VIRTIO_CCW_DOING_WRITE_CONFIG 0x00400000
132 #define VIRTIO_CCW_DOING_WRITE_STATUS 0x00800000
133 #define VIRTIO_CCW_DOING_SET_IND 0x01000000
134 #define VIRTIO_CCW_DOING_READ_VQ_CONF 0x02000000
135 #define VIRTIO_CCW_DOING_SET_CONF_IND 0x04000000
136 #define VIRTIO_CCW_DOING_SET_IND_ADAPTER 0x08000000
137 #define VIRTIO_CCW_INTPARM_MASK 0xffff0000
139 static struct virtio_ccw_device
*to_vc_device(struct virtio_device
*vdev
)
141 return container_of(vdev
, struct virtio_ccw_device
, vdev
);
144 static void drop_airq_indicator(struct virtqueue
*vq
, struct airq_info
*info
)
146 unsigned long i
, flags
;
148 write_lock_irqsave(&info
->lock
, flags
);
149 for (i
= 0; i
< airq_iv_end(info
->aiv
); i
++) {
150 if (vq
== (void *)airq_iv_get_ptr(info
->aiv
, i
)) {
151 airq_iv_free_bit(info
->aiv
, i
);
152 airq_iv_set_ptr(info
->aiv
, i
, 0);
156 write_unlock_irqrestore(&info
->lock
, flags
);
159 static void virtio_airq_handler(struct airq_struct
*airq
)
161 struct airq_info
*info
= container_of(airq
, struct airq_info
, airq
);
164 inc_irq_stat(IRQIO_VAI
);
165 read_lock(&info
->lock
);
166 /* Walk through indicators field, summary indicator active. */
168 ai
= airq_iv_scan(info
->aiv
, ai
, airq_iv_end(info
->aiv
));
171 vring_interrupt(0, (void *)airq_iv_get_ptr(info
->aiv
, ai
));
173 info
->summary_indicator
= 0;
175 /* Walk through indicators field, summary indicator not active. */
177 ai
= airq_iv_scan(info
->aiv
, ai
, airq_iv_end(info
->aiv
));
180 vring_interrupt(0, (void *)airq_iv_get_ptr(info
->aiv
, ai
));
182 read_unlock(&info
->lock
);
185 static struct airq_info
*new_airq_info(void)
187 struct airq_info
*info
;
190 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
193 rwlock_init(&info
->lock
);
194 info
->aiv
= airq_iv_create(VIRTIO_IV_BITS
, AIRQ_IV_ALLOC
| AIRQ_IV_PTR
);
199 info
->airq
.handler
= virtio_airq_handler
;
200 info
->airq
.lsi_ptr
= &info
->summary_indicator
;
201 info
->airq
.lsi_mask
= 0xff;
202 info
->airq
.isc
= VIRTIO_AIRQ_ISC
;
203 rc
= register_adapter_interrupt(&info
->airq
);
205 airq_iv_release(info
->aiv
);
212 static void destroy_airq_info(struct airq_info
*info
)
217 unregister_adapter_interrupt(&info
->airq
);
218 airq_iv_release(info
->aiv
);
222 static unsigned long get_airq_indicator(struct virtqueue
*vqs
[], int nvqs
,
223 u64
*first
, void **airq_info
)
226 struct airq_info
*info
;
227 unsigned long indicator_addr
= 0;
228 unsigned long bit
, flags
;
230 for (i
= 0; i
< MAX_AIRQ_AREAS
&& !indicator_addr
; i
++) {
232 airq_areas
[i
] = new_airq_info();
233 info
= airq_areas
[i
];
236 write_lock_irqsave(&info
->lock
, flags
);
237 bit
= airq_iv_alloc(info
->aiv
, nvqs
);
239 /* Not enough vacancies. */
240 write_unlock_irqrestore(&info
->lock
, flags
);
245 indicator_addr
= (unsigned long)info
->aiv
->vector
;
246 for (j
= 0; j
< nvqs
; j
++) {
247 airq_iv_set_ptr(info
->aiv
, bit
+ j
,
248 (unsigned long)vqs
[j
]);
250 write_unlock_irqrestore(&info
->lock
, flags
);
252 return indicator_addr
;
255 static void virtio_ccw_drop_indicators(struct virtio_ccw_device
*vcdev
)
257 struct virtio_ccw_vq_info
*info
;
259 list_for_each_entry(info
, &vcdev
->virtqueues
, node
)
260 drop_airq_indicator(info
->vq
, vcdev
->airq_info
);
263 static int doing_io(struct virtio_ccw_device
*vcdev
, __u32 flag
)
268 spin_lock_irqsave(get_ccwdev_lock(vcdev
->cdev
), flags
);
272 ret
= vcdev
->curr_io
& flag
;
273 spin_unlock_irqrestore(get_ccwdev_lock(vcdev
->cdev
), flags
);
277 static int ccw_io_helper(struct virtio_ccw_device
*vcdev
,
278 struct ccw1
*ccw
, __u32 intparm
)
282 int flag
= intparm
& VIRTIO_CCW_INTPARM_MASK
;
285 spin_lock_irqsave(get_ccwdev_lock(vcdev
->cdev
), flags
);
286 ret
= ccw_device_start(vcdev
->cdev
, ccw
, intparm
, 0, 0);
290 vcdev
->curr_io
|= flag
;
292 spin_unlock_irqrestore(get_ccwdev_lock(vcdev
->cdev
), flags
);
294 } while (ret
== -EBUSY
);
295 wait_event(vcdev
->wait_q
, doing_io(vcdev
, flag
) == 0);
296 return ret
? ret
: vcdev
->err
;
299 static void virtio_ccw_drop_indicator(struct virtio_ccw_device
*vcdev
,
303 unsigned long *indicatorp
= NULL
;
304 struct virtio_thinint_area
*thinint_area
= NULL
;
305 struct airq_info
*airq_info
= vcdev
->airq_info
;
307 if (vcdev
->is_thinint
) {
308 thinint_area
= kzalloc(sizeof(*thinint_area
),
309 GFP_DMA
| GFP_KERNEL
);
312 thinint_area
->summary_indicator
=
313 (unsigned long) &airq_info
->summary_indicator
;
314 thinint_area
->isc
= VIRTIO_AIRQ_ISC
;
315 ccw
->cmd_code
= CCW_CMD_SET_IND_ADAPTER
;
316 ccw
->count
= sizeof(*thinint_area
);
317 ccw
->cda
= (__u32
)(unsigned long) thinint_area
;
319 indicatorp
= kmalloc(sizeof(&vcdev
->indicators
),
320 GFP_DMA
| GFP_KERNEL
);
324 ccw
->cmd_code
= CCW_CMD_SET_IND
;
325 ccw
->count
= sizeof(vcdev
->indicators
);
326 ccw
->cda
= (__u32
)(unsigned long) indicatorp
;
328 /* Deregister indicators from host. */
329 vcdev
->indicators
= 0;
331 ret
= ccw_io_helper(vcdev
, ccw
,
333 VIRTIO_CCW_DOING_SET_IND_ADAPTER
:
334 VIRTIO_CCW_DOING_SET_IND
);
335 if (ret
&& (ret
!= -ENODEV
))
336 dev_info(&vcdev
->cdev
->dev
,
337 "Failed to deregister indicators (%d)\n", ret
);
338 else if (vcdev
->is_thinint
)
339 virtio_ccw_drop_indicators(vcdev
);
344 static inline long do_kvm_notify(struct subchannel_id schid
,
345 unsigned long queue_index
,
348 register unsigned long __nr
asm("1") = KVM_S390_VIRTIO_CCW_NOTIFY
;
349 register struct subchannel_id __schid
asm("2") = schid
;
350 register unsigned long __index
asm("3") = queue_index
;
351 register long __rc
asm("2");
352 register long __cookie
asm("4") = cookie
;
354 asm volatile ("diag 2,4,0x500\n"
355 : "=d" (__rc
) : "d" (__nr
), "d" (__schid
), "d" (__index
),
361 static bool virtio_ccw_kvm_notify(struct virtqueue
*vq
)
363 struct virtio_ccw_vq_info
*info
= vq
->priv
;
364 struct virtio_ccw_device
*vcdev
;
365 struct subchannel_id schid
;
367 vcdev
= to_vc_device(info
->vq
->vdev
);
368 ccw_device_get_schid(vcdev
->cdev
, &schid
);
369 info
->cookie
= do_kvm_notify(schid
, vq
->index
, info
->cookie
);
370 if (info
->cookie
< 0)
375 static int virtio_ccw_read_vq_conf(struct virtio_ccw_device
*vcdev
,
376 struct ccw1
*ccw
, int index
)
378 vcdev
->config_block
->index
= index
;
379 ccw
->cmd_code
= CCW_CMD_READ_VQ_CONF
;
381 ccw
->count
= sizeof(struct vq_config_block
);
382 ccw
->cda
= (__u32
)(unsigned long)(vcdev
->config_block
);
383 ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_READ_VQ_CONF
);
384 return vcdev
->config_block
->num
;
387 static void virtio_ccw_del_vq(struct virtqueue
*vq
, struct ccw1
*ccw
)
389 struct virtio_ccw_device
*vcdev
= to_vc_device(vq
->vdev
);
390 struct virtio_ccw_vq_info
*info
= vq
->priv
;
394 unsigned int index
= vq
->index
;
396 /* Remove from our list. */
397 spin_lock_irqsave(&vcdev
->lock
, flags
);
398 list_del(&info
->node
);
399 spin_unlock_irqrestore(&vcdev
->lock
, flags
);
401 /* Release from host. */
402 info
->info_block
->queue
= 0;
403 info
->info_block
->align
= 0;
404 info
->info_block
->index
= index
;
405 info
->info_block
->num
= 0;
406 ccw
->cmd_code
= CCW_CMD_SET_VQ
;
408 ccw
->count
= sizeof(*info
->info_block
);
409 ccw
->cda
= (__u32
)(unsigned long)(info
->info_block
);
410 ret
= ccw_io_helper(vcdev
, ccw
,
411 VIRTIO_CCW_DOING_SET_VQ
| index
);
413 * -ENODEV isn't considered an error: The device is gone anyway.
414 * This may happen on device detach.
416 if (ret
&& (ret
!= -ENODEV
))
417 dev_warn(&vq
->vdev
->dev
, "Error %d while deleting queue %d",
420 vring_del_virtqueue(vq
);
421 size
= PAGE_ALIGN(vring_size(info
->num
, KVM_VIRTIO_CCW_RING_ALIGN
));
422 free_pages_exact(info
->queue
, size
);
423 kfree(info
->info_block
);
427 static void virtio_ccw_del_vqs(struct virtio_device
*vdev
)
429 struct virtqueue
*vq
, *n
;
431 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
433 ccw
= kzalloc(sizeof(*ccw
), GFP_DMA
| GFP_KERNEL
);
437 virtio_ccw_drop_indicator(vcdev
, ccw
);
439 list_for_each_entry_safe(vq
, n
, &vdev
->vqs
, list
)
440 virtio_ccw_del_vq(vq
, ccw
);
445 static struct virtqueue
*virtio_ccw_setup_vq(struct virtio_device
*vdev
,
446 int i
, vq_callback_t
*callback
,
450 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
452 struct virtqueue
*vq
= NULL
;
453 struct virtio_ccw_vq_info
*info
;
454 unsigned long size
= 0; /* silence the compiler */
457 /* Allocate queue. */
458 info
= kzalloc(sizeof(struct virtio_ccw_vq_info
), GFP_KERNEL
);
460 dev_warn(&vcdev
->cdev
->dev
, "no info\n");
464 info
->info_block
= kzalloc(sizeof(*info
->info_block
),
465 GFP_DMA
| GFP_KERNEL
);
466 if (!info
->info_block
) {
467 dev_warn(&vcdev
->cdev
->dev
, "no info block\n");
471 info
->num
= virtio_ccw_read_vq_conf(vcdev
, ccw
, i
);
472 size
= PAGE_ALIGN(vring_size(info
->num
, KVM_VIRTIO_CCW_RING_ALIGN
));
473 info
->queue
= alloc_pages_exact(size
, GFP_KERNEL
| __GFP_ZERO
);
474 if (info
->queue
== NULL
) {
475 dev_warn(&vcdev
->cdev
->dev
, "no queue\n");
480 vq
= vring_new_virtqueue(i
, info
->num
, KVM_VIRTIO_CCW_RING_ALIGN
, vdev
,
481 true, info
->queue
, virtio_ccw_kvm_notify
,
484 /* For now, we fail if we can't get the requested size. */
485 dev_warn(&vcdev
->cdev
->dev
, "no vq\n");
490 /* Register it with the host. */
491 info
->info_block
->queue
= (__u64
)info
->queue
;
492 info
->info_block
->align
= KVM_VIRTIO_CCW_RING_ALIGN
;
493 info
->info_block
->index
= i
;
494 info
->info_block
->num
= info
->num
;
495 ccw
->cmd_code
= CCW_CMD_SET_VQ
;
497 ccw
->count
= sizeof(*info
->info_block
);
498 ccw
->cda
= (__u32
)(unsigned long)(info
->info_block
);
499 err
= ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_SET_VQ
| i
);
501 dev_warn(&vcdev
->cdev
->dev
, "SET_VQ failed\n");
508 /* Save it to our list. */
509 spin_lock_irqsave(&vcdev
->lock
, flags
);
510 list_add(&info
->node
, &vcdev
->virtqueues
);
511 spin_unlock_irqrestore(&vcdev
->lock
, flags
);
517 vring_del_virtqueue(vq
);
520 free_pages_exact(info
->queue
, size
);
521 kfree(info
->info_block
);
527 static int virtio_ccw_register_adapter_ind(struct virtio_ccw_device
*vcdev
,
528 struct virtqueue
*vqs
[], int nvqs
,
532 struct virtio_thinint_area
*thinint_area
= NULL
;
533 struct airq_info
*info
;
535 thinint_area
= kzalloc(sizeof(*thinint_area
), GFP_DMA
| GFP_KERNEL
);
540 /* Try to get an indicator. */
541 thinint_area
->indicator
= get_airq_indicator(vqs
, nvqs
,
542 &thinint_area
->bit_nr
,
544 if (!thinint_area
->indicator
) {
548 info
= vcdev
->airq_info
;
549 thinint_area
->summary_indicator
=
550 (unsigned long) &info
->summary_indicator
;
551 thinint_area
->isc
= VIRTIO_AIRQ_ISC
;
552 ccw
->cmd_code
= CCW_CMD_SET_IND_ADAPTER
;
553 ccw
->flags
= CCW_FLAG_SLI
;
554 ccw
->count
= sizeof(*thinint_area
);
555 ccw
->cda
= (__u32
)(unsigned long)thinint_area
;
556 ret
= ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_SET_IND_ADAPTER
);
558 if (ret
== -EOPNOTSUPP
) {
560 * The host does not support adapter interrupts
561 * for virtio-ccw, stop trying.
563 virtio_ccw_use_airq
= 0;
564 pr_info("Adapter interrupts unsupported on host\n");
566 dev_warn(&vcdev
->cdev
->dev
,
567 "enabling adapter interrupts = %d\n", ret
);
568 virtio_ccw_drop_indicators(vcdev
);
575 static int virtio_ccw_find_vqs(struct virtio_device
*vdev
, unsigned nvqs
,
576 struct virtqueue
*vqs
[],
577 vq_callback_t
*callbacks
[],
580 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
581 unsigned long *indicatorp
= NULL
;
585 ccw
= kzalloc(sizeof(*ccw
), GFP_DMA
| GFP_KERNEL
);
589 for (i
= 0; i
< nvqs
; ++i
) {
590 vqs
[i
] = virtio_ccw_setup_vq(vdev
, i
, callbacks
[i
], names
[i
],
592 if (IS_ERR(vqs
[i
])) {
593 ret
= PTR_ERR(vqs
[i
]);
599 /* We need a data area under 2G to communicate. */
600 indicatorp
= kmalloc(sizeof(&vcdev
->indicators
), GFP_DMA
| GFP_KERNEL
);
603 *indicatorp
= (unsigned long) &vcdev
->indicators
;
604 if (vcdev
->is_thinint
) {
605 ret
= virtio_ccw_register_adapter_ind(vcdev
, vqs
, nvqs
, ccw
);
607 /* no error, just fall back to legacy interrupts */
608 vcdev
->is_thinint
= 0;
610 if (!vcdev
->is_thinint
) {
611 /* Register queue indicators with host. */
612 vcdev
->indicators
= 0;
613 ccw
->cmd_code
= CCW_CMD_SET_IND
;
615 ccw
->count
= sizeof(vcdev
->indicators
);
616 ccw
->cda
= (__u32
)(unsigned long) indicatorp
;
617 ret
= ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_SET_IND
);
621 /* Register indicators2 with host for config changes */
622 *indicatorp
= (unsigned long) &vcdev
->indicators2
;
623 vcdev
->indicators2
= 0;
624 ccw
->cmd_code
= CCW_CMD_SET_CONF_IND
;
626 ccw
->count
= sizeof(vcdev
->indicators2
);
627 ccw
->cda
= (__u32
)(unsigned long) indicatorp
;
628 ret
= ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_SET_CONF_IND
);
638 virtio_ccw_del_vqs(vdev
);
642 static void virtio_ccw_reset(struct virtio_device
*vdev
)
644 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
647 ccw
= kzalloc(sizeof(*ccw
), GFP_DMA
| GFP_KERNEL
);
651 /* Zero status bits. */
654 /* Send a reset ccw on device. */
655 ccw
->cmd_code
= CCW_CMD_VDEV_RESET
;
659 ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_RESET
);
663 static u32
virtio_ccw_get_features(struct virtio_device
*vdev
)
665 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
666 struct virtio_feature_desc
*features
;
670 ccw
= kzalloc(sizeof(*ccw
), GFP_DMA
| GFP_KERNEL
);
674 features
= kzalloc(sizeof(*features
), GFP_DMA
| GFP_KERNEL
);
679 /* Read the feature bits from the host. */
680 /* TODO: Features > 32 bits */
682 ccw
->cmd_code
= CCW_CMD_READ_FEAT
;
684 ccw
->count
= sizeof(*features
);
685 ccw
->cda
= (__u32
)(unsigned long)features
;
686 ret
= ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_READ_FEAT
);
692 rc
= le32_to_cpu(features
->features
);
700 static void virtio_ccw_finalize_features(struct virtio_device
*vdev
)
702 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
703 struct virtio_feature_desc
*features
;
707 ccw
= kzalloc(sizeof(*ccw
), GFP_DMA
| GFP_KERNEL
);
711 features
= kzalloc(sizeof(*features
), GFP_DMA
| GFP_KERNEL
);
715 /* Give virtio_ring a chance to accept features. */
716 vring_transport_features(vdev
);
718 for (i
= 0; i
< sizeof(*vdev
->features
) / sizeof(features
->features
);
720 int highbits
= i
% 2 ? 32 : 0;
722 features
->features
= cpu_to_le32(vdev
->features
[i
/ 2]
724 /* Write the feature bits to the host. */
725 ccw
->cmd_code
= CCW_CMD_WRITE_FEAT
;
727 ccw
->count
= sizeof(*features
);
728 ccw
->cda
= (__u32
)(unsigned long)features
;
729 ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_WRITE_FEAT
);
736 static void virtio_ccw_get_config(struct virtio_device
*vdev
,
737 unsigned int offset
, void *buf
, unsigned len
)
739 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
744 ccw
= kzalloc(sizeof(*ccw
), GFP_DMA
| GFP_KERNEL
);
748 config_area
= kzalloc(VIRTIO_CCW_CONFIG_SIZE
, GFP_DMA
| GFP_KERNEL
);
752 /* Read the config area from the host. */
753 ccw
->cmd_code
= CCW_CMD_READ_CONF
;
755 ccw
->count
= offset
+ len
;
756 ccw
->cda
= (__u32
)(unsigned long)config_area
;
757 ret
= ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_READ_CONFIG
);
761 memcpy(vcdev
->config
, config_area
, sizeof(vcdev
->config
));
762 memcpy(buf
, &vcdev
->config
[offset
], len
);
769 static void virtio_ccw_set_config(struct virtio_device
*vdev
,
770 unsigned int offset
, const void *buf
,
773 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
777 ccw
= kzalloc(sizeof(*ccw
), GFP_DMA
| GFP_KERNEL
);
781 config_area
= kzalloc(VIRTIO_CCW_CONFIG_SIZE
, GFP_DMA
| GFP_KERNEL
);
785 memcpy(&vcdev
->config
[offset
], buf
, len
);
786 /* Write the config area to the host. */
787 memcpy(config_area
, vcdev
->config
, sizeof(vcdev
->config
));
788 ccw
->cmd_code
= CCW_CMD_WRITE_CONF
;
790 ccw
->count
= offset
+ len
;
791 ccw
->cda
= (__u32
)(unsigned long)config_area
;
792 ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_WRITE_CONFIG
);
799 static u8
virtio_ccw_get_status(struct virtio_device
*vdev
)
801 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
803 return *vcdev
->status
;
806 static void virtio_ccw_set_status(struct virtio_device
*vdev
, u8 status
)
808 struct virtio_ccw_device
*vcdev
= to_vc_device(vdev
);
811 ccw
= kzalloc(sizeof(*ccw
), GFP_DMA
| GFP_KERNEL
);
815 /* Write the status to the host. */
816 *vcdev
->status
= status
;
817 ccw
->cmd_code
= CCW_CMD_WRITE_STATUS
;
819 ccw
->count
= sizeof(status
);
820 ccw
->cda
= (__u32
)(unsigned long)vcdev
->status
;
821 ccw_io_helper(vcdev
, ccw
, VIRTIO_CCW_DOING_WRITE_STATUS
);
825 static struct virtio_config_ops virtio_ccw_config_ops
= {
826 .get_features
= virtio_ccw_get_features
,
827 .finalize_features
= virtio_ccw_finalize_features
,
828 .get
= virtio_ccw_get_config
,
829 .set
= virtio_ccw_set_config
,
830 .get_status
= virtio_ccw_get_status
,
831 .set_status
= virtio_ccw_set_status
,
832 .reset
= virtio_ccw_reset
,
833 .find_vqs
= virtio_ccw_find_vqs
,
834 .del_vqs
= virtio_ccw_del_vqs
,
839 * ccw bus driver related functions
842 static void virtio_ccw_release_dev(struct device
*_d
)
844 struct virtio_device
*dev
= container_of(_d
, struct virtio_device
,
846 struct virtio_ccw_device
*vcdev
= to_vc_device(dev
);
848 kfree(vcdev
->status
);
849 kfree(vcdev
->config_block
);
853 static int irb_is_error(struct irb
*irb
)
855 if (scsw_cstat(&irb
->scsw
) != 0)
857 if (scsw_dstat(&irb
->scsw
) & ~(DEV_STAT_CHN_END
| DEV_STAT_DEV_END
))
859 if (scsw_cc(&irb
->scsw
) != 0)
864 static struct virtqueue
*virtio_ccw_vq_by_ind(struct virtio_ccw_device
*vcdev
,
867 struct virtio_ccw_vq_info
*info
;
869 struct virtqueue
*vq
;
872 spin_lock_irqsave(&vcdev
->lock
, flags
);
873 list_for_each_entry(info
, &vcdev
->virtqueues
, node
) {
874 if (info
->vq
->index
== index
) {
879 spin_unlock_irqrestore(&vcdev
->lock
, flags
);
883 static void virtio_ccw_int_handler(struct ccw_device
*cdev
,
884 unsigned long intparm
,
887 __u32 activity
= intparm
& VIRTIO_CCW_INTPARM_MASK
;
888 struct virtio_ccw_device
*vcdev
= dev_get_drvdata(&cdev
->dev
);
890 struct virtqueue
*vq
;
894 /* Check if it's a notification from the host. */
895 if ((intparm
== 0) &&
896 (scsw_stctl(&irb
->scsw
) ==
897 (SCSW_STCTL_ALERT_STATUS
| SCSW_STCTL_STATUS_PEND
))) {
900 if (irb_is_error(irb
)) {
901 /* Command reject? */
902 if ((scsw_dstat(&irb
->scsw
) & DEV_STAT_UNIT_CHECK
) &&
903 (irb
->ecw
[0] & SNS0_CMD_REJECT
))
904 vcdev
->err
= -EOPNOTSUPP
;
906 /* Map everything else to -EIO. */
909 if (vcdev
->curr_io
& activity
) {
911 case VIRTIO_CCW_DOING_READ_FEAT
:
912 case VIRTIO_CCW_DOING_WRITE_FEAT
:
913 case VIRTIO_CCW_DOING_READ_CONFIG
:
914 case VIRTIO_CCW_DOING_WRITE_CONFIG
:
915 case VIRTIO_CCW_DOING_WRITE_STATUS
:
916 case VIRTIO_CCW_DOING_SET_VQ
:
917 case VIRTIO_CCW_DOING_SET_IND
:
918 case VIRTIO_CCW_DOING_SET_CONF_IND
:
919 case VIRTIO_CCW_DOING_RESET
:
920 case VIRTIO_CCW_DOING_READ_VQ_CONF
:
921 case VIRTIO_CCW_DOING_SET_IND_ADAPTER
:
922 vcdev
->curr_io
&= ~activity
;
923 wake_up(&vcdev
->wait_q
);
926 /* don't know what to do... */
927 dev_warn(&cdev
->dev
, "Suspicious activity '%08x'\n",
933 for_each_set_bit(i
, &vcdev
->indicators
,
934 sizeof(vcdev
->indicators
) * BITS_PER_BYTE
) {
935 /* The bit clear must happen before the vring kick. */
936 clear_bit(i
, &vcdev
->indicators
);
938 vq
= virtio_ccw_vq_by_ind(vcdev
, i
);
939 vring_interrupt(0, vq
);
941 if (test_bit(0, &vcdev
->indicators2
)) {
942 virtio_config_changed(&vcdev
->vdev
);
943 clear_bit(0, &vcdev
->indicators2
);
948 * We usually want to autoonline all devices, but give the admin
949 * a way to exempt devices from this.
951 #define __DEV_WORDS ((__MAX_SUBCHANNEL + (8*sizeof(long) - 1)) / \
953 static unsigned long devs_no_auto
[__MAX_SSID
+ 1][__DEV_WORDS
];
955 static char *no_auto
= "";
957 module_param(no_auto
, charp
, 0444);
958 MODULE_PARM_DESC(no_auto
, "list of ccw bus id ranges not to be auto-onlined");
960 static int virtio_ccw_check_autoonline(struct ccw_device
*cdev
)
962 struct ccw_dev_id id
;
964 ccw_device_get_id(cdev
, &id
);
965 if (test_bit(id
.devno
, devs_no_auto
[id
.ssid
]))
970 static void virtio_ccw_auto_online(void *data
, async_cookie_t cookie
)
972 struct ccw_device
*cdev
= data
;
975 ret
= ccw_device_set_online(cdev
);
977 dev_warn(&cdev
->dev
, "Failed to set online: %d\n", ret
);
980 static int virtio_ccw_probe(struct ccw_device
*cdev
)
982 cdev
->handler
= virtio_ccw_int_handler
;
984 if (virtio_ccw_check_autoonline(cdev
))
985 async_schedule(virtio_ccw_auto_online
, cdev
);
989 static struct virtio_ccw_device
*virtio_grab_drvdata(struct ccw_device
*cdev
)
992 struct virtio_ccw_device
*vcdev
;
994 spin_lock_irqsave(get_ccwdev_lock(cdev
), flags
);
995 vcdev
= dev_get_drvdata(&cdev
->dev
);
996 if (!vcdev
|| vcdev
->going_away
) {
997 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
1000 vcdev
->going_away
= true;
1001 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
1005 static void virtio_ccw_remove(struct ccw_device
*cdev
)
1007 unsigned long flags
;
1008 struct virtio_ccw_device
*vcdev
= virtio_grab_drvdata(cdev
);
1010 if (vcdev
&& cdev
->online
) {
1011 if (vcdev
->device_lost
)
1012 virtio_break_device(&vcdev
->vdev
);
1013 unregister_virtio_device(&vcdev
->vdev
);
1014 spin_lock_irqsave(get_ccwdev_lock(cdev
), flags
);
1015 dev_set_drvdata(&cdev
->dev
, NULL
);
1016 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
1018 cdev
->handler
= NULL
;
1021 static int virtio_ccw_offline(struct ccw_device
*cdev
)
1023 unsigned long flags
;
1024 struct virtio_ccw_device
*vcdev
= virtio_grab_drvdata(cdev
);
1028 if (vcdev
->device_lost
)
1029 virtio_break_device(&vcdev
->vdev
);
1030 unregister_virtio_device(&vcdev
->vdev
);
1031 spin_lock_irqsave(get_ccwdev_lock(cdev
), flags
);
1032 dev_set_drvdata(&cdev
->dev
, NULL
);
1033 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
1038 static int virtio_ccw_online(struct ccw_device
*cdev
)
1041 struct virtio_ccw_device
*vcdev
;
1042 unsigned long flags
;
1044 vcdev
= kzalloc(sizeof(*vcdev
), GFP_KERNEL
);
1046 dev_warn(&cdev
->dev
, "Could not get memory for virtio\n");
1050 vcdev
->config_block
= kzalloc(sizeof(*vcdev
->config_block
),
1051 GFP_DMA
| GFP_KERNEL
);
1052 if (!vcdev
->config_block
) {
1056 vcdev
->status
= kzalloc(sizeof(*vcdev
->status
), GFP_DMA
| GFP_KERNEL
);
1057 if (!vcdev
->status
) {
1062 vcdev
->is_thinint
= virtio_ccw_use_airq
; /* at least try */
1064 vcdev
->vdev
.dev
.parent
= &cdev
->dev
;
1065 vcdev
->vdev
.dev
.release
= virtio_ccw_release_dev
;
1066 vcdev
->vdev
.config
= &virtio_ccw_config_ops
;
1068 init_waitqueue_head(&vcdev
->wait_q
);
1069 INIT_LIST_HEAD(&vcdev
->virtqueues
);
1070 spin_lock_init(&vcdev
->lock
);
1072 spin_lock_irqsave(get_ccwdev_lock(cdev
), flags
);
1073 dev_set_drvdata(&cdev
->dev
, vcdev
);
1074 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
1075 vcdev
->vdev
.id
.vendor
= cdev
->id
.cu_type
;
1076 vcdev
->vdev
.id
.device
= cdev
->id
.cu_model
;
1077 ret
= register_virtio_device(&vcdev
->vdev
);
1079 dev_warn(&cdev
->dev
, "Failed to register virtio device: %d\n",
1085 spin_lock_irqsave(get_ccwdev_lock(cdev
), flags
);
1086 dev_set_drvdata(&cdev
->dev
, NULL
);
1087 spin_unlock_irqrestore(get_ccwdev_lock(cdev
), flags
);
1088 put_device(&vcdev
->vdev
.dev
);
1092 kfree(vcdev
->status
);
1093 kfree(vcdev
->config_block
);
1099 static int virtio_ccw_cio_notify(struct ccw_device
*cdev
, int event
)
1102 struct virtio_ccw_device
*vcdev
= dev_get_drvdata(&cdev
->dev
);
1105 * Make sure vcdev is set
1106 * i.e. set_offline/remove callback not already running
1113 vcdev
->device_lost
= true;
1123 static struct ccw_device_id virtio_ids
[] = {
1124 { CCW_DEVICE(0x3832, 0) },
1127 MODULE_DEVICE_TABLE(ccw
, virtio_ids
);
1129 static struct ccw_driver virtio_ccw_driver
= {
1131 .owner
= THIS_MODULE
,
1132 .name
= "virtio_ccw",
1135 .probe
= virtio_ccw_probe
,
1136 .remove
= virtio_ccw_remove
,
1137 .set_offline
= virtio_ccw_offline
,
1138 .set_online
= virtio_ccw_online
,
1139 .notify
= virtio_ccw_cio_notify
,
1140 .int_class
= IRQIO_VIR
,
1143 static int __init
pure_hex(char **cp
, unsigned int *val
, int min_digit
,
1144 int max_digit
, int max_val
)
1151 while (diff
<= max_digit
) {
1152 int value
= hex_to_bin(**cp
);
1156 *val
= *val
* 16 + value
;
1161 if ((diff
< min_digit
) || (diff
> max_digit
) || (*val
> max_val
))
1167 static int __init
parse_busid(char *str
, unsigned int *cssid
,
1168 unsigned int *ssid
, unsigned int *devno
)
1179 ret
= pure_hex(&str_work
, cssid
, 1, 2, __MAX_CSSID
);
1180 if (ret
|| (str_work
[0] != '.'))
1183 ret
= pure_hex(&str_work
, ssid
, 1, 1, __MAX_SSID
);
1184 if (ret
|| (str_work
[0] != '.'))
1187 ret
= pure_hex(&str_work
, devno
, 4, 4, __MAX_SUBCHANNEL
);
1188 if (ret
|| (str_work
[0] != '\0'))
1196 static void __init
no_auto_parse(void)
1198 unsigned int from_cssid
, to_cssid
, from_ssid
, to_ssid
, from
, to
;
1203 while ((parm
= strsep(&str
, ","))) {
1204 rc
= parse_busid(strsep(&parm
, "-"), &from_cssid
,
1209 rc
= parse_busid(parm
, &to_cssid
,
1211 if ((from_ssid
> to_ssid
) ||
1212 ((from_ssid
== to_ssid
) && (from
> to
)))
1215 to_cssid
= from_cssid
;
1216 to_ssid
= from_ssid
;
1221 while ((from_ssid
< to_ssid
) ||
1222 ((from_ssid
== to_ssid
) && (from
<= to
))) {
1223 set_bit(from
, devs_no_auto
[from_ssid
]);
1225 if (from
> __MAX_SUBCHANNEL
) {
1233 static int __init
virtio_ccw_init(void)
1235 /* parse no_auto string before we do anything further */
1237 return ccw_driver_register(&virtio_ccw_driver
);
1239 module_init(virtio_ccw_init
);
1241 static void __exit
virtio_ccw_exit(void)
1245 ccw_driver_unregister(&virtio_ccw_driver
);
1246 for (i
= 0; i
< MAX_AIRQ_AREAS
; i
++)
1247 destroy_airq_info(airq_areas
[i
]);
1249 module_exit(virtio_ccw_exit
);