Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/s390/kvm/virtio_ccw.c

  1 /*
  2  * ccw based virtio transport
  3  *
  4  * Copyright IBM Corp. 2012
  5  *
  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.
  9  *
 10  *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
 11  */
 12 
 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>
 28 #include <linux/io.h>
 29 #include <linux/kvm_para.h>
 30 #include <asm/setup.h>
 31 #include <asm/irq.h>
 32 #include <asm/cio.h>
 33 #include <asm/ccwdev.h>
 34 #include <asm/virtio-ccw.h>
 35 
 36 /*
 37  * virtio related functions
 38  */
 39 
 40 struct vq_config_block {
 41         __u16 index;
 42         __u16 num;
 43 } __packed;
 44 
 45 #define VIRTIO_CCW_CONFIG_SIZE 0x100
 46 /* same as PCI config space size, should be enough for all drivers */
 47 
 48 struct virtio_ccw_device {
 49         struct virtio_device vdev;
 50         __u8 *status;
 51         __u8 config[VIRTIO_CCW_CONFIG_SIZE];
 52         struct ccw_device *cdev;
 53         __u32 curr_io;
 54         int err;
 55         wait_queue_head_t wait_q;
 56         spinlock_t lock;
 57         struct list_head virtqueues;
 58         unsigned long indicators;
 59         unsigned long indicators2;
 60         struct vq_config_block *config_block;
 61 };
 62 
 63 struct vq_info_block {
 64         __u64 queue;
 65         __u32 align;
 66         __u16 index;
 67         __u16 num;
 68 } __packed;
 69 
 70 struct virtio_feature_desc {
 71         __u32 features;
 72         __u8 index;
 73 } __packed;
 74 
 75 struct virtio_ccw_vq_info {
 76         struct virtqueue *vq;
 77         int num;
 78         void *queue;
 79         struct vq_info_block *info_block;
 80         struct list_head node;
 81         long cookie;
 82 };
 83 
 84 #define CCW_CMD_SET_VQ 0x13
 85 #define CCW_CMD_VDEV_RESET 0x33
 86 #define CCW_CMD_SET_IND 0x43
 87 #define CCW_CMD_SET_CONF_IND 0x53
 88 #define CCW_CMD_READ_FEAT 0x12
 89 #define CCW_CMD_WRITE_FEAT 0x11
 90 #define CCW_CMD_READ_CONF 0x22
 91 #define CCW_CMD_WRITE_CONF 0x21
 92 #define CCW_CMD_WRITE_STATUS 0x31
 93 #define CCW_CMD_READ_VQ_CONF 0x32
 94 
 95 #define VIRTIO_CCW_DOING_SET_VQ 0x00010000
 96 #define VIRTIO_CCW_DOING_RESET 0x00040000
 97 #define VIRTIO_CCW_DOING_READ_FEAT 0x00080000
 98 #define VIRTIO_CCW_DOING_WRITE_FEAT 0x00100000
 99 #define VIRTIO_CCW_DOING_READ_CONFIG 0x00200000
