[mirror_ubuntu-jammy-kernel.git] / drivers / net / ethernet / broadcom / bgmac-bcma.c

/*
 * Driver for (BCM4706)? GBit MAC core on BCMA bus.
 *
 * Copyright (C) 2012 Rafał Miłecki <zajec5@gmail.com>
 *
 * Licensed under the GNU/GPL. See COPYING for details.
 */

#define pr_fmt(fmt)		KBUILD_MODNAME ": " fmt

#include <linux/bcma/bcma.h>
#include <linux/brcmphy.h>
#include <linux/etherdevice.h>
#include <linux/of_net.h>
#include "bgmac.h"

static inline bool bgmac_is_bcm4707_family(struct bcma_device *core)
{
	switch (core->bus->chipinfo.id) {
	case BCMA_CHIP_ID_BCM4707:
	case BCMA_CHIP_ID_BCM47094:
	case BCMA_CHIP_ID_BCM53018:
		return true;
	default:
		return false;
	}
}

/**************************************************
 * BCMA bus ops
 **************************************************/

static u32 bcma_bgmac_read(struct bgmac *bgmac, u16 offset)
{
	return bcma_read32(bgmac->bcma.core, offset);
}

static void bcma_bgmac_write(struct bgmac *bgmac, u16 offset, u32 value)
{
	bcma_write32(bgmac->bcma.core, offset, value);
}

static u32 bcma_bgmac_idm_read(struct bgmac *bgmac, u16 offset)
{
	return bcma_aread32(bgmac->bcma.core, offset);
}

static void bcma_bgmac_idm_write(struct bgmac *bgmac, u16 offset, u32 value)
{
	return bcma_awrite32(bgmac->bcma.core, offset, value);
}

static bool bcma_bgmac_clk_enabled(struct bgmac *bgmac)
{
	return bcma_core_is_enabled(bgmac->bcma.core);
}

static void bcma_bgmac_clk_enable(struct bgmac *bgmac, u32 flags)
{
	bcma_core_enable(bgmac->bcma.core, flags);
}

static void bcma_bgmac_cco_ctl_maskset(struct bgmac *bgmac, u32 offset,
				       u32 mask, u32 set)
{
	struct bcma_drv_cc *cc = &bgmac->bcma.core->bus->drv_cc;

	bcma_chipco_chipctl_maskset(cc, offset, mask, set);
}

static u32 bcma_bgmac_get_bus_clock(struct bgmac *bgmac)
{
	struct bcma_drv_cc *cc = &bgmac->bcma.core->bus->drv_cc;

	return bcma_pmu_get_bus_clock(cc);
}

static void bcma_bgmac_cmn_maskset32(struct bgmac *bgmac, u16 offset, u32 mask,
				     u32 set)
{
	bcma_maskset32(bgmac->bcma.cmn, offset, mask, set);
}

static int bcma_phy_connect(struct bgmac *bgmac)
{
	struct phy_device *phy_dev;
	char bus_id[MII_BUS_ID_SIZE + 3];

	/* Connect to the PHY */
	snprintf(bus_id, sizeof(bus_id), PHY_ID_FMT, bgmac->mii_bus->id,
		 bgmac->phyaddr);
	phy_dev = phy_connect(bgmac->net_dev, bus_id, bgmac_adjust_link,
			      PHY_INTERFACE_MODE_MII);
	if (IS_ERR(phy_dev)) {
		dev_err(bgmac->dev, "PHY connection failed\n");
		return PTR_ERR(phy_dev);
	}

	return 0;
}

static const struct bcma_device_id bgmac_bcma_tbl[] = {
	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_4706_MAC_GBIT,
		  BCMA_ANY_REV, BCMA_ANY_CLASS),
	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_MAC_GBIT, BCMA_ANY_REV,
		  BCMA_ANY_CLASS),
	{},
};
MODULE_DEVICE_TABLE(bcma, bgmac_bcma_tbl);

