skge.c

这是Marvell Technology Group Ltd. 4355 (rev 12)网卡在linux下的驱动程序源代码

			SK_OUT8(IoC, GPHY_CTRL, 0x02);		/* clear PHY reset */
		}

		SK_OUT8(IoC, GMAC_CTRL, 0x02);			/* clear MAC reset */
#ifdef USE_ASF_DASH_FW
		SkSetFWLinkParams(pAC, IoC, Port);
#else
		SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV, 0x01e1); /* Advertise 10/100 HD/FD */
		SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
		SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0xb300); /* 100 MBps, Autoneg, FD */
		GM_OUT16(IoC, Port, GM_GP_CTRL, 0x383a);
#endif
	} else if ((pAC->GIni.GIChipId == CHIP_ID_YUKON_FE) ||
			   (pAC->GIni.GIChipId == CHIP_ID_YUKON_FE_P)) {
		SK_OUT8(IoC, B0_POWER_CTRL, 0xa9);		/* enable VAUX */
		SK_OUT8(IoC, GPHY_CTRL, 0x02);			/* clear PHY reset */
		SK_OUT8(IoC, GMAC_CTRL, 0x02);			/* clear MAC reset */
		SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_PHY_CTRL, 0x0130); /* Enable Automatic Crossover */
		SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0xb300);     /* 100 MBit, disable Autoneg */

		/*
		 * MAC Configuration:
		 * Set the MAC to 100 HD and enable the auto update
		 * features for Speed and Duplex Mode.
		 * If autonegotiation completes successfully, the
		 * MAC takes the link parameters from the PHY.
		 * If the link partner doesn't support autonegotiation,
		 * the MAC can receive magic packets if the link partner
		 * uses 100 HD.
		 */
		GM_OUT16(IoC, Port, GM_GP_CTRL, 0x383a);
	}

#ifdef USE_ASF_DASH_FW
	SkAsfSuspend(pAC, pAC->IoBase);
#endif

	/*
	 * Set Up Magic Packet parameters
	 */
#ifndef USE_ASF_DASH_FW
	for (i = 0; i < 6; i+=2) {				/* Set up magic packet MAC address */
		SK_IN16(IoC, B2_MAC_1 + i, &Word);
		SK_OUT16(IoC, WOL_MAC_ADDR_LO + i, Word);
	}

	Word = 0x0;
	Word |= WOL_CTL_ENA_PME_ON_MAGIC_PKT;   /* Enable PME on magic packet */
	Word |= WOL_CTL_ENA_MAGIC_PKT_UNIT;     /* Enable magic packet unit */
	SK_OUT16(IoC, WOL_CTRL_STAT, Word);
#endif
#ifdef USE_ASF_DASH_FW
	for (i = 0; i < 6; i+=2) {				/* Delete magic packet MAC address */
		SK_OUT16(IoC, WOL_MAC_ADDR_LO + i, 0x0);
	}

	Word = 0x0;
	Word |= WOL_CTL_DIS_PME_ON_MAGIC_PKT;   /* Disable PME on magic packet */
	Word |= WOL_CTL_DIS_MAGIC_PKT_UNIT;     /* Disable magic packet unit */
	Word |= WOL_CTL_DIS_PME_ON_LINK_CHG;    /* Disable PME on link change */
	Word |= WOL_CTL_DIS_LINK_CHG_UNIT;      /* Disable link change unit */
	SK_OUT16(IoC, WOL_CTRL_STAT, Word);
#endif

	/*
	 * Set up PME generation
	 */
	/* set PME legacy mode */
	/* Only for PCI express based chipsets */
	if ((pAC->GIni.GIChipId == CHIP_ID_YUKON_EC) ||
		(pAC->GIni.GIChipId == CHIP_ID_YUKON_FE) || 
		(CHIP_ID_YUKON_2(pAC))) {
		if (pAC->GIni.GIChipId != CHIP_ID_YUKON_EX) {
	  		SkPciReadCfgDWord(pAC, PCI_OUR_REG_1, &DWord);
	  		DWord |= 0x8000;
	  		SkPciWriteCfgDWord(pAC, PCI_OUR_REG_1, DWord);
		}
	}

#ifndef USE_ASF_DASH_FW
	SK_OUT8(IoC, RX_GMF_CTRL_T, (SK_U8)GMF_RST_SET);
