Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux

Pull second set of s390 patches from Martin Schwidefsky:
 "The handling of the PCI hotplug notifications has been improved, the
  zfcp dumper can now detect the HSA size dynamically and the default
  install kernel has been changed to the compressed bzImage.  And two
  bug-fixes for scm and 3720"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/s390/linux:
  s390/pci: implement hotplug notifications
  s390/scm_block: do not hide eadm subchannel dependency
  s390/sclp: Consolidate early sclp init calls to sclp_early_detect()
  s390/sclp: Move early code from sclp_cmd.c to sclp_early.c
  s390/sclp: Determine HSA size dynamically for zfcpdump
  s390/sclp: Move declarations for sclp_sdias into separate header file
  s390/pci: implement pcibios_remove_bus
  s390/pci: improve handling of bus resources
  s390/3270: fix missing device_destroy() call
  s390/boot: Install bzImage as default kernel image

12 files changed, 197 insertions, 154 deletions

diff --git a/arch/s390/boot/Makefile b/arch/s390/boot/Makefile
index f2737a005afc..9a42ecec5647 100644
--- a/arch/s390/boot/Makefile
+++ b/arch/s390/boot/Makefile
@@ -21,6 +21,6 @@ $(obj)/bzImage: $(obj)/compressed/vmlinux FORCE
 $(obj)/compressed/vmlinux: FORCE
         $(Q)$(MAKE) $(build)=$(obj)/compressed $@
 
-install: $(CONFIGURE) $(obj)/image
-        sh -x  $(srctree)/$(obj)/install.sh $(KERNELRELEASE) $(obj)/image \
+install: $(CONFIGURE) $(obj)/bzImage
+        sh -x  $(srctree)/$(obj)/install.sh $(KERNELRELEASE) $(obj)/bzImage \
               System.map "$(INSTALL_PATH)"
diff --git a/arch/s390/include/asm/ctl_reg.h b/arch/s390/include/asm/ctl_reg.h
index 9b69c0befdca..4e63f1a13600 100644
--- a/arch/s390/include/asm/ctl_reg.h
+++ b/arch/s390/include/asm/ctl_reg.h
@@ -7,6 +7,8 @@
 #ifndef __ASM_CTL_REG_H
 #define __ASM_CTL_REG_H
 
+#include <linux/bug.h>
+
 #ifdef CONFIG_64BIT
 # define __CTL_LOAD     "lctlg"
 # define __CTL_STORE    "stctg"