/* http://bcm-v4.sipsolutions.net/mac-gbit/gmac/chipattach */
static int bgmac_probe(struct bcma_device *core)
{
	struct bcma_chipinfo *ci = &core->bus->chipinfo;
	struct ssb_sprom *sprom = &core->bus->sprom;
	struct mii_bus *mii_bus;
	struct bgmac *bgmac;
	const u8 *mac;
	int err;

	bgmac = bgmac_alloc(&core->dev);
	if (!bgmac)
		return -ENOMEM;

	bgmac->bcma.core = core;
	bgmac->dma_dev = core->dma_dev;
	bgmac->irq = core->irq;

	bcma_set_drvdata(core, bgmac);

	err = of_get_mac_address(bgmac->dev->of_node, bgmac->net_dev->dev_addr);
	if (err == -EPROBE_DEFER)
		return err;

	/* If no MAC address assigned via device tree, check SPROM */
	if (err) {
		switch (core->core_unit) {
		case 0:
			mac = sprom->et0mac;
			break;
		case 1:
			mac = sprom->et1mac;
			break;
		case 2:
			mac = sprom->et2mac;
			break;
		default:
			dev_err(bgmac->dev, "Unsupported core_unit %d\n",
				core->core_unit);
			err = -ENOTSUPP;
			goto err;
		}
		ether_addr_copy(bgmac->net_dev->dev_addr, mac);
	}

	/* On BCM4706 we need common core to access PHY */
	if (core->id.id == BCMA_CORE_4706_MAC_GBIT &&
	    !core->bus->drv_gmac_cmn.core) {
		dev_err(bgmac->dev, "GMAC CMN core not found (required for BCM4706)\n");
		err = -ENODEV;
		goto err;
	}
	bgmac->bcma.cmn = core->bus->drv_gmac_cmn.core;

	switch (core->core_unit) {
	case 0:
		bgmac->phyaddr = sprom->et0phyaddr;
		break;
	case 1:
		bgmac->phyaddr = sprom->et1phyaddr;
		break;
	case 2:
		bgmac->phyaddr = sprom->et2phyaddr;
		break;
	}
	bgmac->phyaddr &= BGMAC_PHY_MASK;
	if (bgmac->phyaddr == BGMAC_PHY_MASK) {
		dev_err(bgmac->dev, "No PHY found\n");
		err = -ENODEV;
		goto err;
	}
	dev_info(bgmac->dev, "Found PHY addr: %d%s\n", bgmac->phyaddr,
		 bgmac->phyaddr == BGMAC_PHY_NOREGS ? " (NOREGS)" : "");

	if (!bgmac_is_bcm4707_family(core) &&
	    !(ci->id == BCMA_CHIP_ID_BCM53573 && core->core_unit == 1)) {
		struct phy_device *phydev;

		mii_bus = bcma_mdio_mii_register(bgmac);
		if (IS_ERR(mii_bus)) {
			err = PTR_ERR(mii_bus);
			goto err;
		}
		bgmac->mii_bus = mii_bus;

		phydev = mdiobus_get_phy(bgmac->mii_bus, bgmac->phyaddr);
		if (ci->id == BCMA_CHIP_ID_BCM53573 && phydev &&
		    (phydev->drv->phy_id & phydev->drv->phy_id_mask) == PHY_ID_BCM54210E)
			phydev->dev_flags |= PHY_BRCM_EN_MASTER_MODE;
	}

	if (core->bus->hosttype == BCMA_HOSTTYPE_PCI) {
		dev_err(bgmac->dev, "PCI setup not implemented\n");
		err = -ENOTSUPP;
		goto err1;
	}

	bgmac->has_robosw = !!(sprom->boardflags_lo & BGMAC_BFL_ENETROBO);
	if (bgmac->has_robosw)
		dev_warn(bgmac->dev, "Support for Roboswitch not implemented\n");

	if (sprom->boardflags_lo & BGMAC_BFL_ENETADM)
		dev_warn(bgmac->dev, "Support for ADMtek ethernet switch not implemented\n");

	/* Feature Flags */
	switch (ci->id) {
	/* BCM 471X/535X family */
	case BCMA_CHIP_ID_BCM4716:
		bgmac->feature_flags |= BGMAC_FEAT_CLKCTLST;
		fallthrough;
	case BCMA_CHIP_ID_BCM47162:
		bgmac->feature_flags |= BGMAC_FEAT_FLW_CTRL2;
		bgmac->feature_flags |= BGMAC_FEAT_SET_RXQ_CLK;
		break;
	case BCMA_CHIP_ID_BCM5357:
	case BCMA_CHIP_ID_BCM53572:
		bgmac->feature_flags |= BGMAC_FEAT_SET_RXQ_CLK;
		bgmac->feature_flags |= BGMAC_FEAT_CLKCTLST;
		bgmac->feature_flags |= BGMAC_FEAT_FLW_CTRL1;
		bgmac->feature_flags |= BGMAC_FEAT_SW_TYPE_PHY;
		if (ci->pkg == BCMA_PKG_ID_BCM47188 ||
		    ci->pkg == BCMA_PKG_ID_BCM47186) {
			bgmac->feature_flags |= BGMAC_FEAT_SW_TYPE_RGMII;
			bgmac->feature_flags |= BGMAC_FEAT_IOST_ATTACHED;
		}
		if (ci->pkg == BCMA_PKG_ID_BCM5358)
			bgmac->feature_flags |= BGMAC_FEAT_SW_TYPE_EPHYRMII;
		break;
	case BCMA_CHIP_ID_BCM53573:
		bgmac->feature_flags |= BGMAC_FEAT_CLKCTLST;
		bgmac->feature_flags |= BGMAC_FEAT_SET_RXQ_CLK;
		if (ci->pkg == BCMA_PKG_ID_BCM47189)
			bgmac->feature_flags |= BGMAC_FEAT_IOST_ATTACHED;
		if (core->core_unit == 0) {
			bgmac->feature_flags |= BGMAC_FEAT_CC4_IF_SW_TYPE;
			if (ci->pkg == BCMA_PKG_ID_BCM47189)
				bgmac->feature_flags |=
					BGMAC_FEAT_CC4_IF_SW_TYPE_RGMII;
		} else if (core->core_unit == 1) {
			bgmac->feature_flags |= BGMAC_FEAT_IRQ_ID_OOB_6;
			bgmac->feature_flags |= BGMAC_FEAT_CC7_IF_TYPE_RGMII;
		}
		break;
	case BCMA_CHIP_ID_BCM4749:
		bgmac->feature_flags |= BGMAC_FEAT_SET_RXQ_CLK;
		bgmac->feature_flags |= BGMAC_FEAT_CLKCTLST;
		bgmac->feature_flags |= BGMAC_FEAT_FLW_CTRL1;
		bgmac->feature_flags |= BGMAC_FEAT_SW_TYPE_PHY;
		if (ci->pkg == 10) {
			bgmac->feature_flags |= BGMAC_FEAT_SW_TYPE_RGMII;
			bgmac->feature_flags |= BGMAC_FEAT_IOST_ATTACHED;
		}
		break;
	/* bcm4707_family */
	case BCMA_CHIP_ID_BCM4707:
	case BCMA_CHIP_ID_BCM47094:
	case BCMA_CHIP_ID_BCM53018:
		bgmac->feature_flags |= BGMAC_FEAT_CLKCTLST;
		bgmac->feature_flags |= BGMAC_FEAT_NO_RESET;
		bgmac->feature_flags |= BGMAC_FEAT_FORCE_SPEED_2500;
		break;
	default:
		bgmac->feature_flags |= BGMAC_FEAT_CLKCTLST;
		bgmac->feature_flags |= BGMAC_FEAT_SET_RXQ_CLK;
	}

	if (!bgmac_is_bcm4707_family(core) && core->id.rev > 2)
		bgmac->feature_flags |= BGMAC_FEAT_MISC_PLL_REQ;

	if (core->id.id == BCMA_CORE_4706_MAC_GBIT) {
		bgmac->feature_flags |= BGMAC_FEAT_CMN_PHY_CTL;
		bgmac->feature_flags |= BGMAC_FEAT_NO_CLR_MIB;
	}

	if (core->id.rev >= 4) {
		bgmac->feature_flags |= BGMAC_FEAT_CMDCFG_SR_REV4;
		bgmac->feature_flags |= BGMAC_FEAT_TX_MASK_SETUP;
		bgmac->feature_flags |= BGMAC_FEAT_RX_MASK_SETUP;
	}

	bgmac->read = bcma_bgmac_read;
	bgmac->write = bcma_bgmac_write;
	bgmac->idm_read = bcma_bgmac_idm_read;
	bgmac->idm_write = bcma_bgmac_idm_write;
	bgmac->clk_enabled = bcma_bgmac_clk_enabled;
	bgmac->clk_enable = bcma_bgmac_clk_enable;
	bgmac->cco_ctl_maskset = bcma_bgmac_cco_ctl_maskset;
	bgmac->get_bus_clock = bcma_bgmac_get_bus_clock;
	bgmac->cmn_maskset32 = bcma_bgmac_cmn_maskset32;
	if (bgmac->mii_bus)
		bgmac->phy_connect = bcma_phy_connect;
	else
		bgmac->phy_connect = bgmac_phy_connect_direct;

	err = bgmac_enet_probe(bgmac);
	if (err)
		goto err1;

	return 0;

err1:
	bcma_mdio_mii_unregister(bgmac->mii_bus);
err:
	bcma_set_drvdata(core, NULL);

	return err;
}

