2 * Interfaces to retrieve and set PDC Stable options (firmware)
4 * Copyright (C) 2005-2006 Thibaut VARENE <varenet@parisc-linux.org>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License, version 2, as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 * DEV NOTE: the PDC Procedures reference states that:
21 * "A minimum of 96 bytes of Stable Storage is required. Providing more than
22 * 96 bytes of Stable Storage is optional [...]. Failure to provide the
23 * optional locations from 96 to 192 results in the loss of certain
24 * functionality during boot."
26 * Since locations between 96 and 192 are the various paths, most (if not
27 * all) PA-RISC machines should have them. Anyway, for safety reasons, the
28 * following code can deal with just 96 bytes of Stable Storage, and all
29 * sizes between 96 and 192 bytes (provided they are multiple of struct
30 * device_path size, eg: 128, 160 and 192) to provide full information.
31 * One last word: there's one path we can always count on: the primary path.
32 * Anything above 224 bytes is used for 'osdep2' OS-dependent storage area.
34 * The first OS-dependent area should always be available. Obviously, this is
35 * not true for the other one. Also bear in mind that reading/writing from/to
36 * osdep2 is much more expensive than from/to osdep1.
37 * NOTE: We do not handle the 2 bytes OS-dep area at 0x5D, nor the first
38 * 2 bytes of storage available right after OSID. That's a total of 4 bytes
39 * sacrificed: -ETOOLAZY :P
41 * The current policy wrt file permissions is:
43 * - read: (reading triggers PDC calls) ? root only : everyone
44 * The rationale is that PDC calls could hog (DoS) the machine.
47 * - timer/fastsize write calls
52 #define DPRINTK(fmt, args...) printk(KERN_DEBUG fmt, ## args)
54 #define DPRINTK(fmt, args...)
57 #include <linux/module.h>
58 #include <linux/init.h>
59 #include <linux/kernel.h>
60 #include <linux/string.h>
61 #include <linux/capability.h>
62 #include <linux/ctype.h>
63 #include <linux/sysfs.h>
64 #include <linux/kobject.h>
65 #include <linux/device.h>
66 #include <linux/errno.h>
67 #include <linux/spinlock.h>
71 #include <asm/uaccess.h>
72 #include <asm/hardware.h>
74 #define PDCS_VERSION "0.30"
75 #define PDCS_PREFIX "PDC Stable Storage"
77 #define PDCS_ADDR_PPRI 0x00
78 #define PDCS_ADDR_OSID 0x40
79 #define PDCS_ADDR_OSD1 0x48
80 #define PDCS_ADDR_DIAG 0x58
81 #define PDCS_ADDR_FSIZ 0x5C
82 #define PDCS_ADDR_PCON 0x60
83 #define PDCS_ADDR_PALT 0x80
84 #define PDCS_ADDR_PKBD 0xA0
85 #define PDCS_ADDR_OSD2 0xE0
87 MODULE_AUTHOR("Thibaut VARENE <varenet@parisc-linux.org>");
88 MODULE_DESCRIPTION("sysfs interface to HP PDC Stable Storage data");
89 MODULE_LICENSE("GPL");
90 MODULE_VERSION(PDCS_VERSION
);
92 /* holds Stable Storage size. Initialized once and for all, no lock needed */
93 static unsigned long pdcs_size __read_mostly
;
95 /* holds OS ID. Initialized once and for all, hopefully to 0x0006 */
96 static u16 pdcs_osid __read_mostly
;
98 /* This struct defines what we need to deal with a parisc pdc path entry */
99 struct pdcspath_entry
{
100 rwlock_t rw_lock
; /* to protect path entry access */
101 short ready
; /* entry record is valid if != 0 */
102 unsigned long addr
; /* entry address in stable storage */
103 char *name
; /* entry name */
104 struct device_path devpath
; /* device path in parisc representation */
105 struct device
*dev
; /* corresponding device */
109 struct pdcspath_attribute
{
110 struct attribute attr
;
111 ssize_t (*show
)(struct pdcspath_entry
*entry
, char *buf
);
112 ssize_t (*store
)(struct pdcspath_entry
*entry
, const char *buf
, size_t count
);
115 #define PDCSPATH_ENTRY(_addr, _name) \
116 struct pdcspath_entry pdcspath_entry_##_name = { \
119 .name = __stringify(_name), \
122 #define PDCS_ATTR(_name, _mode, _show, _store) \
123 struct subsys_attribute pdcs_attr_##_name = { \
124 .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \
129 #define PATHS_ATTR(_name, _mode, _show, _store) \
130 struct pdcspath_attribute paths_attr_##_name = { \
131 .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \
136 #define to_pdcspath_attribute(_attr) container_of(_attr, struct pdcspath_attribute, attr)
137 #define to_pdcspath_entry(obj) container_of(obj, struct pdcspath_entry, kobj)
140 * pdcspath_fetch - This function populates the path entry structs.
141 * @entry: A pointer to an allocated pdcspath_entry.
143 * The general idea is that you don't read from the Stable Storage every time
144 * you access the files provided by the facilites. We store a copy of the
145 * content of the stable storage WRT various paths in these structs. We read
146 * these structs when reading the files, and we will write to these structs when
147 * writing to the files, and only then write them back to the Stable Storage.
149 * This function expects to be called with @entry->rw_lock write-hold.
152 pdcspath_fetch(struct pdcspath_entry
*entry
)
154 struct device_path
*devpath
;
159 devpath
= &entry
->devpath
;
161 DPRINTK("%s: fetch: 0x%p, 0x%p, addr: 0x%lx\n", __func__
,
162 entry
, devpath
, entry
->addr
);
164 /* addr, devpath and count must be word aligned */
165 if (pdc_stable_read(entry
->addr
, devpath
, sizeof(*devpath
)) != PDC_OK
)
168 /* Find the matching device.
169 NOTE: hardware_path overlays with device_path, so the nice cast can
171 entry
->dev
= hwpath_to_device((struct hardware_path
*)devpath
);
175 DPRINTK("%s: device: 0x%p\n", __func__
, entry
->dev
);
181 * pdcspath_store - This function writes a path to stable storage.
182 * @entry: A pointer to an allocated pdcspath_entry.
184 * It can be used in two ways: either by passing it a preset devpath struct
185 * containing an already computed hardware path, or by passing it a device
186 * pointer, from which it'll find out the corresponding hardware path.
187 * For now we do not handle the case where there's an error in writing to the
188 * Stable Storage area, so you'd better not mess up the data :P
190 * This function expects to be called with @entry->rw_lock write-hold.
193 pdcspath_store(struct pdcspath_entry
*entry
)
195 struct device_path
*devpath
;
199 devpath
= &entry
->devpath
;
201 /* We expect the caller to set the ready flag to 0 if the hardware
202 path struct provided is invalid, so that we know we have to fill it.
203 First case, we don't have a preset hwpath... */
205 /* ...but we have a device, map it */
207 device_to_hwpath(entry
->dev
, (struct hardware_path
*)devpath
);
209 /* else, we expect the provided hwpath to be valid. */
211 DPRINTK("%s: store: 0x%p, 0x%p, addr: 0x%lx\n", __func__
,
212 entry
, devpath
, entry
->addr
);
214 /* addr, devpath and count must be word aligned */
215 if (pdc_stable_write(entry
->addr
, devpath
, sizeof(*devpath
)) != PDC_OK
) {
216 printk(KERN_ERR
"%s: an error occured when writing to PDC.\n"
217 "It is likely that the Stable Storage data has been corrupted.\n"
218 "Please check it carefully upon next reboot.\n", __func__
);
222 /* kobject is already registered */
225 DPRINTK("%s: device: 0x%p\n", __func__
, entry
->dev
);
229 * pdcspath_hwpath_read - This function handles hardware path pretty printing.
230 * @entry: An allocated and populated pdscpath_entry struct.
231 * @buf: The output buffer to write to.
233 * We will call this function to format the output of the hwpath attribute file.
236 pdcspath_hwpath_read(struct pdcspath_entry
*entry
, char *buf
)
239 struct device_path
*devpath
;
245 read_lock(&entry
->rw_lock
);
246 devpath
= &entry
->devpath
;
248 read_unlock(&entry
->rw_lock
);
250 if (!i
) /* entry is not ready */
253 for (i
= 0; i
< 6; i
++) {
254 if (devpath
->bc
[i
] >= 128)
256 out
+= sprintf(out
, "%u/", (unsigned char)devpath
->bc
[i
]);
258 out
+= sprintf(out
, "%u\n", (unsigned char)devpath
->mod
);
264 * pdcspath_hwpath_write - This function handles hardware path modifying.
265 * @entry: An allocated and populated pdscpath_entry struct.
266 * @buf: The input buffer to read from.
267 * @count: The number of bytes to be read.
269 * We will call this function to change the current hardware path.
270 * Hardware paths are to be given '/'-delimited, without brackets.
271 * We make sure that the provided path actually maps to an existing
272 * device, BUT nothing would prevent some foolish user to set the path to some
273 * PCI bridge or even a CPU...
274 * A better work around would be to make sure we are at the end of a device tree
275 * for instance, but it would be IMHO beyond the simple scope of that driver.
276 * The aim is to provide a facility. Data correctness is left to userland.
279 pdcspath_hwpath_write(struct pdcspath_entry
*entry
, const char *buf
, size_t count
)
281 struct hardware_path hwpath
;
283 char in
[count
+1], *temp
;
286 if (!entry
|| !buf
|| !count
)
289 /* We'll use a local copy of buf */
290 memset(in
, 0, count
+1);
291 strncpy(in
, buf
, count
);
293 /* Let's clean up the target. 0xff is a blank pattern */
294 memset(&hwpath
, 0xff, sizeof(hwpath
));
296 /* First, pick the mod field (the last one of the input string) */
297 if (!(temp
= strrchr(in
, '/')))
300 hwpath
.mod
= simple_strtoul(temp
+1, NULL
, 10);
301 in
[temp
-in
] = '\0'; /* truncate the remaining string. just precaution */
302 DPRINTK("%s: mod: %d\n", __func__
, hwpath
.mod
);
304 /* Then, loop for each delimiter, making sure we don't have too many.
305 we write the bc fields in a down-top way. No matter what, we stop
306 before writing the last field. If there are too many fields anyway,
307 then the user is a moron and it'll be caught up later when we'll
308 check the consistency of the given hwpath. */
309 for (i
=5; ((temp
= strrchr(in
, '/'))) && (temp
-in
> 0) && (likely(i
)); i
--) {
310 hwpath
.bc
[i
] = simple_strtoul(temp
+1, NULL
, 10);
312 DPRINTK("%s: bc[%d]: %d\n", __func__
, i
, hwpath
.bc
[i
]);
315 /* Store the final field */
316 hwpath
.bc
[i
] = simple_strtoul(in
, NULL
, 10);
317 DPRINTK("%s: bc[%d]: %d\n", __func__
, i
, hwpath
.bc
[i
]);
319 /* Now we check that the user isn't trying to lure us */
320 if (!(dev
= hwpath_to_device((struct hardware_path
*)&hwpath
))) {
321 printk(KERN_WARNING
"%s: attempt to set invalid \"%s\" "
322 "hardware path: %s\n", __func__
, entry
->name
, buf
);
326 /* So far so good, let's get in deep */
327 write_lock(&entry
->rw_lock
);
331 /* Now, dive in. Write back to the hardware */
332 pdcspath_store(entry
);
334 /* Update the symlink to the real device */
335 sysfs_remove_link(&entry
->kobj
, "device");
336 sysfs_create_link(&entry
->kobj
, &entry
->dev
->kobj
, "device");
337 write_unlock(&entry
->rw_lock
);
339 printk(KERN_INFO PDCS_PREFIX
": changed \"%s\" path to \"%s\"\n",
346 * pdcspath_layer_read - Extended layer (eg. SCSI ids) pretty printing.
347 * @entry: An allocated and populated pdscpath_entry struct.
348 * @buf: The output buffer to write to.
350 * We will call this function to format the output of the layer attribute file.
353 pdcspath_layer_read(struct pdcspath_entry
*entry
, char *buf
)
356 struct device_path
*devpath
;
362 read_lock(&entry
->rw_lock
);
363 devpath
= &entry
->devpath
;
365 read_unlock(&entry
->rw_lock
);
367 if (!i
) /* entry is not ready */
370 for (i
= 0; devpath
->layers
[i
] && (likely(i
< 6)); i
++)
371 out
+= sprintf(out
, "%u ", devpath
->layers
[i
]);
373 out
+= sprintf(out
, "\n");
379 * pdcspath_layer_write - This function handles extended layer modifying.
380 * @entry: An allocated and populated pdscpath_entry struct.
381 * @buf: The input buffer to read from.
382 * @count: The number of bytes to be read.
384 * We will call this function to change the current layer value.
385 * Layers are to be given '.'-delimited, without brackets.
386 * XXX beware we are far less checky WRT input data provided than for hwpath.
387 * Potential harm can be done, since there's no way to check the validity of
391 pdcspath_layer_write(struct pdcspath_entry
*entry
, const char *buf
, size_t count
)
393 unsigned int layers
[6]; /* device-specific info (ctlr#, unit#, ...) */
395 char in
[count
+1], *temp
;
397 if (!entry
|| !buf
|| !count
)
400 /* We'll use a local copy of buf */
401 memset(in
, 0, count
+1);
402 strncpy(in
, buf
, count
);
404 /* Let's clean up the target. 0 is a blank pattern */
405 memset(&layers
, 0, sizeof(layers
));
407 /* First, pick the first layer */
408 if (unlikely(!isdigit(*in
)))
410 layers
[0] = simple_strtoul(in
, NULL
, 10);
411 DPRINTK("%s: layer[0]: %d\n", __func__
, layers
[0]);
414 for (i
=1; ((temp
= strchr(temp
, '.'))) && (likely(i
<6)); i
++) {
415 if (unlikely(!isdigit(*(++temp
))))
417 layers
[i
] = simple_strtoul(temp
, NULL
, 10);
418 DPRINTK("%s: layer[%d]: %d\n", __func__
, i
, layers
[i
]);
421 /* So far so good, let's get in deep */
422 write_lock(&entry
->rw_lock
);
424 /* First, overwrite the current layers with the new ones, not touching
425 the hardware path. */
426 memcpy(&entry
->devpath
.layers
, &layers
, sizeof(layers
));
428 /* Now, dive in. Write back to the hardware */
429 pdcspath_store(entry
);
430 write_unlock(&entry
->rw_lock
);
432 printk(KERN_INFO PDCS_PREFIX
": changed \"%s\" layers to \"%s\"\n",
439 * pdcspath_attr_show - Generic read function call wrapper.
440 * @kobj: The kobject to get info from.
441 * @attr: The attribute looked upon.
442 * @buf: The output buffer.
445 pdcspath_attr_show(struct kobject
*kobj
, struct attribute
*attr
, char *buf
)
447 struct pdcspath_entry
*entry
= to_pdcspath_entry(kobj
);
448 struct pdcspath_attribute
*pdcs_attr
= to_pdcspath_attribute(attr
);
452 ret
= pdcs_attr
->show(entry
, buf
);
458 * pdcspath_attr_store - Generic write function call wrapper.
459 * @kobj: The kobject to write info to.
460 * @attr: The attribute to be modified.
461 * @buf: The input buffer.
462 * @count: The size of the buffer.
465 pdcspath_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
466 const char *buf
, size_t count
)
468 struct pdcspath_entry
*entry
= to_pdcspath_entry(kobj
);
469 struct pdcspath_attribute
*pdcs_attr
= to_pdcspath_attribute(attr
);
472 if (!capable(CAP_SYS_ADMIN
))
475 if (pdcs_attr
->store
)
476 ret
= pdcs_attr
->store(entry
, buf
, count
);
481 static struct sysfs_ops pdcspath_attr_ops
= {
482 .show
= pdcspath_attr_show
,
483 .store
= pdcspath_attr_store
,
486 /* These are the two attributes of any PDC path. */
487 static PATHS_ATTR(hwpath
, 0644, pdcspath_hwpath_read
, pdcspath_hwpath_write
);
488 static PATHS_ATTR(layer
, 0644, pdcspath_layer_read
, pdcspath_layer_write
);
490 static struct attribute
*paths_subsys_attrs
[] = {
491 &paths_attr_hwpath
.attr
,
492 &paths_attr_layer
.attr
,
496 /* Specific kobject type for our PDC paths */
497 static struct kobj_type ktype_pdcspath
= {
498 .sysfs_ops
= &pdcspath_attr_ops
,
499 .default_attrs
= paths_subsys_attrs
,
502 /* We hard define the 4 types of path we expect to find */
503 static PDCSPATH_ENTRY(PDCS_ADDR_PPRI
, primary
);
504 static PDCSPATH_ENTRY(PDCS_ADDR_PCON
, console
);
505 static PDCSPATH_ENTRY(PDCS_ADDR_PALT
, alternative
);
506 static PDCSPATH_ENTRY(PDCS_ADDR_PKBD
, keyboard
);
508 /* An array containing all PDC paths we will deal with */
509 static struct pdcspath_entry
*pdcspath_entries
[] = {
510 &pdcspath_entry_primary
,
511 &pdcspath_entry_alternative
,
512 &pdcspath_entry_console
,
513 &pdcspath_entry_keyboard
,
518 /* For more insight of what's going on here, refer to PDC Procedures doc,
519 * Section PDC_STABLE */
522 * pdcs_size_read - Stable Storage size output.
523 * @kset: An allocated and populated struct kset. We don't use it tho.
524 * @buf: The output buffer to write to.
527 pdcs_size_read(struct kset
*kset
, char *buf
)
534 /* show the size of the stable storage */
535 out
+= sprintf(out
, "%ld\n", pdcs_size
);
541 * pdcs_auto_read - Stable Storage autoboot/search flag output.
542 * @kset: An allocated and populated struct kset. We don't use it tho.
543 * @buf: The output buffer to write to.
544 * @knob: The PF_AUTOBOOT or PF_AUTOSEARCH flag
547 pdcs_auto_read(struct kset
*kset
, char *buf
, int knob
)
550 struct pdcspath_entry
*pathentry
;
555 /* Current flags are stored in primary boot path entry */
556 pathentry
= &pdcspath_entry_primary
;
558 read_lock(&pathentry
->rw_lock
);
559 out
+= sprintf(out
, "%s\n", (pathentry
->devpath
.flags
& knob
) ?
561 read_unlock(&pathentry
->rw_lock
);
567 * pdcs_autoboot_read - Stable Storage autoboot flag output.
568 * @kset: An allocated and populated struct kset. We don't use it tho.
569 * @buf: The output buffer to write to.
571 static inline ssize_t
572 pdcs_autoboot_read(struct kset
*kset
, char *buf
)
574 return pdcs_auto_read(kset
, buf
, PF_AUTOBOOT
);
578 * pdcs_autosearch_read - Stable Storage autoboot flag output.
579 * @kset: An allocated and populated struct kset. We don't use it tho.
580 * @buf: The output buffer to write to.
582 static inline ssize_t
583 pdcs_autosearch_read(struct kset
*kset
, char *buf
)
585 return pdcs_auto_read(kset
, buf
, PF_AUTOSEARCH
);
589 * pdcs_timer_read - Stable Storage timer count output (in seconds).
590 * @kset: An allocated and populated struct kset. We don't use it tho.
591 * @buf: The output buffer to write to.
593 * The value of the timer field correponds to a number of seconds in powers of 2.
596 pdcs_timer_read(struct kset
*kset
, char *buf
)
599 struct pdcspath_entry
*pathentry
;
604 /* Current flags are stored in primary boot path entry */
605 pathentry
= &pdcspath_entry_primary
;
607 /* print the timer value in seconds */
608 read_lock(&pathentry
->rw_lock
);
609 out
+= sprintf(out
, "%u\n", (pathentry
->devpath
.flags
& PF_TIMER
) ?
610 (1 << (pathentry
->devpath
.flags
& PF_TIMER
)) : 0);
611 read_unlock(&pathentry
->rw_lock
);
617 * pdcs_osid_read - Stable Storage OS ID register output.
618 * @kset: An allocated and populated struct kset. We don't use it tho.
619 * @buf: The output buffer to write to.
622 pdcs_osid_read(struct kset
*kset
, char *buf
)
629 out
+= sprintf(out
, "%s dependent data (0x%.4x)\n",
630 os_id_to_string(pdcs_osid
), pdcs_osid
);
636 * pdcs_osdep1_read - Stable Storage OS-Dependent data area 1 output.
637 * @kset: An allocated and populated struct kset. We don't use it tho.
638 * @buf: The output buffer to write to.
640 * This can hold 16 bytes of OS-Dependent data.
643 pdcs_osdep1_read(struct kset
*kset
, char *buf
)
651 if (pdc_stable_read(PDCS_ADDR_OSD1
, &result
, sizeof(result
)) != PDC_OK
)
654 out
+= sprintf(out
, "0x%.8x\n", result
[0]);
655 out
+= sprintf(out
, "0x%.8x\n", result
[1]);
656 out
+= sprintf(out
, "0x%.8x\n", result
[2]);
657 out
+= sprintf(out
, "0x%.8x\n", result
[3]);
663 * pdcs_diagnostic_read - Stable Storage Diagnostic register output.
664 * @kset: An allocated and populated struct kset. We don't use it tho.
665 * @buf: The output buffer to write to.
667 * I have NFC how to interpret the content of that register ;-).
670 pdcs_diagnostic_read(struct kset
*kset
, char *buf
)
679 if (pdc_stable_read(PDCS_ADDR_DIAG
, &result
, sizeof(result
)) != PDC_OK
)
682 out
+= sprintf(out
, "0x%.4x\n", (result
>> 16));
688 * pdcs_fastsize_read - Stable Storage FastSize register output.
689 * @kset: An allocated and populated struct kset. We don't use it tho.
690 * @buf: The output buffer to write to.
692 * This register holds the amount of system RAM to be tested during boot sequence.
695 pdcs_fastsize_read(struct kset
*kset
, char *buf
)
704 if (pdc_stable_read(PDCS_ADDR_FSIZ
, &result
, sizeof(result
)) != PDC_OK
)
707 if ((result
& 0x0F) < 0x0E)
708 out
+= sprintf(out
, "%d kB", (1<<(result
& 0x0F))*256);
710 out
+= sprintf(out
, "All");
711 out
+= sprintf(out
, "\n");
717 * pdcs_osdep2_read - Stable Storage OS-Dependent data area 2 output.
718 * @kset: An allocated and populated struct kset. We don't use it tho.
719 * @buf: The output buffer to write to.
721 * This can hold pdcs_size - 224 bytes of OS-Dependent data, when available.
724 pdcs_osdep2_read(struct kset
*kset
, char *buf
)
731 if (unlikely(pdcs_size
<= 224))
734 size
= pdcs_size
- 224;
739 for (i
=0; i
<size
; i
+=4) {
740 if (unlikely(pdc_stable_read(PDCS_ADDR_OSD2
+ i
, &result
,
741 sizeof(result
)) != PDC_OK
))
743 out
+= sprintf(out
, "0x%.8x\n", result
);
750 * pdcs_auto_write - This function handles autoboot/search flag modifying.
751 * @kset: An allocated and populated struct kset. We don't use it tho.
752 * @buf: The input buffer to read from.
753 * @count: The number of bytes to be read.
754 * @knob: The PF_AUTOBOOT or PF_AUTOSEARCH flag
756 * We will call this function to change the current autoboot flag.
757 * We expect a precise syntax:
758 * \"n\" (n == 0 or 1) to toggle AutoBoot Off or On
761 pdcs_auto_write(struct kset
*kset
, const char *buf
, size_t count
, int knob
)
763 struct pdcspath_entry
*pathentry
;
765 char in
[count
+1], *temp
;
768 if (!capable(CAP_SYS_ADMIN
))
771 if (!kset
|| !buf
|| !count
)
774 /* We'll use a local copy of buf */
775 memset(in
, 0, count
+1);
776 strncpy(in
, buf
, count
);
778 /* Current flags are stored in primary boot path entry */
779 pathentry
= &pdcspath_entry_primary
;
781 /* Be nice to the existing flag record */
782 read_lock(&pathentry
->rw_lock
);
783 flags
= pathentry
->devpath
.flags
;
784 read_unlock(&pathentry
->rw_lock
);
786 DPRINTK("%s: flags before: 0x%X\n", __func__
, flags
);
790 while (*temp
&& isspace(*temp
))
794 if ((c
!= 0) && (c
!= 1))
801 DPRINTK("%s: flags after: 0x%X\n", __func__
, flags
);
803 /* So far so good, let's get in deep */
804 write_lock(&pathentry
->rw_lock
);
806 /* Change the path entry flags first */
807 pathentry
->devpath
.flags
= flags
;
809 /* Now, dive in. Write back to the hardware */
810 pdcspath_store(pathentry
);
811 write_unlock(&pathentry
->rw_lock
);
813 printk(KERN_INFO PDCS_PREFIX
": changed \"%s\" to \"%s\"\n",
814 (knob
& PF_AUTOBOOT
) ? "autoboot" : "autosearch",
815 (flags
& knob
) ? "On" : "Off");
820 printk(KERN_WARNING
"%s: Parse error: expect \"n\" (n == 0 or 1)\n", __func__
);
825 * pdcs_autoboot_write - This function handles autoboot flag modifying.
826 * @kset: An allocated and populated struct kset. We don't use it tho.
827 * @buf: The input buffer to read from.
828 * @count: The number of bytes to be read.
830 * We will call this function to change the current boot flags.
831 * We expect a precise syntax:
832 * \"n\" (n == 0 or 1) to toggle AutoSearch Off or On
834 static inline ssize_t
835 pdcs_autoboot_write(struct kset
*kset
, const char *buf
, size_t count
)
837 return pdcs_auto_write(kset
, buf
, count
, PF_AUTOBOOT
);
841 * pdcs_autosearch_write - This function handles autosearch flag modifying.
842 * @kset: An allocated and populated struct kset. We don't use it tho.
843 * @buf: The input buffer to read from.
844 * @count: The number of bytes to be read.
846 * We will call this function to change the current boot flags.
847 * We expect a precise syntax:
848 * \"n\" (n == 0 or 1) to toggle AutoSearch Off or On
850 static inline ssize_t
851 pdcs_autosearch_write(struct kset
*kset
, const char *buf
, size_t count
)
853 return pdcs_auto_write(kset
, buf
, count
, PF_AUTOSEARCH
);
857 * pdcs_osdep1_write - Stable Storage OS-Dependent data area 1 input.
858 * @kset: An allocated and populated struct kset. We don't use it tho.
859 * @buf: The input buffer to read from.
860 * @count: The number of bytes to be read.
862 * This can store 16 bytes of OS-Dependent data. We use a byte-by-byte
863 * write approach. It's up to userspace to deal with it when constructing
867 pdcs_osdep1_write(struct kset
*kset
, const char *buf
, size_t count
)
871 if (!capable(CAP_SYS_ADMIN
))
874 if (!kset
|| !buf
|| !count
)
877 if (unlikely(pdcs_osid
!= OS_ID_LINUX
))
883 /* We'll use a local copy of buf */
885 memcpy(in
, buf
, count
);
887 if (pdc_stable_write(PDCS_ADDR_OSD1
, &in
, sizeof(in
)) != PDC_OK
)
894 * pdcs_osdep2_write - Stable Storage OS-Dependent data area 2 input.
895 * @kset: An allocated and populated struct kset. We don't use it tho.
896 * @buf: The input buffer to read from.
897 * @count: The number of bytes to be read.
899 * This can store pdcs_size - 224 bytes of OS-Dependent data. We use a
900 * byte-by-byte write approach. It's up to userspace to deal with it when
901 * constructing its input buffer.
904 pdcs_osdep2_write(struct kset
*kset
, const char *buf
, size_t count
)
910 if (!capable(CAP_SYS_ADMIN
))
913 if (!kset
|| !buf
|| !count
)
916 if (unlikely(pdcs_size
<= 224))
919 if (unlikely(pdcs_osid
!= OS_ID_LINUX
))
922 size
= pdcs_size
- 224;
927 /* We'll use a local copy of buf */
929 for (i
=0; i
<count
; i
+=4) {
931 memcpy(in
, buf
+i
, (count
-i
< 4) ? count
-i
: 4);
932 if (unlikely(pdc_stable_write(PDCS_ADDR_OSD2
+ i
, &in
,
933 sizeof(in
)) != PDC_OK
))
940 /* The remaining attributes. */
941 static PDCS_ATTR(size
, 0444, pdcs_size_read
, NULL
);
942 static PDCS_ATTR(autoboot
, 0644, pdcs_autoboot_read
, pdcs_autoboot_write
);
943 static PDCS_ATTR(autosearch
, 0644, pdcs_autosearch_read
, pdcs_autosearch_write
);
944 static PDCS_ATTR(timer
, 0444, pdcs_timer_read
, NULL
);
945 static PDCS_ATTR(osid
, 0444, pdcs_osid_read
, NULL
);
946 static PDCS_ATTR(osdep1
, 0600, pdcs_osdep1_read
, pdcs_osdep1_write
);
947 static PDCS_ATTR(diagnostic
, 0400, pdcs_diagnostic_read
, NULL
);
948 static PDCS_ATTR(fastsize
, 0400, pdcs_fastsize_read
, NULL
);
949 static PDCS_ATTR(osdep2
, 0600, pdcs_osdep2_read
, pdcs_osdep2_write
);
951 static struct subsys_attribute
*pdcs_subsys_attrs
[] = {
954 &pdcs_attr_autosearch
,
958 &pdcs_attr_diagnostic
,
964 static decl_subsys(paths
, &ktype_pdcspath
, NULL
);
965 static decl_subsys(stable
, NULL
, NULL
);
968 * pdcs_register_pathentries - Prepares path entries kobjects for sysfs usage.
970 * It creates kobjects corresponding to each path entry with nice sysfs
971 * links to the real device. This is where the magic takes place: when
972 * registering the subsystem attributes during module init, each kobject hereby
973 * created will show in the sysfs tree as a folder containing files as defined
974 * by path_subsys_attr[].
976 static inline int __init
977 pdcs_register_pathentries(void)
980 struct pdcspath_entry
*entry
;
983 /* Initialize the entries rw_lock before anything else */
984 for (i
= 0; (entry
= pdcspath_entries
[i
]); i
++)
985 rwlock_init(&entry
->rw_lock
);
987 for (i
= 0; (entry
= pdcspath_entries
[i
]); i
++) {
988 write_lock(&entry
->rw_lock
);
989 err
= pdcspath_fetch(entry
);
990 write_unlock(&entry
->rw_lock
);
995 if ((err
= kobject_set_name(&entry
->kobj
, "%s", entry
->name
)))
997 kobj_set_kset_s(entry
, paths_subsys
);
998 if ((err
= kobject_register(&entry
->kobj
)))
1001 /* kobject is now registered */
1002 write_lock(&entry
->rw_lock
);
1005 /* Add a nice symlink to the real device */
1007 sysfs_create_link(&entry
->kobj
, &entry
->dev
->kobj
, "device");
1009 write_unlock(&entry
->rw_lock
);
1016 * pdcs_unregister_pathentries - Routine called when unregistering the module.
1019 pdcs_unregister_pathentries(void)
1022 struct pdcspath_entry
*entry
;
1024 for (i
= 0; (entry
= pdcspath_entries
[i
]); i
++) {
1025 read_lock(&entry
->rw_lock
);
1026 if (entry
->ready
>= 2)
1027 kobject_unregister(&entry
->kobj
);
1028 read_unlock(&entry
->rw_lock
);
1033 * For now we register the stable subsystem with the firmware subsystem
1034 * and the paths subsystem with the stable subsystem
1037 pdc_stable_init(void)
1039 struct subsys_attribute
*attr
;
1040 int i
, rc
= 0, error
= 0;
1043 /* find the size of the stable storage */
1044 if (pdc_stable_get_size(&pdcs_size
) != PDC_OK
)
1047 /* make sure we have enough data */
1051 printk(KERN_INFO PDCS_PREFIX
" facility v%s\n", PDCS_VERSION
);
1054 if (pdc_stable_read(PDCS_ADDR_OSID
, &result
, sizeof(result
)) != PDC_OK
)
1057 /* the actual result is 16 bits away */
1058 pdcs_osid
= (u16
)(result
>> 16);
1060 /* For now we'll register the stable subsys within this driver */
1061 if ((rc
= firmware_register(&stable_subsys
)))
1064 /* Don't forget the root entries */
1065 for (i
= 0; (attr
= pdcs_subsys_attrs
[i
]) && !error
; i
++)
1067 error
= subsys_create_file(&stable_subsys
, attr
);
1069 /* register the paths subsys as a subsystem of stable subsys */
1070 kobj_set_kset_s(&paths_subsys
, stable_subsys
);
1071 if ((rc
= subsystem_register(&paths_subsys
)))
1072 goto fail_subsysreg
;
1074 /* now we create all "files" for the paths subsys */
1075 if ((rc
= pdcs_register_pathentries()))
1081 pdcs_unregister_pathentries();
1082 subsystem_unregister(&paths_subsys
);
1085 firmware_unregister(&stable_subsys
);
1088 printk(KERN_INFO PDCS_PREFIX
" bailing out\n");
1093 pdc_stable_exit(void)
1095 pdcs_unregister_pathentries();
1096 subsystem_unregister(&paths_subsys
);
1098 firmware_unregister(&stable_subsys
);
1102 module_init(pdc_stable_init
);
1103 module_exit(pdc_stable_exit
);