Merge tag 'kvm-3.9-1' of git://git.kernel.org/pub/scm/virt/kvm/kvm
Linus Torvalds [Sun, 24 Feb 2013 21:07:18 +0000 (13:07 -0800)]
Pull KVM updates from Marcelo Tosatti:
 "KVM updates for the 3.9 merge window, including x86 real mode
  emulation fixes, stronger memory slot interface restrictions, mmu_lock
  spinlock hold time reduction, improved handling of large page faults
  on shadow, initial APICv HW acceleration support, s390 channel IO
  based virtio, amongst others"

* tag 'kvm-3.9-1' of git://git.kernel.org/pub/scm/virt/kvm/kvm: (143 commits)
  Revert "KVM: MMU: lazily drop large spte"
  x86: pvclock kvm: align allocation size to page size
  KVM: nVMX: Remove redundant get_vmcs12 from nested_vmx_exit_handled_msr
  x86 emulator: fix parity calculation for AAD instruction
  KVM: PPC: BookE: Handle alignment interrupts
  booke: Added DBCR4 SPR number
  KVM: PPC: booke: Allow multiple exception types
  KVM: PPC: booke: use vcpu reference from thread_struct
  KVM: Remove user_alloc from struct kvm_memory_slot
  KVM: VMX: disable apicv by default
  KVM: s390: Fix handling of iscs.
  KVM: MMU: cleanup __direct_map
  KVM: MMU: remove pt_access in mmu_set_spte
  KVM: MMU: cleanup mapping-level
  KVM: MMU: lazily drop large spte
  KVM: VMX: cleanup vmx_set_cr0().
  KVM: VMX: add missing exit names to VMX_EXIT_REASONS array
  KVM: VMX: disable SMEP feature when guest is in non-paging mode
  KVM: Remove duplicate text in api.txt
  Revert "KVM: MMU: split kvm_mmu_free_page"
  ...

20 files changed:
1  2 
Documentation/virtual/kvm/api.txt
arch/powerpc/include/asm/kvm_host.h
arch/powerpc/include/asm/reg.h
arch/powerpc/kernel/asm-offsets.c
arch/powerpc/kvm/book3s_pr.c
arch/powerpc/kvm/emulate.c
arch/s390/include/asm/irq.h
arch/s390/kernel/irq.c
arch/s390/kvm/interrupt.c
arch/s390/kvm/kvm-s390.c
arch/x86/include/asm/kvm_para.h
arch/x86/include/asm/vmx.h
arch/x86/include/uapi/asm/vmx.h
arch/x86/kernel/kvmclock.c
arch/x86/kvm/x86.c
drivers/s390/kvm/kvm_virtio.c
drivers/s390/kvm/virtio_ccw.c
include/linux/kvm_host.h
include/uapi/linux/kvm.h
kernel/sched/core.c

@@@ -1792,28 -1761,8 +1779,29 @@@ registers, find a list below
    PPC   | KVM_REG_PPC_VPA_SLB   | 128
    PPC   | KVM_REG_PPC_VPA_DTL   | 128
    PPC   | KVM_REG_PPC_EPCR    | 32
