drivers/s390/char/sclp_config.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *    Copyright IBM Corp. 2007
   4  *    Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>
   5  */
   6
   7 #define KMSG_COMPONENT "sclp_config"
   8 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
   9
  10 #include <linux/init.h>
  11 #include <linux/errno.h>
  12 #include <linux/cpu.h>
  13 #include <linux/device.h>
  14 #include <linux/workqueue.h>
  15 #include <linux/slab.h>
  16 #include <linux/sysfs.h>
  17 #include <asm/smp.h>
  18
  19 #include "sclp.h"
  20
  21 struct conf_mgm_data {
  22         u8 reserved;
  23         u8 ev_qualifier;
  24 } __attribute__((packed));
  25
  26 #define OFB_DATA_MAX 64
  27
  28 struct sclp_ofb_evbuf {
  29         struct evbuf_header header;
  30         struct conf_mgm_data cm_data;
  31         char ev_data[OFB_DATA_MAX];
  32 } __packed;
  33
  34 struct sclp_ofb_sccb {
  35         struct sccb_header header;
  36         struct sclp_ofb_evbuf ofb_evbuf;
  37 } __packed;
  38
  39 #define EV_QUAL_CPU_CHANGE      1
  40 #define EV_QUAL_CAP_CHANGE      3
  41 #define EV_QUAL_OPEN4BUSINESS   5
  42
  43 static struct work_struct sclp_cpu_capability_work;
  44 static struct work_struct sclp_cpu_change_work;
  45
  46 static void sclp_cpu_capability_notify(struct work_struct *work)
  47 {
  48         int cpu;
  49         struct device *dev;
  50
  51         s390_update_cpu_mhz();
  52         pr_info("CPU capability may have changed\n");
  53         get_online_cpus();
  54         for_each_online_cpu(cpu) {
  55                 dev = get_cpu_device(cpu);
  56                 kobject_uevent(&dev->kobj, KOBJ_CHANGE);
  57         }
  58         put_online_cpus();
  59 }
  60
  61 static void __ref sclp_cpu_change_notify(struct work_struct *work)
  62 {
  63         smp_rescan_cpus();
  64 }
  65
  66 static void sclp_conf_receiver_fn(struct evbuf_header *evbuf)
  67 {
  68         struct conf_mgm_data *cdata;
  69
  70         cdata = (struct conf_mgm_data *)(evbuf + 1);
  71         switch (cdata->ev_qualifier) {
  72         case EV_QUAL_CPU_CHANGE:
  73                 schedule_work(&sclp_cpu_change_work);
  74                 break;
  75         case EV_QUAL_CAP_CHANGE:
  76                 schedule_work(&sclp_cpu_capability_work);
  77                 break;
  78         }
  79 }
  80
  81 static struct sclp_register sclp_conf_register =
  82 {
  83 #ifdef CONFIG_SCLP_OFB
  84         .send_mask    = EVTYP_CONFMGMDATA_MASK,
  85 #endif
  86         .receive_mask = EVTYP_CONFMGMDATA_MASK,
  87         .receiver_fn  = sclp_conf_receiver_fn,
  88 };
  89
  90 #ifdef CONFIG_SCLP_OFB
  91 static int sclp_ofb_send_req(char *ev_data, size_t len)
  92 {
  93         static DEFINE_MUTEX(send_mutex);
  94         struct sclp_ofb_sccb *sccb;
  95         int rc, response;
  96
  97         if (len > OFB_DATA_MAX)
  98                 return -EINVAL;
  99         sccb = (struct sclp_ofb_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
 100         if (!sccb)
 101                 return -ENOMEM;
 102         /* Setup SCCB for Control-Program Identification */
 103         sccb->header.length = sizeof(struct sclp_ofb_sccb);
 104         sccb->ofb_evbuf.header.length = sizeof(struct sclp_ofb_evbuf);
 105         sccb->ofb_evbuf.header.type = EVTYP_CONFMGMDATA;
 106         sccb->ofb_evbuf.cm_data.ev_qualifier = EV_QUAL_OPEN4BUSINESS;
 107         memcpy(sccb->ofb_evbuf.ev_data, ev_data, len);
 108
 109         if (!(sclp_conf_register.sclp_receive_mask & EVTYP_CONFMGMDATA_MASK))
 110                 pr_warn("SCLP receiver did not register to receive "
 111                         "Configuration Management Data Events.\n");
 112
 113         mutex_lock(&send_mutex);
 114         rc = sclp_sync_request(SCLP_CMDW_WRITE_EVENT_DATA, sccb);
 115         mutex_unlock(&send_mutex);
 116         if (rc)
 117                 goto out;
 118         response = sccb->header.response_code;
 119         if (response != 0x0020) {
 120                 pr_err("Open for Business request failed with response code "
 121                        "0x%04x\n", response);
 122                 rc = -EIO;
 123         }
 124 out:
 125         free_page((unsigned long)sccb);
 126         return rc;
 127 }
 128
 129 static ssize_t sysfs_ofb_data_write(struct file *filp, struct kobject *kobj,
 130                                     struct bin_attribute *bin_attr,
 131                                     char *buf, loff_t off, size_t count)
 132 {
 133         int rc;
 134
 135         rc = sclp_ofb_send_req(buf, count);
 136         return rc ?: count;
 137 }
 138
 139 static const struct bin_attribute ofb_bin_attr = {
 140         .attr = {
 141                 .name = "event_data",
 142                 .mode = S_IWUSR,
 143         },
 144         .write = sysfs_ofb_data_write,
 145 };
 146 #endif
 147
 148 static int __init sclp_ofb_setup(void)
 149 {
 150 #ifdef CONFIG_SCLP_OFB
 151         struct kset *ofb_kset;
 152         int rc;
 153
 154         ofb_kset = kset_create_and_add("ofb", NULL, firmware_kobj);
 155         if (!ofb_kset)
 156                 return -ENOMEM;
 157         rc = sysfs_create_bin_file(&ofb_kset->kobj, &ofb_bin_attr);
 158         if (rc) {
 159                 kset_unregister(ofb_kset);
 160                 return rc;
 161         }
 162 #endif
 163         return 0;
 164 }
 165
 166 static int __init sclp_conf_init(void)
 167 {
 168         int rc;
 169
 170         INIT_WORK(&sclp_cpu_capability_work, sclp_cpu_capability_notify);
 171         INIT_WORK(&sclp_cpu_change_work, sclp_cpu_change_notify);
 172         rc = sclp_register(&sclp_conf_register);
 173         if (rc)
 174                 return rc;
 175         return sclp_ofb_setup();
 176 }
 177
 178 __initcall(sclp_conf_init);