1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Interfaces to retrieve and set PDC Stable options (firmware) 4 * 5 * Copyright (C) 2005-2006 Thibaut VARENE <varenet@parisc-linux.org> 6 * 7 * DEV NOTE: the PDC Procedures reference states that: 8 * "A minimum of 96 bytes of Stable Storage is required. Providing more than 9 * 96 bytes of Stable Storage is optional [...]. Failure to provide the 10 * optional locations from 96 to 192 results in the loss of certain 11 * functionality during boot." 12 * 13 * Since locations between 96 and 192 are the various paths, most (if not 14 * all) PA-RISC machines should have them. Anyway, for safety reasons, the 15 * following code can deal with just 96 bytes of Stable Storage, and all 16 * sizes between 96 and 192 bytes (provided they are multiple of struct 17 * device_path size, eg: 128, 160 and 192) to provide full information. 18 * One last word: there's one path we can always count on: the primary path. 19 * Anything above 224 bytes is used for 'osdep2' OS-dependent storage area. 20 * 21 * The first OS-dependent area should always be available. Obviously, this is 22 * not true for the other one. Also bear in mind that reading/writing from/to 23 * osdep2 is much more expensive than from/to osdep1. 24 * NOTE: We do not handle the 2 bytes OS-dep area at 0x5D, nor the first 25 * 2 bytes of storage available right after OSID. That's a total of 4 bytes 26 * sacrificed: -ETOOLAZY :P 27 * 28 * The current policy wrt file permissions is: 29 * - write: root only 30 * - read: (reading triggers PDC calls) ? root only : everyone 31 * The rationale is that PDC calls could hog (DoS) the machine. 32 * 33 * TODO: 34 * - timer/fastsize write calls 35 */ 36 37#undef PDCS_DEBUG 38#ifdef PDCS_DEBUG 39#define DPRINTK(fmt, args...) printk(KERN_DEBUG fmt, ## args) 40#else 41#define DPRINTK(fmt, args...) 42#endif 43 44#include <linux/module.h> 45#include <linux/init.h> 46#include <linux/kernel.h> 47#include <linux/string.h> 48#include <linux/capability.h> 49#include <linux/ctype.h> 50#include <linux/sysfs.h> 51#include <linux/kobject.h> 52#include <linux/device.h> 53#include <linux/errno.h> 54#include <linux/spinlock.h> 55 56#include <asm/pdc.h> 57#include <asm/page.h> 58#include <linux/uaccess.h> 59#include <asm/hardware.h> 60 61#define PDCS_VERSION "0.30" 62#define PDCS_PREFIX "PDC Stable Storage" 63 64#define PDCS_ADDR_PPRI 0x00 65#define PDCS_ADDR_OSID 0x40 66#define PDCS_ADDR_OSD1 0x48 67#define PDCS_ADDR_DIAG 0x58 68#define PDCS_ADDR_FSIZ 0x5C 69#define PDCS_ADDR_PCON 0x60 70#define PDCS_ADDR_PALT 0x80 71#define PDCS_ADDR_PKBD 0xA0 72#define PDCS_ADDR_OSD2 0xE0 73 74MODULE_AUTHOR("Thibaut VARENE <varenet@parisc-linux.org>"); 75MODULE_DESCRIPTION("sysfs interface to HP PDC Stable Storage data"); 76MODULE_LICENSE("GPL"); 77MODULE_VERSION(PDCS_VERSION); 78 79/* holds Stable Storage size. Initialized once and for all, no lock needed */ 80static unsigned long pdcs_size __read_mostly; 81 82/* holds OS ID. Initialized once and for all, hopefully to 0x0006 */ 83static u16 pdcs_osid __read_mostly; 84 85/* This struct defines what we need to deal with a parisc pdc path entry */ 86struct pdcspath_entry { 87 rwlock_t rw_lock; /* to protect path entry access */ 88 short ready; /* entry record is valid if != 0 */ 89 unsigned long addr; /* entry address in stable storage */ 90 char *name; /* entry name */ 91 struct device_path devpath; /* device path in parisc representation */ 92 struct device *dev; /* corresponding device */ 93 struct kobject kobj; 94}; 95 96struct pdcspath_attribute { 97 struct attribute attr; 98 ssize_t (*show)(struct pdcspath_entry *entry, char *buf); 99 ssize_t (*store)(struct pdcspath_entry *entry, const char *buf, size_t count); 100}; 101 102#define PDCSPATH_ENTRY(_addr, _name) \ 103struct pdcspath_entry pdcspath_entry_##_name = { \ 104 .ready = 0, \ 105 .addr = _addr, \ 106 .name = __stringify(_name), \ 107}; 108 109#define PDCS_ATTR(_name, _mode, _show, _store) \ 110struct kobj_attribute pdcs_attr_##_name = { \ 111 .attr = {.name = __stringify(_name), .mode = _mode}, \ 112 .show = _show, \ 113 .store = _store, \ 114}; 115 116#define PATHS_ATTR(_name, _mode, _show, _store) \ 117struct pdcspath_attribute paths_attr_##_name = { \ 118 .attr = {.name = __stringify(_name), .mode = _mode}, \ 119 .show = _show, \ 120 .store = _store, \ 121}; 122 123#define to_pdcspath_attribute(_attr) container_of(_attr, struct pdcspath_attribute, attr) 124#define to_pdcspath_entry(obj) container_of(obj, struct pdcspath_entry, kobj) 125 126/** 127 * pdcspath_fetch - This function populates the path entry structs. 128 * @entry: A pointer to an allocated pdcspath_entry. 129 * 130 * The general idea is that you don't read from the Stable Storage every time 131 * you access the files provided by the facilities. We store a copy of the 132 * content of the stable storage WRT various paths in these structs. We read 133 * these structs when reading the files, and we will write to these structs when 134 * writing to the files, and only then write them back to the Stable Storage. 135 * 136 * This function expects to be called with @entry->rw_lock write-hold. 137 */ 138static int 139pdcspath_fetch(struct pdcspath_entry *entry) 140{ 141 struct device_path *devpath; 142 143 if (!entry) 144 return -EINVAL; 145 146 devpath = &entry->devpath; 147 148 DPRINTK("%s: fetch: 0x%p, 0x%p, addr: 0x%lx\n", __func__, 149 entry, devpath, entry->addr); 150 151 /* addr, devpath and count must be word aligned */ 152 if (pdc_stable_read(entry->addr, devpath, sizeof(*devpath)) != PDC_OK) 153 return -EIO; 154 155 /* Find the matching device. 156 NOTE: hardware_path overlays with device_path, so the nice cast can 157 be used */ 158 entry->dev = hwpath_to_device((struct hardware_path *)devpath); 159 160 entry->ready = 1; 161 162 DPRINTK("%s: device: 0x%p\n", __func__, entry->dev); 163 164 return 0; 165} 166 167/** 168 * pdcspath_store - This function writes a path to stable storage. 169 * @entry: A pointer to an allocated pdcspath_entry. 170 * 171 * It can be used in two ways: either by passing it a preset devpath struct 172 * containing an already computed hardware path, or by passing it a device 173 * pointer, from which it'll find out the corresponding hardware path. 174 * For now we do not handle the case where there's an error in writing to the 175 * Stable Storage area, so you'd better not mess up the data :P 176 * 177 * This function expects to be called with @entry->rw_lock write-hold. 178 */ 179static void 180pdcspath_store(struct pdcspath_entry *entry) 181{ 182 struct device_path *devpath; 183 184 BUG_ON(!entry); 185 186 devpath = &entry->devpath; 187 188 /* We expect the caller to set the ready flag to 0 if the hardware 189 path struct provided is invalid, so that we know we have to fill it. 190 First case, we don't have a preset hwpath... */ 191 if (!entry->ready) { 192 /* ...but we have a device, map it */ 193 BUG_ON(!entry->dev); 194 device_to_hwpath(entry->dev, (struct hardware_path *)devpath); 195 } 196 /* else, we expect the provided hwpath to be valid. */ 197 198 DPRINTK("%s: store: 0x%p, 0x%p, addr: 0x%lx\n", __func__, 199 entry, devpath, entry->addr); 200 201 /* addr, devpath and count must be word aligned */ 202 if (pdc_stable_write(entry->addr, devpath, sizeof(*devpath)) != PDC_OK) 203 WARN(1, KERN_ERR "%s: an error occurred when writing to PDC.\n" 204 "It is likely that the Stable Storage data has been corrupted.\n" 205 "Please check it carefully upon next reboot.\n", __func__); 206 207 /* kobject is already registered */ 208 entry->ready = 2; 209 210 DPRINTK("%s: device: 0x%p\n", __func__, entry->dev); 211} 212 213/** 214 * pdcspath_hwpath_read - This function handles hardware path pretty printing. 215 * @entry: An allocated and populated pdscpath_entry struct. 216 * @buf: The output buffer to write to. 217 * 218 * We will call this function to format the output of the hwpath attribute file. 219 */ 220static ssize_t 221pdcspath_hwpath_read(struct pdcspath_entry *entry, char *buf) 222{ 223 char *out = buf; 224 struct device_path *devpath; 225 short i; 226 227 if (!entry || !buf) 228 return -EINVAL; 229 230 read_lock(&entry->rw_lock); 231 devpath = &entry->devpath; 232 i = entry->ready; 233 read_unlock(&entry->rw_lock); 234 235 if (!i) /* entry is not ready */ 236 return -ENODATA; 237 238 for (i = 0; i < 6; i++) { 239 if (devpath->bc[i] >= 128) 240 continue; 241 out += sprintf(out, "%u/", (unsigned char)devpath->bc[i]); 242 } 243 out += sprintf(out, "%u\n", (unsigned char)devpath->mod); 244 245 return out - buf; 246} 247 248/** 249 * pdcspath_hwpath_write - This function handles hardware path modifying. 250 * @entry: An allocated and populated pdscpath_entry struct. 251 * @buf: The input buffer to read from. 252 * @count: The number of bytes to be read. 253 * 254 * We will call this function to change the current hardware path. 255 * Hardware paths are to be given '/'-delimited, without brackets. 256 * We make sure that the provided path actually maps to an existing 257 * device, BUT nothing would prevent some foolish user to set the path to some 258 * PCI bridge or even a CPU... 259 * A better work around would be to make sure we are at the end of a device tree 260 * for instance, but it would be IMHO beyond the simple scope of that driver. 261 * The aim is to provide a facility. Data correctness is left to userland. 262 */ 263static ssize_t 264pdcspath_hwpath_write(struct pdcspath_entry *entry, const char *buf, size_t count) 265{ 266 struct hardware_path hwpath; 267 unsigned short i; 268 char in[64], *temp; 269 struct device *dev; 270 int ret; 271 272 if (!entry || !buf || !count) 273 return -EINVAL; 274 275 /* We'll use a local copy of buf */ 276 count = min_t(size_t, count, sizeof(in)-1); 277 strncpy(in, buf, count); 278 in[count] = '\0'; 279 280 /* Let's clean up the target. 0xff is a blank pattern */ 281 memset(&hwpath, 0xff, sizeof(hwpath)); 282 283 /* First, pick the mod field (the last one of the input string) */ 284 if (!(temp = strrchr(in, '/'))) 285 return -EINVAL; 286 287 hwpath.mod = simple_strtoul(temp+1, NULL, 10); 288 in[temp-in] = '\0'; /* truncate the remaining string. just precaution */ 289 DPRINTK("%s: mod: %d\n", __func__, hwpath.mod); 290 291 /* Then, loop for each delimiter, making sure we don't have too many. 292 we write the bc fields in a down-top way. No matter what, we stop 293 before writing the last field. If there are too many fields anyway, 294 then the user is a moron and it'll be caught up later when we'll 295 check the consistency of the given hwpath. */ 296 for (i=5; ((temp = strrchr(in, '/'))) && (temp-in > 0) && (likely(i)); i--) { 297 hwpath.bc[i] = simple_strtoul(temp+1, NULL, 10); 298 in[temp-in] = '\0'; 299 DPRINTK("%s: bc[%d]: %d\n", __func__, i, hwpath.bc[i]); 300 } 301 302 /* Store the final field */ 303 hwpath.bc[i] = simple_strtoul(in, NULL, 10); 304 DPRINTK("%s: bc[%d]: %d\n", __func__, i, hwpath.bc[i]); 305 306 /* Now we check that the user isn't trying to lure us */ 307 if (!(dev = hwpath_to_device((struct hardware_path *)&hwpath))) { 308 printk(KERN_WARNING "%s: attempt to set invalid \"%s\" " 309 "hardware path: %s\n", __func__, entry->name, buf); 310 return -EINVAL; 311 } 312 313 /* So far so good, let's get in deep */ 314 write_lock(&entry->rw_lock); 315 entry->ready = 0; 316 entry->dev = dev; 317 318 /* Now, dive in. Write back to the hardware */ 319 pdcspath_store(entry); 320 321 /* Update the symlink to the real device */ 322 sysfs_remove_link(&entry->kobj, "device"); 323 write_unlock(&entry->rw_lock); 324 325 ret = sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device"); 326 WARN_ON(ret); 327 328 printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" path to \"%s\"\n", 329 entry->name, buf); 330 331 return count; 332} 333 334/** 335 * pdcspath_layer_read - Extended layer (eg. SCSI ids) pretty printing. 336 * @entry: An allocated and populated pdscpath_entry struct. 337 * @buf: The output buffer to write to. 338 * 339 * We will call this function to format the output of the layer attribute file. 340 */ 341static ssize_t 342pdcspath_layer_read(struct pdcspath_entry *entry, char *buf) 343{ 344 char *out = buf; 345 struct device_path *devpath; 346 short i; 347 348 if (!entry || !buf) 349 return -EINVAL; 350 351 read_lock(&entry->rw_lock); 352 devpath = &entry->devpath; 353 i = entry->ready; 354 read_unlock(&entry->rw_lock); 355 356 if (!i) /* entry is not ready */ 357 return -ENODATA; 358 359 for (i = 0; i < 6 && devpath->layers[i]; i++) 360 out += sprintf(out, "%u ", devpath->layers[i]); 361 362 out += sprintf(out, "\n"); 363 364 return out - buf; 365} 366 367/** 368 * pdcspath_layer_write - This function handles extended layer modifying. 369 * @entry: An allocated and populated pdscpath_entry struct. 370 * @buf: The input buffer to read from. 371 * @count: The number of bytes to be read. 372 * 373 * We will call this function to change the current layer value. 374 * Layers are to be given '.'-delimited, without brackets. 375 * XXX beware we are far less checky WRT input data provided than for hwpath. 376 * Potential harm can be done, since there's no way to check the validity of 377 * the layer fields. 378 */ 379static ssize_t 380pdcspath_layer_write(struct pdcspath_entry *entry, const char *buf, size_t count) 381{ 382 unsigned int layers[6]; /* device-specific info (ctlr#, unit#, ...) */ 383 unsigned short i; 384 char in[64], *temp; 385 386 if (!entry || !buf || !count) 387 return -EINVAL; 388 389 /* We'll use a local copy of buf */ 390 count = min_t(size_t, count, sizeof(in)-1); 391 strncpy(in, buf, count); 392 in[count] = '\0'; 393 394 /* Let's clean up the target. 0 is a blank pattern */ 395 memset(&layers, 0, sizeof(layers)); 396 397 /* First, pick the first layer */ 398 if (unlikely(!isdigit(*in))) 399 return -EINVAL; 400 layers[0] = simple_strtoul(in, NULL, 10); 401 DPRINTK("%s: layer[0]: %d\n", __func__, layers[0]); 402 403 temp = in; 404 for (i=1; ((temp = strchr(temp, '.'))) && (likely(i<6)); i++) { 405 if (unlikely(!isdigit(*(++temp)))) 406 return -EINVAL; 407 layers[i] = simple_strtoul(temp, NULL, 10); 408 DPRINTK("%s: layer[%d]: %d\n", __func__, i, layers[i]); 409 } 410 411 /* So far so good, let's get in deep */ 412 write_lock(&entry->rw_lock); 413 414 /* First, overwrite the current layers with the new ones, not touching 415 the hardware path. */ 416 memcpy(&entry->devpath.layers, &layers, sizeof(layers)); 417 418 /* Now, dive in. Write back to the hardware */ 419 pdcspath_store(entry); 420 write_unlock(&entry->rw_lock); 421 422 printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" layers to \"%s\"\n", 423 entry->name, buf); 424 425 return count; 426} 427 428/** 429 * pdcspath_attr_show - Generic read function call wrapper. 430 * @kobj: The kobject to get info from. 431 * @attr: The attribute looked upon. 432 * @buf: The output buffer. 433 */ 434static ssize_t 435pdcspath_attr_show(struct kobject *kobj, struct attribute *attr, char *buf) 436{ 437 struct pdcspath_entry *entry = to_pdcspath_entry(kobj); 438 struct pdcspath_attribute *pdcs_attr = to_pdcspath_attribute(attr); 439 ssize_t ret = 0; 440 441 if (pdcs_attr->show) 442 ret = pdcs_attr->show(entry, buf); 443 444 return ret; 445} 446 447/** 448 * pdcspath_attr_store - Generic write function call wrapper. 449 * @kobj: The kobject to write info to. 450 * @attr: The attribute to be modified. 451 * @buf: The input buffer. 452 * @count: The size of the buffer. 453 */ 454static ssize_t 455pdcspath_attr_store(struct kobject *kobj, struct attribute *attr, 456 const char *buf, size_t count) 457{ 458 struct pdcspath_entry *entry = to_pdcspath_entry(kobj); 459 struct pdcspath_attribute *pdcs_attr = to_pdcspath_attribute(attr); 460 ssize_t ret = 0; 461 462 if (!capable(CAP_SYS_ADMIN)) 463 return -EACCES; 464 465 if (pdcs_attr->store) 466 ret = pdcs_attr->store(entry, buf, count); 467 468 return ret; 469} 470 471static const struct sysfs_ops pdcspath_attr_ops = { 472 .show = pdcspath_attr_show, 473 .store = pdcspath_attr_store, 474}; 475 476/* These are the two attributes of any PDC path. */ 477static PATHS_ATTR(hwpath, 0644, pdcspath_hwpath_read, pdcspath_hwpath_write); 478static PATHS_ATTR(layer, 0644, pdcspath_layer_read, pdcspath_layer_write); 479 480static struct attribute *paths_subsys_attrs[] = { 481 &paths_attr_hwpath.attr, 482 &paths_attr_layer.attr, 483 NULL, 484}; 485 486/* Specific kobject type for our PDC paths */ 487static struct kobj_type ktype_pdcspath = { 488 .sysfs_ops = &pdcspath_attr_ops, 489 .default_attrs = paths_subsys_attrs, 490}; 491 492/* We hard define the 4 types of path we expect to find */ 493static PDCSPATH_ENTRY(PDCS_ADDR_PPRI, primary); 494static PDCSPATH_ENTRY(PDCS_ADDR_PCON, console); 495static PDCSPATH_ENTRY(PDCS_ADDR_PALT, alternative); 496static PDCSPATH_ENTRY(PDCS_ADDR_PKBD, keyboard); 497 498/* An array containing all PDC paths we will deal with */ 499static struct pdcspath_entry *pdcspath_entries[] = { 500 &pdcspath_entry_primary, 501 &pdcspath_entry_alternative, 502 &pdcspath_entry_console, 503 &pdcspath_entry_keyboard, 504 NULL, 505}; 506 507 508/* For more insight of what's going on here, refer to PDC Procedures doc, 509 * Section PDC_STABLE */ 510 511/** 512 * pdcs_size_read - Stable Storage size output. 513 * @buf: The output buffer to write to. 514 */ 515static ssize_t pdcs_size_read(struct kobject *kobj, 516 struct kobj_attribute *attr, 517 char *buf) 518{ 519 char *out = buf; 520 521 if (!buf) 522 return -EINVAL; 523 524 /* show the size of the stable storage */ 525 out += sprintf(out, "%ld\n", pdcs_size); 526 527 return out - buf; 528} 529 530/** 531 * pdcs_auto_read - Stable Storage autoboot/search flag output. 532 * @buf: The output buffer to write to. 533 * @knob: The PF_AUTOBOOT or PF_AUTOSEARCH flag 534 */ 535static ssize_t pdcs_auto_read(struct kobject *kobj, 536 struct kobj_attribute *attr, 537 char *buf, int knob) 538{ 539 char *out = buf; 540 struct pdcspath_entry *pathentry; 541 542 if (!buf) 543 return -EINVAL; 544 545 /* Current flags are stored in primary boot path entry */ 546 pathentry = &pdcspath_entry_primary; 547 548 read_lock(&pathentry->rw_lock); 549 out += sprintf(out, "%s\n", (pathentry->devpath.flags & knob) ? 550 "On" : "Off"); 551 read_unlock(&pathentry->rw_lock); 552 553 return out - buf; 554} 555 556/** 557 * pdcs_autoboot_read - Stable Storage autoboot flag output. 558 * @buf: The output buffer to write to. 559 */ 560static ssize_t pdcs_autoboot_read(struct kobject *kobj, 561 struct kobj_attribute *attr, char *buf) 562{ 563 return pdcs_auto_read(kobj, attr, buf, PF_AUTOBOOT); 564} 565 566/** 567 * pdcs_autosearch_read - Stable Storage autoboot flag output. 568 * @buf: The output buffer to write to. 569 */ 570static ssize_t pdcs_autosearch_read(struct kobject *kobj, 571 struct kobj_attribute *attr, char *buf) 572{ 573 return pdcs_auto_read(kobj, attr, buf, PF_AUTOSEARCH); 574} 575 576/** 577 * pdcs_timer_read - Stable Storage timer count output (in seconds). 578 * @buf: The output buffer to write to. 579 * 580 * The value of the timer field correponds to a number of seconds in powers of 2. 581 */ 582static ssize_t pdcs_timer_read(struct kobject *kobj, 583 struct kobj_attribute *attr, char *buf) 584{ 585 char *out = buf; 586 struct pdcspath_entry *pathentry; 587 588 if (!buf) 589 return -EINVAL; 590 591 /* Current flags are stored in primary boot path entry */ 592 pathentry = &pdcspath_entry_primary; 593 594 /* print the timer value in seconds */ 595 read_lock(&pathentry->rw_lock); 596 out += sprintf(out, "%u\n", (pathentry->devpath.flags & PF_TIMER) ? 597 (1 << (pathentry->devpath.flags & PF_TIMER)) : 0); 598 read_unlock(&pathentry->rw_lock); 599 600 return out - buf; 601} 602 603/** 604 * pdcs_osid_read - Stable Storage OS ID register output. 605 * @buf: The output buffer to write to. 606 */ 607static ssize_t pdcs_osid_read(struct kobject *kobj, 608 struct kobj_attribute *attr, char *buf) 609{ 610 char *out = buf; 611 612 if (!buf) 613 return -EINVAL; 614 615 out += sprintf(out, "%s dependent data (0x%.4x)\n", 616 os_id_to_string(pdcs_osid), pdcs_osid); 617 618 return out - buf; 619} 620 621/** 622 * pdcs_osdep1_read - Stable Storage OS-Dependent data area 1 output. 623 * @buf: The output buffer to write to. 624 * 625 * This can hold 16 bytes of OS-Dependent data. 626 */ 627static ssize_t pdcs_osdep1_read(struct kobject *kobj, 628 struct kobj_attribute *attr, char *buf) 629{ 630 char *out = buf; 631 u32 result[4]; 632 633 if (!buf) 634 return -EINVAL; 635 636 if (pdc_stable_read(PDCS_ADDR_OSD1, &result, sizeof(result)) != PDC_OK) 637 return -EIO; 638 639 out += sprintf(out, "0x%.8x\n", result[0]); 640 out += sprintf(out, "0x%.8x\n", result[1]); 641 out += sprintf(out, "0x%.8x\n", result[2]); 642 out += sprintf(out, "0x%.8x\n", result[3]); 643 644 return out - buf; 645} 646 647/** 648 * pdcs_diagnostic_read - Stable Storage Diagnostic register output. 649 * @buf: The output buffer to write to. 650 * 651 * I have NFC how to interpret the content of that register ;-). 652 */ 653static ssize_t pdcs_diagnostic_read(struct kobject *kobj, 654 struct kobj_attribute *attr, char *buf) 655{ 656 char *out = buf; 657 u32 result; 658 659 if (!buf) 660 return -EINVAL; 661 662 /* get diagnostic */ 663 if (pdc_stable_read(PDCS_ADDR_DIAG, &result, sizeof(result)) != PDC_OK) 664 return -EIO; 665 666 out += sprintf(out, "0x%.4x\n", (result >> 16)); 667 668 return out - buf; 669} 670 671/** 672 * pdcs_fastsize_read - Stable Storage FastSize register output. 673 * @buf: The output buffer to write to. 674 * 675 * This register holds the amount of system RAM to be tested during boot sequence. 676 */ 677static ssize_t pdcs_fastsize_read(struct kobject *kobj, 678 struct kobj_attribute *attr, char *buf) 679{ 680 char *out = buf; 681 u32 result; 682 683 if (!buf) 684 return -EINVAL; 685 686 /* get fast-size */ 687 if (pdc_stable_read(PDCS_ADDR_FSIZ, &result, sizeof(result)) != PDC_OK) 688 return -EIO; 689 690 if ((result & 0x0F) < 0x0E) 691 out += sprintf(out, "%d kB", (1<<(result & 0x0F))*256); 692 else 693 out += sprintf(out, "All"); 694 out += sprintf(out, "\n"); 695 696 return out - buf; 697} 698 699/** 700 * pdcs_osdep2_read - Stable Storage OS-Dependent data area 2 output. 701 * @buf: The output buffer to write to. 702 * 703 * This can hold pdcs_size - 224 bytes of OS-Dependent data, when available. 704 */ 705static ssize_t pdcs_osdep2_read(struct kobject *kobj, 706 struct kobj_attribute *attr, char *buf) 707{ 708 char *out = buf; 709 unsigned long size; 710 unsigned short i; 711 u32 result; 712 713 if (unlikely(pdcs_size <= 224)) 714 return -ENODATA; 715 716 size = pdcs_size - 224; 717 718 if (!buf) 719 return -EINVAL; 720 721 for (i=0; i<size; i+=4) { 722 if (unlikely(pdc_stable_read(PDCS_ADDR_OSD2 + i, &result, 723 sizeof(result)) != PDC_OK)) 724 return -EIO; 725 out += sprintf(out, "0x%.8x\n", result); 726 } 727 728 return out - buf; 729} 730 731/** 732 * pdcs_auto_write - This function handles autoboot/search flag modifying. 733 * @buf: The input buffer to read from. 734 * @count: The number of bytes to be read. 735 * @knob: The PF_AUTOBOOT or PF_AUTOSEARCH flag 736 * 737 * We will call this function to change the current autoboot flag. 738 * We expect a precise syntax: 739 * \"n\" (n == 0 or 1) to toggle AutoBoot Off or On 740 */ 741static ssize_t pdcs_auto_write(struct kobject *kobj, 742 struct kobj_attribute *attr, const char *buf, 743 size_t count, int knob) 744{ 745 struct pdcspath_entry *pathentry; 746 unsigned char flags; 747 char in[8], *temp; 748 char c; 749 750 if (!capable(CAP_SYS_ADMIN)) 751 return -EACCES; 752 753 if (!buf || !count) 754 return -EINVAL; 755 756 /* We'll use a local copy of buf */ 757 count = min_t(size_t, count, sizeof(in)-1); 758 strncpy(in, buf, count); 759 in[count] = '\0'; 760 761 /* Current flags are stored in primary boot path entry */ 762 pathentry = &pdcspath_entry_primary; 763 764 /* Be nice to the existing flag record */ 765 read_lock(&pathentry->rw_lock); 766 flags = pathentry->devpath.flags; 767 read_unlock(&pathentry->rw_lock); 768 769 DPRINTK("%s: flags before: 0x%X\n", __func__, flags); 770 771 temp = skip_spaces(in); 772 773 c = *temp++ - '0'; 774 if ((c != 0) && (c != 1)) 775 goto parse_error; 776 if (c == 0) 777 flags &= ~knob; 778 else 779 flags |= knob; 780 781 DPRINTK("%s: flags after: 0x%X\n", __func__, flags); 782 783 /* So far so good, let's get in deep */ 784 write_lock(&pathentry->rw_lock); 785 786 /* Change the path entry flags first */ 787 pathentry->devpath.flags = flags; 788 789 /* Now, dive in. Write back to the hardware */ 790 pdcspath_store(pathentry); 791 write_unlock(&pathentry->rw_lock); 792 793 printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" to \"%s\"\n", 794 (knob & PF_AUTOBOOT) ? "autoboot" : "autosearch", 795 (flags & knob) ? "On" : "Off"); 796 797 return count; 798 799parse_error: 800 printk(KERN_WARNING "%s: Parse error: expect \"n\" (n == 0 or 1)\n", __func__); 801 return -EINVAL; 802} 803 804/** 805 * pdcs_autoboot_write - This function handles autoboot flag modifying. 806 * @buf: The input buffer to read from. 807 * @count: The number of bytes to be read. 808 * 809 * We will call this function to change the current boot flags. 810 * We expect a precise syntax: 811 * \"n\" (n == 0 or 1) to toggle AutoSearch Off or On 812 */ 813static ssize_t pdcs_autoboot_write(struct kobject *kobj, 814 struct kobj_attribute *attr, 815 const char *buf, size_t count) 816{ 817 return pdcs_auto_write(kobj, attr, buf, count, PF_AUTOBOOT); 818} 819 820/** 821 * pdcs_autosearch_write - This function handles autosearch flag modifying. 822 * @buf: The input buffer to read from. 823 * @count: The number of bytes to be read. 824 * 825 * We will call this function to change the current boot flags. 826 * We expect a precise syntax: 827 * \"n\" (n == 0 or 1) to toggle AutoSearch Off or On 828 */ 829static ssize_t pdcs_autosearch_write(struct kobject *kobj, 830 struct kobj_attribute *attr, 831 const char *buf, size_t count) 832{ 833 return pdcs_auto_write(kobj, attr, buf, count, PF_AUTOSEARCH); 834} 835 836/** 837 * pdcs_osdep1_write - Stable Storage OS-Dependent data area 1 input. 838 * @buf: The input buffer to read from. 839 * @count: The number of bytes to be read. 840 * 841 * This can store 16 bytes of OS-Dependent data. We use a byte-by-byte 842 * write approach. It's up to userspace to deal with it when constructing 843 * its input buffer. 844 */ 845static ssize_t pdcs_osdep1_write(struct kobject *kobj, 846 struct kobj_attribute *attr, 847 const char *buf, size_t count) 848{ 849 u8 in[16]; 850 851 if (!capable(CAP_SYS_ADMIN)) 852 return -EACCES; 853 854 if (!buf || !count) 855 return -EINVAL; 856 857 if (unlikely(pdcs_osid != OS_ID_LINUX)) 858 return -EPERM; 859 860 if (count > 16) 861 return -EMSGSIZE; 862 863 /* We'll use a local copy of buf */ 864 memset(in, 0, 16); 865 memcpy(in, buf, count); 866 867 if (pdc_stable_write(PDCS_ADDR_OSD1, &in, sizeof(in)) != PDC_OK) 868 return -EIO; 869 870 return count; 871} 872 873/** 874 * pdcs_osdep2_write - Stable Storage OS-Dependent data area 2 input. 875 * @buf: The input buffer to read from. 876 * @count: The number of bytes to be read. 877 * 878 * This can store pdcs_size - 224 bytes of OS-Dependent data. We use a 879 * byte-by-byte write approach. It's up to userspace to deal with it when 880 * constructing its input buffer. 881 */ 882static ssize_t pdcs_osdep2_write(struct kobject *kobj, 883 struct kobj_attribute *attr, 884 const char *buf, size_t count) 885{ 886 unsigned long size; 887 unsigned short i; 888 u8 in[4]; 889 890 if (!capable(CAP_SYS_ADMIN)) 891 return -EACCES; 892 893 if (!buf || !count) 894 return -EINVAL; 895 896 if (unlikely(pdcs_size <= 224)) 897 return -ENOSYS; 898 899 if (unlikely(pdcs_osid != OS_ID_LINUX)) 900 return -EPERM; 901 902 size = pdcs_size - 224; 903 904 if (count > size) 905 return -EMSGSIZE; 906 907 /* We'll use a local copy of buf */ 908 909 for (i=0; i<count; i+=4) { 910 memset(in, 0, 4); 911 memcpy(in, buf+i, (count-i < 4) ? count-i : 4); 912 if (unlikely(pdc_stable_write(PDCS_ADDR_OSD2 + i, &in, 913 sizeof(in)) != PDC_OK)) 914 return -EIO; 915 } 916 917 return count; 918} 919 920/* The remaining attributes. */ 921static PDCS_ATTR(size, 0444, pdcs_size_read, NULL); 922static PDCS_ATTR(autoboot, 0644, pdcs_autoboot_read, pdcs_autoboot_write); 923static PDCS_ATTR(autosearch, 0644, pdcs_autosearch_read, pdcs_autosearch_write); 924static PDCS_ATTR(timer, 0444, pdcs_timer_read, NULL); 925static PDCS_ATTR(osid, 0444, pdcs_osid_read, NULL); 926static PDCS_ATTR(osdep1, 0600, pdcs_osdep1_read, pdcs_osdep1_write); 927static PDCS_ATTR(diagnostic, 0400, pdcs_diagnostic_read, NULL); 928static PDCS_ATTR(fastsize, 0400, pdcs_fastsize_read, NULL); 929static PDCS_ATTR(osdep2, 0600, pdcs_osdep2_read, pdcs_osdep2_write); 930 931static struct attribute *pdcs_subsys_attrs[] = { 932 &pdcs_attr_size.attr, 933 &pdcs_attr_autoboot.attr, 934 &pdcs_attr_autosearch.attr, 935 &pdcs_attr_timer.attr, 936 &pdcs_attr_osid.attr, 937 &pdcs_attr_osdep1.attr, 938 &pdcs_attr_diagnostic.attr, 939 &pdcs_attr_fastsize.attr, 940 &pdcs_attr_osdep2.attr, 941 NULL, 942}; 943 944static const struct attribute_group pdcs_attr_group = { 945 .attrs = pdcs_subsys_attrs, 946}; 947 948static struct kobject *stable_kobj; 949static struct kset *paths_kset; 950 951/** 952 * pdcs_register_pathentries - Prepares path entries kobjects for sysfs usage. 953 * 954 * It creates kobjects corresponding to each path entry with nice sysfs 955 * links to the real device. This is where the magic takes place: when 956 * registering the subsystem attributes during module init, each kobject hereby 957 * created will show in the sysfs tree as a folder containing files as defined 958 * by path_subsys_attr[]. 959 */ 960static inline int __init 961pdcs_register_pathentries(void) 962{ 963 unsigned short i; 964 struct pdcspath_entry *entry; 965 int err; 966 967 /* Initialize the entries rw_lock before anything else */ 968 for (i = 0; (entry = pdcspath_entries[i]); i++) 969 rwlock_init(&entry->rw_lock); 970 971 for (i = 0; (entry = pdcspath_entries[i]); i++) { 972 write_lock(&entry->rw_lock); 973 err = pdcspath_fetch(entry); 974 write_unlock(&entry->rw_lock); 975 976 if (err < 0) 977 continue; 978 979 entry->kobj.kset = paths_kset; 980 err = kobject_init_and_add(&entry->kobj, &ktype_pdcspath, NULL, 981 "%s", entry->name); 982 if (err) { 983 kobject_put(&entry->kobj); 984 return err; 985 } 986 987 /* kobject is now registered */ 988 write_lock(&entry->rw_lock); 989 entry->ready = 2; 990 write_unlock(&entry->rw_lock); 991 992 /* Add a nice symlink to the real device */ 993 if (entry->dev) { 994 err = sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device"); 995 WARN_ON(err); 996 } 997 998 kobject_uevent(&entry->kobj, KOBJ_ADD); 999 } 1000 1001 return 0; 1002} 1003 1004/** 1005 * pdcs_unregister_pathentries - Routine called when unregistering the module. 1006 */ 1007static inline void 1008pdcs_unregister_pathentries(void) 1009{ 1010 unsigned short i; 1011 struct pdcspath_entry *entry; 1012 1013 for (i = 0; (entry = pdcspath_entries[i]); i++) { 1014 read_lock(&entry->rw_lock); 1015 if (entry->ready >= 2) 1016 kobject_put(&entry->kobj); 1017 read_unlock(&entry->rw_lock); 1018 } 1019} 1020 1021/* 1022 * For now we register the stable subsystem with the firmware subsystem 1023 * and the paths subsystem with the stable subsystem 1024 */ 1025static int __init 1026pdc_stable_init(void) 1027{ 1028 int rc = 0, error = 0; 1029 u32 result; 1030 1031 /* find the size of the stable storage */ 1032 if (pdc_stable_get_size(&pdcs_size) != PDC_OK) 1033 return -ENODEV; 1034 1035 /* make sure we have enough data */ 1036 if (pdcs_size < 96) 1037 return -ENODATA; 1038 1039 printk(KERN_INFO PDCS_PREFIX " facility v%s\n", PDCS_VERSION); 1040 1041 /* get OSID */ 1042 if (pdc_stable_read(PDCS_ADDR_OSID, &result, sizeof(result)) != PDC_OK) 1043 return -EIO; 1044 1045 /* the actual result is 16 bits away */ 1046 pdcs_osid = (u16)(result >> 16); 1047 1048 /* For now we'll register the directory at /sys/firmware/stable */ 1049 stable_kobj = kobject_create_and_add("stable", firmware_kobj); 1050 if (!stable_kobj) { 1051 rc = -ENOMEM; 1052 goto fail_firmreg; 1053 } 1054 1055 /* Don't forget the root entries */ 1056 error = sysfs_create_group(stable_kobj, &pdcs_attr_group); 1057 1058 /* register the paths kset as a child of the stable kset */ 1059 paths_kset = kset_create_and_add("paths", NULL, stable_kobj); 1060 if (!paths_kset) { 1061 rc = -ENOMEM; 1062 goto fail_ksetreg; 1063 } 1064 1065 /* now we create all "files" for the paths kset */ 1066 if ((rc = pdcs_register_pathentries())) 1067 goto fail_pdcsreg; 1068 1069 return rc; 1070 1071fail_pdcsreg: 1072 pdcs_unregister_pathentries(); 1073 kset_unregister(paths_kset); 1074 1075fail_ksetreg: 1076 kobject_put(stable_kobj); 1077 1078fail_firmreg: 1079 printk(KERN_INFO PDCS_PREFIX " bailing out\n"); 1080 return rc; 1081} 1082 1083static void __exit 1084pdc_stable_exit(void) 1085{ 1086 pdcs_unregister_pathentries(); 1087 kset_unregister(paths_kset); 1088 kobject_put(stable_kobj); 1089} 1090 1091 1092module_init(pdc_stable_init); 1093module_exit(pdc_stable_exit); 1094