2 * Sonics Silicon Backplane
3 * Common SPROM support routines
5 * Copyright (C) 2005-2008 Michael Buesch <mb@bu3sch.de>
6 * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
7 * Copyright (C) 2005 Stefano Brivio <st3@riseup.net>
8 * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
9 * Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
11 * Licensed under the GNU/GPL. See COPYING for details.
14 #include "ssb_private.h"
17 static const struct ssb_sprom
*fallback_sprom
;
20 static int sprom2hex(const u16
*sprom
, char *buf
, size_t buf_len
,
21 size_t sprom_size_words
)
25 for (i
= 0; i
< sprom_size_words
; i
++)
26 pos
+= snprintf(buf
+ pos
, buf_len
- pos
- 1,
27 "%04X", swab16(sprom
[i
]) & 0xFFFF);
28 pos
+= snprintf(buf
+ pos
, buf_len
- pos
- 1, "\n");
33 static int hex2sprom(u16
*sprom
, const char *dump
, size_t len
,
34 size_t sprom_size_words
)
40 if (len
< sprom_size_words
* 2)
43 while (cnt
< sprom_size_words
) {
46 parsed
= simple_strtoul(tmp
, NULL
, 16);
47 sprom
[cnt
++] = swab16((u16
)parsed
);
53 /* Common sprom device-attribute show-handler */
54 ssize_t
ssb_attr_sprom_show(struct ssb_bus
*bus
, char *buf
,
55 int (*sprom_read
)(struct ssb_bus
*bus
, u16
*sprom
))
60 size_t sprom_size_words
= bus
->sprom_size
;
62 sprom
= kcalloc(sprom_size_words
, sizeof(u16
), GFP_KERNEL
);
66 /* Use interruptible locking, as the SPROM write might
67 * be holding the lock for several seconds. So allow userspace
68 * to cancel operation. */
70 if (mutex_lock_interruptible(&bus
->sprom_mutex
))
72 err
= sprom_read(bus
, sprom
);
73 mutex_unlock(&bus
->sprom_mutex
);
76 count
= sprom2hex(sprom
, buf
, PAGE_SIZE
, sprom_size_words
);
81 return err
? err
: count
;
84 /* Common sprom device-attribute store-handler */
85 ssize_t
ssb_attr_sprom_store(struct ssb_bus
*bus
,
86 const char *buf
, size_t count
,
87 int (*sprom_check_crc
)(const u16
*sprom
, size_t size
),
88 int (*sprom_write
)(struct ssb_bus
*bus
, const u16
*sprom
))
91 int res
= 0, err
= -ENOMEM
;
92 size_t sprom_size_words
= bus
->sprom_size
;
94 sprom
= kcalloc(bus
->sprom_size
, sizeof(u16
), GFP_KERNEL
);
97 err
= hex2sprom(sprom
, buf
, count
, sprom_size_words
);
102 err
= sprom_check_crc(sprom
, sprom_size_words
);
108 /* Use interruptible locking, as the SPROM write might
109 * be holding the lock for several seconds. So allow userspace
110 * to cancel operation. */
112 if (mutex_lock_interruptible(&bus
->sprom_mutex
))
114 err
= ssb_devices_freeze(bus
);
115 if (err
== -EOPNOTSUPP
) {
116 ssb_printk(KERN_ERR PFX
"SPROM write: Could not freeze devices. "
117 "No suspend support. Is CONFIG_PM enabled?\n");
121 ssb_printk(KERN_ERR PFX
"SPROM write: Could not freeze all devices\n");
124 res
= sprom_write(bus
, sprom
);
125 err
= ssb_devices_thaw(bus
);
127 ssb_printk(KERN_ERR PFX
"SPROM write: Could not thaw all devices\n");
129 mutex_unlock(&bus
->sprom_mutex
);
135 return err
? err
: count
;
139 * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found.
141 * @sprom: The SPROM data structure to register.
143 * With this function the architecture implementation may register a fallback
144 * SPROM data structure. The fallback is only used for PCI based SSB devices,
145 * where no valid SPROM can be found in the shadow registers.
147 * This function is useful for weird architectures that have a half-assed SSB device
148 * hardwired to their PCI bus.
150 * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently
151 * don't use this fallback.
152 * Architectures must provide the SPROM for native SSB devices anyway,
153 * so the fallback also isn't used for native devices.
155 * This function is available for architecture code, only. So it is not exported.
157 int ssb_arch_set_fallback_sprom(const struct ssb_sprom
*sprom
)
161 fallback_sprom
= sprom
;
166 const struct ssb_sprom
*ssb_get_fallback_sprom(void)
168 return fallback_sprom
;
This page took 0.035881 seconds and 6 git commands to generate.