Attachment #142982 for bug #207532

Lines 27-32 static const struct pci_device_id b43_pci_bridge_tbl[] = { Link Here

(-)a/drivers/ssb/b43_pci_bridge.c (+1 lines)
27	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4321) },	27	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4321) },
28	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4324) },	28	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4324) },
29	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4325) },	29	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4325) },
		30	{ PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4328) },
30	{ 0, },	31	{ 0, },
31	};	32	};
32	MODULE_DEVICE_TABLE(pci, b43_pci_bridge_tbl);	33	MODULE_DEVICE_TABLE(pci, b43_pci_bridge_tbl);

Lines 872-885 EXPORT_SYMBOL(ssb_clockspeed); Link Here

(-)a/drivers/ssb/main.c (-1 / +9 lines)
872		872
873	static u32 ssb_tmslow_reject_bitmask(struct ssb_device *dev)	873	static u32 ssb_tmslow_reject_bitmask(struct ssb_device *dev)
874	{	874	{
		875	u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV;
		876
875	/* The REJECT bit changed position in TMSLOW between	877	/* The REJECT bit changed position in TMSLOW between
876	* Backplane revisions. */	878	* Backplane revisions. */
877	switch (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV) {	879	switch (rev) {
878	case SSB_IDLOW_SSBREV_22:	880	case SSB_IDLOW_SSBREV_22:
879	return SSB_TMSLOW_REJECT_22;	881	return SSB_TMSLOW_REJECT_22;
880	case SSB_IDLOW_SSBREV_23:	882	case SSB_IDLOW_SSBREV_23:
881	return SSB_TMSLOW_REJECT_23;	883	return SSB_TMSLOW_REJECT_23;
		884	case SSB_IDLOW_SSBREV_24: /* TODO - find the proper REJECT bits */
		885	case SSB_IDLOW_SSBREV_25: /* same here */
		886	case SSB_IDLOW_SSBREV_26: /* same here */
		887	case SSB_IDLOW_SSBREV_27: /* same here */
		888	return SSB_TMSLOW_REJECT_23; /* this is a guess */
882	default:	889	default:
		890	printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev);
883	WARN_ON(1);	891	WARN_ON(1);
884	}	892	}
885	return (SSB_TMSLOW_REJECT_22 \| SSB_TMSLOW_REJECT_23);	893	return (SSB_TMSLOW_REJECT_22 \| SSB_TMSLOW_REJECT_23);




	return t[crc ^ data];
}

static u8 ssb_sprom_crc(const u16 *sprom, u16 size)
{
	int word;
	u8 crc = 0xFF;

	for (word = 0; word < size - 1; word++) {
		crc = ssb_crc8(crc, sprom[word] & 0x00FF);
		crc = ssb_crc8(crc, (sprom[word] & 0xFF00) >> 8);
	}
	crc = ssb_crc8(crc, sprom[size - 1] & 0x00FF);
	crc ^= 0xFF;

	return crc;
}

static int sprom_check_crc(const u16 *sprom, u16 size)
{
	u8 crc;
	u8 expected_crc;
	u16 tmp;

	crc = ssb_sprom_crc(sprom, size);
	tmp = sprom[size - 1] & SSB_SPROM_REVISION_CRC;
	expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
	if (crc != expected_crc)
		return -EPROTO;

{
	int i;

	for (i = 0; i < bus->sprom_size; i++)
		sprom[i] = readw(bus->mmio + SSB_SPROM_BASE + (i * 2));
}


	struct pci_dev *pdev = bus->host_pci;
	int i, err;
	u32 spromctl;
	u16 size = bus->sprom_size;

	ssb_printk(KERN_NOTICE PFX "Writing SPROM. Do NOT turn off the power! Please stand by...\n");
	err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);

		goto err_ctlreg;
	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(".");

	SPEX(antenna_gain_a, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_A, 0);
	SPEX(antenna_gain_bg, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_BG,
	     SSB_SPROM1_AGAIN_BG_SHIFT);
	for (i = 0; i < 4; i++) {
		v = in[SPOFF(SSB_SPROM1_OEM) + i];
		*(((__le16 *)out->oem) + i) = cpu_to_le16(v);
	}
}