100 #define VIRTIO_CCW_DOING_WRITE_CONFIG 0x00400000
101 #define VIRTIO_CCW_DOING_WRITE_STATUS 0x00800000
102 #define VIRTIO_CCW_DOING_SET_IND 0x01000000
103 #define VIRTIO_CCW_DOING_READ_VQ_CONF 0x02000000
104 #define VIRTIO_CCW_DOING_SET_CONF_IND 0x04000000
105 #define VIRTIO_CCW_INTPARM_MASK 0xffff0000
106 
107 static struct virtio_ccw_device *to_vc_device(struct virtio_device *vdev)
108 {
109         return container_of(vdev, struct virtio_ccw_device, vdev);
110 }
111 
112 static int doing_io(struct virtio_ccw_device *vcdev, __u32 flag)
113 {
114         unsigned long flags;
115         __u32 ret;
116 
117         spin_lock_irqsave(get_ccwdev_lock(vcdev->cdev), flags);
118         if (vcdev->err)
119                 ret = 0;
120         else
121                 ret = vcdev->curr_io & flag;
122         spin_unlock_irqrestore(get_ccwdev_lock(vcdev->cdev), flags);
123         return ret;
124 }
125 
126 static int ccw_io_helper(struct virtio_ccw_device *vcdev,
127                          struct ccw1 *ccw, __u32 intparm)
128 {
129         int ret;
130         unsigned long flags;
131         int flag = intparm & VIRTIO_CCW_INTPARM_MASK;
132 
133         do {
134                 spin_lock_irqsave(get_ccwdev_lock(vcdev->cdev), flags);
135                 ret = ccw_device_start(vcdev->cdev, ccw, intparm, 0, 0);
136                 if (!ret) {
137                         if (!vcdev->curr_io)
138                                 vcdev->err = 0;
139                         vcdev->curr_io |= flag;
140                 }
141                 spin_unlock_irqrestore(get_ccwdev_lock(vcdev->cdev), flags);
142                 cpu_relax();
143         } while (ret == -EBUSY);
144         wait_event(vcdev->wait_q, doing_io(vcdev, flag) == 0);
145         return ret ? ret : vcdev->err;
146 }
147 
148 static inline long do_kvm_notify(struct subchannel_id schid,
149                                  unsigned long queue_index,
150                                  long cookie)
151 {
152         register unsigned long __nr asm("1") = KVM_S390_VIRTIO_CCW_NOTIFY;
153         register struct subchannel_id __schid asm("2") = schid;
154         register unsigned long __index asm("3") = queue_index;
155         register long __rc asm("2");
156         register long __cookie asm("4") = cookie;
157 
158         asm volatile ("diag 2,4,0x500\n"
159                       : "=d" (__rc) : "d" (__nr), "d" (__schid), "d" (__index),
160                       "d"(__cookie)
161                       : "memory", "cc");
162         return __rc;
163 }
164 
165 static bool virtio_ccw_kvm_notify(struct virtqueue *vq)
166 {
167         struct virtio_ccw_vq_info *info = vq->priv;
168         struct virtio_ccw_device *vcdev;
169         struct subchannel_id schid;
170 
171         vcdev = to_vc_device(info->vq->vdev);
172         ccw_device_get_schid(vcdev->cdev, &schid);
173         info->cookie = do_kvm_notify(schid, vq->index, info->cookie);
174         if (info->cookie < 0)
175                 return false;
176         return true;
177 }
178 
179 static int virtio_ccw_read_vq_conf(struct virtio_ccw_device *vcdev,
180                                    struct ccw1 *ccw, int index)
181 {
182         vcdev->config_block->index = index;
183         ccw->cmd_code = CCW_CMD_READ_VQ_CONF;
184         ccw->flags = 0;
185         ccw->count = sizeof(struct vq_config_block);
186         ccw->cda = (__u32)(unsigned long)(vcdev->config_block);
187         ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_VQ_CONF);
188         return vcdev->config_block->num;
189 }
190 
191 static void virtio_ccw_del_vq(struct virtqueue *vq, struct ccw1 *ccw)
192 {
193         struct virtio_ccw_device *vcdev = to_vc_device(vq->vdev);
194         struct virtio_ccw_vq_info *info = vq->priv;
195         unsigned long flags;
196         unsigned long size;
197         int ret;
198         unsigned int index = vq->index;
199 
200         /* Remove from our list. */
201         spin_lock_irqsave(&vcdev->lock, flags);
202         list_del(&info->node);
203         spin_unlock_irqrestore(&vcdev->lock, flags);
204 
205         /* Release from host. */
206         info->info_block->queue = 0;
207         info->info_block->align = 0;
208         info->info_block->index = index;
209         info->info_block->num = 0;
210         ccw->cmd_code = CCW_CMD_SET_VQ;
211         ccw->flags = 0;
212         ccw->count = sizeof(*info->info_block);
213         ccw->cda = (__u32)(unsigned long)(info->info_block);
214         ret = ccw_io_helper(vcdev, ccw,
215                             VIRTIO_CCW_DOING_SET_VQ | index);
216         /*
217          * -ENODEV isn't considered an error: The device is gone anyway.
218          * This may happen on device detach.
219          */
220         if (ret && (ret != -ENODEV))
221                 dev_warn(&vq->vdev->dev, "Error %d while deleting queue %d",
222                          ret, index);
223 
224         vring_del_virtqueue(vq);
225         size = PAGE_ALIGN(vring_size(info->num, KVM_VIRTIO_CCW_RING_ALIGN));
226         free_pages_exact(info->queue, size);
227         kfree(info->info_block);
228         kfree(info);
229 }
230 
231 static void virtio_ccw_del_vqs(struct virtio_device *vdev)
232 {
233         struct virtqueue *vq, *n;
234         struct ccw1 *ccw;
235 
236         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
237         if (!ccw)
238                 return;
239 
240 
241         list_for_each_entry_safe(vq, n, &vdev->vqs, list)
242                 virtio_ccw_del_vq(vq, ccw);
243 
244         kfree(ccw);
245 }
246 
247 static struct virtqueue *virtio_ccw_setup_vq(struct virtio_device *vdev,
248                                              int i, vq_callback_t *callback,
249                                              const char *name,
250                                              struct ccw1 *ccw)
251 {
252         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
253         int err;
254         struct virtqueue *vq = NULL;
255         struct virtio_ccw_vq_info *info;
256         unsigned long size = 0; /* silence the compiler */
257         unsigned long flags;
258 
259         /* Allocate queue. */
260         info = kzalloc(sizeof(struct virtio_ccw_vq_info), GFP_KERNEL);
261         if (!info) {
262                 dev_warn(&vcdev->cdev->dev, "no info\n");
263                 err = -ENOMEM;
264                 goto out_err;
265         }
266         info->info_block = kzalloc(sizeof(*info->info_block),
267                                    GFP_DMA | GFP_KERNEL);
268         if (!info->info_block) {
269                 dev_warn(&vcdev->cdev->dev, "no info block\n");
270                 err = -ENOMEM;
271                 goto out_err;
272         }
273         info->num = virtio_ccw_read_vq_conf(vcdev, ccw, i);
274         size = PAGE_ALIGN(vring_size(info->num, KVM_VIRTIO_CCW_RING_ALIGN));
275         info->queue = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO);
276         if (info->queue == NULL) {
277                 dev_warn(&vcdev->cdev->dev, "no queue\n");
278                 err = -ENOMEM;
279                 goto out_err;
280         }
281 
282         vq = vring_new_virtqueue(i, info->num, KVM_VIRTIO_CCW_RING_ALIGN, vdev,
283                                  true, info->queue, virtio_ccw_kvm_notify,
284                                  callback, name);
285         if (!vq) {
286                 /* For now, we fail if we can't get the requested size. */
287                 dev_warn(&vcdev->cdev->dev, "no vq\n");
288                 err = -ENOMEM;
289                 goto out_err;
290         }
291 
292         /* Register it with the host. */
293         info->info_block->queue = (__u64)info->queue;
294         info->info_block->align = KVM_VIRTIO_CCW_RING_ALIGN;
295         info->info_block->index = i;
296         info->info_block->num = info->num;
297         ccw->cmd_code = CCW_CMD_SET_VQ;
298         ccw->flags = 0;
299         ccw->count = sizeof(*info->info_block);
300         ccw->cda = (__u32)(unsigned long)(info->info_block);
301         err = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_VQ | i);
302         if (err) {
303                 dev_warn(&vcdev->cdev->dev, "SET_VQ failed\n");
304                 goto out_err;
305         }
306 
307         info->vq = vq;
308         vq->priv = info;
309 
310         /* Save it to our list. */
311         spin_lock_irqsave(&vcdev->lock, flags);
312         list_add(&info->node, &vcdev->virtqueues);
313         spin_unlock_irqrestore(&vcdev->lock, flags);
314 
315         return vq;
316 
317 out_err:
318         if (vq)
319                 vring_del_virtqueue(vq);
320         if (info) {
321                 if (info->queue)
322                         free_pages_exact(info->queue, size);
323                 kfree(info->info_block);
324         }
325         kfree(info);
326         return ERR_PTR(err);
327 }
328 
329 static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
330                                struct virtqueue *vqs[],
331                                vq_callback_t *callbacks[],
332                                const char *names[])
333 {
334         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
335         unsigned long *indicatorp = NULL;
336         int ret, i;
337         struct ccw1 *ccw;
338 
339         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
340         if (!ccw)
341                 return -ENOMEM;
342 
343         for (i = 0; i < nvqs; ++i) {
344                 vqs[i] = virtio_ccw_setup_vq(vdev, i, callbacks[i], names[i],
345                                              ccw);
346                 if (IS_ERR(vqs[i])) {
347                         ret = PTR_ERR(vqs[i]);
348                         vqs[i] = NULL;
349                         goto out;
350                 }
351         }
352         ret = -ENOMEM;
353         /* We need a data area under 2G to communicate. */
354         indicatorp = kmalloc(sizeof(&vcdev->indicators), GFP_DMA | GFP_KERNEL);
355         if (!indicatorp)
356                 goto out;
357         *indicatorp = (unsigned long) &vcdev->indicators;
358         /* Register queue indicators with host. */
359         vcdev->indicators = 0;
360         ccw->cmd_code = CCW_CMD_SET_IND;
361         ccw->flags = 0;
362         ccw->count = sizeof(vcdev->indicators);
363         ccw->cda = (__u32)(unsigned long) indicatorp;
364         ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND);
365         if (ret)
366                 goto out;
367         /* Register indicators2 with host for config changes */
368         *indicatorp = (unsigned long) &vcdev->indicators2;
369         vcdev->indicators2 = 0;
370         ccw->cmd_code = CCW_CMD_SET_CONF_IND;
371         ccw->flags = 0;
372         ccw->count = sizeof(vcdev->indicators2);
373         ccw->cda = (__u32)(unsigned long) indicatorp;
374         ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_CONF_IND);
375         if (ret)
376                 goto out;
377 
378         kfree(indicatorp);
379         kfree(ccw);
380         return 0;
381 out:
382         kfree(indicatorp);
383         kfree(ccw);
384         virtio_ccw_del_vqs(vdev);
385         return ret;
386 }
387 
388 static void virtio_ccw_reset(struct virtio_device *vdev)
389 {
390         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
391         struct ccw1 *ccw;
392 
393         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
394         if (!ccw)
395                 return;
396 
397         /* Zero status bits. */
398         *vcdev->status = 0;
399 
400         /* Send a reset ccw on device. */
401         ccw->cmd_code = CCW_CMD_VDEV_RESET;
402         ccw->flags = 0;
403         ccw->count = 0;
404         ccw->cda = 0;
405         ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_RESET);
406         kfree(ccw);
407 }
408 
409 static u32 virtio_ccw_get_features(struct virtio_device *vdev)
410 {
411         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
412         struct virtio_feature_desc *features;
413         int ret, rc;
414         struct ccw1 *ccw;
415 
416         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
417         if (!ccw)
418                 return 0;
419 
420         features = kzalloc(sizeof(*features), GFP_DMA | GFP_KERNEL);
421         if (!features) {
422                 rc = 0;
423                 goto out_free;
424         }
425         /* Read the feature bits from the host. */
426         /* TODO: Features > 32 bits */
427         features->index = 0;
428         ccw->cmd_code = CCW_CMD_READ_FEAT;
429         ccw->flags = 0;
430         ccw->count = sizeof(*features);
431         ccw->cda = (__u32)(unsigned long)features;
432         ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_FEAT);
433         if (ret) {
434                 rc = 0;
435                 goto out_free;
436         }
437 
438         rc = le32_to_cpu(features->features);
439 
440 out_free:
441         kfree(features);
442         kfree(ccw);
443         return rc;
444 }
445 
446 static void virtio_ccw_finalize_features(struct virtio_device *vdev)
447 {
448         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
449         struct virtio_feature_desc *features;
450         int i;
451         struct ccw1 *ccw;
452 
453         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
454         if (!ccw)
455                 return;
456 
457         features = kzalloc(sizeof(*features), GFP_DMA | GFP_KERNEL);
458         if (!features)
459                 goto out_free;
460 
461         /* Give virtio_ring a chance to accept features. */
462         vring_transport_features(vdev);
463 
464         for (i = 0; i < sizeof(*vdev->features) / sizeof(features->features);
465              i++) {
466                 int highbits = i % 2 ? 32 : 0;
467                 features->index = i;
468                 features->features = cpu_to_le32(vdev->features[i / 2]
469                                                  >> highbits);
470                 /* Write the feature bits to the host. */
471                 ccw->cmd_code = CCW_CMD_WRITE_FEAT;
472                 ccw->flags = 0;
473                 ccw->count = sizeof(*features);
474                 ccw->cda = (__u32)(unsigned long)features;
475                 ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_FEAT);
476         }
477 out_free:
478         kfree(features);
479         kfree(ccw);
480 }
481 
482 static void virtio_ccw_get_config(struct virtio_device *vdev,
483                                   unsigned int offset, void *buf, unsigned len)
484 {
485         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
486         int ret;
487         struct ccw1 *ccw;
488         void *config_area;
489 
490         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
491         if (!ccw)
492                 return;
493 
494         config_area = kzalloc(VIRTIO_CCW_CONFIG_SIZE, GFP_DMA | GFP_KERNEL);
495         if (!config_area)
496                 goto out_free;
497 
498         /* Read the config area from the host. */
499         ccw->cmd_code = CCW_CMD_READ_CONF;
500         ccw->flags = 0;
501         ccw->count = offset + len;
502         ccw->cda = (__u32)(unsigned long)config_area;
503         ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_CONFIG);
504         if (ret)
505                 goto out_free;
506 
507         memcpy(vcdev->config, config_area, sizeof(vcdev->config));
508         memcpy(buf, &vcdev->config[offset], len);
509 
510 out_free:
511         kfree(config_area);
512         kfree(ccw);
513 }
514 
515 static void virtio_ccw_set_config(struct virtio_device *vdev,
516                                   unsigned int offset, const void *buf,
517                                   unsigned len)
518 {
519         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
520         struct ccw1 *ccw;
521         void *config_area;
522 
523         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
524         if (!ccw)
525                 return;
526 
527         config_area = kzalloc(VIRTIO_CCW_CONFIG_SIZE, GFP_DMA | GFP_KERNEL);
528         if (!config_area)
529                 goto out_free;
530 
531         memcpy(&vcdev->config[offset], buf, len);
532         /* Write the config area to the host. */
533         memcpy(config_area, vcdev->config, sizeof(vcdev->config));
534         ccw->cmd_code = CCW_CMD_WRITE_CONF;
535         ccw->flags = 0;
536         ccw->count = offset + len;
537         ccw->cda = (__u32)(unsigned long)config_area;
538         ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_CONFIG);
539 
540 out_free:
541         kfree(config_area);
542         kfree(ccw);
543 }
544 
545 static u8 virtio_ccw_get_status(struct virtio_device *vdev)
546 {
547         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
548 
549         return *vcdev->status;
550 }
551 
552 static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)
553 {
554         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
555         struct ccw1 *ccw;
556 
557         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
558         if (!ccw)
559                 return;
560 
561         /* Write the status to the host. */
562         *vcdev->status = status;
563         ccw->cmd_code = CCW_CMD_WRITE_STATUS;
564         ccw->flags = 0;
565         ccw->count = sizeof(status);
566         ccw->cda = (__u32)(unsigned long)vcdev->status;
567         ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_STATUS);
568         kfree(ccw);
569 }
570 
571 static struct virtio_config_ops virtio_ccw_config_ops = {
572         .get_features = virtio_ccw_get_features,
573         .finalize_features = virtio_ccw_finalize_features,
574         .get = virtio_ccw_get_config,
575         .set = virtio_ccw_set_config,
576         .get_status = virtio_ccw_get_status,
577         .set_status = virtio_ccw_set_status,
578         .reset = virtio_ccw_reset,
579         .find_vqs = virtio_ccw_find_vqs,
580         .del_vqs = virtio_ccw_del_vqs,
581 };
582 
583 
584 /*
585  * ccw bus driver related functions
586  */
587 
588 static void virtio_ccw_release_dev(struct device *_d)
589 {
590         struct virtio_device *dev = container_of(_d, struct virtio_device,
591                                                  dev);
592         struct virtio_ccw_device *vcdev = to_vc_device(dev);
593 
594         kfree(vcdev->status);
595         kfree(vcdev->config_block);
596         kfree(vcdev);
597 }
598 
599 static int irb_is_error(struct irb *irb)
600 {
601         if (scsw_cstat(&irb->scsw) != 0)
602                 return 1;
603         if (scsw_dstat(&irb->scsw) & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))
604                 return 1;
605         if (scsw_cc(&irb->scsw) != 0)
606                 return 1;
607         return 0;
608 }
609 
610 static struct virtqueue *virtio_ccw_vq_by_ind(struct virtio_ccw_device *vcdev,
611                                               int index)
612 {
613         struct virtio_ccw_vq_info *info;
614         unsigned long flags;
615         struct virtqueue *vq;
616 
617         vq = NULL;
618         spin_lock_irqsave(&vcdev->lock, flags);
619         list_for_each_entry(info, &vcdev->virtqueues, node) {
620                 if (info->vq->index == index) {
621                         vq = info->vq;
622                         break;
623                 }
624         }
625         spin_unlock_irqrestore(&vcdev->lock, flags);
626         return vq;
627 }
628 
629 static void virtio_ccw_int_handler(struct ccw_device *cdev,
630                                    unsigned long intparm,
631                                    struct irb *irb)
632 {
633         __u32 activity = intparm & VIRTIO_CCW_INTPARM_MASK;
634         struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
635         int i;
636         struct virtqueue *vq;
637         struct virtio_driver *drv;
638 
639         /* Check if it's a notification from the host. */
640         if ((intparm == 0) &&
641             (scsw_stctl(&irb->scsw) ==
642              (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND))) {
643                 /* OK */
644         }
645         if (irb_is_error(irb)) {
646                 /* Command reject? */
647                 if ((scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK) &&
648                     (irb->ecw[0] & SNS0_CMD_REJECT))
649                         vcdev->err = -EOPNOTSUPP;
650                 else
651                         /* Map everything else to -EIO. */
652                         vcdev->err = -EIO;
653         }
654         if (vcdev->curr_io & activity) {
655                 switch (activity) {
656                 case VIRTIO_CCW_DOING_READ_FEAT:
657                 case VIRTIO_CCW_DOING_WRITE_FEAT:
658                 case VIRTIO_CCW_DOING_READ_CONFIG:
659                 case VIRTIO_CCW_DOING_WRITE_CONFIG:
660                 case VIRTIO_CCW_DOING_WRITE_STATUS:
661                 case VIRTIO_CCW_DOING_SET_VQ:
662                 case VIRTIO_CCW_DOING_SET_IND:
663                 case VIRTIO_CCW_DOING_SET_CONF_IND:
664                 case VIRTIO_CCW_DOING_RESET:
665                 case VIRTIO_CCW_DOING_READ_VQ_CONF:
666                         vcdev->curr_io &= ~activity;
667                         wake_up(&vcdev->wait_q);
668                         break;
669                 default:
670                         /* don't know what to do... */
671                         dev_warn(&cdev->dev, "Suspicious activity '%08x'\n",
672                                  activity);
673                         WARN_ON(1);
674                         break;
675                 }
676         }
677         for_each_set_bit(i, &vcdev->indicators,
678                          sizeof(vcdev->indicators) * BITS_PER_BYTE) {
679                 /* The bit clear must happen before the vring kick. */
680                 clear_bit(i, &vcdev->indicators);
681                 barrier();
682                 vq = virtio_ccw_vq_by_ind(vcdev, i);
683                 vring_interrupt(0, vq);
684         }
685         if (test_bit(0, &vcdev->indicators2)) {
686                 drv = container_of(vcdev->vdev.dev.driver,
687                                    struct virtio_driver, driver);
688 
689                 if (drv && drv->config_changed)
690                         drv->config_changed(&vcdev->vdev);
691                 clear_bit(0, &vcdev->indicators2);
692         }
693 }
694 
695 /*
696  * We usually want to autoonline all devices, but give the admin
697  * a way to exempt devices from this.
698  */
699 #define __DEV_WORDS ((__MAX_SUBCHANNEL + (8*sizeof(long) - 1)) / \
700                      (8*sizeof(long)))
701 static unsigned long devs_no_auto[__MAX_SSID + 1][__DEV_WORDS];
702 
703 static char *no_auto = "";
704 
705 module_param(no_auto, charp, 0444);
706 MODULE_PARM_DESC(no_auto, "list of ccw bus id ranges not to be auto-onlined");
707 
708 static int virtio_ccw_check_autoonline(struct ccw_device *cdev)
709 {
710         struct ccw_dev_id id;
711 
712         ccw_device_get_id(cdev, &id);
713         if (test_bit(id.devno, devs_no_auto[id.ssid]))
714                 return 0;
715         return 1;
716 }
717 
718 static void virtio_ccw_auto_online(void *data, async_cookie_t cookie)
719 {
720         struct ccw_device *cdev = data;
721         int ret;
722 
723         ret = ccw_device_set_online(cdev);
724         if (ret)
725                 dev_warn(&cdev->dev, "Failed to set online: %d\n", ret);
726 }
727 
728 static int virtio_ccw_probe(struct ccw_device *cdev)
729 {
730         cdev->handler = virtio_ccw_int_handler;
731 
732         if (virtio_ccw_check_autoonline(cdev))
733                 async_schedule(virtio_ccw_auto_online, cdev);
734         return 0;
735 }
736 
737 static void virtio_ccw_remove(struct ccw_device *cdev)
738 {
739         struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
740 
741         if (cdev->online) {
742                 unregister_virtio_device(&vcdev->vdev);
743                 dev_set_drvdata(&cdev->dev, NULL);
744         }
745         cdev->handler = NULL;
746 }
747 
748 static int virtio_ccw_offline(struct ccw_device *cdev)
749 {
750         struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
751 
752         unregister_virtio_device(&vcdev->vdev);
753         dev_set_drvdata(&cdev->dev, NULL);
754         return 0;
755 }
756 
757 
758 static int virtio_ccw_online(struct ccw_device *cdev)
759 {
760         int ret;
761         struct virtio_ccw_device *vcdev;
762 
763         vcdev = kzalloc(sizeof(*vcdev), GFP_KERNEL);
764         if (!vcdev) {
765                 dev_warn(&cdev->dev, "Could not get memory for virtio\n");
766                 ret = -ENOMEM;
767                 goto out_free;
768         }
769         vcdev->config_block = kzalloc(sizeof(*vcdev->config_block),
770                                    GFP_DMA | GFP_KERNEL);
771         if (!vcdev->config_block) {
772                 ret = -ENOMEM;
773                 goto out_free;
774         }
775         vcdev->status = kzalloc(sizeof(*vcdev->status), GFP_DMA | GFP_KERNEL);
776         if (!vcdev->status) {
777                 ret = -ENOMEM;
778                 goto out_free;
779         }
780 
781         vcdev->vdev.dev.parent = &cdev->dev;
782         vcdev->vdev.dev.release = virtio_ccw_release_dev;
783         vcdev->vdev.config = &virtio_ccw_config_ops;
784         vcdev->cdev = cdev;
785         init_waitqueue_head(&vcdev->wait_q);
786         INIT_LIST_HEAD(&vcdev->virtqueues);
787         spin_lock_init(&vcdev->lock);
788 
789         dev_set_drvdata(&cdev->dev, vcdev);
790         vcdev->vdev.id.vendor = cdev->id.cu_type;
791         vcdev->vdev.id.device = cdev->id.cu_model;
792         ret = register_virtio_device(&vcdev->vdev);
793         if (ret) {
794                 dev_warn(&cdev->dev, "Failed to register virtio device: %d\n",
795                          ret);
796                 goto out_put;
797         }
798         return 0;
799 out_put:
800         dev_set_drvdata(&cdev->dev, NULL);
801         put_device(&vcdev->vdev.dev);
802         return ret;
803 out_free:
804         if (vcdev) {
805                 kfree(vcdev->status);
806                 kfree(vcdev->config_block);
807         }
808         kfree(vcdev);
809         return ret;
810 }
811 
812 static int virtio_ccw_cio_notify(struct ccw_device *cdev, int event)
813 {
814         /* TODO: Check whether we need special handling here. */
815         return 0;
816 }
817 
818 static struct ccw_device_id virtio_ids[] = {
819         { CCW_DEVICE(0x3832, 0) },
820         {},
821 };
822 MODULE_DEVICE_TABLE(ccw, virtio_ids);
823 
824 static struct ccw_driver virtio_ccw_driver = {
825         .driver = {
826                 .owner = THIS_MODULE,
827                 .name = "virtio_ccw",
828         },
829         .ids = virtio_ids,
830         .probe = virtio_ccw_probe,
831         .remove = virtio_ccw_remove,
832         .set_offline = virtio_ccw_offline,
833         .set_online = virtio_ccw_online,
834         .notify = virtio_ccw_cio_notify,
835         .int_class = IRQIO_VIR,
836 };
837 
838 static int __init pure_hex(char **cp, unsigned int *val, int min_digit,
839                            int max_digit, int max_val)
840 {
841         int diff;
842 
843         diff = 0;
844         *val = 0;
845 
846         while (diff <= max_digit) {
847                 int value = hex_to_bin(**cp);
848 
849                 if (value < 0)
850                         break;
851                 *val = *val * 16 + value;
852                 (*cp)++;
853                 diff++;
854         }
855 
856         if ((diff < min_digit) || (diff > max_digit) || (*val > max_val))
857                 return 1;
858 
859         return 0;
860 }
861 
862 static int __init parse_busid(char *str, unsigned int *cssid,
863                               unsigned int *ssid, unsigned int *devno)
864 {
865         char *str_work;
866         int rc, ret;
867 
868         rc = 1;
869 
870         if (*str == '\0')
871                 goto out;
872 
873         str_work = str;
874         ret = pure_hex(&str_work, cssid, 1, 2, __MAX_CSSID);
875         if (ret || (str_work[0] != '.'))
876                 goto out;
877         str_work++;
878         ret = pure_hex(&str_work, ssid, 1, 1, __MAX_SSID);
879         if (ret || (str_work[0] != '.'))
880                 goto out;
881         str_work++;
882         ret = pure_hex(&str_work, devno, 4, 4, __MAX_SUBCHANNEL);
883         if (ret || (str_work[0] != '\0'))
884                 goto out;
885 
886         rc = 0;
887 out:
888         return rc;
889 }
890 
891 static void __init no_auto_parse(void)
892 {
893         unsigned int from_cssid, to_cssid, from_ssid, to_ssid, from, to;
894         char *parm, *str;
895         int rc;
896 
897         str = no_auto;
898         while ((parm = strsep(&str, ","))) {
899                 rc = parse_busid(strsep(&parm, "-"), &from_cssid,
900                                  &from_ssid, &from);
901                 if (rc)
902                         continue;
903                 if (parm != NULL) {
904                         rc = parse_busid(parm, &to_cssid,
905                                          &to_ssid, &to);
906                         if ((from_ssid > to_ssid) ||
907                             ((from_ssid == to_ssid) && (from > to)))
908                                 rc = -EINVAL;
909                 } else {
910                         to_cssid = from_cssid;
911                         to_ssid = from_ssid;
912                         to = from;
913                 }
914                 if (rc)
915                         continue;
916                 while ((from_ssid < to_ssid) ||
917                        ((from_ssid == to_ssid) && (from <= to))) {
918                         set_bit(from, devs_no_auto[from_ssid]);
919                         from++;
920                         if (from > __MAX_SUBCHANNEL) {
921                                 from_ssid++;
922                                 from = 0;
923                         }
924                 }
925         }
926 }
927 
928 static int __init virtio_ccw_init(void)
929 {
930         /* parse no_auto string before we do anything further */
931         no_auto_parse();
932         return ccw_driver_register(&virtio_ccw_driver);
933 }
934 module_init(virtio_ccw_init);
935 
936 static void __exit virtio_ccw_exit(void)
937 {
938         ccw_driver_unregister(&virtio_ccw_driver);
939 }
940 module_exit(virtio_ccw_exit);
941 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us