Kernel/linux-next
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git synced 2025-01-06 05:02:31 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

ssb: Add SPROM/invariants support for PCMCIA devices

Browse Source 
This adds support for reading/writing the SPROM invariants
for PCMCIA based devices.

Signed-off-by: Michael Buesch <mb@bu3sch.de>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
This commit is contained in:
Michael Buesch 2008-03-10 17:26:32 +01:00 committed by John W. Linville
parent 068edceb7e
commit e7ec2e3230
8 changed files with 648 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
drivers/ssb/Kconfig
View File

@ -20,6 +20,10 @@ config SSB
If unsure, say N. If unsure, say N.
# Common SPROM support routines
config SSB_SPROM
bool
config SSB_PCIHOST_POSSIBLE config SSB_PCIHOST_POSSIBLE
bool bool
depends on SSB && (PCI = y || PCI = SSB) depends on SSB && (PCI = y || PCI = SSB)
@ -28,6 +32,7 @@ config SSB_PCIHOST_POSSIBLE
config SSB_PCIHOST config SSB_PCIHOST
bool "Support for SSB on PCI-bus host" bool "Support for SSB on PCI-bus host"
depends on SSB_PCIHOST_POSSIBLE depends on SSB_PCIHOST_POSSIBLE
select SSB_SPROM
default y default y
help help
Support for a Sonics Silicon Backplane on top Support for a Sonics Silicon Backplane on top
@ -48,6 +53,7 @@ config SSB_PCMCIAHOST_POSSIBLE
config SSB_PCMCIAHOST config SSB_PCMCIAHOST
bool "Support for SSB on PCMCIA-bus host (EXPERIMENTAL)" bool "Support for SSB on PCMCIA-bus host (EXPERIMENTAL)"
depends on SSB_PCMCIAHOST_POSSIBLE depends on SSB_PCMCIAHOST_POSSIBLE
select SSB_SPROM
help help
Support for a Sonics Silicon Backplane on top Support for a Sonics Silicon Backplane on top
of a PCMCIA device. of a PCMCIA device.

1
drivers/ssb/Makefile
View File

@ -1,6 +1,7 @@
# core # core
ssb-y += main.o scan.o ssb-y += main.o scan.o
ssb-$(CONFIG_SSB_EMBEDDED) += embedded.o ssb-$(CONFIG_SSB_EMBEDDED) += embedded.o
ssb-$(CONFIG_SSB_SPROM) += sprom.o
# host support # host support
ssb-$(CONFIG_SSB_PCIHOST) += pci.o pcihost_wrapper.o ssb-$(CONFIG_SSB_PCIHOST) += pci.o pcihost_wrapper.o

23
drivers/ssb/main.c
View File