+   PPC   | KVM_REG_PPC_EPR     | 32
  
 +ARM registers are mapped using the lower 32 bits.  The upper 16 of that
 +is the register group type, or coprocessor number:
 +
 +ARM core registers have the following id bit patterns:
 +  0x4002 0000 0010 <index into the kvm_regs struct:16>
 +
 +ARM 32-bit CP15 registers have the following id bit patterns:
 +  0x4002 0000 000F <zero:1> <crn:4> <crm:4> <opc1:4> <opc2:3>
 +
 +ARM 64-bit CP15 registers have the following id bit patterns:
 +  0x4003 0000 000F <zero:1> <zero:4> <crm:4> <opc1:4> <zero:3>
 +
 +ARM CCSIDR registers are demultiplexed by CSSELR value:
 +  0x4002 0000 0011 00 <csselr:8>
 +
 +ARM 32-bit VFP control registers have the following id bit patterns:
 +  0x4002 0000 0012 1 <regno:12>
 +
 +ARM 64-bit FP registers have the following id bit patterns:
 +  0x4002 0000 0012 0 <regno:12>
 +
  4.69 KVM_GET_ONE_REG
  
  Capability: KVM_CAP_ONE_REG
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -2,61 -2,44 +2,62 @@@
  #define _ASM_IRQ_H
  
  #include <linux/hardirq.h>
 +#include <linux/percpu.h>
 +#include <linux/cache.h>
  #include <linux/types.h>
  
 -enum interruption_class {
 +enum interruption_main_class {
        EXTERNAL_INTERRUPT,
        IO_INTERRUPT,
 -      EXTINT_CLK,
 -      EXTINT_EXC,
 -      EXTINT_EMS,
 -      EXTINT_TMR,
 -      EXTINT_TLA,
 -      EXTINT_PFL,
 -      EXTINT_DSD,
 -      EXTINT_VRT,
 -      EXTINT_SCP,
 -      EXTINT_IUC,
 -      EXTINT_CMS,
 -      EXTINT_CMC,
 -      EXTINT_CMR,
 -      IOINT_CIO,
 -      IOINT_QAI,
 -      IOINT_DAS,
 -      IOINT_C15,
 -      IOINT_C70,
 -      IOINT_TAP,
 -      IOINT_VMR,
 -      IOINT_LCS,
 -      IOINT_CLW,
 -      IOINT_CTC,
 -      IOINT_APB,
 -      IOINT_ADM,
 -      IOINT_CSC,
 -      IOINT_PCI,
 -      IOINT_MSI,
 -      IOINT_VIR,
 +      NR_IRQS
 +};
 +
 +enum interruption_class {
 +      IRQEXT_CLK,
 +      IRQEXT_EXC,
 +      IRQEXT_EMS,
 +      IRQEXT_TMR,
 +      IRQEXT_TLA,
 +      IRQEXT_PFL,
 +      IRQEXT_DSD,
 +      IRQEXT_VRT,
 +      IRQEXT_SCP,
 +      IRQEXT_IUC,
 +      IRQEXT_CMS,
 +      IRQEXT_CMC,
 +      IRQEXT_CMR,
 +      IRQIO_CIO,
 +      IRQIO_QAI,
 +      IRQIO_DAS,
 +      IRQIO_C15,
 +      IRQIO_C70,
 +      IRQIO_TAP,
 +      IRQIO_VMR,
 +      IRQIO_LCS,
 +      IRQIO_CLW,
 +      IRQIO_CTC,
 +      IRQIO_APB,
 +      IRQIO_ADM,
 +      IRQIO_CSC,
 +      IRQIO_PCI,
 +      IRQIO_MSI,
++      IRQIO_VIR,
        NMI_NMI,
 -      NR_IRQS,
 +      CPU_RST,
 +      NR_ARCH_IRQS
  };
  
 +struct irq_stat {
 +      unsigned int irqs[NR_ARCH_IRQS];
 +};
 +
 +DECLARE_PER_CPU_SHARED_ALIGNED(struct irq_stat, irq_stat);
 +
 +static __always_inline void inc_irq_stat(enum interruption_class irq)
 +{
 +      __get_cpu_var(irq_stat).irqs[irq]++;
 +}
 +
  struct ext_code {
        unsigned short subcode;
        unsigned short code;
@@@ -32,57 -29,39 +32,58 @@@ struct irq_class 
        char *desc;
  };
  
 -static const struct irq_class intrclass_names[] = {
 +/*
 + * The list of "main" irq classes on s390. This is the list of interrrupts
 + * that appear both in /proc/stat ("intr" line) and /proc/interrupts.
 + * Historically only external and I/O interrupts have been part of /proc/stat.
 + * We can't add the split external and I/O sub classes since the first field
 + * in the "intr" line in /proc/stat is supposed to be the sum of all other
 + * fields.
 + * Since the external and I/O interrupt fields are already sums we would end
 + * up with having a sum which accounts each interrupt twice.
 + */
 +static const struct irq_class irqclass_main_desc[NR_IRQS] = {
        [EXTERNAL_INTERRUPT] = {.name = "EXT"},
 -      [IO_INTERRUPT]       = {.name = "I/O"},
 -      [EXTINT_CLK] = {.name = "CLK", .desc = "[EXT] Clock Comparator"},
 -      [EXTINT_EXC] = {.name = "EXC", .desc = "[EXT] External Call"},
 -      [EXTINT_EMS] = {.name = "EMS", .desc = "[EXT] Emergency Signal"},
 -      [EXTINT_TMR] = {.name = "TMR", .desc = "[EXT] CPU Timer"},
 -      [EXTINT_TLA] = {.name = "TAL", .desc = "[EXT] Timing Alert"},
 -      [EXTINT_PFL] = {.name = "PFL", .desc = "[EXT] Pseudo Page Fault"},
 -      [EXTINT_DSD] = {.name = "DSD", .desc = "[EXT] DASD Diag"},
 -      [EXTINT_VRT] = {.name = "VRT", .desc = "[EXT] Virtio"},
 -      [EXTINT_SCP] = {.name = "SCP", .desc = "[EXT] Service Call"},
 -      [EXTINT_IUC] = {.name = "IUC", .desc = "[EXT] IUCV"},
 -      [EXTINT_CMS] = {.name = "CMS", .desc = "[EXT] CPU-Measurement: Sampling"},
 -      [EXTINT_CMC] = {.name = "CMC", .desc = "[EXT] CPU-Measurement: Counter"},
 -      [EXTINT_CMR] = {.name = "CMR", .desc = "[EXT] CPU-Measurement: RI"},
 -      [IOINT_CIO]  = {.name = "CIO", .desc = "[I/O] Common I/O Layer Interrupt"},
 -      [IOINT_QAI]  = {.name = "QAI", .desc = "[I/O] QDIO Adapter Interrupt"},
 -      [IOINT_DAS]  = {.name = "DAS", .desc = "[I/O] DASD"},
 -      [IOINT_C15]  = {.name = "C15", .desc = "[I/O] 3215"},
 -      [IOINT_C70]  = {.name = "C70", .desc = "[I/O] 3270"},
 -      [IOINT_TAP]  = {.name = "TAP", .desc = "[I/O] Tape"},
 -      [IOINT_VMR]  = {.name = "VMR", .desc = "[I/O] Unit Record Devices"},
 -      [IOINT_LCS]  = {.name = "LCS", .desc = "[I/O] LCS"},
 -      [IOINT_CLW]  = {.name = "CLW", .desc = "[I/O] CLAW"},
 -      [IOINT_CTC]  = {.name = "CTC", .desc = "[I/O] CTC"},
 -      [IOINT_APB]  = {.name = "APB", .desc = "[I/O] AP Bus"},
 -      [IOINT_ADM]  = {.name = "ADM", .desc = "[I/O] EADM Subchannel"},
 -      [IOINT_CSC]  = {.name = "CSC", .desc = "[I/O] CHSC Subchannel"},
 -      [IOINT_PCI]  = {.name = "PCI", .desc = "[I/O] PCI Interrupt" },
 -      [IOINT_MSI] =  {.name = "MSI", .desc = "[I/O] MSI Interrupt" },
 -      [IOINT_VIR]  = {.name = "VIR", .desc = "[I/O] Virtual I/O Devices"},
 +      [IO_INTERRUPT]       = {.name = "I/O"}
 +};
 +
 +/*
 + * The list of split external and I/O interrupts that appear only in
 + * /proc/interrupts.
 + * In addition this list contains non external / I/O events like NMIs.
 + */
 +static const struct irq_class irqclass_sub_desc[NR_ARCH_IRQS] = {
 +      [IRQEXT_CLK] = {.name = "CLK", .desc = "[EXT] Clock Comparator"},
 +      [IRQEXT_EXC] = {.name = "EXC", .desc = "[EXT] External Call"},
 +      [IRQEXT_EMS] = {.name = "EMS", .desc = "[EXT] Emergency Signal"},
 +      [IRQEXT_TMR] = {.name = "TMR", .desc = "[EXT] CPU Timer"},
 +      [IRQEXT_TLA] = {.name = "TAL", .desc = "[EXT] Timing Alert"},
 +      [IRQEXT_PFL] = {.name = "PFL", .desc = "[EXT] Pseudo Page Fault"},
 +      [IRQEXT_DSD] = {.name = "DSD", .desc = "[EXT] DASD Diag"},
 +      [IRQEXT_VRT] = {.name = "VRT", .desc = "[EXT] Virtio"},
 +      [IRQEXT_SCP] = {.name = "SCP", .desc = "[EXT] Service Call"},
 +      [IRQEXT_IUC] = {.name = "IUC", .desc = "[EXT] IUCV"},
 +      [IRQEXT_CMS] = {.name = "CMS", .desc = "[EXT] CPU-Measurement: Sampling"},
 +      [IRQEXT_CMC] = {.name = "CMC", .desc = "[EXT] CPU-Measurement: Counter"},
 +      [IRQEXT_CMR] = {.name = "CMR", .desc = "[EXT] CPU-Measurement: RI"},
 +      [IRQIO_CIO]  = {.name = "CIO", .desc = "[I/O] Common I/O Layer Interrupt"},
 +      [IRQIO_QAI]  = {.name = "QAI", .desc = "[I/O] QDIO Adapter Interrupt"},
 +      [IRQIO_DAS]  = {.name = "DAS", .desc = "[I/O] DASD"},
 +      [IRQIO_C15]  = {.name = "C15", .desc = "[I/O] 3215"},
 +      [IRQIO_C70]  = {.name = "C70", .desc = "[I/O] 3270"},
 +      [IRQIO_TAP]  = {.name = "TAP", .desc = "[I/O] Tape"},
 +      [IRQIO_VMR]  = {.name = "VMR", .desc = "[I/O] Unit Record Devices"},
 +      [IRQIO_LCS]  = {.name = "LCS", .desc = "[I/O] LCS"},
 +      [IRQIO_CLW]  = {.name = "CLW", .desc = "[I/O] CLAW"},
 +      [IRQIO_CTC]  = {.name = "CTC", .desc = "[I/O] CTC"},
 +      [IRQIO_APB]  = {.name = "APB", .desc = "[I/O] AP Bus"},
 +      [IRQIO_ADM]  = {.name = "ADM", .desc = "[I/O] EADM Subchannel"},
 +      [IRQIO_CSC]  = {.name = "CSC", .desc = "[I/O] CHSC Subchannel"},
 +      [IRQIO_PCI]  = {.name = "PCI", .desc = "[I/O] PCI Interrupt" },
 +      [IRQIO_MSI]  = {.name = "MSI", .desc = "[I/O] MSI Interrupt" },
++      [IRQIO_VIR]  = {.name = "VIR", .desc = "[I/O] Virtual I/O Devices"},
        [NMI_NMI]    = {.name = "NMI", .desc = "[NMI] Machine Check"},
 +      [CPU_RST]    = {.name = "RST", .desc = "[CPU] CPU Restart"},
  };
  
  /*
Simple merge
Simple merge
Simple merge
Simple merge
index 979d03b,0000000..2871fcc
mode 100644,000000..100644
--- /dev/null
@@@ -1,109 -1,0 +1,116 @@@
 +/*
 + * vmx.h: VMX Architecture related definitions
 + * Copyright (c) 2004, Intel Corporation.
 + *
 + * This program is free software; you can redistribute it and/or modify it
 + * under the terms and conditions of the GNU General Public License,
 + * version 2, as published by the Free Software Foundation.
 + *
 + * This program is distributed in the hope it will be useful, but WITHOUT
 + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 + * more details.
 + *
 + * You should have received a copy of the GNU General Public License along with
 + * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 + * Place - Suite 330, Boston, MA 02111-1307 USA.
 + *
 + * A few random additions are:
 + * Copyright (C) 2006 Qumranet
 + *    Avi Kivity <avi@qumranet.com>
 + *    Yaniv Kamay <yaniv@qumranet.com>
 + *
 + */
 +#ifndef _UAPIVMX_H
 +#define _UAPIVMX_H
 +
 +
 +#define VMX_EXIT_REASONS_FAILED_VMENTRY         0x80000000
 +
 +#define EXIT_REASON_EXCEPTION_NMI       0
 +#define EXIT_REASON_EXTERNAL_INTERRUPT  1
 +#define EXIT_REASON_TRIPLE_FAULT        2
 +
 +#define EXIT_REASON_PENDING_INTERRUPT   7
 +#define EXIT_REASON_NMI_WINDOW          8
 +#define EXIT_REASON_TASK_SWITCH         9
 +#define EXIT_REASON_CPUID               10
 +#define EXIT_REASON_HLT                 12
 +#define EXIT_REASON_INVD                13
 +#define EXIT_REASON_INVLPG              14
 +#define EXIT_REASON_RDPMC               15
 +#define EXIT_REASON_RDTSC               16
 +#define EXIT_REASON_VMCALL              18
 +#define EXIT_REASON_VMCLEAR             19
 +#define EXIT_REASON_VMLAUNCH            20
 +#define EXIT_REASON_VMPTRLD             21
 +#define EXIT_REASON_VMPTRST             22
 +#define EXIT_REASON_VMREAD              23
 +#define EXIT_REASON_VMRESUME            24
 +#define EXIT_REASON_VMWRITE             25
 +#define EXIT_REASON_VMOFF               26
 +#define EXIT_REASON_VMON                27
 +#define EXIT_REASON_CR_ACCESS           28
 +#define EXIT_REASON_DR_ACCESS           29
 +#define EXIT_REASON_IO_INSTRUCTION      30
 +#define EXIT_REASON_MSR_READ            31
 +#define EXIT_REASON_MSR_WRITE           32
 +#define EXIT_REASON_INVALID_STATE       33
 +#define EXIT_REASON_MWAIT_INSTRUCTION   36
 +#define EXIT_REASON_MONITOR_INSTRUCTION 39
 +#define EXIT_REASON_PAUSE_INSTRUCTION   40
 +#define EXIT_REASON_MCE_DURING_VMENTRY  41
 +#define EXIT_REASON_TPR_BELOW_THRESHOLD 43
 +#define EXIT_REASON_APIC_ACCESS         44
++#define EXIT_REASON_EOI_INDUCED         45
 +#define EXIT_REASON_EPT_VIOLATION       48
 +#define EXIT_REASON_EPT_MISCONFIG       49
 +#define EXIT_REASON_WBINVD              54
 +#define EXIT_REASON_XSETBV              55
++#define EXIT_REASON_APIC_WRITE          56
 +#define EXIT_REASON_INVPCID             58
 +
 +#define VMX_EXIT_REASONS \
 +      { EXIT_REASON_EXCEPTION_NMI,         "EXCEPTION_NMI" }, \
 +      { EXIT_REASON_EXTERNAL_INTERRUPT,    "EXTERNAL_INTERRUPT" }, \
 +      { EXIT_REASON_TRIPLE_FAULT,          "TRIPLE_FAULT" }, \
 +      { EXIT_REASON_PENDING_INTERRUPT,     "PENDING_INTERRUPT" }, \
 +      { EXIT_REASON_NMI_WINDOW,            "NMI_WINDOW" }, \
 +      { EXIT_REASON_TASK_SWITCH,           "TASK_SWITCH" }, \
 +      { EXIT_REASON_CPUID,                 "CPUID" }, \
 +      { EXIT_REASON_HLT,                   "HLT" }, \
 +      { EXIT_REASON_INVLPG,                "INVLPG" }, \
 +      { EXIT_REASON_RDPMC,                 "RDPMC" }, \
 +      { EXIT_REASON_RDTSC,                 "RDTSC" }, \
 +      { EXIT_REASON_VMCALL,                "VMCALL" }, \
 +      { EXIT_REASON_VMCLEAR,               "VMCLEAR" }, \
 +      { EXIT_REASON_VMLAUNCH,              "VMLAUNCH" }, \
 +      { EXIT_REASON_VMPTRLD,               "VMPTRLD" }, \
 +      { EXIT_REASON_VMPTRST,               "VMPTRST" }, \
 +      { EXIT_REASON_VMREAD,                "VMREAD" }, \
 +      { EXIT_REASON_VMRESUME,              "VMRESUME" }, \
 +      { EXIT_REASON_VMWRITE,               "VMWRITE" }, \
 +      { EXIT_REASON_VMOFF,                 "VMOFF" }, \
 +      { EXIT_REASON_VMON,                  "VMON" }, \
 +      { EXIT_REASON_CR_ACCESS,             "CR_ACCESS" }, \
 +      { EXIT_REASON_DR_ACCESS,             "DR_ACCESS" }, \
 +      { EXIT_REASON_IO_INSTRUCTION,        "IO_INSTRUCTION" }, \
 +      { EXIT_REASON_MSR_READ,              "MSR_READ" }, \
 +      { EXIT_REASON_MSR_WRITE,             "MSR_WRITE" }, \
 +      { EXIT_REASON_MWAIT_INSTRUCTION,     "MWAIT_INSTRUCTION" }, \
 +      { EXIT_REASON_MONITOR_INSTRUCTION,   "MONITOR_INSTRUCTION" }, \
 +      { EXIT_REASON_PAUSE_INSTRUCTION,     "PAUSE_INSTRUCTION" }, \
 +      { EXIT_REASON_MCE_DURING_VMENTRY,    "MCE_DURING_VMENTRY" }, \
 +      { EXIT_REASON_TPR_BELOW_THRESHOLD,   "TPR_BELOW_THRESHOLD" }, \
 +      { EXIT_REASON_APIC_ACCESS,           "APIC_ACCESS" }, \
 +      { EXIT_REASON_EPT_VIOLATION,         "EPT_VIOLATION" }, \
 +      { EXIT_REASON_EPT_MISCONFIG,         "EPT_MISCONFIG" }, \
-       { EXIT_REASON_WBINVD,                "WBINVD" }
++      { EXIT_REASON_WBINVD,                "WBINVD" }, \
++      { EXIT_REASON_APIC_WRITE,            "APIC_WRITE" }, \
++      { EXIT_REASON_EOI_INDUCED,           "EOI_INDUCED" }, \
++      { EXIT_REASON_INVALID_STATE,         "INVALID_STATE" }, \
++      { EXIT_REASON_INVD,                  "INVD" }, \
++      { EXIT_REASON_INVPCID,               "INVPCID" }
 +
 +
 +#endif /* _UAPIVMX_H */
Simple merge
Simple merge
Simple merge
index 0000000,3217dfe..2029b6c
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,926 +1,926 @@@
+ /*
+  * ccw based virtio transport
+  *
+  * Copyright IBM Corp. 2012
+  *
+  * This program is free software; you can redistribute it and/or modify
+  * it under the terms of the GNU General Public License (version 2 only)
+  * as published by the Free Software Foundation.
+  *
+  *    Author(s): Cornelia Huck <cornelia.huck@de.ibm.com>
+  */
+ #include <linux/kernel_stat.h>
+ #include <linux/init.h>
+ #include <linux/bootmem.h>
+ #include <linux/err.h>
+ #include <linux/virtio.h>
+ #include <linux/virtio_config.h>
+ #include <linux/slab.h>
+ #include <linux/interrupt.h>
+ #include <linux/virtio_ring.h>
+ #include <linux/pfn.h>
+ #include <linux/async.h>
+ #include <linux/wait.h>
+ #include <linux/list.h>
+ #include <linux/bitops.h>
+ #include <linux/module.h>
+ #include <linux/io.h>
+ #include <linux/kvm_para.h>
+ #include <asm/setup.h>
+ #include <asm/irq.h>
+ #include <asm/cio.h>
+ #include <asm/ccwdev.h>
+ /*
+  * virtio related functions
+  */
+ struct vq_config_block {
+       __u16 index;
+       __u16 num;
+ } __packed;
+ #define VIRTIO_CCW_CONFIG_SIZE 0x100
+ /* same as PCI config space size, should be enough for all drivers */
+ struct virtio_ccw_device {
+       struct virtio_device vdev;
+       __u8 *status;
+       __u8 config[VIRTIO_CCW_CONFIG_SIZE];
+       struct ccw_device *cdev;
+       __u32 curr_io;
+       int err;
+       wait_queue_head_t wait_q;
+       spinlock_t lock;
+       struct list_head virtqueues;
+       unsigned long indicators;
+       unsigned long indicators2;
+       struct vq_config_block *config_block;
+ };
+ struct vq_info_block {
+       __u64 queue;
+       __u32 align;
+       __u16 index;
+       __u16 num;
+ } __packed;
+ struct virtio_feature_desc {
+       __u32 features;
+       __u8 index;
+ } __packed;
+ struct virtio_ccw_vq_info {
+       struct virtqueue *vq;
+       int num;
+       void *queue;
+       struct vq_info_block *info_block;
+       struct list_head node;
+ };
+ #define KVM_VIRTIO_CCW_RING_ALIGN 4096
+ #define KVM_S390_VIRTIO_CCW_NOTIFY 3
+ #define CCW_CMD_SET_VQ 0x13
+ #define CCW_CMD_VDEV_RESET 0x33
+ #define CCW_CMD_SET_IND 0x43
+ #define CCW_CMD_SET_CONF_IND 0x53
+ #define CCW_CMD_READ_FEAT 0x12
+ #define CCW_CMD_WRITE_FEAT 0x11
+ #define CCW_CMD_READ_CONF 0x22
+ #define CCW_CMD_WRITE_CONF 0x21
+ #define CCW_CMD_WRITE_STATUS 0x31
+ #define CCW_CMD_READ_VQ_CONF 0x32
+ #define VIRTIO_CCW_DOING_SET_VQ 0x00010000
+ #define VIRTIO_CCW_DOING_RESET 0x00040000
+ #define VIRTIO_CCW_DOING_READ_FEAT 0x00080000
+ #define VIRTIO_CCW_DOING_WRITE_FEAT 0x00100000
+ #define VIRTIO_CCW_DOING_READ_CONFIG 0x00200000
+ #define VIRTIO_CCW_DOING_WRITE_CONFIG 0x00400000
+ #define VIRTIO_CCW_DOING_WRITE_STATUS 0x00800000
+ #define VIRTIO_CCW_DOING_SET_IND 0x01000000
+ #define VIRTIO_CCW_DOING_READ_VQ_CONF 0x02000000
+ #define VIRTIO_CCW_DOING_SET_CONF_IND 0x04000000
+ #define VIRTIO_CCW_INTPARM_MASK 0xffff0000
+ static struct virtio_ccw_device *to_vc_device(struct virtio_device *vdev)
+ {
+       return container_of(vdev, struct virtio_ccw_device, vdev);
+ }
+ static int doing_io(struct virtio_ccw_device *vcdev, __u32 flag)
+ {
+       unsigned long flags;
+       __u32 ret;
+       spin_lock_irqsave(get_ccwdev_lock(vcdev->cdev), flags);
+       if (vcdev->err)
+               ret = 0;
+       else
+               ret = vcdev->curr_io & flag;
+       spin_unlock_irqrestore(get_ccwdev_lock(vcdev->cdev), flags);
+       return ret;
+ }
+ static int ccw_io_helper(struct virtio_ccw_device *vcdev,
+                        struct ccw1 *ccw, __u32 intparm)
+ {
+       int ret;
+       unsigned long flags;
+       int flag = intparm & VIRTIO_CCW_INTPARM_MASK;
+       do {
+               spin_lock_irqsave(get_ccwdev_lock(vcdev->cdev), flags);
+               ret = ccw_device_start(vcdev->cdev, ccw, intparm, 0, 0);
+               if (!ret)
+                       vcdev->curr_io |= flag;
+               spin_unlock_irqrestore(get_ccwdev_lock(vcdev->cdev), flags);
+               cpu_relax();
+       } while (ret == -EBUSY);
+       wait_event(vcdev->wait_q, doing_io(vcdev, flag) == 0);
+       return ret ? ret : vcdev->err;
+ }
+ static inline long do_kvm_notify(struct subchannel_id schid,
+                                unsigned long queue_index)
+ {
+       register unsigned long __nr asm("1") = KVM_S390_VIRTIO_CCW_NOTIFY;
+       register struct subchannel_id __schid asm("2") = schid;
+       register unsigned long __index asm("3") = queue_index;
+       register long __rc asm("2");
+       asm volatile ("diag 2,4,0x500\n"
+                     : "=d" (__rc) : "d" (__nr), "d" (__schid), "d" (__index)
+                     : "memory", "cc");
+       return __rc;
+ }
+ static void virtio_ccw_kvm_notify(struct virtqueue *vq)
+ {
+       struct virtio_ccw_vq_info *info = vq->priv;
+       struct virtio_ccw_device *vcdev;
+       struct subchannel_id schid;
+       vcdev = to_vc_device(info->vq->vdev);
+       ccw_device_get_schid(vcdev->cdev, &schid);
+       do_kvm_notify(schid, virtqueue_get_queue_index(vq));
+ }
+ static int virtio_ccw_read_vq_conf(struct virtio_ccw_device *vcdev,
+                                  struct ccw1 *ccw, int index)
+ {
+       vcdev->config_block->index = index;
+       ccw->cmd_code = CCW_CMD_READ_VQ_CONF;
+       ccw->flags = 0;
+       ccw->count = sizeof(struct vq_config_block);
+       ccw->cda = (__u32)(unsigned long)(vcdev->config_block);
+       ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_VQ_CONF);
+       return vcdev->config_block->num;
+ }
+ static void virtio_ccw_del_vq(struct virtqueue *vq, struct ccw1 *ccw)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vq->vdev);
+       struct virtio_ccw_vq_info *info = vq->priv;
+       unsigned long flags;
+       unsigned long size;
+       int ret;
+       unsigned int index = virtqueue_get_queue_index(vq);
+       /* Remove from our list. */
+       spin_lock_irqsave(&vcdev->lock, flags);
+       list_del(&info->node);
+       spin_unlock_irqrestore(&vcdev->lock, flags);
+       /* Release from host. */
+       info->info_block->queue = 0;
+       info->info_block->align = 0;
+       info->info_block->index = index;
+       info->info_block->num = 0;
+       ccw->cmd_code = CCW_CMD_SET_VQ;
+       ccw->flags = 0;
+       ccw->count = sizeof(*info->info_block);
+       ccw->cda = (__u32)(unsigned long)(info->info_block);
+       ret = ccw_io_helper(vcdev, ccw,
+                           VIRTIO_CCW_DOING_SET_VQ | index);
+       /*
+        * -ENODEV isn't considered an error: The device is gone anyway.
+        * This may happen on device detach.
+        */
+       if (ret && (ret != -ENODEV))
+               dev_warn(&vq->vdev->dev, "Error %d while deleting queue %d",
+                        ret, index);
+       vring_del_virtqueue(vq);
+       size = PAGE_ALIGN(vring_size(info->num, KVM_VIRTIO_CCW_RING_ALIGN));
+       free_pages_exact(info->queue, size);
+       kfree(info->info_block);
+       kfree(info);
+ }
+ static void virtio_ccw_del_vqs(struct virtio_device *vdev)
+ {
+       struct virtqueue *vq, *n;
+       struct ccw1 *ccw;
+       ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+       if (!ccw)
+               return;
+       list_for_each_entry_safe(vq, n, &vdev->vqs, list)
+               virtio_ccw_del_vq(vq, ccw);
+       kfree(ccw);
+ }
+ static struct virtqueue *virtio_ccw_setup_vq(struct virtio_device *vdev,
+                                            int i, vq_callback_t *callback,
+                                            const char *name,
+                                            struct ccw1 *ccw)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       int err;
+       struct virtqueue *vq = NULL;
+       struct virtio_ccw_vq_info *info;
+       unsigned long size = 0; /* silence the compiler */
+       unsigned long flags;
+       /* Allocate queue. */
+       info = kzalloc(sizeof(struct virtio_ccw_vq_info), GFP_KERNEL);
+       if (!info) {
+               dev_warn(&vcdev->cdev->dev, "no info\n");
+               err = -ENOMEM;
+               goto out_err;
+       }
+       info->info_block = kzalloc(sizeof(*info->info_block),
+                                  GFP_DMA | GFP_KERNEL);
+       if (!info->info_block) {
+               dev_warn(&vcdev->cdev->dev, "no info block\n");
+               err = -ENOMEM;
+               goto out_err;
+       }
+       info->num = virtio_ccw_read_vq_conf(vcdev, ccw, i);
+       size = PAGE_ALIGN(vring_size(info->num, KVM_VIRTIO_CCW_RING_ALIGN));
+       info->queue = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO);
+       if (info->queue == NULL) {
+               dev_warn(&vcdev->cdev->dev, "no queue\n");
+               err = -ENOMEM;
+               goto out_err;
+       }
+       vq = vring_new_virtqueue(i, info->num, KVM_VIRTIO_CCW_RING_ALIGN, vdev,
+                                true, info->queue, virtio_ccw_kvm_notify,
+                                callback, name);
+       if (!vq) {
+               /* For now, we fail if we can't get the requested size. */
+               dev_warn(&vcdev->cdev->dev, "no vq\n");
+               err = -ENOMEM;
+               goto out_err;
+       }
+       /* Register it with the host. */
+       info->info_block->queue = (__u64)info->queue;
+       info->info_block->align = KVM_VIRTIO_CCW_RING_ALIGN;
+       info->info_block->index = i;
+       info->info_block->num = info->num;
+       ccw->cmd_code = CCW_CMD_SET_VQ;
+       ccw->flags = 0;
+       ccw->count = sizeof(*info->info_block);
+       ccw->cda = (__u32)(unsigned long)(info->info_block);
+       err = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_VQ | i);
+       if (err) {
+               dev_warn(&vcdev->cdev->dev, "SET_VQ failed\n");
+               goto out_err;
+       }
+       info->vq = vq;
+       vq->priv = info;
+       /* Save it to our list. */
+       spin_lock_irqsave(&vcdev->lock, flags);
+       list_add(&info->node, &vcdev->virtqueues);
+       spin_unlock_irqrestore(&vcdev->lock, flags);
+       return vq;
+ out_err:
+       if (vq)
+               vring_del_virtqueue(vq);
+       if (info) {
+               if (info->queue)
+                       free_pages_exact(info->queue, size);
+               kfree(info->info_block);
+       }
+       kfree(info);
+       return ERR_PTR(err);
+ }
+ static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
+                              struct virtqueue *vqs[],
+                              vq_callback_t *callbacks[],
+                              const char *names[])
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       unsigned long *indicatorp = NULL;
+       int ret, i;
+       struct ccw1 *ccw;
+       ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+       if (!ccw)
+               return -ENOMEM;
+       for (i = 0; i < nvqs; ++i) {
+               vqs[i] = virtio_ccw_setup_vq(vdev, i, callbacks[i], names[i],
+                                            ccw);
+               if (IS_ERR(vqs[i])) {
+                       ret = PTR_ERR(vqs[i]);
+                       vqs[i] = NULL;
+                       goto out;
+               }
+       }
+       ret = -ENOMEM;
+       /* We need a data area under 2G to communicate. */
+       indicatorp = kmalloc(sizeof(&vcdev->indicators), GFP_DMA | GFP_KERNEL);
+       if (!indicatorp)
+               goto out;
+       *indicatorp = (unsigned long) &vcdev->indicators;
+       /* Register queue indicators with host. */
+       vcdev->indicators = 0;
+       ccw->cmd_code = CCW_CMD_SET_IND;
+       ccw->flags = 0;
+       ccw->count = sizeof(vcdev->indicators);
+       ccw->cda = (__u32)(unsigned long) indicatorp;
+       ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_IND);
+       if (ret)
+               goto out;
+       /* Register indicators2 with host for config changes */
+       *indicatorp = (unsigned long) &vcdev->indicators2;
+       vcdev->indicators2 = 0;
+       ccw->cmd_code = CCW_CMD_SET_CONF_IND;
+       ccw->flags = 0;
+       ccw->count = sizeof(vcdev->indicators2);
+       ccw->cda = (__u32)(unsigned long) indicatorp;
+       ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_SET_CONF_IND);
+       if (ret)
+               goto out;
+       kfree(indicatorp);
+       kfree(ccw);
+       return 0;
+ out:
+       kfree(indicatorp);
+       kfree(ccw);
+       virtio_ccw_del_vqs(vdev);
+       return ret;
+ }
+ static void virtio_ccw_reset(struct virtio_device *vdev)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       struct ccw1 *ccw;
+       ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+       if (!ccw)
+               return;
+       /* Zero status bits. */
+       *vcdev->status = 0;
+       /* Send a reset ccw on device. */
+       ccw->cmd_code = CCW_CMD_VDEV_RESET;
+       ccw->flags = 0;
+       ccw->count = 0;
+       ccw->cda = 0;
+       ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_RESET);
+       kfree(ccw);
+ }
+ static u32 virtio_ccw_get_features(struct virtio_device *vdev)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       struct virtio_feature_desc *features;
+       int ret, rc;
+       struct ccw1 *ccw;
+       ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+       if (!ccw)
+               return 0;
+       features = kzalloc(sizeof(*features), GFP_DMA | GFP_KERNEL);
+       if (!features) {
+               rc = 0;
+               goto out_free;
+       }
+       /* Read the feature bits from the host. */
+       /* TODO: Features > 32 bits */
+       features->index = 0;
+       ccw->cmd_code = CCW_CMD_READ_FEAT;
+       ccw->flags = 0;
+       ccw->count = sizeof(*features);
+       ccw->cda = (__u32)(unsigned long)features;
+       ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_FEAT);
+       if (ret) {
+               rc = 0;
+               goto out_free;
+       }
+       rc = le32_to_cpu(features->features);
+ out_free:
+       kfree(features);
+       kfree(ccw);
+       return rc;
+ }
+ static void virtio_ccw_finalize_features(struct virtio_device *vdev)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       struct virtio_feature_desc *features;
+       int i;
+       struct ccw1 *ccw;
+       ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+       if (!ccw)
+               return;
+       features = kzalloc(sizeof(*features), GFP_DMA | GFP_KERNEL);
+       if (!features)
+               goto out_free;
+       /* Give virtio_ring a chance to accept features. */
+       vring_transport_features(vdev);
+       for (i = 0; i < sizeof(*vdev->features) / sizeof(features->features);
+            i++) {
+               int highbits = i % 2 ? 32 : 0;
+               features->index = i;
+               features->features = cpu_to_le32(vdev->features[i / 2]
+                                                >> highbits);
+               /* Write the feature bits to the host. */
+               ccw->cmd_code = CCW_CMD_WRITE_FEAT;
+               ccw->flags = 0;
+               ccw->count = sizeof(*features);
+               ccw->cda = (__u32)(unsigned long)features;
+               ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_FEAT);
+       }
+ out_free:
+       kfree(features);
+       kfree(ccw);
+ }
+ static void virtio_ccw_get_config(struct virtio_device *vdev,
+                                 unsigned int offset, void *buf, unsigned len)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       int ret;
+       struct ccw1 *ccw;
+       void *config_area;
+       ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+       if (!ccw)
+               return;
+       config_area = kzalloc(VIRTIO_CCW_CONFIG_SIZE, GFP_DMA | GFP_KERNEL);
+       if (!config_area)
+               goto out_free;
+       /* Read the config area from the host. */
+       ccw->cmd_code = CCW_CMD_READ_CONF;
+       ccw->flags = 0;
+       ccw->count = offset + len;
+       ccw->cda = (__u32)(unsigned long)config_area;
+       ret = ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_READ_CONFIG);
+       if (ret)
+               goto out_free;
+       memcpy(vcdev->config, config_area, sizeof(vcdev->config));
+       memcpy(buf, &vcdev->config[offset], len);
+ out_free:
+       kfree(config_area);
+       kfree(ccw);
+ }
+ static void virtio_ccw_set_config(struct virtio_device *vdev,
+                                 unsigned int offset, const void *buf,
+                                 unsigned len)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       struct ccw1 *ccw;
+       void *config_area;
+       ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+       if (!ccw)
+               return;
+       config_area = kzalloc(VIRTIO_CCW_CONFIG_SIZE, GFP_DMA | GFP_KERNEL);
+       if (!config_area)
+               goto out_free;
+       memcpy(&vcdev->config[offset], buf, len);
+       /* Write the config area to the host. */
+       memcpy(config_area, vcdev->config, sizeof(vcdev->config));
+       ccw->cmd_code = CCW_CMD_WRITE_CONF;
+       ccw->flags = 0;
+       ccw->count = offset + len;
+       ccw->cda = (__u32)(unsigned long)config_area;
+       ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_CONFIG);
+ out_free:
+       kfree(config_area);
+       kfree(ccw);
+ }
+ static u8 virtio_ccw_get_status(struct virtio_device *vdev)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       return *vcdev->status;
+ }
+ static void virtio_ccw_set_status(struct virtio_device *vdev, u8 status)
+ {
+       struct virtio_ccw_device *vcdev = to_vc_device(vdev);
+       struct ccw1 *ccw;
+       ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
+       if (!ccw)
+               return;
+       /* Write the status to the host. */
+       *vcdev->status = status;
+       ccw->cmd_code = CCW_CMD_WRITE_STATUS;
+       ccw->flags = 0;
+       ccw->count = sizeof(status);
+       ccw->cda = (__u32)(unsigned long)vcdev->status;
+       ccw_io_helper(vcdev, ccw, VIRTIO_CCW_DOING_WRITE_STATUS);
+       kfree(ccw);
+ }
+ static struct virtio_config_ops virtio_ccw_config_ops = {
+       .get_features = virtio_ccw_get_features,
+       .finalize_features = virtio_ccw_finalize_features,
+       .get = virtio_ccw_get_config,
+       .set = virtio_ccw_set_config,
+       .get_status = virtio_ccw_get_status,
+       .set_status = virtio_ccw_set_status,
+       .reset = virtio_ccw_reset,
+       .find_vqs = virtio_ccw_find_vqs,
+       .del_vqs = virtio_ccw_del_vqs,
+ };
+ /*
+  * ccw bus driver related functions
+  */
+ static void virtio_ccw_release_dev(struct device *_d)
+ {
+       struct virtio_device *dev = container_of(_d, struct virtio_device,
+                                                dev);
+       struct virtio_ccw_device *vcdev = to_vc_device(dev);
+       kfree(vcdev->status);
+       kfree(vcdev->config_block);
+       kfree(vcdev);
+ }
+ static int irb_is_error(struct irb *irb)
+ {
+       if (scsw_cstat(&irb->scsw) != 0)
+               return 1;
+       if (scsw_dstat(&irb->scsw) & ~(DEV_STAT_CHN_END | DEV_STAT_DEV_END))
+               return 1;
+       if (scsw_cc(&irb->scsw) != 0)
+               return 1;
+       return 0;
+ }
+ static struct virtqueue *virtio_ccw_vq_by_ind(struct virtio_ccw_device *vcdev,
+                                             int index)
+ {
+       struct virtio_ccw_vq_info *info;
+       unsigned long flags;
+       struct virtqueue *vq;
+       vq = NULL;
+       spin_lock_irqsave(&vcdev->lock, flags);
+       list_for_each_entry(info, &vcdev->virtqueues, node) {
+               if (virtqueue_get_queue_index(info->vq) == index) {
+                       vq = info->vq;
+                       break;
+               }
+       }
+       spin_unlock_irqrestore(&vcdev->lock, flags);
+       return vq;
+ }
+ static void virtio_ccw_int_handler(struct ccw_device *cdev,
+                                  unsigned long intparm,
+                                  struct irb *irb)
+ {
+       __u32 activity = intparm & VIRTIO_CCW_INTPARM_MASK;
+       struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
+       int i;
+       struct virtqueue *vq;
+       struct virtio_driver *drv;
+       /* Check if it's a notification from the host. */
+       if ((intparm == 0) &&
+           (scsw_stctl(&irb->scsw) ==
+            (SCSW_STCTL_ALERT_STATUS | SCSW_STCTL_STATUS_PEND))) {
+               /* OK */
+       }
+       if (irb_is_error(irb))
+               vcdev->err = -EIO; /* XXX - use real error */
+       if (vcdev->curr_io & activity) {
+               switch (activity) {
+               case VIRTIO_CCW_DOING_READ_FEAT:
+               case VIRTIO_CCW_DOING_WRITE_FEAT:
+               case VIRTIO_CCW_DOING_READ_CONFIG:
+               case VIRTIO_CCW_DOING_WRITE_CONFIG:
+               case VIRTIO_CCW_DOING_WRITE_STATUS:
+               case VIRTIO_CCW_DOING_SET_VQ:
+               case VIRTIO_CCW_DOING_SET_IND:
+               case VIRTIO_CCW_DOING_SET_CONF_IND:
+               case VIRTIO_CCW_DOING_RESET:
+               case VIRTIO_CCW_DOING_READ_VQ_CONF:
+                       vcdev->curr_io &= ~activity;
+                       wake_up(&vcdev->wait_q);
+                       break;
+               default:
+                       /* don't know what to do... */
+                       dev_warn(&cdev->dev, "Suspicious activity '%08x'\n",
+                                activity);
+                       WARN_ON(1);
+                       break;
+               }
+       }
+       for_each_set_bit(i, &vcdev->indicators,
+                        sizeof(vcdev->indicators) * BITS_PER_BYTE) {
+               /* The bit clear must happen before the vring kick. */
+               clear_bit(i, &vcdev->indicators);
+               barrier();
+               vq = virtio_ccw_vq_by_ind(vcdev, i);
+               vring_interrupt(0, vq);
+       }
+       if (test_bit(0, &vcdev->indicators2)) {
+               drv = container_of(vcdev->vdev.dev.driver,
+                                  struct virtio_driver, driver);
+               if (drv && drv->config_changed)
+                       drv->config_changed(&vcdev->vdev);
+               clear_bit(0, &vcdev->indicators2);
+       }
+ }
+ /*
+  * We usually want to autoonline all devices, but give the admin
+  * a way to exempt devices from this.
+  */
+ #define __DEV_WORDS ((__MAX_SUBCHANNEL + (8*sizeof(long) - 1)) / \
+                    (8*sizeof(long)))
+ static unsigned long devs_no_auto[__MAX_SSID + 1][__DEV_WORDS];
+ static char *no_auto = "";
+ module_param(no_auto, charp, 0444);
+ MODULE_PARM_DESC(no_auto, "list of ccw bus id ranges not to be auto-onlined");
+ static int virtio_ccw_check_autoonline(struct ccw_device *cdev)
+ {
+       struct ccw_dev_id id;
+       ccw_device_get_id(cdev, &id);
+       if (test_bit(id.devno, devs_no_auto[id.ssid]))
+               return 0;
+       return 1;
+ }
+ static void virtio_ccw_auto_online(void *data, async_cookie_t cookie)
+ {
+       struct ccw_device *cdev = data;
+       int ret;
+       ret = ccw_device_set_online(cdev);
+       if (ret)
+               dev_warn(&cdev->dev, "Failed to set online: %d\n", ret);
+ }
+ static int virtio_ccw_probe(struct ccw_device *cdev)
+ {
+       cdev->handler = virtio_ccw_int_handler;
+       if (virtio_ccw_check_autoonline(cdev))
+               async_schedule(virtio_ccw_auto_online, cdev);
+       return 0;
+ }
+ static void virtio_ccw_remove(struct ccw_device *cdev)
+ {
+       struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
+       if (cdev->online) {
+               unregister_virtio_device(&vcdev->vdev);
+               dev_set_drvdata(&cdev->dev, NULL);
+       }
+       cdev->handler = NULL;
+ }
+ static int virtio_ccw_offline(struct ccw_device *cdev)
+ {
+       struct virtio_ccw_device *vcdev = dev_get_drvdata(&cdev->dev);
+       unregister_virtio_device(&vcdev->vdev);
+       dev_set_drvdata(&cdev->dev, NULL);
+       return 0;
+ }
+ static int virtio_ccw_online(struct ccw_device *cdev)
+ {
+       int ret;
+       struct virtio_ccw_device *vcdev;
+       vcdev = kzalloc(sizeof(*vcdev), GFP_KERNEL);
+       if (!vcdev) {
+               dev_warn(&cdev->dev, "Could not get memory for virtio\n");
+               ret = -ENOMEM;
+               goto out_free;
+       }
+       vcdev->config_block = kzalloc(sizeof(*vcdev->config_block),
+                                  GFP_DMA | GFP_KERNEL);
+       if (!vcdev->config_block) {
+               ret = -ENOMEM;
+               goto out_free;
+       }
+       vcdev->status = kzalloc(sizeof(*vcdev->status), GFP_DMA | GFP_KERNEL);
+       if (!vcdev->status) {
+               ret = -ENOMEM;
+               goto out_free;
+       }
+       vcdev->vdev.dev.parent = &cdev->dev;
+       vcdev->vdev.dev.release = virtio_ccw_release_dev;
+       vcdev->vdev.config = &virtio_ccw_config_ops;
+       vcdev->cdev = cdev;
+       init_waitqueue_head(&vcdev->wait_q);
+       INIT_LIST_HEAD(&vcdev->virtqueues);
+       spin_lock_init(&vcdev->lock);
+       dev_set_drvdata(&cdev->dev, vcdev);
+       vcdev->vdev.id.vendor = cdev->id.cu_type;
+       vcdev->vdev.id.device = cdev->id.cu_model;
+       ret = register_virtio_device(&vcdev->vdev);
+       if (ret) {
+               dev_warn(&cdev->dev, "Failed to register virtio device: %d\n",
+                        ret);
+               goto out_put;
+       }
+       return 0;
+ out_put:
+       dev_set_drvdata(&cdev->dev, NULL);
+       put_device(&vcdev->vdev.dev);
+       return ret;
+ out_free:
+       if (vcdev) {
+               kfree(vcdev->status);
+               kfree(vcdev->config_block);
+       }
+       kfree(vcdev);
+       return ret;
+ }
+ static int virtio_ccw_cio_notify(struct ccw_device *cdev, int event)
+ {
+       /* TODO: Check whether we need special handling here. */
+       return 0;
+ }
+ static struct ccw_device_id virtio_ids[] = {
+       { CCW_DEVICE(0x3832, 0) },
+       {},
+ };
+ MODULE_DEVICE_TABLE(ccw, virtio_ids);
+ static struct ccw_driver virtio_ccw_driver = {
+       .driver = {
+               .owner = THIS_MODULE,
+               .name = "virtio_ccw",
+       },
+       .ids = virtio_ids,
+       .probe = virtio_ccw_probe,
+       .remove = virtio_ccw_remove,
+       .set_offline = virtio_ccw_offline,
+       .set_online = virtio_ccw_online,
+       .notify = virtio_ccw_cio_notify,
 -      .int_class = IOINT_VIR,
++      .int_class = IRQIO_VIR,
+ };
+ static int __init pure_hex(char **cp, unsigned int *val, int min_digit,
+                          int max_digit, int max_val)
+ {
+       int diff;
+       diff = 0;
+       *val = 0;
+       while (diff <= max_digit) {
+               int value = hex_to_bin(**cp);
+               if (value < 0)
+                       break;
+               *val = *val * 16 + value;
+               (*cp)++;
+               diff++;
+       }
+       if ((diff < min_digit) || (diff > max_digit) || (*val > max_val))
+               return 1;
+       return 0;
+ }
+ static int __init parse_busid(char *str, unsigned int *cssid,
+                             unsigned int *ssid, unsigned int *devno)
+ {
+       char *str_work;
+       int rc, ret;
+       rc = 1;
+       if (*str == '\0')
+               goto out;
+       str_work = str;
+       ret = pure_hex(&str_work, cssid, 1, 2, __MAX_CSSID);
+       if (ret || (str_work[0] != '.'))
+               goto out;
+       str_work++;
+       ret = pure_hex(&str_work, ssid, 1, 1, __MAX_SSID);
+       if (ret || (str_work[0] != '.'))
+               goto out;
+       str_work++;
+       ret = pure_hex(&str_work, devno, 4, 4, __MAX_SUBCHANNEL);
+       if (ret || (str_work[0] != '\0'))
+               goto out;
+       rc = 0;
+ out:
+       return rc;
+ }
+ static void __init no_auto_parse(void)
+ {
+       unsigned int from_cssid, to_cssid, from_ssid, to_ssid, from, to;
+       char *parm, *str;
+       int rc;
+       str = no_auto;
+       while ((parm = strsep(&str, ","))) {
+               rc = parse_busid(strsep(&parm, "-"), &from_cssid,
+                                &from_ssid, &from);
+               if (rc)
+                       continue;
+               if (parm != NULL) {
+                       rc = parse_busid(parm, &to_cssid,
+                                        &to_ssid, &to);
+                       if ((from_ssid > to_ssid) ||
+                           ((from_ssid == to_ssid) && (from > to)))
+                               rc = -EINVAL;
+               } else {
+                       to_cssid = from_cssid;
+                       to_ssid = from_ssid;
+                       to = from;
+               }
+               if (rc)
+                       continue;
+               while ((from_ssid < to_ssid) ||
+                      ((from_ssid == to_ssid) && (from <= to))) {
+                       set_bit(from, devs_no_auto[from_ssid]);
+                       from++;
+                       if (from > __MAX_SUBCHANNEL) {
+                               from_ssid++;
+                               from = 0;
+                       }
+               }
+       }
+ }
+ static int __init virtio_ccw_init(void)
+ {
+       /* parse no_auto string before we do anything further */
+       no_auto_parse();
+       return ccw_driver_register(&virtio_ccw_driver);
+ }
+ module_init(virtio_ccw_init);
+ static void __exit virtio_ccw_exit(void)
+ {
+       ccw_driver_unregister(&virtio_ccw_driver);
+ }
+ module_exit(virtio_ccw_exit);
Simple merge
@@@ -636,8 -660,8 +661,10 @@@ struct kvm_ppc_smmu_info 
  #define KVM_CAP_IRQFD_RESAMPLE 82
  #define KVM_CAP_PPC_BOOKE_WATCHDOG 83
  #define KVM_CAP_PPC_HTAB_FD 84
+ #define KVM_CAP_S390_CSS_SUPPORT 85
+ #define KVM_CAP_PPC_EPR 86
 +#define KVM_CAP_ARM_PSCI 87
 +#define KVM_CAP_ARM_SET_DEVICE_ADDR 88
  
  #ifdef KVM_CAP_IRQ_ROUTING
  
Simple merge