#endif

	SK_OUT16(IoC, B0_CTST, Y2_HW_WOL_OFF);

	/* clear PME status and switch adapter to DState 3 */
	SkPciReadCfgWord(pAC, PCI_PM_CTL_STS, &Word);
	Word |= 0x103;
	SkPciWriteCfgWord(pAC, PCI_PM_CTL_STS, Word);

} /* SkEnableWOMagicPacket */

#ifdef USE_ASF_DASH_FW
static void SkSetFWLinkParams(
SK_AC         *pAC,      /* Adapter Control Context */
SK_IOC         IoC,      /* I/O control context     */
int            Port)     /* Port number             */
{
	if ((pAC->SuspendLinkSpeed == 0) && (pAC->SuspendDuplexMode == 0)) {

		SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV, 0x01e1); /* Advertise 10/100 HD/FD */
		SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
		SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0xb300); /* 100 MBps, Autoneg, FD */
		GM_OUT16(IoC, Port, GM_GP_CTRL, 0x383a);
		printk("sk98lin: suspended with 100 Mbps, autoneg on, full duplex\n");
	}
	else if (pAC->SuspendLinkSpeed == SK_LSPEED_100MBPS) {

		switch (pAC->SuspendDuplexMode) {
		case SK_LMODE_AUTOFULL:
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV, 0x01e1); /* Advertise 10/100 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0xb300); /* 100 MBps, Autoneg, FD */
			GM_OUT16(IoC, Port, GM_GP_CTRL, 0x383a);
			printk("sk98lin: suspended with 100 Mbps, autoneg on, full duplex\n");
			break;

		case SK_LMODE_AUTOHALF:
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV, 0x00a1); /* Advertise 10/100 HD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0xb200); /* 100 MBps, Autoneg, HD */
			GM_OUT16(IoC, Port, GM_GP_CTRL, 0x381a);
			printk("sk98lin: suspended with 100 Mbps, autoneg on, half duplex\n");
			break;

		case SK_LMODE_FULL:
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0xa100); /* 100 MBps, FD */
			GM_OUT16(IoC, Port, GM_GP_CTRL, 0x383f);
			printk("sk98lin: suspended with 100 Mbps, autoneg off, full duplex\n");
			break;

		case SK_LMODE_HALF:
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0xa000); /* 100 MBps, HD */
			GM_OUT16(IoC, Port, GM_GP_CTRL, 0x381f);
			printk("sk98lin: suspended with 100 Mbps, autoneg off, half duplex\n");
			break;
		}
	}
	else if (pAC->SuspendLinkSpeed == SK_LSPEED_10MBPS) {

		switch (pAC->SuspendDuplexMode) {
		case SK_LMODE_AUTOFULL:
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV, 0x0061); /* Advertise 10 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0x9300); /* 10 MBps, Autoneg, FD */
			GM_OUT16(IoC, Port, GM_GP_CTRL, 0x3831);
			printk("sk98lin: suspended with 10 Mbps, autoneg on, full duplex\n");
			break;

		case SK_LMODE_AUTOHALF:
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_AUNE_ADV, 0x0021); /* Advertise 10 HD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0x9200); /* 10 MBps, Autoneg, HD */
			GM_OUT16(IoC, Port, GM_GP_CTRL, 0x3811);
			printk("sk98lin: suspended with 10 Mbps, autoneg on, half duplex\n");
			break;

		case SK_LMODE_FULL:
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0x8100); /* 10 MBps, FD */
			GM_OUT16(IoC, Port, GM_GP_CTRL, 0x3837);
			printk("sk98lin: suspended with 10 Mbps, autoneg off, full duplex\n");
			break;

		case SK_LMODE_HALF:
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_1000T_CTRL, 0x0000); /* Do not advertise 1000 HD/FD */
			SkGmPhyWrite(pAC, IoC, Port, PHY_MARV_CTRL, 0x8000); /* 10 MBps, HD */
			GM_OUT16(IoC, Port, GM_GP_CTRL, 0x3817);
			printk("sk98lin: suspended with 10 Mbps, autoneg off, half duplex\n");
			break;
		}
	}
} /* SkSetFWLinkParams */
#endif
#endif


