[linux.git] / drivers / bcma / driver_pci.c

/*
 * Broadcom specific AMBA
 * PCI Core
 *
 * Copyright 2005, 2011, Broadcom Corporation
 * Copyright 2006, 2007, Michael Buesch <[email protected]>
 * Copyright 2011, 2012, Hauke Mehrtens <[email protected]>
 *
 * Licensed under the GNU/GPL. See COPYING for details.
 */

#include "bcma_private.h"
#include <linux/export.h>
#include <linux/bcma/bcma.h>

/**************************************************
 * R/W ops.
 **************************************************/

u32 bcma_pcie_read(struct bcma_drv_pci *pc, u32 address)
{
	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address);
	pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR);
	return pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_DATA);
}

static void bcma_pcie_write(struct bcma_drv_pci *pc, u32 address, u32 data)
{
	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address);
	pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR);
	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_DATA, data);
}

static void bcma_pcie_mdio_set_phy(struct bcma_drv_pci *pc, u16 phy)
{
	u32 v;
	int i;

	v = BCMA_CORE_PCI_MDIODATA_START;
	v |= BCMA_CORE_PCI_MDIODATA_WRITE;
	v |= (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
	      BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
	v |= (BCMA_CORE_PCI_MDIODATA_BLK_ADDR <<
	      BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
	v |= BCMA_CORE_PCI_MDIODATA_TA;
	v |= (phy << 4);
	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);

	udelay(10);
	for (i = 0; i < 200; i++) {
		v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
		if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE)
			break;
		usleep_range(1000, 2000);
	}
}

static u16 bcma_pcie_mdio_read(struct bcma_drv_pci *pc, u16 device, u8 address)
{
	int max_retries = 10;
	u16 ret = 0;
	u32 v;
	int i;

	/* enable mdio access to SERDES */
	v = BCMA_CORE_PCI_MDIOCTL_PREAM_EN;
	v |= BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL;
	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, v);

	if (pc->core->id.rev >= 10) {
		max_retries = 200;
		bcma_pcie_mdio_set_phy(pc, device);
		v = (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
		     BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
		v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
	} else {
		v = (device << BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD);
		v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD);
	}

	v = BCMA_CORE_PCI_MDIODATA_START;
	v |= BCMA_CORE_PCI_MDIODATA_READ;
	v |= BCMA_CORE_PCI_MDIODATA_TA;

	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);
	/* Wait for the device to complete the transaction */
	udelay(10);
	for (i = 0; i < max_retries; i++) {
		v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
		if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE) {
			udelay(10);
			ret = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_DATA);
			break;
		}
		usleep_range(1000, 2000);
	}
	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, 0);
	return ret;
}

static void bcma_pcie_mdio_write(struct bcma_drv_pci *pc, u16 device,
				u8 address, u16 data)
{
	int max_retries = 10;
	u32 v;
	int i;

	/* enable mdio access to SERDES */
	v = BCMA_CORE_PCI_MDIOCTL_PREAM_EN;
	v |= BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL;
	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, v);

	if (pc->core->id.rev >= 10) {
		max_retries = 200;
		bcma_pcie_mdio_set_phy(pc, device);
		v = (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
		     BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
		v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
	} else {
		v = (device << BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD);
		v |= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD);
	}

	v = BCMA_CORE_PCI_MDIODATA_START;
	v |= BCMA_CORE_PCI_MDIODATA_WRITE;
	v |= BCMA_CORE_PCI_MDIODATA_TA;
	v |= data;
	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);
	/* Wait for the device to complete the transaction */
	udelay(10);
	for (i = 0; i < max_retries; i++) {
		v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
		if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE)
			break;
		usleep_range(1000, 2000);
	}
	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, 0);
}

static u16 bcma_pcie_mdio_writeread(struct bcma_drv_pci *pc, u16 device,
				    u8 address, u16 data)
{
	bcma_pcie_mdio_write(pc, device, address, data);
	return bcma_pcie_mdio_read(pc, device, address);
}

