skge.c

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

	/* 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");


#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]);
		kfree(pAC->dev[1]);
	}

	FreeResources(dev);

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

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

#ifdef CONFIG_PROC_FS
	/* Remove all Proc entries if last device */
	if (sk98lin_max_boards_found == 0) {
		/* clear proc-dir */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,24)
#ifndef SK_DISABLE_PROC_UNLOAD
		remove_proc_entry(pSkRootDir->name, proc_net);
#endif
#else
		remove_proc_entry(pSkRootDir->name, init_net.proc_net);
#endif
	}
#endif

}


/*****************************************************************************
 *
 * 	SkGeBoardInit - do level 0 and 1 initialization
 *
 * Description:
 *	This function prepares the board hardware for running. The desriptor
 *	ring is set up, the IRQ is allocated and the configuration settings
 *	are examined.
 *
 * Returns:
 *	0, if everything is ok
 *	!=0, on error
 */
static int __devinit SkGeBoardInit(struct SK_NET_DEVICE *dev, SK_AC *pAC)
{
short	i;
char	*DescrString = "sk98lin: Driver for Linux"; /* this is given to PNMI */
char	*VerStr	= VER_STRING;
int	Ret;			/* return code of request_irq */
SK_BOOL	DualNet;
#ifndef SK_ASF	
unsigned long   Flags;    	/* for the spin locks	*/
#endif

	SK_DBG_MSG(NULL, SK_DBGMOD_DRV, SK_DBGCAT_DRV_ENTRY,
		("IoBase: %08lX\n", (unsigned long)pAC->IoBase));
	for (i=0; i<SK_MAX_MACS; i++) {
		pAC->TxPort[i][0].HwAddr = pAC->IoBase + TxQueueAddr[i][0];
		pAC->TxPort[i][0].PortIndex = i;
		pAC->RxPort[i].HwAddr = pAC->IoBase + RxQueueAddr[i];
		pAC->RxPort[i].PortIndex = i;
	}

	/* Initialize the mutexes */
	for (i=0; i<SK_MAX_MACS; i++) {
		spin_lock_init(&pAC->TxPort[i][0].TxDesRingLock);
		spin_lock_init(&pAC->RxPort[i].RxDesRingLock);
	}

	spin_lock_init(&pAC->InitLock);		/* Init lock */
	spin_lock_init(&pAC->SlowPathLock);
	spin_lock_init(&pAC->TxQueueLock);	/* for Yukon2 chipsets */
	spin_lock_init(&pAC->SetPutIndexLock);	/* for Yukon2 chipsets */

	/* level 0 init common modules here */

#ifdef SK_ASF	
	spin_lock(&pAC->SlowPathLock);
#endif
#ifndef SK_ASF
	spin_lock_irqsave(&pAC->SlowPathLock, Flags);
#endif
	/* Does a RESET on board ...*/
	if (SkGeInit(pAC, pAC->IoBase, SK_INIT_DATA) != 0) {
		printk("HWInit (0) failed.\n");
#ifdef SK_ASF	
		spin_unlock(&pAC->SlowPathLock);
#endif
#ifndef SK_ASF	
		spin_unlock_irqrestore(&pAC->SlowPathLock, Flags);
#endif
		return(-EAGAIN);
	}
	SkI2cInit(  pAC, pAC->IoBase, SK_INIT_DATA);
	SkEventInit(pAC, pAC->IoBase, SK_INIT_DATA);
	SkPnmiInit( pAC, pAC->IoBase, SK_INIT_DATA);
	SkAddrInit( pAC, pAC->IoBase, SK_INIT_DATA);