/*****************************************************************************
 *
 * 	FreeResources - release resources allocated for adapter
 *
 * Description:
 *	This function releases the IRQ, unmaps the IO and
 *	frees the desriptor ring.
 *
 * Returns: N/A
 *	
 */
static void FreeResources(struct SK_NET_DEVICE *dev)
{
SK_U32 AllocFlag;
DEV_NET		*pNet;
SK_AC		*pAC;

	if (dev->priv) {
		pNet = (DEV_NET*) dev->priv;
		pAC = pNet->pAC;
		AllocFlag = pAC->AllocFlag;
		if (pAC->PciDev) {
			pci_release_regions(pAC->PciDev);
		}
		if (AllocFlag & SK_ALLOC_IRQ) {
			free_irq(dev->irq, dev);
		}
		if (pAC->IoBase) {
			iounmap(pAC->IoBase);
		}
		if (CHIP_ID_YUKON_2(pAC)) {
			SkY2FreeResources(pAC);
		} else {
			BoardFreeMem(pAC);
		}
	}
	
} /* FreeResources */

MODULE_AUTHOR("Mirko Lindner <[e-mail]>");
MODULE_DESCRIPTION("SysKonnect SK-NET Gigabit Ethernet SK-98xx driver");
MODULE_LICENSE("GPL");

MODULE_VERSION(DRV_VERSION);