@ -69,6 +69,25 @@ struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev)
} }
#endif /* CONFIG_SSB_PCIHOST */ #endif /* CONFIG_SSB_PCIHOST */
#ifdef CONFIG_SSB_PCMCIAHOST
struct ssb_bus *ssb_pcmcia_dev_to_bus(struct pcmcia_device *pdev)
{
struct ssb_bus *bus;
ssb_buses_lock();
list_for_each_entry(bus, &buses, list) {
if (bus->bustype == SSB_BUSTYPE_PCMCIA &&
bus->host_pcmcia == pdev)
goto found;
}
bus = NULL;
found:
ssb_buses_unlock();
return bus;
}
#endif /* CONFIG_SSB_PCMCIAHOST */
int ssb_for_each_bus_call(unsigned long data, int ssb_for_each_bus_call(unsigned long data,
int (*func)(struct ssb_bus *bus, unsigned long data)) int (*func)(struct ssb_bus *bus, unsigned long data))
{ {
@ -398,7 +417,7 @@ void ssb_bus_unregister(struct ssb_bus *bus)
list_del(&bus->list); list_del(&bus->list);
ssb_buses_unlock(); ssb_buses_unlock();
/* ssb_pcmcia_exit(bus); */ ssb_pcmcia_exit(bus);
ssb_pci_exit(bus); ssb_pci_exit(bus);
ssb_iounmap(bus); ssb_iounmap(bus);
} }
@ -663,7 +682,7 @@ static int ssb_bus_register(struct ssb_bus *bus,
err_dequeue: err_dequeue:
list_del(&bus->list); list_del(&bus->list);
err_pcmcia_exit: err_pcmcia_exit:
/* ssb_pcmcia_exit(bus); */ ssb_pcmcia_exit(bus);
err_pci_exit: err_pci_exit:
ssb_pci_exit(bus); ssb_pci_exit(bus);
err_unmap: err_unmap:

113
drivers/ssb/pci.c
View File

@ -227,7 +227,7 @@ static u8 ssb_sprom_crc(const u16 *sprom, u16 size)
return crc; return crc;
} }
static int sprom_check_crc(const u16 *sprom, u16 size) static int sprom_check_crc(const u16 *sprom, size_t size)
{ {
u8 crc; u8 crc;
u8 expected_crc; u8 expected_crc;
@ -242,12 +242,14 @@ static int sprom_check_crc(const u16 *sprom, u16 size)
return 0; return 0;
} }
static void sprom_do_read(struct ssb_bus *bus, u16 *sprom) static int sprom_do_read(struct ssb_bus *bus, u16 *sprom)
{ {
int i; int i;
for (i = 0; i < bus->sprom_size; i++) for (i = 0; i < bus->sprom_size; i++)
sprom[i] = ioread16(bus->mmio + SSB_SPROM_BASE + (i * 2)); sprom[i] = ioread16(bus->mmio + SSB_SPROM_BASE + (i * 2));
return 0;
} }
static int sprom_do_write(struct ssb_bus *bus, const u16 *sprom) static int sprom_do_write(struct ssb_bus *bus, const u16 *sprom)
@ -660,71 +662,18 @@ const struct ssb_bus_ops ssb_pci_ops = {
.write32 = ssb_pci_write32, .write32 = ssb_pci_write32,
}; };
static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, u16 size)
{
int i, pos = 0;
for (i = 0; i < size; i++)
pos += snprintf(buf + pos, buf_len - pos - 1,
"%04X", swab16(sprom[i]) & 0xFFFF);
pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
return pos + 1;
}
static int hex2sprom(u16 *sprom, const char *dump, size_t len, u16 size)
{
char tmp[5] = { 0 };
int cnt = 0;
unsigned long parsed;
if (len < size * 2)
return -EINVAL;
while (cnt < size) {
memcpy(tmp, dump, 4);
dump += 4;
parsed = simple_strtoul(tmp, NULL, 16);
sprom[cnt++] = swab16((u16)parsed);
}
return 0;
}
static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev, static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev,
struct device_attribute *attr, struct device_attribute *attr,
char *buf) char *buf)
{ {
struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev); struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
struct ssb_bus *bus; struct ssb_bus *bus;
u16 *sprom;
int err = -ENODEV;
ssize_t count = 0;
bus = ssb_pci_dev_to_bus(pdev); bus = ssb_pci_dev_to_bus(pdev);
if (!bus) if (!bus)
goto out; return -ENODEV;
err = -ENOMEM;
sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
if (!sprom)
goto out;
/* Use interruptible locking, as the SPROM write might return ssb_attr_sprom_show(bus, buf, sprom_do_read);
* be holding the lock for several seconds. So allow userspace
* to cancel operation. */
err = -ERESTARTSYS;
if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
goto out_kfree;
sprom_do_read(bus, sprom);
mutex_unlock(&bus->pci_sprom_mutex);
count = sprom2hex(sprom, buf, PAGE_SIZE, bus->sprom_size);
err = 0;
out_kfree:
kfree(sprom);
out:
return err ? err : count;
} }
static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev, static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev,
@ -733,55 +682,13 @@ static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev,
{ {
struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev); struct pci_dev *pdev = container_of(pcidev, struct pci_dev, dev);
struct ssb_bus *bus; struct ssb_bus *bus;
u16 *sprom;
int res = 0, err = -ENODEV;
bus = ssb_pci_dev_to_bus(pdev); bus = ssb_pci_dev_to_bus(pdev);
if (!bus) if (!bus)
goto out; return -ENODEV;
err = -ENOMEM;
sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
if (!sprom)
goto out;
err = hex2sprom(sprom, buf, count, bus->sprom_size);
if (err) {
err = -EINVAL;
goto out_kfree;
}
err = sprom_check_crc(sprom, bus->sprom_size);
if (err) {
err = -EINVAL;
goto out_kfree;
}
/* Use interruptible locking, as the SPROM write might return ssb_attr_sprom_store(bus, buf, count,
* be holding the lock for several seconds. So allow userspace sprom_check_crc, sprom_do_write);
* to cancel operation. */
err = -ERESTARTSYS;
if (mutex_lock_interruptible(&bus->pci_sprom_mutex))
goto out_kfree;
err = ssb_devices_freeze(bus);
if (err == -EOPNOTSUPP) {
ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. "
"No suspend support. Is CONFIG_PM enabled?\n");
goto out_unlock;
}
if (err) {
ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n");
goto out_unlock;
}
res = sprom_do_write(bus, sprom);
err = ssb_devices_thaw(bus);
if (err)
ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n");
out_unlock:
mutex_unlock(&bus->pci_sprom_mutex);
out_kfree:
kfree(sprom);
out:
if (res)
return res;
return err ? err : count;
} }
static DEVICE_ATTR(ssb_sprom, 0600, static DEVICE_ATTR(ssb_sprom, 0600,
@ -808,7 +715,7 @@ int ssb_pci_init(struct ssb_bus *bus)
return 0; return 0;
pdev = bus->host_pci; pdev = bus->host_pci;
mutex_init(&bus->pci_sprom_mutex); mutex_init(&bus->sprom_mutex);
err = device_create_file(&pdev->dev, &dev_attr_ssb_sprom); err = device_create_file(&pdev->dev, &dev_attr_ssb_sprom);
if (err) if (err)
goto out; goto out;

518
drivers/ssb/pcmcia.c
View File

@ -3,7 +3,7 @@
* PCMCIA-Hostbus related functions * PCMCIA-Hostbus related functions
* *
* Copyright 2006 Johannes Berg <johannes@sipsolutions.net> * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
* Copyright 2007 Michael Buesch <mb@bu3sch.de> * Copyright 2007-2008 Michael Buesch <mb@bu3sch.de>
* *
* Licensed under the GNU/GPL. See COPYING for details. * Licensed under the GNU/GPL. See COPYING for details.
*/ */
@ -11,6 +11,7 @@
#include <linux/ssb/ssb.h> #include <linux/ssb/ssb.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/io.h> #include <linux/io.h>
#include <linux/etherdevice.h>
#include <pcmcia/cs_types.h> #include <pcmcia/cs_types.h>
#include <pcmcia/cs.h> #include <pcmcia/cs.h>
@ -26,59 +27,132 @@
#define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0 #define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0
/* PCMCIA configuration registers */
#define SSB_PCMCIA_CORECTL 0x00
#define SSB_PCMCIA_CORECTL_RESET 0x80 /* Core reset */
#define SSB_PCMCIA_CORECTL_IRQEN 0x04 /* IRQ enable */
#define SSB_PCMCIA_CORECTL_FUNCEN 0x01 /* Function enable */
#define SSB_PCMCIA_CORECTL2 0x80
#define SSB_PCMCIA_ADDRESS0 0x2E
#define SSB_PCMCIA_ADDRESS1 0x30
#define SSB_PCMCIA_ADDRESS2 0x32
#define SSB_PCMCIA_MEMSEG 0x34
#define SSB_PCMCIA_SPROMCTL 0x36
#define SSB_PCMCIA_SPROMCTL_IDLE 0
#define SSB_PCMCIA_SPROMCTL_WRITE 1
#define SSB_PCMCIA_SPROMCTL_READ 2
#define SSB_PCMCIA_SPROMCTL_WRITEEN 4
#define SSB_PCMCIA_SPROMCTL_WRITEDIS 7
#define SSB_PCMCIA_SPROMCTL_DONE 8
#define SSB_PCMCIA_SPROM_DATALO 0x38
#define SSB_PCMCIA_SPROM_DATAHI 0x3A
#define SSB_PCMCIA_SPROM_ADDRLO 0x3C
#define SSB_PCMCIA_SPROM_ADDRHI 0x3E
/* Hardware invariants CIS tuples */
#define SSB_PCMCIA_CIS 0x80
#define SSB_PCMCIA_CIS_ID 0x01
#define SSB_PCMCIA_CIS_BOARDREV 0x02
#define SSB_PCMCIA_CIS_PA 0x03
#define SSB_PCMCIA_CIS_PA_PA0B0_LO 0
#define SSB_PCMCIA_CIS_PA_PA0B0_HI 1
#define SSB_PCMCIA_CIS_PA_PA0B1_LO 2
#define SSB_PCMCIA_CIS_PA_PA0B1_HI 3
#define SSB_PCMCIA_CIS_PA_PA0B2_LO 4
#define SSB_PCMCIA_CIS_PA_PA0B2_HI 5
#define SSB_PCMCIA_CIS_PA_ITSSI 6
#define SSB_PCMCIA_CIS_PA_MAXPOW 7
#define SSB_PCMCIA_CIS_OEMNAME 0x04
#define SSB_PCMCIA_CIS_CCODE 0x05
#define SSB_PCMCIA_CIS_ANTENNA 0x06
#define SSB_PCMCIA_CIS_ANTGAIN 0x07
#define SSB_PCMCIA_CIS_BFLAGS 0x08
#define SSB_PCMCIA_CIS_LEDS 0x09
/* PCMCIA SPROM size. */
#define SSB_PCMCIA_SPROM_SIZE 256
#define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16))
/* Write to a PCMCIA configuration register. */
static int ssb_pcmcia_cfg_write(struct ssb_bus *bus, u8 offset, u8 value)
{
conf_reg_t reg;
int res;
memset(&reg, 0, sizeof(reg));
reg.Offset = offset;
reg.Action = CS_WRITE;
reg.Value = value;
res = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
if (unlikely(res != CS_SUCCESS))
return -EBUSY;
return 0;
}
/* Read from a PCMCIA configuration register. */
static int ssb_pcmcia_cfg_read(struct ssb_bus *bus, u8 offset, u8 *value)
{
conf_reg_t reg;
int res;
memset(&reg, 0, sizeof(reg));
reg.Offset = offset;
reg.Action = CS_READ;
res = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
if (unlikely(res != CS_SUCCESS))
return -EBUSY;
*value = reg.Value;
return 0;
}
int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus, int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
u8 coreidx) u8 coreidx)
{ {
struct pcmcia_device *pdev = bus->host_pcmcia;
int err; int err;
int attempts = 0; int attempts = 0;
u32 cur_core; u32 cur_core;
conf_reg_t reg;
u32 addr; u32 addr;
u32 read_addr; u32 read_addr;
u8 val;
addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
while (1) { while (1) {
reg.Action = CS_WRITE; err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS0,
reg.Offset = 0x2E; (addr & 0x0000F000) >> 12);
reg.Value = (addr & 0x0000F000) >> 12; if (err)
err = pcmcia_access_configuration_register(pdev, &reg);
if (err != CS_SUCCESS)
goto error; goto error;
reg.Offset = 0x30; err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS1,
reg.Value = (addr & 0x00FF0000) >> 16; (addr & 0x00FF0000) >> 16);
err = pcmcia_access_configuration_register(pdev, &reg); if (err)
if (err != CS_SUCCESS)
goto error; goto error;
reg.Offset = 0x32; err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS2,
reg.Value = (addr & 0xFF000000) >> 24; (addr & 0xFF000000) >> 24);
err = pcmcia_access_configuration_register(pdev, &reg); if (err)
if (err != CS_SUCCESS)
goto error; goto error;
read_addr = 0; read_addr = 0;
reg.Action = CS_READ; err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS0, &val);
reg.Offset = 0x2E; if (err)
err = pcmcia_access_configuration_register(pdev, &reg);
if (err != CS_SUCCESS)
goto error; goto error;
read_addr |= ((u32)(reg.Value & 0x0F)) << 12; read_addr |= ((u32)(val & 0x0F)) << 12;
reg.Offset = 0x30; err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS1, &val);
err = pcmcia_access_configuration_register(pdev, &reg); if (err)
if (err != CS_SUCCESS)
goto error; goto error;
read_addr |= ((u32)reg.Value) << 16; read_addr |= ((u32)val) << 16;
reg.Offset = 0x32; err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS2, &val);
err = pcmcia_access_configuration_register(pdev, &reg); if (err)
if (err != CS_SUCCESS)
goto error; goto error;
read_addr |= ((u32)reg.Value) << 24; read_addr |= ((u32)val) << 24;
cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE; cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE;
if (cur_core == coreidx) if (cur_core == coreidx)
break; break;
err = -ETIMEDOUT;
if (attempts++ > SSB_BAR0_MAX_RETRIES) if (attempts++ > SSB_BAR0_MAX_RETRIES)
goto error; goto error;
udelay(10); udelay(10);
@ -87,7 +161,7 @@ int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
return 0; return 0;
error: error:
ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx); ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx);
return -ENODEV; return err;
} }
int ssb_pcmcia_switch_core(struct ssb_bus *bus, int ssb_pcmcia_switch_core(struct ssb_bus *bus,
@ -112,27 +186,21 @@ int ssb_pcmcia_switch_core(struct ssb_bus *bus,
int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg) int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
{ {
int attempts = 0; int attempts = 0;
conf_reg_t reg; int err;
int res; u8 val;
SSB_WARN_ON((seg != 0) && (seg != 1)); SSB_WARN_ON((seg != 0) && (seg != 1));
reg.Offset = 0x34;
reg.Function = 0;
while (1) { while (1) {
reg.Action = CS_WRITE; err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_MEMSEG, seg);
reg.Value = seg; if (err)
res = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
if (unlikely(res != CS_SUCCESS))
goto error; goto error;
reg.Value = 0xFF; err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_MEMSEG, &val);
reg.Action = CS_READ; if (err)
res = pcmcia_access_configuration_register(bus->host_pcmcia, &reg);
if (unlikely(res != CS_SUCCESS))
goto error; goto error;
if (val == seg)
if (reg.Value == seg)
break; break;
err = -ETIMEDOUT;
if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES)) if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES))
goto error; goto error;
udelay(10); udelay(10);
@ -142,7 +210,7 @@ int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg)
return 0; return 0;
error: error:
ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n"); ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n");
return -ENODEV; return err;
} }
static int select_core_and_segment(struct ssb_device *dev, static int select_core_and_segment(struct ssb_device *dev,
@ -276,18 +344,344 @@ const struct ssb_bus_ops ssb_pcmcia_ops = {
.write32 = ssb_pcmcia_write32, .write32 = ssb_pcmcia_write32,
}; };
#include <linux/etherdevice.h> static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command)
{
unsigned int i;
int err;
u8 value;
err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command);
if (err)
return err;
for (i = 0; i < 1000; i++) {
err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value);
if (err)
return err;
if (value & SSB_PCMCIA_SPROMCTL_DONE)
return 0;
udelay(10);
}
return -ETIMEDOUT;
}
/* offset is the 16bit word offset */
static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value)
{
int err;
u8 lo, hi;
offset *= 2; /* Make byte offset */
err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
(offset & 0x00FF));
if (err)
return err;
err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
(offset & 0xFF00) >> 8);
if (err)
return err;
err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ);
if (err)
return err;
err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo);
if (err)
return err;
err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi);
if (err)
return err;
*value = (lo | (((u16)hi) << 8));
return 0;
}
/* offset is the 16bit word offset */
static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value)
{
int err;
offset *= 2; /* Make byte offset */
err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO,
(offset & 0x00FF));
if (err)
return err;
err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI,
(offset & 0xFF00) >> 8);
if (err)
return err;
err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO,
(value & 0x00FF));
if (err)
return err;
err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI,
(value & 0xFF00) >> 8);
if (err)
return err;
err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE);
if (err)
return err;
msleep(20);
return 0;
}
/* Read the SPROM image. bufsize is in 16bit words. */
static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom)
{
int err, i;
for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) {
err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]);
if (err)
return err;
}
return 0;
}
/* Write the SPROM image. size is in 16bit words. */
static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom)
{
int i, err;
bool failed = 0;
size_t size = SSB_PCMCIA_SPROM_SIZE;
ssb_printk(KERN_NOTICE PFX
"Writing SPROM. Do NOT turn off the power! "
"Please stand by...\n");
err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN);
if (err) {
ssb_printk(KERN_NOTICE PFX
"Could not enable SPROM write access.\n");
return -EBUSY;
}
ssb_printk(KERN_NOTICE PFX "[ 0%%");
msleep(500);
for (i = 0; i < size; i++) {
if (i == size / 4)
ssb_printk("25%%");
else if (i == size / 2)
ssb_printk("50%%");
else if (i == (size * 3) / 4)
ssb_printk("75%%");
else if (i % 2)
ssb_printk(".");
err = ssb_pcmcia_sprom_write(bus, i, sprom[i]);
if (err) {
ssb_printk("\n" KERN_NOTICE PFX
"Failed to write to SPROM.\n");
failed = 1;
break;
}
}
err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS);
if (err) {
ssb_printk("\n" KERN_NOTICE PFX
"Could not disable SPROM write access.\n");
failed = 1;
}
msleep(500);
if (!failed) {
ssb_printk("100%% ]\n");
ssb_printk(KERN_NOTICE PFX "SPROM written.\n");
}
return failed ? -EBUSY : 0;
}
static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
{
//TODO
return 0;
}
#define GOTO_ERROR_ON(condition, description) do { \
if (unlikely(condition)) { \
error_description = description; \
goto error; \
} \
} while (0)
int ssb_pcmcia_get_invariants(struct ssb_bus *bus, int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
struct ssb_init_invariants *iv) struct ssb_init_invariants *iv)
{ {
//TODO tuple_t tuple;
random_ether_addr(iv->sprom.il0mac); int res;
unsigned char buf[32];
struct ssb_sprom *sprom = &iv->sprom;
struct ssb_boardinfo *bi = &iv->boardinfo;
const char *error_description;
memset(sprom, 0xFF, sizeof(*sprom));
sprom->revision = 1;
sprom->boardflags_lo = 0;
sprom->boardflags_hi = 0;
/* First fetch the MAC address. */
memset(&tuple, 0, sizeof(tuple));
tuple.DesiredTuple = CISTPL_FUNCE;
tuple.TupleData = buf;
tuple.TupleDataMax = sizeof(buf);
res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
GOTO_ERROR_ON(res != CS_SUCCESS, "MAC first tpl");
res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
GOTO_ERROR_ON(res != CS_SUCCESS, "MAC first tpl data");
while (1) {
GOTO_ERROR_ON(tuple.TupleDataLen < 1, "MAC tpl < 1");
if (tuple.TupleData[0] == CISTPL_FUNCE_LAN_NODE_ID)
break;
res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
GOTO_ERROR_ON(res != CS_SUCCESS, "MAC next tpl");
res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
GOTO_ERROR_ON(res != CS_SUCCESS, "MAC next tpl data");
}
GOTO_ERROR_ON(tuple.TupleDataLen != ETH_ALEN + 2, "MAC tpl size");
memcpy(sprom->il0mac, &tuple.TupleData[2], ETH_ALEN);
/* Fetch the vendor specific tuples. */
memset(&tuple, 0, sizeof(tuple));
tuple.DesiredTuple = SSB_PCMCIA_CIS;
tuple.TupleData = buf;
tuple.TupleDataMax = sizeof(buf);
res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
GOTO_ERROR_ON(res != CS_SUCCESS, "VEN first tpl");
res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
GOTO_ERROR_ON(res != CS_SUCCESS, "VEN first tpl data");
while (1) {
GOTO_ERROR_ON(tuple.TupleDataLen < 1, "VEN tpl < 1");
switch (tuple.TupleData[0]) {
case SSB_PCMCIA_CIS_ID:
GOTO_ERROR_ON((tuple.TupleDataLen != 5) &&
(tuple.TupleDataLen != 7),
"id tpl size");
bi->vendor = tuple.TupleData[1] |
((u16)tuple.TupleData[2] << 8);
break;
case SSB_PCMCIA_CIS_BOARDREV:
GOTO_ERROR_ON(tuple.TupleDataLen != 2,
"boardrev tpl size");
sprom->board_rev = tuple.TupleData[1];
break;
case SSB_PCMCIA_CIS_PA:
GOTO_ERROR_ON(tuple.TupleDataLen != 9,
"pa tpl size");
sprom->pa0b0 = tuple.TupleData[1] |
((u16)tuple.TupleData[2] << 8);
sprom->pa0b1 = tuple.TupleData[3] |
((u16)tuple.TupleData[4] << 8);
sprom->pa0b2 = tuple.TupleData[5] |
((u16)tuple.TupleData[6] << 8);
sprom->itssi_a = tuple.TupleData[7];
sprom->itssi_bg = tuple.TupleData[7];
sprom->maxpwr_a = tuple.TupleData[8];
sprom->maxpwr_bg = tuple.TupleData[8];
break;
case SSB_PCMCIA_CIS_OEMNAME:
/* We ignore this. */
break;
case SSB_PCMCIA_CIS_CCODE:
GOTO_ERROR_ON(tuple.TupleDataLen != 2,
"ccode tpl size");
sprom->country_code = tuple.TupleData[1];
break;
case SSB_PCMCIA_CIS_ANTENNA:
GOTO_ERROR_ON(tuple.TupleDataLen != 2,
"ant tpl size");
sprom->ant_available_a = tuple.TupleData[1];
sprom->ant_available_bg = tuple.TupleData[1];
break;
case SSB_PCMCIA_CIS_ANTGAIN:
GOTO_ERROR_ON(tuple.TupleDataLen != 2,
"antg tpl size");
sprom->antenna_gain.ghz24.a0 = tuple.TupleData[1];
sprom->antenna_gain.ghz24.a1 = tuple.TupleData[1];
sprom->antenna_gain.ghz24.a2 = tuple.TupleData[1];
sprom->antenna_gain.ghz24.a3 = tuple.TupleData[1];
sprom->antenna_gain.ghz5.a0 = tuple.TupleData[1];
sprom->antenna_gain.ghz5.a1 = tuple.TupleData[1];
sprom->antenna_gain.ghz5.a2 = tuple.TupleData[1];
sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1];
break;
case SSB_PCMCIA_CIS_BFLAGS:
GOTO_ERROR_ON(tuple.TupleDataLen != 3,
"bfl tpl size");
sprom->boardflags_lo = tuple.TupleData[1] |
((u16)tuple.TupleData[2] << 8);
break;
case SSB_PCMCIA_CIS_LEDS:
GOTO_ERROR_ON(tuple.TupleDataLen != 5,
"leds tpl size");
sprom->gpio0 = tuple.TupleData[1];
sprom->gpio1 = tuple.TupleData[2];
sprom->gpio2 = tuple.TupleData[3];
sprom->gpio3 = tuple.TupleData[4];
break;
}
res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
if (res == CS_NO_MORE_ITEMS)
break;
GOTO_ERROR_ON(res != CS_SUCCESS, "VEN next tpl");
res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
GOTO_ERROR_ON(res != CS_SUCCESS, "VEN next tpl data");
}
return 0; return 0;
error:
ssb_printk(KERN_ERR PFX
"PCMCIA: Failed to fetch device invariants: %s\n",
error_description);
return -ENODEV;
}
static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev,
struct device_attribute *attr,
char *buf)
{
struct pcmcia_device *pdev =
container_of(pcmciadev, struct pcmcia_device, dev);
struct ssb_bus *bus;
bus = ssb_pcmcia_dev_to_bus(pdev);
if (!bus)
return -ENODEV;
return ssb_attr_sprom_show(bus, buf,
ssb_pcmcia_sprom_read_all);
}
static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct pcmcia_device *pdev =
container_of(pcmciadev, struct pcmcia_device, dev);
struct ssb_bus *bus;
bus = ssb_pcmcia_dev_to_bus(pdev);
if (!bus)
return -ENODEV;
return ssb_attr_sprom_store(bus, buf, count,
ssb_pcmcia_sprom_check_crc,
ssb_pcmcia_sprom_write_all);
}
static DEVICE_ATTR(ssb_sprom, 0600,
ssb_pcmcia_attr_sprom_show,
ssb_pcmcia_attr_sprom_store);
void ssb_pcmcia_exit(struct ssb_bus *bus)
{
if (bus->bustype != SSB_BUSTYPE_PCMCIA)
return;
device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
} }
int ssb_pcmcia_init(struct ssb_bus *bus) int ssb_pcmcia_init(struct ssb_bus *bus)
{ {
conf_reg_t reg; u8 val, offset;
int err; int err;
if (bus->bustype != SSB_BUSTYPE_PCMCIA) if (bus->bustype != SSB_BUSTYPE_PCMCIA)
@ -298,22 +692,26 @@ int ssb_pcmcia_init(struct ssb_bus *bus)
ssb_pcmcia_switch_segment(bus, 0); ssb_pcmcia_switch_segment(bus, 0);
/* Init IRQ routing */ /* Init IRQ routing */
reg.Action = CS_READ;
reg.Function = 0;
if (bus->chip_id == 0x4306) if (bus->chip_id == 0x4306)
reg.Offset = 0x00; offset = SSB_PCMCIA_CORECTL;
else else
reg.Offset = 0x80; offset = SSB_PCMCIA_CORECTL2;
err = pcmcia_access_configuration_register(bus->host_pcmcia, &reg); err = ssb_pcmcia_cfg_read(bus, offset, &val);
if (err != CS_SUCCESS) if (err)
goto error; goto error;
reg.Action = CS_WRITE; val |= SSB_PCMCIA_CORECTL_IRQEN | SSB_PCMCIA_CORECTL_FUNCEN;
reg.Value |= 0x04 | 0x01; err = ssb_pcmcia_cfg_write(bus, offset, val);
err = pcmcia_access_configuration_register(bus->host_pcmcia, &reg); if (err)
if (err != CS_SUCCESS) goto error;
bus->sprom_size = SSB_PCMCIA_SPROM_SIZE;
mutex_init(&bus->sprom_mutex);
err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom);
if (err)
goto error; goto error;
return 0; return 0;
error: error:
return -ENODEV; ssb_printk(KERN_ERR PFX "Failed to initialize PCMCIA host device\n");
return err;
} }