static void sprom_extract_r123(struct ssb_sprom *out, const u16 *in)
{
	int i;
	u16 v;
	u16 loc[3];

	if (out->revision == 3) {			/* rev 3 moved MAC */
		loc[0] = SSB_SPROM3_IL0MAC;
		loc[1] = SSB_SPROM3_ET0MAC;
		loc[2] = SSB_SPROM3_ET1MAC;
	} else {
		loc[0] = SSB_SPROM1_IL0MAC;
		loc[1] = SSB_SPROM1_ET0MAC;
		loc[2] = SSB_SPROM1_ET1MAC;
	}
	for (i = 0; i < 3; i++) {
		v = in[SPOFF(loc[0]) + i];
		*(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
	}
	for (i = 0; i < 3; i++) {
		v = in[SPOFF(loc[1]) + i];
		*(((__be16 *)out->et0mac) + i) = cpu_to_be16(v);
	}
	for (i = 0; i < 3; i++) {
		v = in[SPOFF(loc[2]) + i];
		*(((__be16 *)out->et1mac) + i) = cpu_to_be16(v);
	}
	SPEX(et0phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0A, 0);
	SPEX(et1phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1A,
	     SSB_SPROM1_ETHPHY_ET1A_SHIFT);
	SPEX(country_code, SSB_SPROM1_BINF, SSB_SPROM1_BINF_CCODE,
	     SSB_SPROM1_BINF_CCODE_SHIFT);
	SPEX(pa0b0, SSB_SPROM1_PA0B0, 0xFFFF, 0);
	SPEX(pa0b1, SSB_SPROM1_PA0B1, 0xFFFF, 0);
	SPEX(pa0b2, SSB_SPROM1_PA0B2, 0xFFFF, 0);
	SPEX(pa1b0, SSB_SPROM1_PA1B0, 0xFFFF, 0);
	SPEX(pa1b1, SSB_SPROM1_PA1B1, 0xFFFF, 0);
	SPEX(pa1b2, SSB_SPROM1_PA1B2, 0xFFFF, 0);
	SPEX(gpio0, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P0, 0);
	SPEX(gpio1, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P1,
	     SSB_SPROM1_GPIOA_P1_SHIFT);
	SPEX(gpio2, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P2, 0);
	SPEX(gpio3, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P3,
	     SSB_SPROM1_GPIOB_P3_SHIFT);
	SPEX(maxpwr_a, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_A,
	     SSB_SPROM1_MAXPWR_A_SHIFT);
	SPEX(maxpwr_bg, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_BG, 0);
	SPEX(itssi_a, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_A,
	     SSB_SPROM1_ITSSI_A_SHIFT);
	SPEX(itssi_bg, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_BG, 0);
	SPEX(boardflags_lo, SSB_SPROM1_BFLLO, 0xFFFF, 0);
	SPEX(antenna_gain_a, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_A, 0);
	SPEX(antenna_gain_bg, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_BG,
	     SSB_SPROM1_AGAIN_BG_SHIFT);
}

static void sprom_extract_r4(struct ssb_sprom *out, const u16 *in)
{
	int i;
	u16 v;

	/* extract the r1 variables */
	for (i = 0; i < 3; i++) {
		v = in[SPOFF(SSB_SPROM4_IL0MAC) + i];
		*(((__be16 *)out->il0mac) + i) = cpu_to_be16(v);
	}
	for (i = 0; i < 3; i++) {
		v = in[SPOFF(SSB_SPROM4_ET0MAC) + i];
		*(((__be16 *)out->et0mac) + i) = cpu_to_be16(v);
	}
	for (i = 0; i < 3; i++) {
		v = in[SPOFF(SSB_SPROM4_ET1MAC) + i];
		*(((__be16 *)out->et1mac) + i) = cpu_to_be16(v);
	}
	SPEX(et0phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET0A, 0);
	SPEX(et1phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET1A,
	     SSB_SPROM4_ETHPHY_ET1A_SHIFT);
	SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0);
	SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0);
	SPEX(antenna_gain_a, SSB_SPROM4_AGAIN, SSB_SPROM4_AGAIN_0, 0);
	SPEX(antenna_gain_bg, SSB_SPROM4_AGAIN, SSB_SPROM4_AGAIN_1,
	     SSB_SPROM4_AGAIN_1_SHIFT);
	/* TODO - get remaining rev 4 stuff needed */
	SPEX(cckpo_55M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_55M,
	     SSB_SPROM3_CCKPO_55M_SHIFT);
	SPEX(cckpo_11M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_11M,
	     SSB_SPROM3_CCKPO_11M_SHIFT);

	out->ofdmgpo  = (in[SPOFF(SSB_SPROM3_OFDMGPO) + 0] & 0xFF00) >> 8;
	out->ofdmgpo |= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 0] & 0x00FF) << 8;
	out->ofdmgpo <<= 16;
	out->ofdmgpo |= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 1] & 0xFF00) >> 8;
	out->ofdmgpo |= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 1] & 0x00FF) << 8;
}

static int sprom_extract(struct ssb_bus *bus, struct ssb_sprom *out,
			 const u16 *in, u16 size)
{
	memset(out, 0, sizeof(*out));

	out->revision = in[size - 1] & 0x00FF;

	if ((bus->chip_id & 0xFF00) == 0x4400) {
		/* Workaround: The BCM44XX chip has a stupid revision
		 * number stored in the SPROM.
		 * Always extract r1. */
		out->revision = 1;
		sprom_extract_r123(out, in);
		sprom_extract_r1(&out->r1, in);
	} else if (bus->chip_id == 0x4321) {
		/* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */
		out->revision = 4;
		sprom_extract_r4(out, in);
	} else {
		if (out->revision == 0)
			goto unsupported;
		if (out->revision >= 1 && out->revision <= 3) {
			sprom_extract_r123(out, in);
			sprom_extract_r1(&out->r1, in);
		}
		if (out->revision == 4)
			sprom_extract_r4(out, in);
		if (out->revision >= 5)
		if (out->revision >= 4)
			goto unsupported;
	}


	int err = -ENOMEM;
	u16 *buf;

	buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL);
	if (!buf)
		goto out;
	bus->sprom_size = SSB_SPROMSIZE_WORDS_R123;
	sprom_do_read(bus, buf);
	err = sprom_check_crc(buf, bus->sprom_size);
	if (err) {
		/* check for rev 4 sprom - has special signature */
		if (buf [32] == 0x5372) {
			ssb_printk(KERN_WARNING PFX "Extracting a rev 4"
				   " SPROM\n");
			kfree(buf);
			buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
				      GFP_KERNEL);
			if (!buf)
				goto out;
			bus->sprom_size = SSB_SPROMSIZE_WORDS_R4;
			sprom_do_read(bus, buf);
			err = sprom_check_crc(buf, bus->sprom_size);
		}
		if (err)
			ssb_printk(KERN_WARNING PFX "WARNING: Invalid"
				   " SPROM CRC (corrupt SPROM)\n");
	}
	err = sprom_extract(bus, sprom, buf, bus->sprom_size);

	kfree(buf);
