drivers/s390/char/sclp_cpi_sys.c

   1 /*
   2  *  drivers/s390/char/sclp_cpi_sys.c
   3  *    SCLP control program identification sysfs interface
   4  *
   5  *    Copyright IBM Corp. 2001, 2007
   6  *    Author(s): Martin Peschke <mpeschke@de.ibm.com>
   7  *               Michael Ernst <mernst@de.ibm.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/init.h>
  12 #include <linux/stat.h>
  13 #include <linux/device.h>
  14 #include <linux/string.h>
  15 #include <linux/ctype.h>
  16 #include <linux/kmod.h>
  17 #include <linux/timer.h>
  18 #include <linux/err.h>
  19 #include <linux/slab.h>
  20 #include <linux/completion.h>
  21 #include <asm/ebcdic.h>
  22 #include <asm/sclp.h>
  23 #include "sclp.h"
  24 #include "sclp_rw.h"
  25 #include "sclp_cpi_sys.h"
  26
  27 #define CPI_LENGTH_NAME 8
  28 #define CPI_LENGTH_LEVEL 16
  29
  30 struct cpi_evbuf {
  31         struct evbuf_header header;
  32         u8      id_format;
  33         u8      reserved0;
  34         u8      system_type[CPI_LENGTH_NAME];
  35         u64     reserved1;
  36         u8      system_name[CPI_LENGTH_NAME];
  37         u64     reserved2;
  38         u64     system_level;
  39         u64     reserved3;
  40         u8      sysplex_name[CPI_LENGTH_NAME];
  41         u8      reserved4[16];
  42 } __attribute__((packed));
  43
  44 struct cpi_sccb {
  45         struct sccb_header header;
  46         struct cpi_evbuf cpi_evbuf;
  47 } __attribute__((packed));
  48
  49 static struct sclp_register sclp_cpi_event = {
  50         .send_mask = EVTYP_CTLPROGIDENT_MASK,
  51 };
  52
  53 static char system_name[CPI_LENGTH_NAME + 1];
  54 static char sysplex_name[CPI_LENGTH_NAME + 1];
  55 static char system_type[CPI_LENGTH_NAME + 1];
  56 static u64 system_level;
  57
  58 static void set_data(char *field, char *data)
  59 {
  60         memset(field, ' ', CPI_LENGTH_NAME);
  61         memcpy(field, data, strlen(data));
  62         sclp_ascebc_str(field, CPI_LENGTH_NAME);
  63 }
  64
  65 static void cpi_callback(struct sclp_req *req, void *data)
  66 {
  67         struct completion *completion = data;
  68
  69         complete(completion);
  70 }
  71
  72 static struct sclp_req *cpi_prepare_req(void)
  73 {
  74         struct sclp_req *req;
  75         struct cpi_sccb *sccb;
  76         struct cpi_evbuf *evb;
  77
  78         req = kzalloc(sizeof(struct sclp_req), GFP_KERNEL);
  79         if (!req)
  80                 return ERR_PTR(-ENOMEM);
  81         sccb = (struct cpi_sccb *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
  82         if (!sccb) {
  83                 kfree(req);
  84                 return ERR_PTR(-ENOMEM);
  85         }
  86
  87         /* setup SCCB for Control-Program Identification */
  88         sccb->header.length = sizeof(struct cpi_sccb);
  89         sccb->cpi_evbuf.header.length = sizeof(struct cpi_evbuf);
  90         sccb->cpi_evbuf.header.type = 0x0b;
  91         evb = &sccb->cpi_evbuf;
  92
  93         /* set system type */
  94         set_data(evb->system_type, system_type);
  95
  96         /* set system name */
  97         set_data(evb->system_name, system_name);
  98
  99         /* set sytem level */
 100         evb->system_level = system_level;
 101
 102         /* set sysplex name */
 103         set_data(evb->sysplex_name, sysplex_name);
 104
 105         /* prepare request data structure presented to SCLP driver */
 106         req->command = SCLP_CMDW_WRITE_EVENT_DATA;
 107         req->sccb = sccb;
 108         req->status = SCLP_REQ_FILLED;
 109         req->callback = cpi_callback;
 110         return req;
 111 }
 112
 113 static void cpi_free_req(struct sclp_req *req)
 114 {
 115         free_page((unsigned long) req->sccb);
 116         kfree(req);
 117 }
 118
 119 static int cpi_req(void)
 120 {
 121         struct completion completion;
 122         struct sclp_req *req;
 123         int rc;
 124         int response;
 125
 126         rc = sclp_register(&sclp_cpi_event);
 127         if (rc) {
 128                 printk(KERN_WARNING "cpi: could not register "
 129                         "to hardware console.\n");
 130                 goto out;
 131         }
 132 <<<<<<< HEAD:drivers/s390/char/sclp_cpi_sys.c
 133         if (!(sclp_cpi_event.sclp_send_mask & EVTYP_CTLPROGIDENT_MASK)) {
 134 =======
 135         if (!(sclp_cpi_event.sclp_receive_mask & EVTYP_CTLPROGIDENT_MASK)) {
 136 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/s390/char/sclp_cpi_sys.c
 137                 printk(KERN_WARNING "cpi: no control program "
 138                         "identification support\n");
 139                 rc = -EOPNOTSUPP;
 140                 goto out_unregister;
 141         }
 142
 143         req = cpi_prepare_req();
 144         if (IS_ERR(req)) {
 145                 printk(KERN_WARNING "cpi: could not allocate request\n");
 146                 rc = PTR_ERR(req);
 147                 goto out_unregister;
 148         }
 149
 150         init_completion(&completion);
 151         req->callback_data = &completion;
 152
 153         /* Add request to sclp queue */
 154         rc = sclp_add_request(req);
 155         if (rc) {
 156                 printk(KERN_WARNING "cpi: could not start request\n");
 157                 goto out_free_req;
 158         }
 159
 160         wait_for_completion(&completion);
 161
 162         if (req->status != SCLP_REQ_DONE) {
 163                 printk(KERN_WARNING "cpi: request failed (status=0x%02x)\n",
 164                         req->status);
 165                 rc = -EIO;
 166                 goto out_free_req;
 167         }
 168
 169         response = ((struct cpi_sccb *) req->sccb)->header.response_code;
 170         if (response != 0x0020) {
 171                 printk(KERN_WARNING "cpi: failed with "
 172                         "response code 0x%x\n", response);
 173                 rc = -EIO;
 174         }
 175
 176 out_free_req:
 177         cpi_free_req(req);
 178
 179 out_unregister:
 180         sclp_unregister(&sclp_cpi_event);
 181
 182 out:
 183         return rc;
 184 }
 185
 186 static int check_string(const char *attr, const char *str)
 187 {
 188         size_t len;
 189         size_t i;
 190
 191         len = strlen(str);
 192
 193         if ((len > 0) && (str[len - 1] == '\n'))
 194                 len--;
 195
 196         if (len > CPI_LENGTH_NAME)
 197                 return -EINVAL;
 198
 199         for (i = 0; i < len ; i++) {
 200                 if (isalpha(str[i]) || isdigit(str[i]) ||
 201                     strchr("$@# ", str[i]))
 202                         continue;
 203                 return -EINVAL;
 204         }
 205
 206         return 0;
 207 }
 208
 209 static void set_string(char *attr, const char *value)
 210 {
 211         size_t len;
 212         size_t i;
 213
 214         len = strlen(value);
 215
 216         if ((len > 0) && (value[len - 1] == '\n'))
 217                 len--;
 218
 219         for (i = 0; i < CPI_LENGTH_NAME; i++) {
 220                 if (i < len)
 221                         attr[i] = toupper(value[i]);
 222                 else
 223                         attr[i] = ' ';
 224         }
 225 }
 226
 227 static ssize_t system_name_show(struct kobject *kobj,
 228                                 struct kobj_attribute *attr, char *page)
 229 {
 230         return snprintf(page, PAGE_SIZE, "%s\n", system_name);
 231 }
 232
 233 static ssize_t system_name_store(struct kobject *kobj,
 234                                  struct kobj_attribute *attr,
 235                                  const char *buf,
 236         size_t len)
 237 {
 238         int rc;
 239
 240         rc = check_string("system_name", buf);
 241         if (rc)
 242                 return rc;
 243
 244         set_string(system_name, buf);
 245
 246         return len;
 247 }
 248
 249 static struct kobj_attribute system_name_attr =
 250         __ATTR(system_name, 0644, system_name_show, system_name_store);
 251
 252 static ssize_t sysplex_name_show(struct kobject *kobj,
 253                                  struct kobj_attribute *attr, char *page)
 254 {
 255         return snprintf(page, PAGE_SIZE, "%s\n", sysplex_name);
 256 }
 257
 258 static ssize_t sysplex_name_store(struct kobject *kobj,
 259                                   struct kobj_attribute *attr,
 260                                   const char *buf,
 261         size_t len)
 262 {
 263         int rc;
 264
 265         rc = check_string("sysplex_name", buf);
 266         if (rc)
 267                 return rc;
 268
 269         set_string(sysplex_name, buf);
 270
 271         return len;
 272 }
 273
 274 static struct kobj_attribute sysplex_name_attr =
 275         __ATTR(sysplex_name, 0644, sysplex_name_show, sysplex_name_store);
 276
 277 static ssize_t system_type_show(struct kobject *kobj,
 278                                 struct kobj_attribute *attr, char *page)
 279 {
 280         return snprintf(page, PAGE_SIZE, "%s\n", system_type);
 281 }
 282
 283 static ssize_t system_type_store(struct kobject *kobj,
 284                                  struct kobj_attribute *attr,
 285                                  const char *buf,
 286         size_t len)
 287 {
 288         int rc;
 289
 290         rc = check_string("system_type", buf);
 291         if (rc)
 292                 return rc;
 293
 294         set_string(system_type, buf);
 295
 296         return len;
 297 }
 298
 299 static struct kobj_attribute system_type_attr =
 300         __ATTR(system_type, 0644, system_type_show, system_type_store);
 301
 302 static ssize_t system_level_show(struct kobject *kobj,
 303                                  struct kobj_attribute *attr, char *page)
 304 {
 305         unsigned long long level = system_level;
 306
 307         return snprintf(page, PAGE_SIZE, "%#018llx\n", level);
 308 }
 309
 310 static ssize_t system_level_store(struct kobject *kobj,
 311                                   struct kobj_attribute *attr,
 312                                   const char *buf,
 313         size_t len)
 314 {
 315         unsigned long long level;
 316         char *endp;
 317
 318         level = simple_strtoull(buf, &endp, 16);
 319
 320         if (endp == buf)
 321                 return -EINVAL;
 322         if (*endp == '\n')
 323                 endp++;
 324         if (*endp)
 325                 return -EINVAL;
 326
 327         system_level = level;
 328
 329         return len;
 330 }
 331
 332 static struct kobj_attribute system_level_attr =
 333         __ATTR(system_level, 0644, system_level_show, system_level_store);
 334
 335 static ssize_t set_store(struct kobject *kobj,
 336                          struct kobj_attribute *attr,
 337                          const char *buf, size_t len)
 338 {
 339         int rc;
 340
 341         rc = cpi_req();
 342         if (rc)
 343                 return rc;
 344
 345         return len;
 346 }
 347
 348 static struct kobj_attribute set_attr = __ATTR(set, 0200, NULL, set_store);
 349
 350 static struct attribute *cpi_attrs[] = {
 351         &system_name_attr.attr,
 352         &sysplex_name_attr.attr,
 353         &system_type_attr.attr,
 354         &system_level_attr.attr,
 355         &set_attr.attr,
 356         NULL,
 357 };
 358
 359 static struct attribute_group cpi_attr_group = {
 360         .attrs = cpi_attrs,
 361 };
 362
 363 static struct kset *cpi_kset;
 364
 365 int sclp_cpi_set_data(const char *system, const char *sysplex, const char *type,
 366                       const u64 level)
 367 {
 368         int rc;
 369
 370         rc = check_string("system_name", system);
 371         if (rc)
 372                 return rc;
 373         rc = check_string("sysplex_name", sysplex);
 374         if (rc)
 375                 return rc;
 376         rc = check_string("system_type", type);
 377         if (rc)
 378                 return rc;
 379
 380         set_string(system_name, system);
 381         set_string(sysplex_name, sysplex);
 382         set_string(system_type, type);
 383         system_level = level;
 384
 385         return cpi_req();
 386 }
 387 EXPORT_SYMBOL(sclp_cpi_set_data);
 388
 389 static int __init cpi_init(void)
 390 {
 391         int rc;
 392
 393         cpi_kset = kset_create_and_add("cpi", NULL, firmware_kobj);
 394         if (!cpi_kset)
 395                 return -ENOMEM;
 396
 397         rc = sysfs_create_group(&cpi_kset->kobj, &cpi_attr_group);
 398         if (rc)
 399                 kset_unregister(cpi_kset);
 400
 401         return rc;
 402 }
 403
 404 __initcall(cpi_init);