static void bgmac_remove(struct bcma_device *core)
{
	struct bgmac *bgmac = bcma_get_drvdata(core);

	bcma_mdio_mii_unregister(bgmac->mii_bus);
	bgmac_enet_remove(bgmac);
	bcma_set_drvdata(core, NULL);
}

static struct bcma_driver bgmac_bcma_driver = {
	.name		= KBUILD_MODNAME,
	.id_table	= bgmac_bcma_tbl,
	.probe		= bgmac_probe,
	.remove		= bgmac_remove,
};

static int __init bgmac_init(void)
{
	int err;

	err = bcma_driver_register(&bgmac_bcma_driver);
	if (err)
		return err;
	pr_info("Broadcom 47xx GBit MAC driver loaded\n");

	return 0;
}

static void __exit bgmac_exit(void)
{
	bcma_driver_unregister(&bgmac_bcma_driver);
}

module_init(bgmac_init)
module_exit(bgmac_exit)

MODULE_AUTHOR("Rafał Miłecki");
MODULE_LICENSE("GPL");
Commit	Line	Data
f6a95a24 JM	1	/*
	2	* Driver for (BCM4706)? GBit MAC core on BCMA bus.
	3	*
	4	* Copyright (C) 2012 Rafał Miłecki <zajec5@gmail.com>
	5	*
	6	* Licensed under the GNU/GPL. See COPYING for details.
	7	*/
	8
	9	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	10
	11	#include <linux/bcma/bcma.h>
	12	#include <linux/brcmphy.h>
	13	#include <linux/etherdevice.h>
