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