diff --git a/arch/s390/include/asm/eadm.h b/arch/s390/include/asm/eadm.h
index dc9200ca32ed..67026300c88e 100644
--- a/arch/s390/include/asm/eadm.h
+++ b/arch/s390/include/asm/eadm.h
@@ -111,18 +111,7 @@ struct scm_driver {
 int scm_driver_register(struct scm_driver *scmdrv);
 void scm_driver_unregister(struct scm_driver *scmdrv);
 
-int scm_start_aob(struct aob *aob);
+int eadm_start_aob(struct aob *aob);
 void scm_irq_handler(struct aob *aob, int error);
 
-struct eadm_ops {
-        int (*eadm_start) (struct aob *aob);
-        struct module *owner;
-};
-
-int scm_get_ref(void);
-void scm_put_ref(void);
-
-void register_eadm_ops(struct eadm_ops *ops);
-void unregister_eadm_ops(struct eadm_ops *ops);
-
 #endif /* _ASM_S390_EADM_H */
diff --git a/arch/s390/include/asm/pci.h b/arch/s390/include/asm/pci.h
index 1cc185da9d38..c129ab2ac731 100644
--- a/arch/s390/include/asm/pci.h
+++ b/arch/s390/include/asm/pci.h
@@ -63,9 +63,10 @@ enum zpci_state {
 };
 
 struct zpci_bar_struct {
+        struct resource *res;           /* bus resource */
         u32             val;            /* bar start & 3 flag bits */
-        u8              size;           /* order 2 exponent */
         u16             map_idx;        /* index into bar mapping array */
+        u8              size;           /* order 2 exponent */
 };
 
 /* Private data per function */
@@ -97,6 +98,7 @@ struct zpci_dev {
         unsigned long   iommu_pages;
         unsigned int    next_bit;
 
+        char res_name[16];
         struct zpci_bar_struct bars[PCI_BAR_COUNT];
 
         u64             start_dma;      /* Start of available DMA addresses */
@@ -122,12 +124,10 @@ static inline bool zdev_enabled(struct zpci_dev *zdev)
   Prototypes
 ----------------------------------------------------------------------------- */
 /* Base stuff */
-struct zpci_dev *zpci_alloc_device(void);
 int zpci_create_device(struct zpci_dev *);
 int zpci_enable_device(struct zpci_dev *);
 int zpci_disable_device(struct zpci_dev *);
 void zpci_stop_device(struct zpci_dev *);
-void zpci_free_device(struct zpci_dev *);
 int zpci_register_ioat(struct zpci_dev *, u8, u64, u64, u64);
 int zpci_unregister_ioat(struct zpci_dev *, u8);
 
diff --git a/arch/s390/include/asm/sclp.h b/arch/s390/include/asm/sclp.h
index 7dc7f9c63b65..30ef748bc161 100644
--- a/arch/s390/include/asm/sclp.h
+++ b/arch/s390/include/asm/sclp.h
@@ -43,7 +43,6 @@ struct sclp_cpu_info {
 int sclp_get_cpu_info(struct sclp_cpu_info *info);
 int sclp_cpu_configure(u8 cpu);
 int sclp_cpu_deconfigure(u8 cpu);
-void sclp_facilities_detect(void);
 unsigned long long sclp_get_rnmax(void);
 unsigned long long sclp_get_rzm(void);
 int sclp_sdias_blk_count(void);
@@ -57,5 +56,7 @@ bool sclp_has_vt220(void);
 int sclp_pci_configure(u32 fid);
 int sclp_pci_deconfigure(u32 fid);
 int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode);
+unsigned long sclp_get_hsa_size(void);
+void sclp_early_detect(void);
 
 #endif /* _ASM_S390_SCLP_H */
diff --git a/arch/s390/include/asm/setup.h b/arch/s390/include/asm/setup.h
index df802ee14af6..94cfbe442f12 100644
--- a/arch/s390/include/asm/setup.h
+++ b/arch/s390/include/asm/setup.h
@@ -107,9 +107,6 @@ void create_mem_hole(struct mem_chunk mem_chunk[], unsigned long addr,
 #define MACHINE_HAS_RRBM        (S390_lowcore.machine_flags & MACHINE_FLAG_RRBM)
 #endif /* CONFIG_64BIT */
 
-#define ZFCPDUMP_HSA_SIZE       (32UL<<20)
-#define ZFCPDUMP_HSA_SIZE_MAX   (64UL<<20)
-
 /*
  * Console mode. Override with conmode=
  */
diff --git a/arch/s390/kernel/crash_dump.c b/arch/s390/kernel/crash_dump.c
index f45b2ab0cb81..d7658c4b2ed5 100644
--- a/arch/s390/kernel/crash_dump.c
+++ b/arch/s390/kernel/crash_dump.c
@@ -95,7 +95,7 @@ static void *elfcorehdr_newmem;
 /*
  * Copy one page from zfcpdump "oldmem"
  *
- * For pages below ZFCPDUMP_HSA_SIZE memory from the HSA is copied. Otherwise
+ * For pages below HSA size memory from the HSA is copied. Otherwise
  * real memory copy is used.
  */
 static ssize_t copy_oldmem_page_zfcpdump(char *buf, size_t csize,
@@ -103,7 +103,7 @@ static ssize_t copy_oldmem_page_zfcpdump(char *buf, size_t csize,
 {
         int rc;
 
-        if (src < ZFCPDUMP_HSA_SIZE) {
+        if (src < sclp_get_hsa_size()) {
                 rc = memcpy_hsa(buf, src, csize, userbuf);
         } else {
                 if (userbuf)
@@ -188,18 +188,19 @@ static int remap_oldmem_pfn_range_kdump(struct vm_area_struct *vma,
 /*
  * Remap "oldmem" for zfcpdump
  *
- * We only map available memory above ZFCPDUMP_HSA_SIZE. Memory below
- * ZFCPDUMP_HSA_SIZE is read on demand using the copy_oldmem_page() function.
+ * We only map available memory above HSA size. Memory below HSA size
+ * is read on demand using the copy_oldmem_page() function.
  */
 static int remap_oldmem_pfn_range_zfcpdump(struct vm_area_struct *vma,
                                            unsigned long from,
                                            unsigned long pfn,
                                            unsigned long size, pgprot_t prot)
 {
+        unsigned long hsa_end = sclp_get_hsa_size();
         unsigned long size_hsa;
 
-        if (pfn < ZFCPDUMP_HSA_SIZE >> PAGE_SHIFT) {
-                size_hsa = min(size, ZFCPDUMP_HSA_SIZE - (pfn << PAGE_SHIFT));
+        if (pfn < hsa_end >> PAGE_SHIFT) {
+                size_hsa = min(size, hsa_end - (pfn << PAGE_SHIFT));
                 if (size == size_hsa)
                         return 0;
                 size -= size_hsa;
@@ -238,9 +239,9 @@ int copy_from_oldmem(void *dest, void *src, size_t count)
                                 return rc;
                 }
         } else {
-                if ((unsigned long) src < ZFCPDUMP_HSA_SIZE) {
-                        copied = min(count,
-                                     ZFCPDUMP_HSA_SIZE - (unsigned long) src);
+                unsigned long hsa_end = sclp_get_hsa_size();
+                if ((unsigned long) src < hsa_end) {
+                        copied = min(count, hsa_end - (unsigned long) src);
                         rc = memcpy_hsa(dest, (unsigned long) src, copied, 0);
                         if (rc)
                                 return rc;
@@ -580,6 +581,9 @@ int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size)
         /* If elfcorehdr= has been passed via cmdline, we use that one */
         if (elfcorehdr_addr != ELFCORE_ADDR_MAX)
                 return 0;
+        /* If we cannot get HSA size for zfcpdump return error */
+        if (ipl_info.type == IPL_TYPE_FCP_DUMP && !sclp_get_hsa_size())
+                return -ENODEV;
         mem_chunk_cnt = get_mem_chunk_cnt();
 
         alloc_size = 0x1000 + get_cpu_cnt() * 0x300 +
diff --git a/arch/s390/kernel/early.c b/arch/s390/kernel/early.c
index 96543ac400a7..fca20b5fe79e 100644
--- a/arch/s390/kernel/early.c
+++ b/arch/s390/kernel/early.c
@@ -483,7 +483,7 @@ void __init startup_init(void)
         detect_diag44();
         detect_machine_facilities();
         setup_topology();
-        sclp_facilities_detect();
+        sclp_early_detect();
 #ifdef CONFIG_DYNAMIC_FTRACE
         S390_lowcore.ftrace_func = (unsigned long)ftrace_caller;
 #endif
diff --git a/arch/s390/kernel/setup.c b/arch/s390/kernel/setup.c
index ffe1c53264a7..4444875266ee 100644
--- a/arch/s390/kernel/setup.c
+++ b/arch/s390/kernel/setup.c
@@ -471,8 +471,9 @@ static void __init setup_memory_end(void)
 
 
 #ifdef CONFIG_ZFCPDUMP
-        if (ipl_info.type == IPL_TYPE_FCP_DUMP && !OLDMEM_BASE) {
-                memory_end = ZFCPDUMP_HSA_SIZE;
+        if (ipl_info.type == IPL_TYPE_FCP_DUMP &&
+            !OLDMEM_BASE && sclp_get_hsa_size()) {
+                memory_end = sclp_get_hsa_size();
                 memory_end_set = 1;
         }
 #endif
@@ -586,7 +587,7 @@ static unsigned long __init find_crash_base(unsigned long crash_size,
                 crash_base = (chunk->addr + chunk->size) - crash_size;
                 if (crash_base < crash_size)
                         continue;
-                if (crash_base < ZFCPDUMP_HSA_SIZE_MAX)
+                if (crash_base < sclp_get_hsa_size())
                         continue;
                 if (crash_base < (unsigned long) INITRD_START + INITRD_SIZE)
                         continue;
diff --git a/arch/s390/pci/pci.c b/arch/s390/pci/pci.c
index 0c9a17780e4b..bf7c73d71eef 100644
--- a/arch/s390/pci/pci.c
+++ b/arch/s390/pci/pci.c
@@ -530,20 +530,6 @@ static void zpci_unmap_resources(struct zpci_dev *zdev)
         }
 }
 
-struct zpci_dev *zpci_alloc_device(void)
-{
-        struct zpci_dev *zdev;
-
-        /* Alloc memory for our private pci device data */
-        zdev = kzalloc(sizeof(*zdev), GFP_KERNEL);
-        return zdev ? : ERR_PTR(-ENOMEM);
-}
-
-void zpci_free_device(struct zpci_dev *zdev)
-{
-        kfree(zdev);
-}
-
 int pcibios_add_platform_entries(struct pci_dev *pdev)
 {
         return zpci_sysfs_add_device(&pdev->dev);
@@ -579,37 +565,6 @@ static void zpci_irq_exit(void)
         unregister_adapter_interrupt(&zpci_airq);
 }
 
-static struct resource *zpci_alloc_bus_resource(unsigned long start, unsigned long size,
-                                                unsigned long flags, int domain)
-{
-        struct resource *r;
-        char *name;
-        int rc;
-
-        r = kzalloc(sizeof(*r), GFP_KERNEL);
-        if (!r)
-                return ERR_PTR(-ENOMEM);
-        r->start = start;
-        r->end = r->start + size - 1;
-        r->flags = flags;
-        r->parent = &iomem_resource;
-        name = kmalloc(18, GFP_KERNEL);
-        if (!name) {
-                kfree(r);
-                return ERR_PTR(-ENOMEM);
-        }
-        sprintf(name, "PCI Bus: %04x:%02x", domain, ZPCI_BUS_NR);
-        r->name = name;
-
-        rc = request_resource(&iomem_resource, r);
-        if (rc) {
-                kfree(r->name);
-                kfree(r);
-                return ERR_PTR(-ENOMEM);
-        }
-        return r;
-}
-
 static int zpci_alloc_iomap(struct zpci_dev *zdev)
 {
         int entry;
@@ -633,6 +588,82 @@ static void zpci_free_iomap(struct zpci_dev *zdev, int entry)
         spin_unlock(&zpci_iomap_lock);
 }
 
+static struct resource *__alloc_res(struct zpci_dev *zdev, unsigned long start,
+                                    unsigned long size, unsigned long flags)
+{
+        struct resource *r;
+
+        r = kzalloc(sizeof(*r), GFP_KERNEL);
+        if (!r)
+                return NULL;
+
+        r->start = start;
+        r->end = r->start + size - 1;
+        r->flags = flags;
+        r->name = zdev->res_name;
+
+        if (request_resource(&iomem_resource, r)) {
+                kfree(r);
+                return NULL;
+        }
+        return r;
+}
+
+static int zpci_setup_bus_resources(struct zpci_dev *zdev,
+                                    struct list_head *resources)
+{
+        unsigned long addr, size, flags;
+        struct resource *res;
+        int i, entry;
+
+        snprintf(zdev->res_name, sizeof(zdev->res_name),
+                 "PCI Bus %04x:%02x", zdev->domain, ZPCI_BUS_NR);
+
+        for (i = 0; i < PCI_BAR_COUNT; i++) {
+                if (!zdev->bars[i].size)
+                        continue;
+                entry = zpci_alloc_iomap(zdev);
+                if (entry < 0)
+                        return entry;
+                zdev->bars[i].map_idx = entry;
+
+                /* only MMIO is supported */
+                flags = IORESOURCE_MEM;
+                if (zdev->bars[i].val & 8)
+                        flags |= IORESOURCE_PREFETCH;
+                if (zdev->bars[i].val & 4)
+                        flags |= IORESOURCE_MEM_64;
+
+                addr = ZPCI_IOMAP_ADDR_BASE + ((u64) entry << 48);
+
+                size = 1UL << zdev->bars[i].size;
+
+                res = __alloc_res(zdev, addr, size, flags);
+                if (!res) {
+                        zpci_free_iomap(zdev, entry);
+                        return -ENOMEM;
+                }
+                zdev->bars[i].res = res;
+                pci_add_resource(resources, res);
+        }
+
+        return 0;
+}
+
+static void zpci_cleanup_bus_resources(struct zpci_dev *zdev)
+{
+        int i;
+
+        for (i = 0; i < PCI_BAR_COUNT; i++) {
+                if (!zdev->bars[i].size)
+                        continue;
+
+                zpci_free_iomap(zdev, zdev->bars[i].map_idx);
+                release_resource(zdev->bars[i].res);
+                kfree(zdev->bars[i].res);
+        }
+}
+
 int pcibios_add_device(struct pci_dev *pdev)
 {
         struct zpci_dev *zdev = get_zdev(pdev);
@@ -729,52 +760,6 @@ struct dev_pm_ops pcibios_pm_ops = {
 };
 #endif /* CONFIG_HIBERNATE_CALLBACKS */
 
-static int zpci_scan_bus(struct zpci_dev *zdev)
-{
-        struct resource *res;
-        LIST_HEAD(resources);
-        int i;
-
-        /* allocate mapping entry for each used bar */
-        for (i = 0; i < PCI_BAR_COUNT; i++) {
-                unsigned long addr, size, flags;
-                int entry;
-
-                if (!zdev->bars[i].size)
-                        continue;
-                entry = zpci_alloc_iomap(zdev);
-                if (entry < 0)
-                        return entry;
-                zdev->bars[i].map_idx = entry;
-
-                /* only MMIO is supported */
-                flags = IORESOURCE_MEM;
-                if (zdev->bars[i].val & 8)
-                        flags |= IORESOURCE_PREFETCH;
-                if (zdev->bars[i].val & 4)
-                        flags |= IORESOURCE_MEM_64;
-
-                addr = ZPCI_IOMAP_ADDR_BASE + ((u64) entry << 48);
-
-                size = 1UL << zdev->bars[i].size;
-
-                res = zpci_alloc_bus_resource(addr, size, flags, zdev->domain);
-                if (IS_ERR(res)) {
-                        zpci_free_iomap(zdev, entry);
-                        return PTR_ERR(res);
-                }
-                pci_add_resource(&resources, res);
-        }
-
-        zdev->bus = pci_scan_root_bus(NULL, ZPCI_BUS_NR, &pci_root_ops,
-                                      zdev, &resources);
-        if (!zdev->bus)
-                return -EIO;
-
-        zdev->bus->max_bus_speed = zdev->max_bus_speed;
-        return 0;
-}
-
 static int zpci_alloc_domain(struct zpci_dev *zdev)
 {
         spin_lock(&zpci_domain_lock);
@@ -795,6 +780,41 @@ static void zpci_free_domain(struct zpci_dev *zdev)
         spin_unlock(&zpci_domain_lock);
 }
 
+void pcibios_remove_bus(struct pci_bus *bus)
+{
+        struct zpci_dev *zdev = get_zdev_by_bus(bus);
+
+        zpci_exit_slot(zdev);
+        zpci_cleanup_bus_resources(zdev);
+        zpci_free_domain(zdev);
+
+        spin_lock(&zpci_list_lock);
+        list_del(&zdev->entry);
+        spin_unlock(&zpci_list_lock);
+
+        kfree(zdev);
+}
+
+static int zpci_scan_bus(struct zpci_dev *zdev)
+{
+        LIST_HEAD(resources);
+        int ret;
+
+        ret = zpci_setup_bus_resources(zdev, &resources);
+        if (ret)
+                return ret;
+
+        zdev->bus = pci_scan_root_bus(NULL, ZPCI_BUS_NR, &pci_root_ops,
+                                      zdev, &resources);
+        if (!zdev->bus) {
+                zpci_cleanup_bus_resources(zdev);
+                return -EIO;
+        }
+
+        zdev->bus->max_bus_speed = zdev->max_bus_speed;
+        return 0;
+}
+
 int zpci_enable_device(struct zpci_dev *zdev)
 {
         int rc;
diff --git a/arch/s390/pci/pci_clp.c b/arch/s390/pci/pci_clp.c
index 84147984224a..c747394029ee 100644
--- a/arch/s390/pci/pci_clp.c
+++ b/arch/s390/pci/pci_clp.c
@@ -155,9 +155,9 @@ int clp_add_pci_device(u32 fid, u32 fh, int configured)
         int rc;
 
         zpci_dbg(3, "add fid:%x, fh:%x, c:%d\n", fid, fh, configured);
-        zdev = zpci_alloc_device();
-        if (IS_ERR(zdev))
-                return PTR_ERR(zdev);
+        zdev = kzalloc(sizeof(*zdev), GFP_KERNEL);
+        if (!zdev)
+                return -ENOMEM;
 
         zdev->fh = fh;
         zdev->fid = fid;
@@ -178,7 +178,7 @@ int clp_add_pci_device(u32 fid, u32 fh, int configured)
         return 0;
 
 error:
-        zpci_free_device(zdev);
+        kfree(zdev);
         return rc;
 }
 
diff --git a/arch/s390/pci/pci_event.c b/arch/s390/pci/pci_event.c
index 278e671ec9ac..800f064b0da7 100644
--- a/arch/s390/pci/pci_event.c
+++ b/arch/s390/pci/pci_event.c
@@ -11,6 +11,7 @@
 #include <linux/kernel.h>
 #include <linux/pci.h>
 #include <asm/pci_debug.h>
+#include <asm/sclp.h>
 
 /* Content Code Description for PCI Function Error */
 struct zpci_ccdf_err {
@@ -42,10 +43,27 @@ struct zpci_ccdf_avail {
         u16 pec;                        /* PCI event code */
 } __packed;
 
-static void zpci_event_log_avail(struct zpci_ccdf_avail *ccdf)
+void zpci_event_error(void *data)
 {
+        struct zpci_ccdf_err *ccdf = data;
+        struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
+
+        zpci_err("error CCDF:\n");
+        zpci_err_hex(ccdf, sizeof(*ccdf));
+
+        if (!zdev)
+                return;
+
+        pr_err("%s: Event 0x%x reports an error for PCI function 0x%x\n",
+               pci_name(zdev->pdev), ccdf->pec, ccdf->fid);
+}
+
+void zpci_event_availability(void *data)
+{
+        struct zpci_ccdf_avail *ccdf = data;
         struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
         struct pci_dev *pdev = zdev ? zdev->pdev : NULL;
+        int ret;
 
         pr_info("%s: Event 0x%x reconfigured PCI function 0x%x\n",
                 pdev ? pci_name(pdev) : "n/a", ccdf->pec, ccdf->fid);
@@ -53,36 +71,47 @@ static void zpci_event_log_avail(struct zpci_ccdf_avail *ccdf)
         zpci_err_hex(ccdf, sizeof(*ccdf));
 
         switch (ccdf->pec) {
-        case 0x0301:
-                zpci_enable_device(zdev);
+        case 0x0301: /* Standby -> Configured */
+                if (!zdev || zdev->state == ZPCI_FN_STATE_CONFIGURED)
+                        break;
+                zdev->state = ZPCI_FN_STATE_CONFIGURED;
+                ret = zpci_enable_device(zdev);
+                if (ret)
+                        break;
+                pci_rescan_bus(zdev->bus);
                 break;
-        case 0x0302:
+        case 0x0302: /* Reserved -> Standby */
                 clp_add_pci_device(ccdf->fid, ccdf->fh, 0);
                 break;
-        case 0x0306:
+        case 0x0303: /* Deconfiguration requested */
+                if (pdev)
+                        pci_stop_and_remove_bus_device(pdev);
+
+                ret = zpci_disable_device(zdev);
+                if (ret)
+                        break;
+
+                ret = sclp_pci_deconfigure(zdev->fid);
+                zpci_dbg(3, "deconf fid:%x, rc:%d\n", zdev->fid, ret);
+                if (!ret)
+                        zdev->state = ZPCI_FN_STATE_STANDBY;
+
+                break;
+        case 0x0304: /* Configured -> Standby */
+                if (pdev)
+                        pci_stop_and_remove_bus_device(pdev);
+
+                zpci_disable_device(zdev);
+                zdev->state = ZPCI_FN_STATE_STANDBY;
+                break;
+        case 0x0306: /* 0x308 or 0x302 for multiple devices */
                 clp_rescan_pci_devices();
                 break;
+        case 0x0308: /* Standby -> Reserved */
+                pci_stop_root_bus(zdev->bus);
+                pci_remove_root_bus(zdev->bus);
+                break;
         default:
                 break;
         }
 }
-
-void zpci_event_error(void *data)
-{
-        struct zpci_ccdf_err *ccdf = data;
-        struct zpci_dev *zdev = get_zdev_by_fid(ccdf->fid);
-
-        zpci_err("error CCDF:\n");
-        zpci_err_hex(ccdf, sizeof(*ccdf));
-
-        if (!zdev)
-                return;
-
-        pr_err("%s: Event 0x%x reports an error for PCI function 0x%x\n",
-               pci_name(zdev->pdev), ccdf->pec, ccdf->fid);
-}
-
-void zpci_event_availability(void *data)
-{
-        zpci_event_log_avail(data);
-}