2f771399	14	#include <linux/of_net.h>
f6a95a24 JM	15	#include "bgmac.h"
	16
	17	static inline bool bgmac_is_bcm4707_family(struct bcma_device *core)
	18	{
	19	switch (core->bus->chipinfo.id) {
	20	case BCMA_CHIP_ID_BCM4707:
	21	case BCMA_CHIP_ID_BCM47094:
	22	case BCMA_CHIP_ID_BCM53018:
	23	return true;
	24	default:
	25	return false;
	26	}
	27	}
	28
	29	/**************************************************
	30	* BCMA bus ops
	31	**************************************************/
	32
	33	static u32 bcma_bgmac_read(struct bgmac *bgmac, u16 offset)
	34	{
	35	return bcma_read32(bgmac->bcma.core, offset);
	36	}
	37
	38	static void bcma_bgmac_write(struct bgmac *bgmac, u16 offset, u32 value)
	39	{
	40	bcma_write32(bgmac->bcma.core, offset, value);
	41	}
	42
	43	static u32 bcma_bgmac_idm_read(struct bgmac *bgmac, u16 offset)
	44	{
	45	return bcma_aread32(bgmac->bcma.core, offset);
	46	}
	47
	48	static void bcma_bgmac_idm_write(struct bgmac *bgmac, u16 offset, u32 value)
	49	{
	50	return bcma_awrite32(bgmac->bcma.core, offset, value);
	51	}
	52
	53	static bool bcma_bgmac_clk_enabled(struct bgmac *bgmac)
	54	{
	55	return bcma_core_is_enabled(bgmac->bcma.core);
	56	}
	57
	58	static void bcma_bgmac_clk_enable(struct bgmac *bgmac, u32 flags)
	59	{
	60	bcma_core_enable(bgmac->bcma.core, flags);
	61	}
	62
	63	static void bcma_bgmac_cco_ctl_maskset(struct bgmac *bgmac, u32 offset,
	64	u32 mask, u32 set)
	65	{
	66	struct bcma_drv_cc *cc = &bgmac->bcma.core->bus->drv_cc;
	67
	68	bcma_chipco_chipctl_maskset(cc, offset, mask, set);
	69	}
	70
	71	static u32 bcma_bgmac_get_bus_clock(struct bgmac *bgmac)
	72	{
	73	struct bcma_drv_cc *cc = &bgmac->bcma.core->bus->drv_cc;
	74
	75	return bcma_pmu_get_bus_clock(cc);
	76	}
	77
	78	static void bcma_bgmac_cmn_maskset32(struct bgmac *bgmac, u16 offset, u32 mask,
79	u32 set)
80	{
81	bcma_maskset32(bgmac->bcma.cmn, offset, mask, set);
82	}
83
1676aba5 JM	84	static int bcma_phy_connect(struct bgmac *bgmac)
	85	{
	86	struct phy_device *phy_dev;
	87	char bus_id[MII_BUS_ID_SIZE + 3];
	88
	89	/* Connect to the PHY */
	90	snprintf(bus_id, sizeof(bus_id), PHY_ID_FMT, bgmac->mii_bus->id,
	91	bgmac->phyaddr);
	92	phy_dev = phy_connect(bgmac->net_dev, bus_id, bgmac_adjust_link,
	93	PHY_INTERFACE_MODE_MII);
	94	if (IS_ERR(phy_dev)) {
	95	dev_err(bgmac->dev, "PHY connection failed\n");
	96	return PTR_ERR(phy_dev);
	97	}
	98
	99	return 0;
	100	}
	101