133
drivers/ssb/sprom.c Normal file
View File

@ -0,0 +1,133 @@
/*
* Sonics Silicon Backplane
* Common SPROM support routines
*
* Copyright (C) 2005-2008 Michael Buesch <mb@bu3sch.de>
* Copyright (C) 2005 Martin Langer <martin-langer@gmx.de>
* Copyright (C) 2005 Stefano Brivio <st3@riseup.net>
* Copyright (C) 2005 Danny van Dyk <kugelfang@gentoo.org>
* Copyright (C) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
*
* Licensed under the GNU/GPL. See COPYING for details.
*/
#include "ssb_private.h"
static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len,
size_t sprom_size_words)
{
int i, pos = 0;
for (i = 0; i < sprom_size_words; i++)
pos += snprintf(buf + pos, buf_len - pos - 1,
"%04X", swab16(sprom[i]) & 0xFFFF);
pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
return pos + 1;
}
static int hex2sprom(u16 *sprom, const char *dump, size_t len,
size_t sprom_size_words)
{
char tmp[5] = { 0 };
int cnt = 0;
unsigned long parsed;
if (len < sprom_size_words * 2)
return -EINVAL;
while (cnt < sprom_size_words) {
memcpy(tmp, dump, 4);
dump += 4;
parsed = simple_strtoul(tmp, NULL, 16);
sprom[cnt++] = swab16((u16)parsed);
}
return 0;
}
/* Common sprom device-attribute show-handler */
ssize_t ssb_attr_sprom_show(struct ssb_bus *bus, char *buf,
int (*sprom_read)(struct ssb_bus *bus, u16 *sprom))
{
u16 *sprom;
int err = -ENOMEM;
ssize_t count = 0;
size_t sprom_size_words = bus->sprom_size;
sprom = kcalloc(sprom_size_words, sizeof(u16), GFP_KERNEL);
if (!sprom)
goto out;
/* Use interruptible locking, as the SPROM write might
* be holding the lock for several seconds. So allow userspace
* to cancel operation. */
err = -ERESTARTSYS;
if (mutex_lock_interruptible(&bus->sprom_mutex))
goto out_kfree;
err = sprom_read(bus, sprom);
mutex_unlock(&bus->sprom_mutex);
if (!err)
count = sprom2hex(sprom, buf, PAGE_SIZE, sprom_size_words);
out_kfree:
kfree(sprom);
out:
return err ? err : count;
}
/* Common sprom device-attribute store-handler */
ssize_t ssb_attr_sprom_store(struct ssb_bus *bus,
const char *buf, size_t count,
int (*sprom_check_crc)(const u16 *sprom, size_t size),
int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom))
{
u16 *sprom;
int res = 0, err = -ENOMEM;
size_t sprom_size_words = bus->sprom_size;
sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
if (!sprom)
goto out;
err = hex2sprom(sprom, buf, count, sprom_size_words);
if (err) {
err = -EINVAL;
goto out_kfree;
}
err = sprom_check_crc(sprom, sprom_size_words);
if (err) {
err = -EINVAL;
goto out_kfree;
}
/* Use interruptible locking, as the SPROM write might
* be holding the lock for several seconds. So allow userspace
* to cancel operation. */
err = -ERESTARTSYS;
if (mutex_lock_interruptible(&bus->sprom_mutex))
goto out_kfree;
err = ssb_devices_freeze(bus);
if (err == -EOPNOTSUPP) {
ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. "
"No suspend support. Is CONFIG_PM enabled?\n");
goto out_unlock;
}
if (err) {
ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n");
goto out_unlock;
}
res = sprom_write(bus, sprom);
err = ssb_devices_thaw(bus);
if (err)
ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n");
out_unlock:
mutex_unlock(&bus->sprom_mutex);
out_kfree:
kfree(sprom);
out:
if (res)
return res;
return err ? err : count;
}