/**************************************************
 * Early init.
 **************************************************/

static void bcma_core_pci_fixcfg(struct bcma_drv_pci *pc)
{
	struct bcma_device *core = pc->core;
	u16 val16, core_index;
	uint regoff;

	regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_PI_OFFSET);
	core_index = (u16)core->core_index;

	val16 = pcicore_read16(pc, regoff);
	if (((val16 & BCMA_CORE_PCI_SPROM_PI_MASK) >> BCMA_CORE_PCI_SPROM_PI_SHIFT)
	     != core_index) {
		val16 = (core_index << BCMA_CORE_PCI_SPROM_PI_SHIFT) |
			(val16 & ~BCMA_CORE_PCI_SPROM_PI_MASK);
		pcicore_write16(pc, regoff, val16);
	}
}

/*
 * Apply some early fixes required before accessing SPROM.
 * See also si_pci_fixcfg.
 */
void bcma_core_pci_early_init(struct bcma_drv_pci *pc)
{
	if (pc->early_setup_done)
		return;

	pc->hostmode = bcma_core_pci_is_in_hostmode(pc);
	if (pc->hostmode)
		goto out;

	bcma_core_pci_fixcfg(pc);

out:
	pc->early_setup_done = true;
}

/**************************************************
 * Workarounds.
 **************************************************/

static u8 bcma_pcicore_polarity_workaround(struct bcma_drv_pci *pc)
{
	u32 tmp;

	tmp = bcma_pcie_read(pc, BCMA_CORE_PCI_PLP_STATUSREG);
	if (tmp & BCMA_CORE_PCI_PLP_POLARITYINV_STAT)
		return BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE |
		       BCMA_CORE_PCI_SERDES_RX_CTRL_POLARITY;
	else
		return BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE;
}

static void bcma_pcicore_serdes_workaround(struct bcma_drv_pci *pc)
{
	u16 tmp;

	bcma_pcie_mdio_write(pc, BCMA_CORE_PCI_MDIODATA_DEV_RX,
	                     BCMA_CORE_PCI_SERDES_RX_CTRL,
			     bcma_pcicore_polarity_workaround(pc));
	tmp = bcma_pcie_mdio_read(pc, BCMA_CORE_PCI_MDIODATA_DEV_PLL,
	                          BCMA_CORE_PCI_SERDES_PLL_CTRL);
	if (tmp & BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN)
		bcma_pcie_mdio_write(pc, BCMA_CORE_PCI_MDIODATA_DEV_PLL,
		                     BCMA_CORE_PCI_SERDES_PLL_CTRL,
		                     tmp & ~BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN);
}

/* Fix MISC config to allow coming out of L2/L3-Ready state w/o PRST */
/* Needs to happen when coming out of 'standby'/'hibernate' */
static void bcma_core_pci_config_fixup(struct bcma_drv_pci *pc)
{
	u16 val16;
	uint regoff;

	regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_MISC_CONFIG);

	val16 = pcicore_read16(pc, regoff);

	if (!(val16 & BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST)) {
		val16 |= BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST;
		pcicore_write16(pc, regoff, val16);
	}
}

/**************************************************
 * Init.
 **************************************************/

static void bcma_core_pci_clientmode_init(struct bcma_drv_pci *pc)
{
	bcma_pcicore_serdes_workaround(pc);
	bcma_core_pci_config_fixup(pc);
}

void bcma_core_pci_init(struct bcma_drv_pci *pc)
{
	if (pc->setup_done)
		return;

	bcma_core_pci_early_init(pc);

	if (pc->hostmode)
		bcma_core_pci_hostmode_init(pc);
	else
		bcma_core_pci_clientmode_init(pc);
}