f6a95a24 JM	102	static const struct bcma_device_id bgmac_bcma_tbl[] = {
	103	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_4706_MAC_GBIT,
	104	BCMA_ANY_REV, BCMA_ANY_CLASS),
	105	BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_MAC_GBIT, BCMA_ANY_REV,
	106	BCMA_ANY_CLASS),
	107	{},
	108	};
	109	MODULE_DEVICE_TABLE(bcma, bgmac_bcma_tbl);
	110
	111	/* http://bcm-v4.sipsolutions.net/mac-gbit/gmac/chipattach */
	112	static int bgmac_probe(struct bcma_device *core)
	113	{
1cb94db3	114	struct bcma_chipinfo *ci = &core->bus->chipinfo;
f6a95a24 JM	115	struct ssb_sprom *sprom = &core->bus->sprom;
	116	struct mii_bus *mii_bus;
	117	struct bgmac *bgmac;
83216e39	118	const u8 *mac;
f6a95a24 JM	119	int err;
f6a95a24 JM	120
34a5102c	121	bgmac = bgmac_alloc(&core->dev);
f6a95a24 JM	122	if (!bgmac)
	123	return -ENOMEM;
	124
	125	bgmac->bcma.core = core;
f6a95a24 JM	126	bgmac->dma_dev = core->dma_dev;
	127	bgmac->irq = core->irq;
	128
	129	bcma_set_drvdata(core, bgmac);
	130
83216e39	131	err = of_get_mac_address(bgmac->dev->of_node, bgmac->net_dev->dev_addr);
029497e6 CL	132	if (err == -EPROBE_DEFER)
029497e6 CL	133	return err;
2f771399 SL	134
2f771399 SL	135	/* If no MAC address assigned via device tree, check SPROM */
83216e39	136	if (err) {
2f771399 SL	137	switch (core->core_unit) {
	138	case 0:
	139	mac = sprom->et0mac;
	140	break;
	141	case 1:
	142	mac = sprom->et1mac;
	143	break;
	144	case 2:
	145	mac = sprom->et2mac;
	146	break;
	147	default:
	148	dev_err(bgmac->dev, "Unsupported core_unit %d\n",
	149	core->core_unit);
	150	err = -ENOTSUPP;
	151	goto err;
	152	}
83216e39	153	ether_addr_copy(bgmac->net_dev->dev_addr, mac);
f6a95a24 JM	154	}
f6a95a24 JM	155
f6a95a24 JM	156	/* On BCM4706 we need common core to access PHY */
	157	if (core->id.id == BCMA_CORE_4706_MAC_GBIT &&
	158	!core->bus->drv_gmac_cmn.core) {
	159	dev_err(bgmac->dev, "GMAC CMN core not found (required for BCM4706)\n");
	160	err = -ENODEV;
	161	goto err;
	162	}
	163	bgmac->bcma.cmn = core->bus->drv_gmac_cmn.core;
	164
	165	switch (core->core_unit) {
	166	case 0:
	167	bgmac->phyaddr = sprom->et0phyaddr;
	168	break;
	169	case 1:
	170	bgmac->phyaddr = sprom->et1phyaddr;
	171	break;
	172	case 2:
	173	bgmac->phyaddr = sprom->et2phyaddr;
	174	break;
	175	}
	176	bgmac->phyaddr &= BGMAC_PHY_MASK;
	177	if (bgmac->phyaddr == BGMAC_PHY_MASK) {
	178	dev_err(bgmac->dev, "No PHY found\n");
	179	err = -ENODEV;
	180	goto err;
	181	}
	182	dev_info(bgmac->dev, "Found PHY addr: %d%s\n", bgmac->phyaddr,
	183	bgmac->phyaddr == BGMAC_PHY_NOREGS ? " (NOREGS)" : "");
	184
1cb94db3 RM	185	if (!bgmac_is_bcm4707_family(core) &&
1cb94db3 RM	186	!(ci->id == BCMA_CHIP_ID_BCM53573 && core->core_unit == 1)) {
12acd136 RM	187	struct phy_device *phydev;
12acd136 RM	188
aa8863e5	189	mii_bus = bcma_mdio_mii_register(bgmac);
b9f63ae7	190	if (IS_ERR(mii_bus)) {
f6a95a24 JM	191	err = PTR_ERR(mii_bus);
	192	goto err;
	193	}
f6a95a24	194	bgmac->mii_bus = mii_bus;
12acd136 RM	195
	196	phydev = mdiobus_get_phy(bgmac->mii_bus, bgmac->phyaddr);
	197	if (ci->id == BCMA_CHIP_ID_BCM53573 && phydev &&
	198	(phydev->drv->phy_id & phydev->drv->phy_id_mask) == PHY_ID_BCM54210E)
	199	phydev->dev_flags \|= PHY_BRCM_EN_MASTER_MODE;
f6a95a24 JM	200	}
	201
	202	if (core->bus->hosttype == BCMA_HOSTTYPE_PCI) {
	203	dev_err(bgmac->dev, "PCI setup not implemented\n");
	204	err = -ENOTSUPP;
	205	goto err1;
	206	}
	207
cb1b0f90	208	bgmac->has_robosw = !!(sprom->boardflags_lo & BGMAC_BFL_ENETROBO);
f6a95a24 JM	209	if (bgmac->has_robosw)
	210	dev_warn(bgmac->dev, "Support for Roboswitch not implemented\n");
	211
cb1b0f90	212	if (sprom->boardflags_lo & BGMAC_BFL_ENETADM)
f6a95a24 JM	213	dev_warn(bgmac->dev, "Support for ADMtek ethernet switch not implemented\n");
	214
	215	/* Feature Flags */
cb1b0f90 JM	216	switch (ci->id) {
	217	/* BCM 471X/535X family */
	218	case BCMA_CHIP_ID_BCM4716:
	219	bgmac->feature_flags \|= BGMAC_FEAT_CLKCTLST;
df561f66	220	fallthrough;
cb1b0f90 JM	221	case BCMA_CHIP_ID_BCM47162:
	222	bgmac->feature_flags \|= BGMAC_FEAT_FLW_CTRL2;
	223	bgmac->feature_flags \|= BGMAC_FEAT_SET_RXQ_CLK;
	224	break;
f6a95a24	225	case BCMA_CHIP_ID_BCM5357:
cb1b0f90	226	case BCMA_CHIP_ID_BCM53572:
f6a95a24 JM	227	bgmac->feature_flags \|= BGMAC_FEAT_SET_RXQ_CLK;
	228	bgmac->feature_flags \|= BGMAC_FEAT_CLKCTLST;
	229	bgmac->feature_flags \|= BGMAC_FEAT_FLW_CTRL1;
	230	bgmac->feature_flags \|= BGMAC_FEAT_SW_TYPE_PHY;
cb1b0f90 JM	231	if (ci->pkg == BCMA_PKG_ID_BCM47188 \|\|
cb1b0f90 JM	232	ci->pkg == BCMA_PKG_ID_BCM47186) {
f6a95a24	233	bgmac->feature_flags \|= BGMAC_FEAT_SW_TYPE_RGMII;
cb1b0f90	234	bgmac->feature_flags \|= BGMAC_FEAT_IOST_ATTACHED;
f6a95a24	235	}
cb1b0f90	236	if (ci->pkg == BCMA_PKG_ID_BCM5358)
f6a95a24 JM	237	bgmac->feature_flags \|= BGMAC_FEAT_SW_TYPE_EPHYRMII;
f6a95a24 JM	238	break;
cb1b0f90	239	case BCMA_CHIP_ID_BCM53573:
f6a95a24	240	bgmac->feature_flags \|= BGMAC_FEAT_CLKCTLST;
cb1b0f90 JM	241	bgmac->feature_flags \|= BGMAC_FEAT_SET_RXQ_CLK;
cb1b0f90 JM	242	if (ci->pkg == BCMA_PKG_ID_BCM47189)
f6a95a24	243	bgmac->feature_flags \|= BGMAC_FEAT_IOST_ATTACHED;
cb1b0f90 JM	244	if (core->core_unit == 0) {
	245	bgmac->feature_flags \|= BGMAC_FEAT_CC4_IF_SW_TYPE;
	246	if (ci->pkg == BCMA_PKG_ID_BCM47189)
	247	bgmac->feature_flags \|=
	248	BGMAC_FEAT_CC4_IF_SW_TYPE_RGMII;
	249	} else if (core->core_unit == 1) {
	250	bgmac->feature_flags \|= BGMAC_FEAT_IRQ_ID_OOB_6;
	251	bgmac->feature_flags \|= BGMAC_FEAT_CC7_IF_TYPE_RGMII;
f6a95a24 JM	252	}
	253	break;
	254	case BCMA_CHIP_ID_BCM4749:
	255	bgmac->feature_flags \|= BGMAC_FEAT_SET_RXQ_CLK;
	256	bgmac->feature_flags \|= BGMAC_FEAT_CLKCTLST;
	257	bgmac->feature_flags \|= BGMAC_FEAT_FLW_CTRL1;
	258	bgmac->feature_flags \|= BGMAC_FEAT_SW_TYPE_PHY;
cb1b0f90	259	if (ci->pkg == 10) {
f6a95a24 JM	260	bgmac->feature_flags \|= BGMAC_FEAT_SW_TYPE_RGMII;
	261	bgmac->feature_flags \|= BGMAC_FEAT_IOST_ATTACHED;
	262	}
	263	break;
f6a95a24 JM	264	/* bcm4707_family */
	265	case BCMA_CHIP_ID_BCM4707:
	266	case BCMA_CHIP_ID_BCM47094:
	267	case BCMA_CHIP_ID_BCM53018:
	268	bgmac->feature_flags \|= BGMAC_FEAT_CLKCTLST;
	269	bgmac->feature_flags \|= BGMAC_FEAT_NO_RESET;
	270	bgmac->feature_flags \|= BGMAC_FEAT_FORCE_SPEED_2500;
	271	break;
	272	default:
	273	bgmac->feature_flags \|= BGMAC_FEAT_CLKCTLST;
	274	bgmac->feature_flags \|= BGMAC_FEAT_SET_RXQ_CLK;
	275	}
	276
	277	if (!bgmac_is_bcm4707_family(core) && core->id.rev > 2)
	278	bgmac->feature_flags \|= BGMAC_FEAT_MISC_PLL_REQ;
	279
	280	if (core->id.id == BCMA_CORE_4706_MAC_GBIT) {
	281	bgmac->feature_flags \|= BGMAC_FEAT_CMN_PHY_CTL;
	282	bgmac->feature_flags \|= BGMAC_FEAT_NO_CLR_MIB;
	283	}
	284
	285	if (core->id.rev >= 4) {
	286	bgmac->feature_flags \|= BGMAC_FEAT_CMDCFG_SR_REV4;
	287	bgmac->feature_flags \|= BGMAC_FEAT_TX_MASK_SETUP;
	288	bgmac->feature_flags \|= BGMAC_FEAT_RX_MASK_SETUP;
	289	}
	290
	291	bgmac->read = bcma_bgmac_read;
	292	bgmac->write = bcma_bgmac_write;
	293	bgmac->idm_read = bcma_bgmac_idm_read;
	294	bgmac->idm_write = bcma_bgmac_idm_write;
	295	bgmac->clk_enabled = bcma_bgmac_clk_enabled;
	296	bgmac->clk_enable = bcma_bgmac_clk_enable;
	297	bgmac->cco_ctl_maskset = bcma_bgmac_cco_ctl_maskset;
	298	bgmac->get_bus_clock = bcma_bgmac_get_bus_clock;
	299	bgmac->cmn_maskset32 = bcma_bgmac_cmn_maskset32;
1676aba5 JM	300	if (bgmac->mii_bus)
	301	bgmac->phy_connect = bcma_phy_connect;
	302	else
	303	bgmac->phy_connect = bgmac_phy_connect_direct;
f6a95a24 JM	304
	305	err = bgmac_enet_probe(bgmac);
	306	if (err)
	307	goto err1;
	308
	309	return 0;
	310
	311	err1:
	312	bcma_mdio_mii_unregister(bgmac->mii_bus);
	313	err:
f6a95a24 JM	314	bcma_set_drvdata(core, NULL);
	315
	316	return err;
	317	}
	318
	319	static void bgmac_remove(struct bcma_device *core)
	320	{
	321	struct bgmac *bgmac = bcma_get_drvdata(core);
	322
	323	bcma_mdio_mii_unregister(bgmac->mii_bus);
	324	bgmac_enet_remove(bgmac);
	325	bcma_set_drvdata(core, NULL);
f6a95a24 JM	326	}
	327
	328	static struct bcma_driver bgmac_bcma_driver = {
	329	.name = KBUILD_MODNAME,
	330	.id_table = bgmac_bcma_tbl,
	331	.probe = bgmac_probe,
	332	.remove = bgmac_remove,
	333	};
	334
	335	static int __init bgmac_init(void)
	336	{
	337	int err;
	338
	339	err = bcma_driver_register(&bgmac_bcma_driver);
	340	if (err)
	341	return err;
	342	pr_info("Broadcom 47xx GBit MAC driver loaded\n");
	343
	344	return 0;
	345	}
	346
	347	static void __exit bgmac_exit(void)
	348	{
	349	bcma_driver_unregister(&bgmac_bcma_driver);
	350	}
	351
	352	module_init(bgmac_init)
	353	module_exit(bgmac_exit)
	354
	355	MODULE_AUTHOR("Rafał Miłecki");
	356	MODULE_LICENSE("GPL");