drivers/s390/cio/scm.c

   1 /*
   2  * Recognize and maintain s390 storage class memory.
   3  *
   4  * Copyright IBM Corp. 2012
   5  * Author(s): Sebastian Ott <sebott@linux.vnet.ibm.com>
   6  */
   7
   8 #include <linux/device.h>
   9 #include <linux/module.h>
  10 #include <linux/mutex.h>
  11 #include <linux/slab.h>
  12 #include <linux/init.h>
  13 #include <linux/err.h>
  14 #include <asm/eadm.h>
  15 #include "chsc.h"
  16
  17 static struct device *scm_root;
  18
  19 #define to_scm_dev(n) container_of(n, struct scm_device, dev)
  20 #define to_scm_drv(d) container_of(d, struct scm_driver, drv)
  21
  22 static int scmdev_probe(struct device *dev)
  23 {
  24         struct scm_device *scmdev = to_scm_dev(dev);
  25         struct scm_driver *scmdrv = to_scm_drv(dev->driver);
  26
  27         return scmdrv->probe ? scmdrv->probe(scmdev) : -ENODEV;
  28 }
  29
  30 static int scmdev_remove(struct device *dev)
  31 {
  32         struct scm_device *scmdev = to_scm_dev(dev);
  33         struct scm_driver *scmdrv = to_scm_drv(dev->driver);
  34
  35         return scmdrv->remove ? scmdrv->remove(scmdev) : -ENODEV;
  36 }
  37
  38 static int scmdev_uevent(struct device *dev, struct kobj_uevent_env *env)
  39 {
  40         return add_uevent_var(env, "MODALIAS=scm:scmdev");
  41 }
  42
  43 static struct bus_type scm_bus_type = {
  44         .name  = "scm",
  45         .probe = scmdev_probe,
  46         .remove = scmdev_remove,
  47         .uevent = scmdev_uevent,
  48 };
  49
  50 /**
  51  * scm_driver_register() - register a scm driver
  52  * @scmdrv: driver to be registered
  53  */
  54 int scm_driver_register(struct scm_driver *scmdrv)
  55 {
  56         struct device_driver *drv = &scmdrv->drv;
  57
  58         drv->bus = &scm_bus_type;
  59
  60         return driver_register(drv);
  61 }
  62 EXPORT_SYMBOL_GPL(scm_driver_register);
  63
  64 /**
  65  * scm_driver_unregister() - deregister a scm driver
  66  * @scmdrv: driver to be deregistered
  67  */
  68 void scm_driver_unregister(struct scm_driver *scmdrv)
  69 {
  70         driver_unregister(&scmdrv->drv);
  71 }
  72 EXPORT_SYMBOL_GPL(scm_driver_unregister);
  73
  74 void scm_irq_handler(struct aob *aob, int error)
  75 {
  76         struct aob_rq_header *aobrq = (void *) aob->request.data;
  77         struct scm_device *scmdev = aobrq->scmdev;
  78         struct scm_driver *scmdrv = to_scm_drv(scmdev->dev.driver);
  79
  80         scmdrv->handler(scmdev, aobrq->data, error);
  81 }
  82 EXPORT_SYMBOL_GPL(scm_irq_handler);
  83
  84 #define scm_attr(name)                                                  \
  85 static ssize_t show_##name(struct device *dev,                          \
  86                struct device_attribute *attr, char *buf)                \
  87 {                                                                       \
  88         struct scm_device *scmdev = to_scm_dev(dev);                    \
  89         int ret;                                                        \
  90                                                                         \
  91         device_lock(dev);                                               \
  92         ret = sprintf(buf, "%u\n", scmdev->attrs.name);                 \
  93         device_unlock(dev);                                             \
  94                                                                         \
  95         return ret;                                                     \
  96 }                                                                       \
  97 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
  98
  99 scm_attr(persistence);
 100 scm_attr(oper_state);
 101 scm_attr(data_state);
 102 scm_attr(rank);
 103 scm_attr(release);
 104 scm_attr(res_id);
 105
 106 static struct attribute *scmdev_attrs[] = {
 107         &dev_attr_persistence.attr,
 108         &dev_attr_oper_state.attr,
 109         &dev_attr_data_state.attr,
 110         &dev_attr_rank.attr,
 111         &dev_attr_release.attr,
 112         &dev_attr_res_id.attr,
 113         NULL,
 114 };
 115
 116 static struct attribute_group scmdev_attr_group = {
 117         .attrs = scmdev_attrs,
 118 };
 119
 120 static const struct attribute_group *scmdev_attr_groups[] = {
 121         &scmdev_attr_group,
 122         NULL,
 123 };
 124
 125 static void scmdev_release(struct device *dev)
 126 {
 127         struct scm_device *scmdev = to_scm_dev(dev);
 128
 129         kfree(scmdev);
 130 }
 131
 132 static void scmdev_setup(struct scm_device *scmdev, struct sale *sale,
 133                          unsigned int size, unsigned int max_blk_count)
 134 {
 135         dev_set_name(&scmdev->dev, "%016llx", (unsigned long long) sale->sa);
 136         scmdev->nr_max_block = max_blk_count;
 137         scmdev->address = sale->sa;
 138         scmdev->size = 1UL << size;
 139         scmdev->attrs.rank = sale->rank;
 140         scmdev->attrs.persistence = sale->p;
 141         scmdev->attrs.oper_state = sale->op_state;
 142         scmdev->attrs.data_state = sale->data_state;
 143         scmdev->attrs.rank = sale->rank;
 144         scmdev->attrs.release = sale->r;
 145         scmdev->attrs.res_id = sale->rid;
 146         scmdev->dev.parent = scm_root;
 147         scmdev->dev.bus = &scm_bus_type;
 148         scmdev->dev.release = scmdev_release;
 149         scmdev->dev.groups = scmdev_attr_groups;
 150 }
 151
 152 /*
 153  * Check for state-changes, notify the driver and userspace.
 154  */
 155 static void scmdev_update(struct scm_device *scmdev, struct sale *sale)
 156 {
 157         struct scm_driver *scmdrv;
 158         bool changed;
 159
 160         device_lock(&scmdev->dev);
 161         changed = scmdev->attrs.rank != sale->rank ||
 162                   scmdev->attrs.oper_state != sale->op_state;
 163         scmdev->attrs.rank = sale->rank;
 164         scmdev->attrs.oper_state = sale->op_state;
 165         if (!scmdev->dev.driver)
 166                 goto out;
 167         scmdrv = to_scm_drv(scmdev->dev.driver);
 168         if (changed && scmdrv->notify)
 169                 scmdrv->notify(scmdev, SCM_CHANGE);
 170 out:
 171         device_unlock(&scmdev->dev);
 172         if (changed)
 173                 kobject_uevent(&scmdev->dev.kobj, KOBJ_CHANGE);
 174 }
 175
 176 static int check_address(struct device *dev, void *data)
 177 {
 178         struct scm_device *scmdev = to_scm_dev(dev);
 179         struct sale *sale = data;
 180
 181         return scmdev->address == sale->sa;
 182 }
 183
 184 static struct scm_device *scmdev_find(struct sale *sale)
 185 {
 186         struct device *dev;
 187
 188         dev = bus_find_device(&scm_bus_type, NULL, sale, check_address);
 189
 190         return dev ? to_scm_dev(dev) : NULL;
 191 }
 192
 193 static int scm_add(struct chsc_scm_info *scm_info, size_t num)
 194 {
 195         struct sale *sale, *scmal = scm_info->scmal;
 196         struct scm_device *scmdev;
 197         int ret;
 198
 199         for (sale = scmal; sale < scmal + num; sale++) {
 200                 scmdev = scmdev_find(sale);
 201                 if (scmdev) {
 202                         scmdev_update(scmdev, sale);
 203                         /* Release reference from scm_find(). */
 204                         put_device(&scmdev->dev);
 205                         continue;
 206                 }
 207                 scmdev = kzalloc(sizeof(*scmdev), GFP_KERNEL);
 208                 if (!scmdev)
 209                         return -ENODEV;
 210                 scmdev_setup(scmdev, sale, scm_info->is, scm_info->mbc);
 211                 ret = device_register(&scmdev->dev);
 212                 if (ret) {
 213                         /* Release reference from device_initialize(). */
 214                         put_device(&scmdev->dev);
 215                         return ret;
 216                 }
 217         }
 218
 219         return 0;
 220 }
 221
 222 int scm_update_information(void)
 223 {
 224         struct chsc_scm_info *scm_info;
 225         u64 token = 0;
 226         size_t num;
 227         int ret;
 228
 229         scm_info = (void *)__get_free_page(GFP_KERNEL | GFP_DMA);
 230         if (!scm_info)
 231                 return -ENOMEM;
 232
 233         do {
 234                 ret = chsc_scm_info(scm_info, token);
 235                 if (ret)
 236                         break;
 237
 238                 num = (scm_info->response.length -
 239                        (offsetof(struct chsc_scm_info, scmal) -
 240                         offsetof(struct chsc_scm_info, response))
 241                       ) / sizeof(struct sale);
 242
 243                 ret = scm_add(scm_info, num);
 244                 if (ret)
 245                         break;
 246
 247                 token = scm_info->restok;
 248         } while (token);
 249
 250         free_page((unsigned long)scm_info);
 251
 252         return ret;
 253 }
 254
 255 static int scm_dev_avail(struct device *dev, void *unused)
 256 {
 257         struct scm_driver *scmdrv = to_scm_drv(dev->driver);
 258         struct scm_device *scmdev = to_scm_dev(dev);
 259
 260         if (dev->driver && scmdrv->notify)
 261                 scmdrv->notify(scmdev, SCM_AVAIL);
 262
 263         return 0;
 264 }
 265
 266 int scm_process_availability_information(void)
 267 {
 268         return bus_for_each_dev(&scm_bus_type, NULL, NULL, scm_dev_avail);
 269 }
 270
 271 static int __init scm_init(void)
 272 {
 273         int ret;
 274
 275         ret = bus_register(&scm_bus_type);
 276         if (ret)
 277                 return ret;
 278
 279         scm_root = root_device_register("scm");
 280         if (IS_ERR(scm_root)) {
 281                 bus_unregister(&scm_bus_type);
 282                 return PTR_ERR(scm_root);
 283         }
 284
 285         scm_update_information();
 286         return 0;
 287 }
 288 subsys_initcall_sync(scm_init);