void bcma_core_pci_power_save(struct bcma_bus *bus, bool up)
{
	struct bcma_drv_pci *pc;
	u16 data;

	if (bus->hosttype != BCMA_HOSTTYPE_PCI)
		return;

	pc = &bus->drv_pci[0];

	if (pc->core->id.rev >= 15 && pc->core->id.rev <= 20) {
		data = up ? 0x74 : 0x7C;
		bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
					 BCMA_CORE_PCI_MDIO_BLK1_MGMT1, 0x7F64);
		bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
					 BCMA_CORE_PCI_MDIO_BLK1_MGMT3, data);
	} else if (pc->core->id.rev >= 21 && pc->core->id.rev <= 22) {
		data = up ? 0x75 : 0x7D;
		bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
					 BCMA_CORE_PCI_MDIO_BLK1_MGMT1, 0x7E65);
		bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
					 BCMA_CORE_PCI_MDIO_BLK1_MGMT3, data);
	}
}
EXPORT_SYMBOL_GPL(bcma_core_pci_power_save);

static void bcma_core_pci_extend_L1timer(struct bcma_drv_pci *pc, bool extend)
{
	u32 w;

	w = bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG);
	if (extend)
		w |= BCMA_CORE_PCI_ASPMTIMER_EXTEND;
	else
		w &= ~BCMA_CORE_PCI_ASPMTIMER_EXTEND;
	bcma_pcie_write(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG, w);
	bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG);
}

void bcma_core_pci_up(struct bcma_drv_pci *pc)
{
	bcma_core_pci_extend_L1timer(pc, true);
}

void bcma_core_pci_down(struct bcma_drv_pci *pc)
{
	bcma_core_pci_extend_L1timer(pc, false);
}
Commit	Line	Data
8369ae33 RM	1	/*
	2	* Broadcom specific AMBA
	3	* PCI Core
	4	*
49dc9577	5	* Copyright 2005, 2011, Broadcom Corporation
eb032b98	6	* Copyright 2006, 2007, Michael Buesch <[email protected]>
2be25cac	7	* Copyright 2011, 2012, Hauke Mehrtens <[email protected]>
8369ae33 RM	8	*
	9	* Licensed under the GNU/GPL. See COPYING for details.
	10	*/
	11
	12	#include "bcma_private.h"
44a8e377	13	#include <linux/export.h>
8369ae33 RM	14	#include <linux/bcma/bcma.h>
	15
	16	/**************************************************
	17	* R/W ops.
	18	**************************************************/
	19
4b259a5c	20	u32 bcma_pcie_read(struct bcma_drv_pci *pc, u32 address)
8369ae33	21	{
2be25cac HM	22	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address);
	23	pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR);
	24	return pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_DATA);
8369ae33 RM	25	}
8369ae33 RM	26
8369ae33 RM	27	static void bcma_pcie_write(struct bcma_drv_pci *pc, u32 address, u32 data)
8369ae33 RM	28	{
2be25cac HM	29	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address);
	30	pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR);
	31	pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_DATA, data);
8369ae33	32	}
8369ae33	33
521deea6	34	static void bcma_pcie_mdio_set_phy(struct bcma_drv_pci *pc, u16 phy)
8369ae33	35	{
8369ae33 RM	36	u32 v;
	37	int i;
	38
2be25cac HM	39	v = BCMA_CORE_PCI_MDIODATA_START;
	40	v \|= BCMA_CORE_PCI_MDIODATA_WRITE;
	41	v \|= (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
	42	BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
	43	v \|= (BCMA_CORE_PCI_MDIODATA_BLK_ADDR <<
	44	BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
	45	v \|= BCMA_CORE_PCI_MDIODATA_TA;
8369ae33	46	v \|= (phy << 4);
2be25cac	47	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);
8369ae33 RM	48
	49	udelay(10);
	50	for (i = 0; i < 200; i++) {
2be25cac HM	51	v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
2be25cac HM	52	if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE)
8369ae33	53	break;
1fd41a65	54	usleep_range(1000, 2000);
8369ae33 RM	55	}
	56	}
	57