out:

	.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);

	if (!bus)
		goto out;
	err = -ENOMEM;
	sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
	if (!sprom)
		goto out;


	sprom_do_read(bus, sprom);
	mutex_unlock(&bus->pci_sprom_mutex);

	count = sprom2hex(sprom, buf, PAGE_SIZE, bus->sprom_size);
	err = 0;

out_kfree:

	if (!bus)
		goto out;
	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;

Lines 308-313 struct ssb_bus { Link Here

(-)a/include/linux/ssb/ssb.h (+1 lines)
308	/* ID information about the Chip. */	308	/* ID information about the Chip. */
309	u16 chip_id;	309	u16 chip_id;
310	u16 chip_rev;	310	u16 chip_rev;
		311	u16 sprom_size; /* number of words in sprom */
311	u8 chip_package;	312	u8 chip_package;
312		313
313	/* List of devices (cores) on the backplane. */	314	/* List of devices (cores) on the backplane. */

Return to bug 207532

Lines 212-240 static inline u8 ssb_crc8(u8 crc, u8 data) Link Here

(-)a/drivers/ssb/pci.c (-92 / +132 lines)
212	return t[crc ^ data];	212	return t[crc ^ data];
213	}	213	}
214		214
215	static u8 ssb_sprom_crc(const u16 *sprom)	215	static u8 ssb_sprom_crc(const u16 *sprom, u16 size)
216	{	216	{
217	int word;	217	int word;
218	u8 crc = 0xFF;	218	u8 crc = 0xFF;
219		219
220	for (word = 0; word < SSB_SPROMSIZE_WORDS - 1; word++) {	220	for (word = 0; word < size - 1; word++) {
221	crc = ssb_crc8(crc, sprom[word] & 0x00FF);	221	crc = ssb_crc8(crc, sprom[word] & 0x00FF);
222	crc = ssb_crc8(crc, (sprom[word] & 0xFF00) >> 8);	222	crc = ssb_crc8(crc, (sprom[word] & 0xFF00) >> 8);
223	}	223	}
224	crc = ssb_crc8(crc, sprom[SPOFF(SSB_SPROM_REVISION)] & 0x00FF);	224	crc = ssb_crc8(crc, sprom[size - 1] & 0x00FF);
225	crc ^= 0xFF;	225	crc ^= 0xFF;
226		226
227	return crc;	227	return crc;
228	}	228	}
229		229
230	static int sprom_check_crc(const u16 *sprom)	230	static int sprom_check_crc(const u16 *sprom, u16 size)
231	{	231	{
232	u8 crc;	232	u8 crc;
233	u8 expected_crc;	233	u8 expected_crc;
234	u16 tmp;	234	u16 tmp;
235		235
236	crc = ssb_sprom_crc(sprom);	236	crc = ssb_sprom_crc(sprom, size);
237	tmp = sprom[SPOFF(SSB_SPROM_REVISION)] & SSB_SPROM_REVISION_CRC;	237	tmp = sprom[size - 1] & SSB_SPROM_REVISION_CRC;
238	expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;	238	expected_crc = tmp >> SSB_SPROM_REVISION_CRC_SHIFT;
239	if (crc != expected_crc)	239	if (crc != expected_crc)
240	return -EPROTO;	240	return -EPROTO;
Lines 246-252 static void sprom_do_read(struct ssb_bus bus, u16 sprom) Link Here
246	{	246	{
247	int i;	247	int i;
248		248
249	for (i = 0; i < SSB_SPROMSIZE_WORDS; i++)	249	for (i = 0; i < bus->sprom_size; i++)
250	sprom[i] = readw(bus->mmio + SSB_SPROM_BASE + (i * 2));	250	sprom[i] = readw(bus->mmio + SSB_SPROM_BASE + (i * 2));
251	}	251	}
252		252
Lines 255-260 static int sprom_do_write(struct ssb_bus bus, const u16 sprom) Link Here
255	struct pci_dev *pdev = bus->host_pci;	255	struct pci_dev *pdev = bus->host_pci;
256	int i, err;	256	int i, err;
257	u32 spromctl;	257	u32 spromctl;
		258	u16 size = bus->sprom_size;
258		259
259	ssb_printk(KERN_NOTICE PFX "Writing SPROM. Do NOT turn off the power! Please stand by...\n");	260	ssb_printk(KERN_NOTICE PFX "Writing SPROM. Do NOT turn off the power! Please stand by...\n");
260	err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);	261	err = pci_read_config_dword(pdev, SSB_SPROMCTL, &spromctl);
Lines 266-277 static int sprom_do_write(struct ssb_bus bus, const u16 sprom) Link Here
266	goto err_ctlreg;	267	goto err_ctlreg;
267	ssb_printk(KERN_NOTICE PFX "[ 0%%");	268	ssb_printk(KERN_NOTICE PFX "[ 0%%");
268	msleep(500);	269	msleep(500);
269	for (i = 0; i < SSB_SPROMSIZE_WORDS; i++) {	270	for (i = 0; i < size; i++) {
270	if (i == SSB_SPROMSIZE_WORDS / 4)	271	if (i == size / 4)
271	ssb_printk("25%%");	272	ssb_printk("25%%");
272	else if (i == SSB_SPROMSIZE_WORDS / 2)	273	else if (i == size / 2)
273	ssb_printk("50%%");	274	ssb_printk("50%%");
274	else if (i == (SSB_SPROMSIZE_WORDS / 4) * 3)	275	else if (i == (size * 3) / 4)
275	ssb_printk("75%%");	276	ssb_printk("75%%");
276	else if (i % 2)	277	else if (i % 2)
277	ssb_printk(".");	278	ssb_printk(".");
Lines 350-444 static void sprom_extract_r1(struct ssb_sprom_r1 out, const u16 in) Link Here
350	SPEX(antenna_gain_a, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_A, 0);	351	SPEX(antenna_gain_a, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_A, 0);
351	SPEX(antenna_gain_bg, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_BG,	352	SPEX(antenna_gain_bg, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_BG,
352	SSB_SPROM1_AGAIN_BG_SHIFT);	353	SSB_SPROM1_AGAIN_BG_SHIFT);
353	for (i = 0; i < 4; i++) {
354	v = in[SPOFF(SSB_SPROM1_OEM) + i];
355	(((__le16 )out->oem) + i) = cpu_to_le16(v);
356	}
357	}	354	}
358		355
359	static void sprom_extract_r2(struct ssb_sprom_r2 out, const u16 in)	356	static void sprom_extract_r123(struct ssb_sprom out, const u16 in)
360	{	357	{
361	int i;	358	int i;
362	u16 v;	359	u16 v;
		360	u16 loc[3];
363		361
364	SPEX(boardflags_hi, SSB_SPROM2_BFLHI, 0xFFFF, 0);	362	if (out->revision == 3) { /* rev 3 moved MAC */
365	SPEX(maxpwr_a_hi, SSB_SPROM2_MAXP_A, SSB_SPROM2_MAXP_A_HI, 0);	363	loc[0] = SSB_SPROM3_IL0MAC;
366	SPEX(maxpwr_a_lo, SSB_SPROM2_MAXP_A, SSB_SPROM2_MAXP_A_LO,	364	loc[1] = SSB_SPROM3_ET0MAC;
367	SSB_SPROM2_MAXP_A_LO_SHIFT);	365	loc[2] = SSB_SPROM3_ET1MAC;
368	SPEX(pa1lob0, SSB_SPROM2_PA1LOB0, 0xFFFF, 0);	366	} else {
369	SPEX(pa1lob1, SSB_SPROM2_PA1LOB1, 0xFFFF, 0);	367	loc[0] = SSB_SPROM1_IL0MAC;
370	SPEX(pa1lob2, SSB_SPROM2_PA1LOB2, 0xFFFF, 0);	368	loc[1] = SSB_SPROM1_ET0MAC;
371	SPEX(pa1hib0, SSB_SPROM2_PA1HIB0, 0xFFFF, 0);	369	loc[2] = SSB_SPROM1_ET1MAC;
372	SPEX(pa1hib1, SSB_SPROM2_PA1HIB1, 0xFFFF, 0);	370	}
373	SPEX(pa1hib2, SSB_SPROM2_PA1HIB2, 0xFFFF, 0);	371	for (i = 0; i < 3; i++) {
374	SPEX(ofdm_pwr_off, SSB_SPROM2_OPO, SSB_SPROM2_OPO_VALUE, 0);	372	v = in[SPOFF(loc[0]) + i];
375	for (i = 0; i < 4; i++) {	373	(((__be16 )out->il0mac) + i) = cpu_to_be16(v);
376	v = in[SPOFF(SSB_SPROM2_CCODE) + i];	374	}
377	(((__le16 )out->country_str) + i) = cpu_to_le16(v);	375	for (i = 0; i < 3; i++) {
		376	v = in[SPOFF(loc[1]) + i];
		377	(((__be16 )out->et0mac) + i) = cpu_to_be16(v);
		378	}
		379	for (i = 0; i < 3; i++) {
		380	v = in[SPOFF(loc[2]) + i];
		381	(((__be16 )out->et1mac) + i) = cpu_to_be16(v);
378	}	382	}
		383	SPEX(et0phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET0A, 0);
		384	SPEX(et1phyaddr, SSB_SPROM1_ETHPHY, SSB_SPROM1_ETHPHY_ET1A,
		385	SSB_SPROM1_ETHPHY_ET1A_SHIFT);
		386	SPEX(country_code, SSB_SPROM1_BINF, SSB_SPROM1_BINF_CCODE,
		387	SSB_SPROM1_BINF_CCODE_SHIFT);
		388	SPEX(pa0b0, SSB_SPROM1_PA0B0, 0xFFFF, 0);
		389	SPEX(pa0b1, SSB_SPROM1_PA0B1, 0xFFFF, 0);
		390	SPEX(pa0b2, SSB_SPROM1_PA0B2, 0xFFFF, 0);
		391	SPEX(pa1b0, SSB_SPROM1_PA1B0, 0xFFFF, 0);
		392	SPEX(pa1b1, SSB_SPROM1_PA1B1, 0xFFFF, 0);
		393	SPEX(pa1b2, SSB_SPROM1_PA1B2, 0xFFFF, 0);
		394	SPEX(gpio0, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P0, 0);
		395	SPEX(gpio1, SSB_SPROM1_GPIOA, SSB_SPROM1_GPIOA_P1,
		396	SSB_SPROM1_GPIOA_P1_SHIFT);
		397	SPEX(gpio2, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P2, 0);
		398	SPEX(gpio3, SSB_SPROM1_GPIOB, SSB_SPROM1_GPIOB_P3,
		399	SSB_SPROM1_GPIOB_P3_SHIFT);
		400	SPEX(maxpwr_a, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_A,
		401	SSB_SPROM1_MAXPWR_A_SHIFT);
		402	SPEX(maxpwr_bg, SSB_SPROM1_MAXPWR, SSB_SPROM1_MAXPWR_BG, 0);
		403	SPEX(itssi_a, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_A,
		404	SSB_SPROM1_ITSSI_A_SHIFT);
		405	SPEX(itssi_bg, SSB_SPROM1_ITSSI, SSB_SPROM1_ITSSI_BG, 0);
		406	SPEX(boardflags_lo, SSB_SPROM1_BFLLO, 0xFFFF, 0);
		407	SPEX(antenna_gain_a, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_A, 0);
		408	SPEX(antenna_gain_bg, SSB_SPROM1_AGAIN, SSB_SPROM1_AGAIN_BG,
		409	SSB_SPROM1_AGAIN_BG_SHIFT);
379	}	410	}
380		411
381	static void sprom_extract_r3(struct ssb_sprom_r3 out, const u16 in)	412	static void sprom_extract_r4(struct ssb_sprom out, const u16 in)
382	{	413	{
383	out->ofdmapo = (in[SPOFF(SSB_SPROM3_OFDMAPO) + 0] & 0xFF00) >> 8;	414	int i;
384	out->ofdmapo \|= (in[SPOFF(SSB_SPROM3_OFDMAPO) + 0] & 0x00FF) << 8;	415	u16 v;
385	out->ofdmapo <<= 16;	416
386	out->ofdmapo \|= (in[SPOFF(SSB_SPROM3_OFDMAPO) + 1] & 0xFF00) >> 8;	417	/* extract the r1 variables */
387	out->ofdmapo \|= (in[SPOFF(SSB_SPROM3_OFDMAPO) + 1] & 0x00FF) << 8;	418	for (i = 0; i < 3; i++) {
388		419	v = in[SPOFF(SSB_SPROM4_IL0MAC) + i];
389	out->ofdmalpo = (in[SPOFF(SSB_SPROM3_OFDMALPO) + 0] & 0xFF00) >> 8;	420	(((__be16 )out->il0mac) + i) = cpu_to_be16(v);
390	out->ofdmalpo \|= (in[SPOFF(SSB_SPROM3_OFDMALPO) + 0] & 0x00FF) << 8;	421	}
391	out->ofdmalpo <<= 16;	422	for (i = 0; i < 3; i++) {
392	out->ofdmalpo \|= (in[SPOFF(SSB_SPROM3_OFDMALPO) + 1] & 0xFF00) >> 8;	423	v = in[SPOFF(SSB_SPROM4_ET0MAC) + i];
393	out->ofdmalpo \|= (in[SPOFF(SSB_SPROM3_OFDMALPO) + 1] & 0x00FF) << 8;	424	(((__be16 )out->et0mac) + i) = cpu_to_be16(v);
394		425	}
395	out->ofdmahpo = (in[SPOFF(SSB_SPROM3_OFDMAHPO) + 0] & 0xFF00) >> 8;	426	for (i = 0; i < 3; i++) {
396	out->ofdmahpo \|= (in[SPOFF(SSB_SPROM3_OFDMAHPO) + 0] & 0x00FF) << 8;	427	v = in[SPOFF(SSB_SPROM4_ET1MAC) + i];
397	out->ofdmahpo <<= 16;	428	(((__be16 )out->et1mac) + i) = cpu_to_be16(v);
398	out->ofdmahpo \|= (in[SPOFF(SSB_SPROM3_OFDMAHPO) + 1] & 0xFF00) >> 8;	429	}
399	out->ofdmahpo \|= (in[SPOFF(SSB_SPROM3_OFDMAHPO) + 1] & 0x00FF) << 8;	430	SPEX(et0phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET0A, 0);
400		431	SPEX(et1phyaddr, SSB_SPROM4_ETHPHY, SSB_SPROM4_ETHPHY_ET1A,
401	SPEX(gpioldc_on_cnt, SSB_SPROM3_GPIOLDC, SSB_SPROM3_GPIOLDC_ON,	432	SSB_SPROM4_ETHPHY_ET1A_SHIFT);
402	SSB_SPROM3_GPIOLDC_ON_SHIFT);	433	SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0);
403	SPEX(gpioldc_off_cnt, SSB_SPROM3_GPIOLDC, SSB_SPROM3_GPIOLDC_OFF,	434	SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0);
404	SSB_SPROM3_GPIOLDC_OFF_SHIFT);	435	SPEX(antenna_gain_a, SSB_SPROM4_AGAIN, SSB_SPROM4_AGAIN_0, 0);
405	SPEX(cckpo_1M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_1M, 0);	436	SPEX(antenna_gain_bg, SSB_SPROM4_AGAIN, SSB_SPROM4_AGAIN_1,
406	SPEX(cckpo_2M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_2M,	437	SSB_SPROM4_AGAIN_1_SHIFT);
407	SSB_SPROM3_CCKPO_2M_SHIFT);	438	/* TODO - get remaining rev 4 stuff needed */
408	SPEX(cckpo_55M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_55M,
409	SSB_SPROM3_CCKPO_55M_SHIFT);
410	SPEX(cckpo_11M, SSB_SPROM3_CCKPO, SSB_SPROM3_CCKPO_11M,
411	SSB_SPROM3_CCKPO_11M_SHIFT);
412
413	out->ofdmgpo = (in[SPOFF(SSB_SPROM3_OFDMGPO) + 0] & 0xFF00) >> 8;
414	out->ofdmgpo \|= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 0] & 0x00FF) << 8;
415	out->ofdmgpo <<= 16;
416	out->ofdmgpo \|= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 1] & 0xFF00) >> 8;
417	out->ofdmgpo \|= (in[SPOFF(SSB_SPROM3_OFDMGPO) + 1] & 0x00FF) << 8;
418	}	439	}
419		440
420	static int sprom_extract(struct ssb_bus *bus,	441	static int sprom_extract(struct ssb_bus bus, struct ssb_sprom out,
421	struct ssb_sprom out, const u16 in)	442	const u16 *in, u16 size)
422	{	443	{
423	memset(out, 0, sizeof(*out));	444	memset(out, 0, sizeof(*out));
424		445
425	SPEX(revision, SSB_SPROM_REVISION, SSB_SPROM_REVISION_REV, 0);	446	out->revision = in[size - 1] & 0x00FF;
426
427	if ((bus->chip_id & 0xFF00) == 0x4400) {	447	if ((bus->chip_id & 0xFF00) == 0x4400) {
428	/* Workaround: The BCM44XX chip has a stupid revision	448	/* Workaround: The BCM44XX chip has a stupid revision
429	* number stored in the SPROM.	449	* number stored in the SPROM.
430	* Always extract r1. */	450	* Always extract r1. */
		451	out->revision = 1;
		452	sprom_extract_r123(out, in);
431	sprom_extract_r1(&out->r1, in);	453	sprom_extract_r1(&out->r1, in);
		454	} else if (bus->chip_id == 0x4321) {
		455	/* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */
		456	out->revision = 4;
		457	sprom_extract_r4(out, in);
432	} else {	458	} else {
433	if (out->revision == 0)	459	if (out->revision == 0)
434	goto unsupported;	460	goto unsupported;
435	if (out->revision >= 1 && out->revision <= 3)	461	if (out->revision >= 1 && out->revision <= 3) {
		462	sprom_extract_r123(out, in);
436	sprom_extract_r1(&out->r1, in);	463	sprom_extract_r1(&out->r1, in);
437	if (out->revision >= 2 && out->revision <= 3)	464	}
438	sprom_extract_r2(&out->r2, in);	465	if (out->revision == 4)
439	if (out->revision == 3)	466	sprom_extract_r4(out, in);
440	sprom_extract_r3(&out->r3, in);	467	if (out->revision >= 5)
441	if (out->revision >= 4)
442	goto unsupported;	468	goto unsupported;
443	}	469	}
444		470
Lines 456-471 static int ssb_pci_sprom_get(struct ssb_bus *bus, Link Here
456	int err = -ENOMEM;	482	int err = -ENOMEM;
457	u16 *buf;	483	u16 *buf;
458		484
459	buf = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);	485	buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL);
460	if (!buf)	486	if (!buf)
461	goto out;	487	goto out;
		488	bus->sprom_size = SSB_SPROMSIZE_WORDS_R123;
462	sprom_do_read(bus, buf);	489	sprom_do_read(bus, buf);
463	err = sprom_check_crc(buf);	490	err = sprom_check_crc(buf, bus->sprom_size);
464	if (err) {	491	if (err) {
465	ssb_printk(KERN_WARNING PFX	492	/* check for rev 4 sprom - has special signature */
466	"WARNING: Invalid SPROM CRC (corrupt SPROM)\n");	493	if (buf [32] == 0x5372) {
		494	ssb_printk(KERN_WARNING PFX "Extracting a rev 4"
		495	" SPROM\n");
		496	kfree(buf);
		497	buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16),
		498	GFP_KERNEL);
		499	if (!buf)
		500	goto out;
		501	bus->sprom_size = SSB_SPROMSIZE_WORDS_R4;
		502	sprom_do_read(bus, buf);
		503	err = sprom_check_crc(buf, bus->sprom_size);
		504	}
		505	if (err)
		506	ssb_printk(KERN_WARNING PFX "WARNING: Invalid"
		507	" SPROM CRC (corrupt SPROM)\n");
467	}	508	}
468	err = sprom_extract(bus, sprom, buf);	509	err = sprom_extract(bus, sprom, buf, bus->sprom_size);
469		510
470	kfree(buf);	511	kfree(buf);
471	out:	512	out:
Lines 579-607 const struct ssb_bus_ops ssb_pci_ops = { Link Here
579	.write32 = ssb_pci_write32,	620	.write32 = ssb_pci_write32,
580	};	621	};
581		622
582	static int sprom2hex(const u16 sprom, char buf, size_t buf_len)	623	static int sprom2hex(const u16 sprom, char buf, size_t buf_len, u16 size)
583	{	624	{
584	int i, pos = 0;	625	int i, pos = 0;
585		626
586	for (i = 0; i < SSB_SPROMSIZE_WORDS; i++) {	627	for (i = 0; i < size; i++)
587	pos += snprintf(buf + pos, buf_len - pos - 1,	628	pos += snprintf(buf + pos, buf_len - pos - 1,
588	"%04X", swab16(sprom[i]) & 0xFFFF);	629	"%04X", swab16(sprom[i]) & 0xFFFF);
589	}
590	pos += snprintf(buf + pos, buf_len - pos - 1, "\n");	630	pos += snprintf(buf + pos, buf_len - pos - 1, "\n");
591		631
592	return pos + 1;	632	return pos + 1;
593	}	633	}
594		634
595	static int hex2sprom(u16 sprom, const char dump, size_t len)	635	static int hex2sprom(u16 sprom, const char dump, size_t len, u16 size)
596	{	636	{
597	char tmp[5] = { 0 };	637	char tmp[5] = { 0 };
598	int cnt = 0;	638	int cnt = 0;
599	unsigned long parsed;	639	unsigned long parsed;
600		640
601	if (len < SSB_SPROMSIZE_BYTES * 2)	641	if (len < size * 2)
602	return -EINVAL;	642	return -EINVAL;
603		643
604	while (cnt < SSB_SPROMSIZE_WORDS) {	644	while (cnt < size) {
605	memcpy(tmp, dump, 4);	645	memcpy(tmp, dump, 4);
606	dump += 4;	646	dump += 4;
607	parsed = simple_strtoul(tmp, NULL, 16);	647	parsed = simple_strtoul(tmp, NULL, 16);
Lines 625-631 static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev, Link Here
625	if (!bus)	665	if (!bus)
626	goto out;	666	goto out;
627	err = -ENOMEM;	667	err = -ENOMEM;
628	sprom = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);	668	sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
629	if (!sprom)	669	if (!sprom)
630	goto out;	670	goto out;
631		671
Lines 638-644 static ssize_t ssb_pci_attr_sprom_show(struct device *pcidev, Link Here
638	sprom_do_read(bus, sprom);	678	sprom_do_read(bus, sprom);
639	mutex_unlock(&bus->pci_sprom_mutex);	679	mutex_unlock(&bus->pci_sprom_mutex);
640		680
641	count = sprom2hex(sprom, buf, PAGE_SIZE);	681	count = sprom2hex(sprom, buf, PAGE_SIZE, bus->sprom_size);
642	err = 0;	682	err = 0;
643		683
644	out_kfree:	684	out_kfree:
Lines 660-674 static ssize_t ssb_pci_attr_sprom_store(struct device *pcidev, Link Here
660	if (!bus)	700	if (!bus)
661	goto out;	701	goto out;
662	err = -ENOMEM;	702	err = -ENOMEM;
663	sprom = kcalloc(SSB_SPROMSIZE_WORDS, sizeof(u16), GFP_KERNEL);	703	sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
664	if (!sprom)	704	if (!sprom)
665	goto out;	705	goto out;
666	err = hex2sprom(sprom, buf, count);	706	err = hex2sprom(sprom, buf, count, bus->sprom_size);
667	if (err) {	707	if (err) {
668	err = -EINVAL;	708	err = -EINVAL;
669	goto out_kfree;	709	goto out_kfree;
670	}	710	}
671	err = sprom_check_crc(sprom);	711	err = sprom_check_crc(sprom, bus->sprom_size);
672	if (err) {	712	if (err) {
673	err = -EINVAL;	713	err = -EINVAL;
674	goto out_kfree;	714	goto out_kfree;

Lines 147-152 Link Here

(-)a/include/linux/ssb/ssb_regs.h (-12 / +27 lines)
147	#define SSB_IDLOW_SSBREV 0xF0000000 /* Sonics Backplane Revision code */	147	#define SSB_IDLOW_SSBREV 0xF0000000 /* Sonics Backplane Revision code */
148	#define SSB_IDLOW_SSBREV_22 0x00000000 /* <= 2.2 */	148	#define SSB_IDLOW_SSBREV_22 0x00000000 /* <= 2.2 */
149	#define SSB_IDLOW_SSBREV_23 0x10000000 /* 2.3 */	149	#define SSB_IDLOW_SSBREV_23 0x10000000 /* 2.3 */
		150	#define SSB_IDLOW_SSBREV_24 0x40000000 /* ?? Found in BCM4328 */
		151	#define SSB_IDLOW_SSBREV_25 0x50000000 /* ?? Not Found yet */
		152	#define SSB_IDLOW_SSBREV_26 0x60000000 /* ?? Found in some BCM4311/2 */
		153	#define SSB_IDLOW_SSBREV_27 0x70000000 /* ?? Found in some BCM4311/2 */
150	#define SSB_IDHIGH 0x0FFC /* SB Identification High */	154	#define SSB_IDHIGH 0x0FFC /* SB Identification High */
151	#define SSB_IDHIGH_RCLO 0x0000000F /* Revision Code (low part) */	155	#define SSB_IDHIGH_RCLO 0x0000000F /* Revision Code (low part) */
152	#define SSB_IDHIGH_CC 0x00008FF0 /* Core Code */	156	#define SSB_IDHIGH_CC 0x00008FF0 /* Core Code */
Lines 162-167 Link Here
162	*/	166	*/
163	#define SSB_SPROMSIZE_WORDS 64	167	#define SSB_SPROMSIZE_WORDS 64
164	#define SSB_SPROMSIZE_BYTES (SSB_SPROMSIZE_WORDS * sizeof(u16))	168	#define SSB_SPROMSIZE_BYTES (SSB_SPROMSIZE_WORDS * sizeof(u16))
		169	#define SSB_SPROMSIZE_WORDS_R123 64
		170	#define SSB_SPROMSIZE_WORDS_R4 220
		171	#define SSB_SPROMSIZE_BYTES_R123 (SSB_SPROMSIZE_WORDS_R123 * sizeof(u16))
		172	#define SSB_SPROMSIZE_BYTES_R4 (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16))
165	#define SSB_SPROM_BASE 0x1000	173	#define SSB_SPROM_BASE 0x1000
166	#define SSB_SPROM_REVISION 0x107E	174	#define SSB_SPROM_REVISION 0x107E
167	#define SSB_SPROM_REVISION_REV 0x00FF /* SPROM Revision number */	175	#define SSB_SPROM_REVISION_REV 0x00FF /* SPROM Revision number */
Lines 232-238 Link Here
232	#define SSB_SPROM2_OPO_VALUE 0x00FF	240	#define SSB_SPROM2_OPO_VALUE 0x00FF
233	#define SSB_SPROM2_OPO_UNUSED 0xFF00	241	#define SSB_SPROM2_OPO_UNUSED 0xFF00
234	#define SSB_SPROM2_CCODE 0x107C /* Two char Country Code */	242	#define SSB_SPROM2_CCODE 0x107C /* Two char Country Code */
235	/* SPROM Revision 3 (inherits from rev 2) */	243	/* SPROM Revision 3 (inherits most data from rev 2) */
		244	#define SSB_SPROM3_IL0MAC 0x104A /* 6 bytes MAC address for 802.11b/g */
		245	#define SSB_SPROM3_ET0MAC 0x1050 /* 6 bytes MAC address for Ethernet ?? */
		246	#define SSB_SPROM3_ET1MAC 0x1050 /* 6 bytes MAC address for 802.11a ?? */
236	#define SSB_SPROM3_OFDMAPO 0x102C /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */	247	#define SSB_SPROM3_OFDMAPO 0x102C /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */
237	#define SSB_SPROM3_OFDMALPO 0x1030 /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */	248	#define SSB_SPROM3_OFDMALPO 0x1030 /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */
238	#define SSB_SPROM3_OFDMAHPO 0x1034 /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */	249	#define SSB_SPROM3_OFDMAHPO 0x1034 /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */
Lines 250-257 Link Here
250	#define SSB_SPROM3_CCKPO_11M 0xF000 /* 11M Rate PO */	261	#define SSB_SPROM3_CCKPO_11M 0xF000 /* 11M Rate PO */
251	#define SSB_SPROM3_CCKPO_11M_SHIFT 12	262	#define SSB_SPROM3_CCKPO_11M_SHIFT 12
252	#define SSB_SPROM3_OFDMGPO 0x107A /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */	263	#define SSB_SPROM3_OFDMGPO 0x107A /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */
253	/* SPROM Revision 4 */	264	/* SPROM Revision 4 entries with ?? in comment are unknown */
254	#define SSB_SPROM4_IL0MAC 0x104C /* 6 byte MAC address for b/g */	265	#define SSB_SPROM4_IL0MAC 0x104C /* 6 byte MAC address for b/g */
		266	#define SSB_SPROM4_ET0MAC 0x1018 /* 6 bytes MAC address for Ethernet ?? */
		267	#define SSB_SPROM4_ET1MAC 0x1018 /* 6 bytes MAC address for 802.11a ?? */
255	#define SSB_SPROM4_ETHPHY 0x105A /* Ethernet PHY settings */	268	#define SSB_SPROM4_ETHPHY 0x105A /* Ethernet PHY settings */
256	#define SSB_SPROM4_ETHPHY_ET0A 0x001F /* MII Address for enet0 */	269	#define SSB_SPROM4_ETHPHY_ET0A 0x001F /* MII Address for enet0 */
257	#define SSB_SPROM4_ETHPHY_ET1A 0x03E0 /* MII Address for enet1 */	270	#define SSB_SPROM4_ETHPHY_ET1A 0x03E0 /* MII Address for enet1 */
Lines 263-281 Link Here
263	#define SSB_SPROM4_ANT_BG 0x105C /* B/G Antennas */	276	#define SSB_SPROM4_ANT_BG 0x105C /* B/G Antennas */
264	#define SSB_SPROM4_BFLLO 0x1044 /* Boardflags (low 16 bits) */	277	#define SSB_SPROM4_BFLLO 0x1044 /* Boardflags (low 16 bits) */
265	#define SSB_SPROM4_AGAIN 0x105E /* Antenna Gain (in dBm Q5.2) */	278	#define SSB_SPROM4_AGAIN 0x105E /* Antenna Gain (in dBm Q5.2) */
		279	#define SSB_SPROM4_AGAIN_0 0x00FF /* Antenna 0 */
		280	#define SSB_SPROM4_AGAIN_1 0xFF00 /* Antenna 1 */
		281	#define SSB_SPROM4_AGAIN_1_SHIFT 8
266	#define SSB_SPROM4_BFLHI 0x1046 /* Board Flags Hi */	282	#define SSB_SPROM4_BFLHI 0x1046 /* Board Flags Hi */
267	#define SSB_SPROM4_MAXP_A 0x1000 /* Max Power A */	283	#define SSB_SPROM4_MAXP_A 0x1000 /* Max Power A ?? */
268	#define SSB_SPROM4_MAXP_A_HI 0x00FF /* Mask for Hi */	284	#define SSB_SPROM4_MAXP_A_HI 0x00FF /* Mask for Hi */
269	#define SSB_SPROM4_MAXP_A_LO 0xFF00 /* Mask for Lo */	285	#define SSB_SPROM4_MAXP_A_LO 0xFF00 /* Mask for Lo */
270	#define SSB_SPROM4_MAXP_A_LO_SHIFT 16 /* Shift for Lo */	286	#define SSB_SPROM4_MAXP_A_LO_SHIFT 16 /* Shift for Lo */
271	#define SSB_SPROM4_PA1LOB0 0x1000	287	#define SSB_SPROM4_PA1LOB0 0x1000 /* ?? */
272	#define SSB_SPROM4_PA1LOB1 0x1000	288	#define SSB_SPROM4_PA1LOB1 0x1000 /* ?? */
273	#define SSB_SPROM4_PA1LOB2 0x1000	289	#define SSB_SPROM4_PA1LOB2 0x1000 /* ?? */
274	#define SSB_SPROM4_PA1HIB0 0x1000	290	#define SSB_SPROM4_PA1HIB0 0x1000 /* ?? */
275	#define SSB_SPROM4_PA1HIB1 0x1000	291	#define SSB_SPROM4_PA1HIB1 0x1000 /* ?? */
276	#define SSB_SPROM4_PA1HIB2 0x1000	292	#define SSB_SPROM4_PA1HIB2 0x1000 /* ?? */
277	#define SSB_SPROM4_OPO 0x1000	293	#define SSB_SPROM4_OPO 0x1000 /* ?? */
278	#define SSB_SPROM4_OPO_VALUE 0x0000	294	#define SSB_SPROM4_OPO_VALUE 0x0000 /* ?? */
279	#define SSB_SPROM4_GPIOLDC 0x105A /* LED Powersave Duty Cycle */	295	#define SSB_SPROM4_GPIOLDC 0x105A /* LED Powersave Duty Cycle */
280	#define SSB_SPROM4_GPIOLDC_OFF 0x0000FF00 /* Off Count */	296	#define SSB_SPROM4_GPIOLDC_OFF 0x0000FF00 /* Off Count */
281	#define SSB_SPROM4_GPIOLDC_OFF_SHIFT 8	297	#define SSB_SPROM4_GPIOLDC_OFF_SHIFT 8
282	-