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