drivers/s390/char/sclp_config.c

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