#ifdef LINK_SPEED_A
static char *Speed_A[SK_MAX_CARD_PARAM] = LINK_SPEED;
#else
static char *Speed_A[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef LINK_SPEED_B
static char *Speed_B[SK_MAX_CARD_PARAM] = LINK_SPEED;
#else
static char *Speed_B[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef AUTO_NEG_A
static char *AutoNeg_A[SK_MAX_CARD_PARAM] = AUTO_NEG_A;
#else
static char *AutoNeg_A[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef DUP_CAP_A
static char *DupCap_A[SK_MAX_CARD_PARAM] = DUP_CAP_A;
#else
static char *DupCap_A[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef FLOW_CTRL_A
static char *FlowCtrl_A[SK_MAX_CARD_PARAM] = FLOW_CTRL_A;
#else
static char *FlowCtrl_A[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef ROLE_A
static char *Role_A[SK_MAX_CARD_PARAM] = ROLE_A;
#else
static char *Role_A[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef AUTO_NEG_B
static char *AutoNeg_B[SK_MAX_CARD_PARAM] = AUTO_NEG_B;
#else
static char *AutoNeg_B[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef DUP_CAP_B
static char *DupCap_B[SK_MAX_CARD_PARAM] = DUP_CAP_B;
#else
static char *DupCap_B[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef FLOW_CTRL_B
static char *FlowCtrl_B[SK_MAX_CARD_PARAM] = FLOW_CTRL_B;
#else
static char *FlowCtrl_B[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef ROLE_B
static char *Role_B[SK_MAX_CARD_PARAM] = ROLE_B;
#else
static char *Role_B[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef CON_TYPE
static char *ConType[SK_MAX_CARD_PARAM] = CON_TYPE;
#else
static char *ConType[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef PREF_PORT
static char *PrefPort[SK_MAX_CARD_PARAM] = PREF_PORT;
#else
static char *PrefPort[SK_MAX_CARD_PARAM] = {"", };
#endif

#ifdef RLMT_MODE
static char *RlmtMode[SK_MAX_CARD_PARAM] = RLMT_MODE;
#else
static char *RlmtMode[SK_MAX_CARD_PARAM] = {"", };
#endif

static int   IntsPerSec[SK_MAX_CARD_PARAM];
static char *Moderation[SK_MAX_CARD_PARAM];
static char *ModerationMask[SK_MAX_CARD_PARAM];

static int   TxModeration[SK_MAX_CARD_PARAM];
static char *LowLatency[SK_MAX_CARD_PARAM];
static char *BroadcastPrio[SK_MAX_CARD_PARAM];

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,9)
module_param_array(Speed_A, charp, NULL, 0);
module_param_array(Speed_B, charp, NULL, 0);
module_param_array(AutoNeg_A, charp, NULL, 0);
module_param_array(AutoNeg_B, charp, NULL, 0);
module_param_array(DupCap_A, charp, NULL, 0);
module_param_array(DupCap_B, charp, NULL, 0);
module_param_array(FlowCtrl_A, charp, NULL, 0);
module_param_array(FlowCtrl_B, charp, NULL, 0);
module_param_array(Role_A, charp, NULL, 0);
module_param_array(Role_B, charp, NULL, 0);
module_param_array(ConType, charp, NULL, 0);
module_param_array(PrefPort, charp, NULL, 0);
module_param_array(RlmtMode, charp, NULL, 0);
/* used for interrupt moderation */
module_param_array(IntsPerSec, int, NULL, 0);
module_param_array(Moderation, charp, NULL, 0);
module_param_array(ModerationMask, charp, NULL, 0);
module_param_array(LowLatency, charp, NULL, 0);
module_param_array(TxModeration, int, NULL, 0);
module_param_array(BroadcastPrio, charp, NULL, 0);
#else
MODULE_PARM(Speed_A,    "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(Speed_B,    "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(AutoNeg_A,  "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(AutoNeg_B,  "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(DupCap_A,   "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(DupCap_B,   "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(FlowCtrl_A, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(FlowCtrl_B, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(Role_A,	"1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(Role_B,	"1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(ConType,	"1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(PrefPort,   "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(RlmtMode,   "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(IntsPerSec,     "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "i");
MODULE_PARM(Moderation,     "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(ModerationMask, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(LowLatency, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(TxModeration, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
MODULE_PARM(BroadcastPrio, "1-" __MODULE_STRING(SK_MAX_CARD_PARAM) "s");
#endif


/*****************************************************************************
 *
 * 	sk98lin_remove_device - device deinit function
 *
 * Description:
 *	Disable adapter if it is still running, free resources,
 *	free device struct.
 *
 * Returns: N/A
 */

static void sk98lin_remove_device(struct pci_dev *pdev)
{
DEV_NET		*pNet;
SK_AC		*pAC;
struct SK_NET_DEVICE *next;
unsigned long Flags;
struct net_device *dev = pci_get_drvdata(pdev);


	/* Device not available. Return. */
	if (!dev)
		return;

	pNet = (DEV_NET*) dev->priv;
	pAC = pNet->pAC;
	next = pAC->Next;

#ifndef SK_ASF
	netif_stop_queue(dev);
#endif

	SkAddrMcUpdate(pAC,pAC->IoBase, 0); /* Mac update */
	SkGeYellowLED(pAC, pAC->IoBase, 0);

	if(pAC->BoardLevel == SK_INIT_RUN) {
		/* board is still alive */
		spin_lock_irqsave(&pAC->SlowPathLock, Flags);
#ifndef SK_ASF
		SkLocalEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP,
					0, -1, SK_FALSE);
		SkLocalEventQueue(pAC, SKGE_RLMT, SK_RLMT_STOP,
					1, -1, SK_TRUE);
#endif

		/* disable interrupts */
		SK_OUT32(pAC->IoBase, B0_IMSK, 0);
		SkGeDeInit(pAC, pAC->IoBase);

#ifdef SK_ASF
		SkAsfDeInit(pAC, pAC->IoBase);
#endif
		spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
		pAC->BoardLevel = SK_INIT_DATA;
		/* We do NOT check here, if IRQ was pending, of course*/
	}

	if(pAC->BoardLevel == SK_INIT_IO) {
		/* board is still alive */
		SkGeDeInit(pAC, pAC->IoBase);
#ifdef SK_ASF
		SkAsfDeInit(pAC, pAC->IoBase);
#endif
		pAC->BoardLevel = SK_INIT_DATA;
	}

	if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 2){
		unregister_netdev(pAC->dev[1]);
		free_netdev(pAC->dev[1]);
	}

	FreeResources(dev);

#ifdef CONFIG_PROC_FS
	/* Remove the sk98lin procfs device entries */
	if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 2){
		if (pAC->InterfaceUp[1] == 1) {
			remove_proc_entry(pAC->dev[1]->name, pSkRootDir);
		}
	}
	if (pAC->InterfaceUp[0] == 1) {
		remove_proc_entry(pAC->dev[0]->name, pSkRootDir);
	}
#endif

	dev->get_stats = NULL;
	/*
	 * otherwise unregister_netdev calls get_stats with
	 * invalid IO ...  :-(
	 */
	unregister_netdev(dev);
	free_netdev(dev);
	kfree(pAC);
	sk98lin_max_boards_found--;