17
drivers/ssb/ssb_private.h
View File

@ -81,6 +81,7 @@ extern int ssb_pcmcia_switch_segment(struct ssb_bus *bus,
u8 seg); u8 seg);
extern int ssb_pcmcia_get_invariants(struct ssb_bus *bus, extern int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
struct ssb_init_invariants *iv); struct ssb_init_invariants *iv);
extern void ssb_pcmcia_exit(struct ssb_bus *bus);
extern int ssb_pcmcia_init(struct ssb_bus *bus); extern int ssb_pcmcia_init(struct ssb_bus *bus);
extern const struct ssb_bus_ops ssb_pcmcia_ops; extern const struct ssb_bus_ops ssb_pcmcia_ops;
#else /* CONFIG_SSB_PCMCIAHOST */ #else /* CONFIG_SSB_PCMCIAHOST */
@ -99,6 +100,9 @@ static inline int ssb_pcmcia_switch_segment(struct ssb_bus *bus,
{ {
return 0; return 0;
} }
static inline void ssb_pcmcia_exit(struct ssb_bus *bus)
{
}
static inline int ssb_pcmcia_init(struct ssb_bus *bus) static inline int ssb_pcmcia_init(struct ssb_bus *bus)
{ {
return 0; return 0;
@ -113,6 +117,17 @@ extern int ssb_bus_scan(struct ssb_bus *bus,
extern void ssb_iounmap(struct ssb_bus *ssb); extern void ssb_iounmap(struct ssb_bus *ssb);
/* sprom.c */
extern
ssize_t ssb_attr_sprom_show(struct ssb_bus *bus, char *buf,
int (*sprom_read)(struct ssb_bus *bus, u16 *sprom));
extern
ssize_t ssb_attr_sprom_store(struct ssb_bus *bus,
const char *buf, size_t count,
int (*sprom_check_crc)(const u16 *sprom, size_t size),
int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom));
/* core.c */ /* core.c */
extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m); extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m);
extern int ssb_devices_freeze(struct ssb_bus *bus); extern int ssb_devices_freeze(struct ssb_bus *bus);
@ -120,6 +135,8 @@ extern int ssb_devices_thaw(struct ssb_bus *bus);
extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev); extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev);
int ssb_for_each_bus_call(unsigned long data, int ssb_for_each_bus_call(unsigned long data,
int (*func)(struct ssb_bus *bus, unsigned long data)); int (*func)(struct ssb_bus *bus, unsigned long data));
extern struct ssb_bus *ssb_pcmcia_dev_to_bus(struct pcmcia_device *pdev);
/* b43_pci_bridge.c */ /* b43_pci_bridge.c */
#ifdef CONFIG_SSB_B43_PCI_BRIDGE #ifdef CONFIG_SSB_B43_PCI_BRIDGE

4
include/linux/ssb/ssb.h
View File

@ -245,9 +245,9 @@ struct ssb_bus {
/* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */
struct pcmcia_device *host_pcmcia; struct pcmcia_device *host_pcmcia;
#ifdef CONFIG_SSB_PCIHOST #ifdef CONFIG_SSB_SPROM
/* Mutex to protect the SPROM writing. */ /* Mutex to protect the SPROM writing. */
struct mutex pci_sprom_mutex; struct mutex sprom_mutex;
#endif #endif
/* ID information about the Chip. */ /* ID information about the Chip. */