521deea6	58	static u16 bcma_pcie_mdio_read(struct bcma_drv_pci *pc, u16 device, u8 address)
8369ae33	59	{
8369ae33 RM	60	int max_retries = 10;
	61	u16 ret = 0;
	62	u32 v;
	63	int i;
	64
2be25cac HM	65	/* enable mdio access to SERDES */
	66	v = BCMA_CORE_PCI_MDIOCTL_PREAM_EN;
	67	v \|= BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL;
	68	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, v);
8369ae33 RM	69
	70	if (pc->core->id.rev >= 10) {
	71	max_retries = 200;
	72	bcma_pcie_mdio_set_phy(pc, device);
2be25cac HM	73	v = (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
	74	BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
	75	v \|= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
	76	} else {
	77	v = (device << BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD);
	78	v \|= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD);
8369ae33 RM	79	}
8369ae33 RM	80
2be25cac HM	81	v = BCMA_CORE_PCI_MDIODATA_START;
	82	v \|= BCMA_CORE_PCI_MDIODATA_READ;
	83	v \|= BCMA_CORE_PCI_MDIODATA_TA;
	84
	85	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);
8369ae33 RM	86	/* Wait for the device to complete the transaction */
8369ae33 RM	87	udelay(10);
f1a9c1e6	88	for (i = 0; i < max_retries; i++) {
2be25cac HM	89	v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
2be25cac HM	90	if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE) {
8369ae33	91	udelay(10);
2be25cac	92	ret = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_DATA);
8369ae33 RM	93	break;
8369ae33 RM	94	}
1fd41a65	95	usleep_range(1000, 2000);
8369ae33	96	}
2be25cac	97	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, 0);
8369ae33 RM	98	return ret;
	99	}
	100
521deea6	101	static void bcma_pcie_mdio_write(struct bcma_drv_pci *pc, u16 device,
8369ae33 RM	102	u8 address, u16 data)
8369ae33 RM	103	{
8369ae33 RM	104	int max_retries = 10;
	105	u32 v;
	106	int i;
	107
2be25cac HM	108	/* enable mdio access to SERDES */
	109	v = BCMA_CORE_PCI_MDIOCTL_PREAM_EN;
	110	v \|= BCMA_CORE_PCI_MDIOCTL_DIVISOR_VAL;
	111	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, v);
8369ae33 RM	112
	113	if (pc->core->id.rev >= 10) {
	114	max_retries = 200;
	115	bcma_pcie_mdio_set_phy(pc, device);
2be25cac HM	116	v = (BCMA_CORE_PCI_MDIODATA_DEV_ADDR <<
	117	BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF);
	118	v \|= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF);
	119	} else {
	120	v = (device << BCMA_CORE_PCI_MDIODATA_DEVADDR_SHF_OLD);
	121	v \|= (address << BCMA_CORE_PCI_MDIODATA_REGADDR_SHF_OLD);
8369ae33 RM	122	}
8369ae33 RM	123
2be25cac HM	124	v = BCMA_CORE_PCI_MDIODATA_START;
	125	v \|= BCMA_CORE_PCI_MDIODATA_WRITE;
	126	v \|= BCMA_CORE_PCI_MDIODATA_TA;
8369ae33	127	v \|= data;
2be25cac	128	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_DATA, v);
8369ae33 RM	129	/* Wait for the device to complete the transaction */
	130	udelay(10);
	131	for (i = 0; i < max_retries; i++) {
2be25cac HM	132	v = pcicore_read32(pc, BCMA_CORE_PCI_MDIO_CONTROL);
2be25cac HM	133	if (v & BCMA_CORE_PCI_MDIOCTL_ACCESS_DONE)
8369ae33	134	break;
1fd41a65	135	usleep_range(1000, 2000);
8369ae33	136	}
2be25cac	137	pcicore_write32(pc, BCMA_CORE_PCI_MDIO_CONTROL, 0);
8369ae33 RM	138	}
8369ae33 RM	139
521deea6 HM	140	static u16 bcma_pcie_mdio_writeread(struct bcma_drv_pci *pc, u16 device,
	141	u8 address, u16 data)
	142	{
	143	bcma_pcie_mdio_write(pc, device, address, data);
	144	return bcma_pcie_mdio_read(pc, device, address);
	145	}
	146
