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