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);