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 16*e33761e6SMichael Buesch #include <linux/ctype.h> 17*e33761e6SMichael Buesch 18e7ec2e32SMichael Buesch 19e79c1ba8SMichael Buesch static const struct ssb_sprom *fallback_sprom; 20e79c1ba8SMichael Buesch 21e79c1ba8SMichael Buesch 22e7ec2e32SMichael Buesch static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, 23e7ec2e32SMichael Buesch size_t sprom_size_words) 24e7ec2e32SMichael Buesch { 25e7ec2e32SMichael Buesch int i, pos = 0; 26e7ec2e32SMichael Buesch 27e7ec2e32SMichael Buesch for (i = 0; i < sprom_size_words; i++) 28e7ec2e32SMichael Buesch pos += snprintf(buf + pos, buf_len - pos - 1, 29e7ec2e32SMichael Buesch "%04X", swab16(sprom[i]) & 0xFFFF); 30e7ec2e32SMichael Buesch pos += snprintf(buf + pos, buf_len - pos - 1, "\n"); 31e7ec2e32SMichael Buesch 32e7ec2e32SMichael Buesch return pos + 1; 33e7ec2e32SMichael Buesch } 34e7ec2e32SMichael Buesch 35e7ec2e32SMichael Buesch static int hex2sprom(u16 *sprom, const char *dump, size_t len, 36e7ec2e32SMichael Buesch size_t sprom_size_words) 37e7ec2e32SMichael Buesch { 38*e33761e6SMichael Buesch char c, tmp[5] = { 0 }; 39*e33761e6SMichael Buesch int err, cnt = 0; 40e7ec2e32SMichael Buesch unsigned long parsed; 41e7ec2e32SMichael Buesch 42*e33761e6SMichael Buesch /* Strip whitespace at the end. */ 43*e33761e6SMichael Buesch while (len) { 44*e33761e6SMichael Buesch c = dump[len - 1]; 45*e33761e6SMichael Buesch if (!isspace(c) && c != '\0') 46*e33761e6SMichael Buesch break; 47*e33761e6SMichael Buesch len--; 48*e33761e6SMichael Buesch } 49*e33761e6SMichael Buesch /* Length must match exactly. */ 50*e33761e6SMichael Buesch if (len != sprom_size_words * 4) 51e7ec2e32SMichael Buesch return -EINVAL; 52e7ec2e32SMichael Buesch 53e7ec2e32SMichael Buesch while (cnt < sprom_size_words) { 54e7ec2e32SMichael Buesch memcpy(tmp, dump, 4); 55e7ec2e32SMichael Buesch dump += 4; 56*e33761e6SMichael Buesch err = strict_strtoul(tmp, 16, &parsed); 57*e33761e6SMichael Buesch if (err) 58*e33761e6SMichael Buesch return err; 59e7ec2e32SMichael Buesch sprom[cnt++] = swab16((u16)parsed); 60e7ec2e32SMichael Buesch } 61e7ec2e32SMichael Buesch 62e7ec2e32SMichael Buesch return 0; 63e7ec2e32SMichael Buesch } 64e7ec2e32SMichael Buesch 65e7ec2e32SMichael Buesch /* Common sprom device-attribute show-handler */ 66e7ec2e32SMichael Buesch ssize_t ssb_attr_sprom_show(struct ssb_bus *bus, char *buf, 67e7ec2e32SMichael Buesch int (*sprom_read)(struct ssb_bus *bus, u16 *sprom)) 68e7ec2e32SMichael Buesch { 69e7ec2e32SMichael Buesch u16 *sprom; 70e7ec2e32SMichael Buesch int err = -ENOMEM; 71e7ec2e32SMichael Buesch ssize_t count = 0; 72e7ec2e32SMichael Buesch size_t sprom_size_words = bus->sprom_size; 73e7ec2e32SMichael Buesch 74e7ec2e32SMichael Buesch sprom = kcalloc(sprom_size_words, sizeof(u16), GFP_KERNEL); 75e7ec2e32SMichael Buesch if (!sprom) 76e7ec2e32SMichael Buesch goto out; 77e7ec2e32SMichael Buesch 78e7ec2e32SMichael Buesch /* Use interruptible locking, as the SPROM write might 79e7ec2e32SMichael Buesch * be holding the lock for several seconds. So allow userspace 80e7ec2e32SMichael Buesch * to cancel operation. */ 81e7ec2e32SMichael Buesch err = -ERESTARTSYS; 82e7ec2e32SMichael Buesch if (mutex_lock_interruptible(&bus->sprom_mutex)) 83e7ec2e32SMichael Buesch goto out_kfree; 84e7ec2e32SMichael Buesch err = sprom_read(bus, sprom); 85e7ec2e32SMichael Buesch mutex_unlock(&bus->sprom_mutex); 86e7ec2e32SMichael Buesch 87e7ec2e32SMichael Buesch if (!err) 88e7ec2e32SMichael Buesch count = sprom2hex(sprom, buf, PAGE_SIZE, sprom_size_words); 89e7ec2e32SMichael Buesch 90e7ec2e32SMichael Buesch out_kfree: 91e7ec2e32SMichael Buesch kfree(sprom); 92e7ec2e32SMichael Buesch out: 93e7ec2e32SMichael Buesch return err ? err : count; 94e7ec2e32SMichael Buesch } 95e7ec2e32SMichael Buesch 96e7ec2e32SMichael Buesch /* Common sprom device-attribute store-handler */ 97e7ec2e32SMichael Buesch ssize_t ssb_attr_sprom_store(struct ssb_bus *bus, 98e7ec2e32SMichael Buesch const char *buf, size_t count, 99e7ec2e32SMichael Buesch int (*sprom_check_crc)(const u16 *sprom, size_t size), 100e7ec2e32SMichael Buesch int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom)) 101e7ec2e32SMichael Buesch { 102e7ec2e32SMichael Buesch u16 *sprom; 103e7ec2e32SMichael Buesch int res = 0, err = -ENOMEM; 104e7ec2e32SMichael Buesch size_t sprom_size_words = bus->sprom_size; 1053ba6018aSMichael Buesch struct ssb_freeze_context freeze; 106e7ec2e32SMichael Buesch 107e7ec2e32SMichael Buesch sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL); 108e7ec2e32SMichael Buesch if (!sprom) 109e7ec2e32SMichael Buesch goto out; 110e7ec2e32SMichael Buesch err = hex2sprom(sprom, buf, count, sprom_size_words); 111e7ec2e32SMichael Buesch if (err) { 112e7ec2e32SMichael Buesch err = -EINVAL; 113e7ec2e32SMichael Buesch goto out_kfree; 114e7ec2e32SMichael Buesch } 115e7ec2e32SMichael Buesch err = sprom_check_crc(sprom, sprom_size_words); 116e7ec2e32SMichael Buesch if (err) { 117e7ec2e32SMichael Buesch err = -EINVAL; 118e7ec2e32SMichael Buesch goto out_kfree; 119e7ec2e32SMichael Buesch } 120e7ec2e32SMichael Buesch 121e7ec2e32SMichael Buesch /* Use interruptible locking, as the SPROM write might 122e7ec2e32SMichael Buesch * be holding the lock for several seconds. So allow userspace 123e7ec2e32SMichael Buesch * to cancel operation. */ 124e7ec2e32SMichael Buesch err = -ERESTARTSYS; 125e7ec2e32SMichael Buesch if (mutex_lock_interruptible(&bus->sprom_mutex)) 126e7ec2e32SMichael Buesch goto out_kfree; 1273ba6018aSMichael Buesch err = ssb_devices_freeze(bus, &freeze); 128e7ec2e32SMichael Buesch if (err) { 129e7ec2e32SMichael Buesch ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 130e7ec2e32SMichael Buesch goto out_unlock; 131e7ec2e32SMichael Buesch } 132e7ec2e32SMichael Buesch res = sprom_write(bus, sprom); 1333ba6018aSMichael Buesch err = ssb_devices_thaw(&freeze); 134e7ec2e32SMichael Buesch if (err) 135e7ec2e32SMichael Buesch ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 136e7ec2e32SMichael Buesch out_unlock: 137e7ec2e32SMichael Buesch mutex_unlock(&bus->sprom_mutex); 138e7ec2e32SMichael Buesch out_kfree: 139e7ec2e32SMichael Buesch kfree(sprom); 140e7ec2e32SMichael Buesch out: 141e7ec2e32SMichael Buesch if (res) 142e7ec2e32SMichael Buesch return res; 143e7ec2e32SMichael Buesch return err ? err : count; 144e7ec2e32SMichael Buesch } 145e79c1ba8SMichael Buesch 146e79c1ba8SMichael Buesch /** 147e79c1ba8SMichael Buesch * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found. 148e79c1ba8SMichael Buesch * 149e79c1ba8SMichael Buesch * @sprom: The SPROM data structure to register. 150e79c1ba8SMichael Buesch * 151e79c1ba8SMichael Buesch * With this function the architecture implementation may register a fallback 152e79c1ba8SMichael Buesch * SPROM data structure. The fallback is only used for PCI based SSB devices, 153e79c1ba8SMichael Buesch * where no valid SPROM can be found in the shadow registers. 154e79c1ba8SMichael Buesch * 155e79c1ba8SMichael Buesch * This function is useful for weird architectures that have a half-assed SSB device 156e79c1ba8SMichael Buesch * hardwired to their PCI bus. 157e79c1ba8SMichael Buesch * 158e79c1ba8SMichael Buesch * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently 159e79c1ba8SMichael Buesch * don't use this fallback. 160e79c1ba8SMichael Buesch * Architectures must provide the SPROM for native SSB devices anyway, 161e79c1ba8SMichael Buesch * so the fallback also isn't used for native devices. 162e79c1ba8SMichael Buesch * 163e79c1ba8SMichael Buesch * This function is available for architecture code, only. So it is not exported. 164e79c1ba8SMichael Buesch */ 165e79c1ba8SMichael Buesch int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom) 166e79c1ba8SMichael Buesch { 167e79c1ba8SMichael Buesch if (fallback_sprom) 168e79c1ba8SMichael Buesch return -EEXIST; 169e79c1ba8SMichael Buesch fallback_sprom = sprom; 170e79c1ba8SMichael Buesch 171e79c1ba8SMichael Buesch return 0; 172e79c1ba8SMichael Buesch } 173e79c1ba8SMichael Buesch 174e79c1ba8SMichael Buesch const struct ssb_sprom *ssb_get_fallback_sprom(void) 175e79c1ba8SMichael Buesch { 176e79c1ba8SMichael Buesch return fallback_sprom; 177e79c1ba8SMichael Buesch } 178