b504075f RM	147	/**************************************************
	148	* Early init.
	149	**************************************************/
	150
	151	static void bcma_core_pci_fixcfg(struct bcma_drv_pci *pc)
	152	{
	153	struct bcma_device *core = pc->core;
	154	u16 val16, core_index;
	155	uint regoff;
	156
	157	regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_PI_OFFSET);
	158	core_index = (u16)core->core_index;
	159
	160	val16 = pcicore_read16(pc, regoff);
	161	if (((val16 & BCMA_CORE_PCI_SPROM_PI_MASK) >> BCMA_CORE_PCI_SPROM_PI_SHIFT)
	162	!= core_index) {
	163	val16 = (core_index << BCMA_CORE_PCI_SPROM_PI_SHIFT) \|
	164	(val16 & ~BCMA_CORE_PCI_SPROM_PI_MASK);
	165	pcicore_write16(pc, regoff, val16);
	166	}
	167	}
	168
	169	/*
	170	* Apply some early fixes required before accessing SPROM.
	171	* See also si_pci_fixcfg.
	172	*/
	173	void bcma_core_pci_early_init(struct bcma_drv_pci *pc)
	174	{
	175	if (pc->early_setup_done)
	176	return;
	177
	178	pc->hostmode = bcma_core_pci_is_in_hostmode(pc);
	179	if (pc->hostmode)
	180	goto out;
	181
	182	bcma_core_pci_fixcfg(pc);
	183
	184	out:
	185	pc->early_setup_done = true;
	186	}
	187
8369ae33 RM	188	/**************************************************
	189	* Workarounds.
	190	**************************************************/
	191
	192	static u8 bcma_pcicore_polarity_workaround(struct bcma_drv_pci *pc)
	193	{
2be25cac HM	194	u32 tmp;
	195
	196	tmp = bcma_pcie_read(pc, BCMA_CORE_PCI_PLP_STATUSREG);
	197	if (tmp & BCMA_CORE_PCI_PLP_POLARITYINV_STAT)
	198	return BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE \|
	199	BCMA_CORE_PCI_SERDES_RX_CTRL_POLARITY;
	200	else
	201	return BCMA_CORE_PCI_SERDES_RX_CTRL_FORCE;
8369ae33 RM	202	}
	203
	204	static void bcma_pcicore_serdes_workaround(struct bcma_drv_pci *pc)
	205	{
8369ae33 RM	206	u16 tmp;
8369ae33 RM	207
2be25cac HM	208	bcma_pcie_mdio_write(pc, BCMA_CORE_PCI_MDIODATA_DEV_RX,
	209	BCMA_CORE_PCI_SERDES_RX_CTRL,
	210	bcma_pcicore_polarity_workaround(pc));
	211	tmp = bcma_pcie_mdio_read(pc, BCMA_CORE_PCI_MDIODATA_DEV_PLL,
	212	BCMA_CORE_PCI_SERDES_PLL_CTRL);
	213	if (tmp & BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN)
	214	bcma_pcie_mdio_write(pc, BCMA_CORE_PCI_MDIODATA_DEV_PLL,
	215	BCMA_CORE_PCI_SERDES_PLL_CTRL,
	216	tmp & ~BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN);
8369ae33 RM	217	}
8369ae33 RM	218
2b2715b8 HM	219	/* Fix MISC config to allow coming out of L2/L3-Ready state w/o PRST */
	220	/* Needs to happen when coming out of 'standby'/'hibernate' */
	221	static void bcma_core_pci_config_fixup(struct bcma_drv_pci *pc)
	222	{
	223	u16 val16;
	224	uint regoff;
	225
	226	regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_MISC_CONFIG);
	227
	228	val16 = pcicore_read16(pc, regoff);
	229
	230	if (!(val16 & BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST)) {
	231	val16 \|= BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST;
	232	pcicore_write16(pc, regoff, val16);
	233	}
	234	}
	235
