1e7ec2e32SMichael Buesch /* 2e7ec2e32SMichael Buesch * Sonics Silicon Backplane 3e7ec2e32SMichael Buesch * Common SPROM support routines 4e7ec2e32SMichael Buesch * 5e7ec2e32SMichael Buesch * Copyright (C) 2005-2008 Michael Buesch <mb@bu3sch.de> 6e7ec2e32SMichael Buesch * Copyright (C) 2005 Martin Langer <martin-langer@gmx.de> 7e7ec2e32SMichael Buesch * Copyright (C) 2005 Stefano Brivio <st3@riseup.net> 8e7ec2e32SMichael Buesch * Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org> 9e7ec2e32SMichael Buesch * Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch> 10e7ec2e32SMichael Buesch * 11e7ec2e32SMichael Buesch * Licensed under the GNU/GPL. See COPYING for details. 12e7ec2e32SMichael Buesch */ 13e7ec2e32SMichael Buesch 14e7ec2e32SMichael Buesch #include "ssb_private.h" 15e7ec2e32SMichael Buesch 16e33761e6SMichael Buesch #include <linux/ctype.h> 175a0e3ad6STejun Heo #include <linux/slab.h> 18e33761e6SMichael Buesch 19e7ec2e32SMichael Buesch 20e79c1ba8SMichael Buesch static const struct ssb_sprom *fallback_sprom; 21e79c1ba8SMichael Buesch 22e79c1ba8SMichael Buesch 23e7ec2e32SMichael Buesch static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, 24e7ec2e32SMichael Buesch size_t sprom_size_words) 25e7ec2e32SMichael Buesch { 26e7ec2e32SMichael Buesch int i, pos = 0; 27e7ec2e32SMichael Buesch 28e7ec2e32SMichael Buesch for (i = 0; i < sprom_size_words; i++) 29e7ec2e32SMichael Buesch pos += snprintf(buf + pos, buf_len - pos - 1, 30e7ec2e32SMichael Buesch "%04X", swab16(sprom[i]) & 0xFFFF); 31e7ec2e32SMichael Buesch pos += snprintf(buf + pos, buf_len - pos - 1, "\n"); 32e7ec2e32SMichael Buesch 33e7ec2e32SMichael Buesch return pos + 1; 34e7ec2e32SMichael Buesch } 35e7ec2e32SMichael Buesch 36e7ec2e32SMichael Buesch static int hex2sprom(u16 *sprom, const char *dump, size_t len, 37e7ec2e32SMichael Buesch size_t sprom_size_words) 38e7ec2e32SMichael Buesch { 39e33761e6SMichael Buesch char c, tmp[5] = { 0 }; 40e33761e6SMichael Buesch int err, cnt = 0; 41e7ec2e32SMichael Buesch unsigned long parsed; 42e7ec2e32SMichael Buesch 43e33761e6SMichael Buesch /* Strip whitespace at the end. */ 44e33761e6SMichael Buesch while (len) { 45e33761e6SMichael Buesch c = dump[len - 1]; 46e33761e6SMichael Buesch if (!isspace(c) && c != '\0') 47e33761e6SMichael Buesch break; 48e33761e6SMichael Buesch len--; 49e33761e6SMichael Buesch } 50e33761e6SMichael Buesch /* Length must match exactly. */ 51e33761e6SMichael Buesch if (len != sprom_size_words * 4) 52e7ec2e32SMichael Buesch return -EINVAL; 53e7ec2e32SMichael Buesch 54e7ec2e32SMichael Buesch while (cnt < sprom_size_words) { 55e7ec2e32SMichael Buesch memcpy(tmp, dump, 4); 56e7ec2e32SMichael Buesch dump += 4; 57e33761e6SMichael Buesch err = strict_strtoul(tmp, 16, &parsed); 58e33761e6SMichael Buesch if (err) 59e33761e6SMichael Buesch return err; 60e7ec2e32SMichael Buesch sprom[cnt++] = swab16((u16)parsed); 61e7ec2e32SMichael Buesch } 62e7ec2e32SMichael Buesch 63e7ec2e32SMichael Buesch return 0; 64e7ec2e32SMichael Buesch } 65e7ec2e32SMichael Buesch 66e7ec2e32SMichael Buesch /* Common sprom device-attribute show-handler */ 67e7ec2e32SMichael Buesch ssize_t ssb_attr_sprom_show(struct ssb_bus *bus, char *buf, 68e7ec2e32SMichael Buesch int (*sprom_read)(struct ssb_bus *bus, u16 *sprom)) 69e7ec2e32SMichael Buesch { 70e7ec2e32SMichael Buesch u16 *sprom; 71e7ec2e32SMichael Buesch int err = -ENOMEM; 72e7ec2e32SMichael Buesch ssize_t count = 0; 73e7ec2e32SMichael Buesch size_t sprom_size_words = bus->sprom_size; 74e7ec2e32SMichael Buesch 75e7ec2e32SMichael Buesch sprom = kcalloc(sprom_size_words, sizeof(u16), GFP_KERNEL); 76e7ec2e32SMichael Buesch if (!sprom) 77e7ec2e32SMichael Buesch goto out; 78e7ec2e32SMichael Buesch 79e7ec2e32SMichael Buesch /* Use interruptible locking, as the SPROM write might 80e7ec2e32SMichael Buesch * be holding the lock for several seconds. So allow userspace 81e7ec2e32SMichael Buesch * to cancel operation. */ 82e7ec2e32SMichael Buesch err = -ERESTARTSYS; 83e7ec2e32SMichael Buesch if (mutex_lock_interruptible(&bus->sprom_mutex)) 84e7ec2e32SMichael Buesch goto out_kfree; 85e7ec2e32SMichael Buesch err = sprom_read(bus, sprom); 86e7ec2e32SMichael Buesch mutex_unlock(&bus->sprom_mutex); 87e7ec2e32SMichael Buesch 88e7ec2e32SMichael Buesch if (!err) 89e7ec2e32SMichael Buesch count = sprom2hex(sprom, buf, PAGE_SIZE, sprom_size_words); 90e7ec2e32SMichael Buesch 91e7ec2e32SMichael Buesch out_kfree: 92e7ec2e32SMichael Buesch kfree(sprom); 93e7ec2e32SMichael Buesch out: 94e7ec2e32SMichael Buesch return err ? err : count; 95e7ec2e32SMichael Buesch } 96e7ec2e32SMichael Buesch 97e7ec2e32SMichael Buesch /* Common sprom device-attribute store-handler */ 98e7ec2e32SMichael Buesch ssize_t ssb_attr_sprom_store(struct ssb_bus *bus, 99e7ec2e32SMichael Buesch const char *buf, size_t count, 100e7ec2e32SMichael Buesch int (*sprom_check_crc)(const u16 *sprom, size_t size), 101e7ec2e32SMichael Buesch int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom)) 102e7ec2e32SMichael Buesch { 103e7ec2e32SMichael Buesch u16 *sprom; 104e7ec2e32SMichael Buesch int res = 0, err = -ENOMEM; 105e7ec2e32SMichael Buesch size_t sprom_size_words = bus->sprom_size; 1063ba6018aSMichael Buesch struct ssb_freeze_context freeze; 107e7ec2e32SMichael Buesch 108e7ec2e32SMichael Buesch sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL); 109e7ec2e32SMichael Buesch if (!sprom) 110e7ec2e32SMichael Buesch goto out; 111e7ec2e32SMichael Buesch err = hex2sprom(sprom, buf, count, sprom_size_words); 112e7ec2e32SMichael Buesch if (err) { 113e7ec2e32SMichael Buesch err = -EINVAL; 114e7ec2e32SMichael Buesch goto out_kfree; 115e7ec2e32SMichael Buesch } 116e7ec2e32SMichael Buesch err = sprom_check_crc(sprom, sprom_size_words); 117e7ec2e32SMichael Buesch if (err) { 118e7ec2e32SMichael Buesch err = -EINVAL; 119e7ec2e32SMichael Buesch goto out_kfree; 120e7ec2e32SMichael Buesch } 121e7ec2e32SMichael Buesch 122e7ec2e32SMichael Buesch /* Use interruptible locking, as the SPROM write might 123e7ec2e32SMichael Buesch * be holding the lock for several seconds. So allow userspace 124e7ec2e32SMichael Buesch * to cancel operation. */ 125e7ec2e32SMichael Buesch err = -ERESTARTSYS; 126e7ec2e32SMichael Buesch if (mutex_lock_interruptible(&bus->sprom_mutex)) 127e7ec2e32SMichael Buesch goto out_kfree; 1283ba6018aSMichael Buesch err = ssb_devices_freeze(bus, &freeze); 129e7ec2e32SMichael Buesch if (err) { 130e7ec2e32SMichael Buesch ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 131e7ec2e32SMichael Buesch goto out_unlock; 132e7ec2e32SMichael Buesch } 133e7ec2e32SMichael Buesch res = sprom_write(bus, sprom); 1343ba6018aSMichael Buesch err = ssb_devices_thaw(&freeze); 135e7ec2e32SMichael Buesch if (err) 136e7ec2e32SMichael Buesch ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 137e7ec2e32SMichael Buesch out_unlock: 138e7ec2e32SMichael Buesch mutex_unlock(&bus->sprom_mutex); 139e7ec2e32SMichael Buesch out_kfree: 140e7ec2e32SMichael Buesch kfree(sprom); 141e7ec2e32SMichael Buesch out: 142e7ec2e32SMichael Buesch if (res) 143e7ec2e32SMichael Buesch return res; 144e7ec2e32SMichael Buesch return err ? err : count; 145e7ec2e32SMichael Buesch } 146e79c1ba8SMichael Buesch 147e79c1ba8SMichael Buesch /** 148e79c1ba8SMichael Buesch * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found. 149e79c1ba8SMichael Buesch * 150e79c1ba8SMichael Buesch * @sprom: The SPROM data structure to register. 151e79c1ba8SMichael Buesch * 152e79c1ba8SMichael Buesch * With this function the architecture implementation may register a fallback 153e79c1ba8SMichael Buesch * SPROM data structure. The fallback is only used for PCI based SSB devices, 154e79c1ba8SMichael Buesch * where no valid SPROM can be found in the shadow registers. 155e79c1ba8SMichael Buesch * 156e79c1ba8SMichael Buesch * This function is useful for weird architectures that have a half-assed SSB device 157e79c1ba8SMichael Buesch * hardwired to their PCI bus. 158e79c1ba8SMichael Buesch * 159e79c1ba8SMichael Buesch * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently 160e79c1ba8SMichael Buesch * don't use this fallback. 161e79c1ba8SMichael Buesch * Architectures must provide the SPROM for native SSB devices anyway, 162e79c1ba8SMichael Buesch * so the fallback also isn't used for native devices. 163e79c1ba8SMichael Buesch * 164e79c1ba8SMichael Buesch * This function is available for architecture code, only. So it is not exported. 165e79c1ba8SMichael Buesch */ 166e79c1ba8SMichael Buesch int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom) 167e79c1ba8SMichael Buesch { 168e79c1ba8SMichael Buesch if (fallback_sprom) 169e79c1ba8SMichael Buesch return -EEXIST; 170e79c1ba8SMichael Buesch fallback_sprom = sprom; 171e79c1ba8SMichael Buesch 172e79c1ba8SMichael Buesch return 0; 173e79c1ba8SMichael Buesch } 174e79c1ba8SMichael Buesch 175e79c1ba8SMichael Buesch const struct ssb_sprom *ssb_get_fallback_sprom(void) 176e79c1ba8SMichael Buesch { 177e79c1ba8SMichael Buesch return fallback_sprom; 178e79c1ba8SMichael Buesch } 179d53cdbb9SJohn W. Linville 180d53cdbb9SJohn W. Linville /* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 181d53cdbb9SJohn W. Linville bool ssb_is_sprom_available(struct ssb_bus *bus) 182d53cdbb9SJohn W. Linville { 183d53cdbb9SJohn W. Linville /* status register only exists on chipcomon rev >= 11 and we need check 184d53cdbb9SJohn W. Linville for >= 31 only */ 185d53cdbb9SJohn W. Linville /* this routine differs from specs as we do not access SPROM directly 186d53cdbb9SJohn W. Linville on PCMCIA */ 187d53cdbb9SJohn W. Linville if (bus->bustype == SSB_BUSTYPE_PCI && 188*25985edcSLucas De Marchi bus->chipco.dev && /* can be unavailable! */ 189d53cdbb9SJohn W. Linville bus->chipco.dev->id.revision >= 31) 190d53cdbb9SJohn W. Linville return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 191d53cdbb9SJohn W. Linville 192d53cdbb9SJohn W. Linville return true; 193d53cdbb9SJohn W. Linville } 194