8369ae33 RM	236	/**************************************************
	237	* Init.
	238	**************************************************/
	239
0f58a01d	240	static void bcma_core_pci_clientmode_init(struct bcma_drv_pci *pc)
8369ae33 RM	241	{
8369ae33 RM	242	bcma_pcicore_serdes_workaround(pc);
2b2715b8	243	bcma_core_pci_config_fixup(pc);
8369ae33	244	}
1de520f4	245
0f58a01d	246	void bcma_core_pci_init(struct bcma_drv_pci *pc)
9352f69c	247	{
517f43e5 HM	248	if (pc->setup_done)
	249	return;
	250
b504075f RM	251	bcma_core_pci_early_init(pc);
b504075f RM	252
49dc9577	253	if (pc->hostmode)
9352f69c	254	bcma_core_pci_hostmode_init(pc);
b504075f	255	else
49dc9577	256	bcma_core_pci_clientmode_init(pc);
9352f69c RM	257	}
9352f69c RM	258
2bedea8f AS	259	void bcma_core_pci_power_save(struct bcma_bus *bus, bool up)
	260	{
	261	struct bcma_drv_pci *pc;
	262	u16 data;
	263
	264	if (bus->hosttype != BCMA_HOSTTYPE_PCI)
	265	return;
	266
	267	pc = &bus->drv_pci[0];
	268
	269	if (pc->core->id.rev >= 15 && pc->core->id.rev <= 20) {
	270	data = up ? 0x74 : 0x7C;
	271	bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
	272	BCMA_CORE_PCI_MDIO_BLK1_MGMT1, 0x7F64);
	273	bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
	274	BCMA_CORE_PCI_MDIO_BLK1_MGMT3, data);
	275	} else if (pc->core->id.rev >= 21 && pc->core->id.rev <= 22) {
	276	data = up ? 0x75 : 0x7D;
	277	bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
	278	BCMA_CORE_PCI_MDIO_BLK1_MGMT1, 0x7E65);
	279	bcma_pcie_mdio_writeread(pc, BCMA_CORE_PCI_MDIO_BLK1,
	280	BCMA_CORE_PCI_MDIO_BLK1_MGMT3, data);
	281	}
	282	}
	283	EXPORT_SYMBOL_GPL(bcma_core_pci_power_save);
	284
780335ac	285	static void bcma_core_pci_extend_L1timer(struct bcma_drv_pci *pc, bool extend)
29f6b3d8 HM	286	{
	287	u32 w;
	288
	289	w = bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG);
	290	if (extend)
	291	w \|= BCMA_CORE_PCI_ASPMTIMER_EXTEND;
	292	else
	293	w &= ~BCMA_CORE_PCI_ASPMTIMER_EXTEND;
	294	bcma_pcie_write(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG, w);
	295	bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG);
	296	}
cfe51ec1	297
4186721d	298	void bcma_core_pci_up(struct bcma_drv_pci *pc)
cfe51ec1	299	{
cfe51ec1 HM	300	bcma_core_pci_extend_L1timer(pc, true);
cfe51ec1 HM	301	}
cfe51ec1	302
4186721d	303	void bcma_core_pci_down(struct bcma_drv_pci *pc)
cfe51ec1	304	{
cfe51ec1 HM	305	bcma_core_pci_extend_L1timer(pc, false);
cfe51ec1 HM	306	}