Merge bk://kernel.bkbits.net/jgarzik/net-drivers-2.5

into home.transmeta.com:/home/torvalds/v2.5/linux

drivers/net/sk98lin/skge.c

@@ -48,6 +48,9 @@
  * History:
  *
  *	$Log: skge.c,v $
+ *	Revision x.xx.x.x  2003/06/07 02:31:17  romieu@fr.zoreil.com
+ *      pci api style init.
+ *
  *	Revision 1.29.2.6  2001/05/21 07:59:29  mlindner
  *	fix: MTU init problems
  *	
@@ -275,6 +278,10 @@
 #include	"h/skdrv2nd.h"
 
 /* defines ******************************************************************/
+
+#define DRV_MODULE_NAME		"sk98lin"
+#define PFX DRV_MODULE_NAME	": "
+
 /* for debuging on x86 only */
 /* #define BREAKPOINT() asm(" int $3"); */
 
@@ -361,9 +368,7 @@ static void	DumpLong(char*, int);
 
 
 /* global variables *********************************************************/
-static const char *BootString = BOOT_STRING;
-struct net_device *sk98lin_root_dev = NULL;
-static int probed __initdata = 0;
+static int boards_found;
 struct inode_operations SkInodeOps;
 //static struct file_operations SkFileOps;  /* with open/relase */
 
@@ -371,75 +376,108 @@ struct inode_operations SkInodeOps;
 static uintptr_t TxQueueAddr[SK_MAX_MACS][2] = {{0x680, 0x600},{0x780, 0x700}};
 static uintptr_t RxQueueAddr[SK_MAX_MACS] = {0x400, 0x480};
 
+spinlock_t sk_devs_lock = SPIN_LOCK_UNLOCKED;
+
+static int SkGeDevInit(struct net_device *dev)
+{
+	DEV_NET *pNet = dev->priv;
+	int ret = 0;
+
+	dev->open =		&SkGeOpen;
+	dev->stop =		&SkGeClose;
+	dev->hard_start_xmit =	&SkGeXmit;
+	dev->get_stats =	&SkGeStats;
+	dev->set_multicast_list = &SkGeSetRxMode;
+	dev->set_mac_address =	&SkGeSetMacAddr;
+	dev->do_ioctl =		&SkGeIoctl;
+	dev->change_mtu =	&SkGeChangeMtu;
+
+	if (register_netdev(dev) != 0) {
+		printk(KERN_ERR "Unable to register etherdev\n");
+		ret = -ENOMEM;
+		goto out;
+	}
+	pNet->proc = create_proc_entry(dev->name, S_IFREG | 0444, pSkRootDir);
+	if (pNet->proc) {
+		pNet->proc->data = dev;
+		pNet->proc->owner = THIS_MODULE;
+		pNet->proc->proc_fops = &sk_proc_fops;
+	}
+out:
+	return ret;
+}
+
+static void SkGeDevCleanUp(struct net_device *dev)
+{
+	DEV_NET *pNet = dev->priv;
+	
+	if (pNet->proc) {
+		spin_lock(&sk_devs_lock);
+		pNet->proc->data = NULL;
+		spin_unlock(&sk_devs_lock);
+		remove_proc_entry(dev->name, pSkRootDir);
+	}
+	unregister_netdev(dev);
+}
 
 /*****************************************************************************
  *
- * 	skge_probe - find all SK-98xx adapters
+ * 	skge_init_one - init a single instance of a SK-98xx adapter
  *
  * Description:
- *	This function scans the PCI bus for SK-98xx adapters. Resources for
- *	each adapter are allocated and the adapter is brought into Init 1
- *	state.
+ *	This function allocates resources for an SK-98xx adapter and brings
+ *	it into Init 1 state.
  *
  * Returns:
  *	0, if everything is ok
- *	!=0, on error
+ *	<0, on error
  */
-static int __init skge_probe (void)
+static int __devinit skge_init_one(struct pci_dev *pdev,
+				   const struct pci_device_id *ent)
 {
-	int			proc_root_initialized = 0;
-	int 		boards_found = 0;
-	int			version_disp = 0;
 	SK_AC		*pAC;
-	DEV_NET		*pNet = NULL;
-	struct 		pci_dev	*pdev = NULL;
+	DEV_NET		*pNet;
 	unsigned long	base_address;
-	struct net_device *dev = NULL;
+	struct net_device *dev;
+	int ret;
 
-	if (probed)
-		return -ENODEV;
-	probed++;
-	
-	/* display driver info */
-	if (!version_disp)
-	{
-		/* set display flag to TRUE so that */
-		/* we only display this string ONCE */
-		version_disp = 1;
-		printk("%s\n", BootString);
-	}
-
-	while((pdev = pci_find_device(PCI_VENDOR_ID_SYSKONNECT,
-				      PCI_DEVICE_ID_SYSKONNECT_GE, pdev)) != NULL) {
-
-		pNet = NULL;
+#ifndef MODULE
+	static int	version_disp = 0;
 
-		if (pci_enable_device(pdev))
-			continue;
+if (!version_disp++)
+		printk(KERN_INFO "%s\n", BOOT_STRING);
+#endif
+	ret = pci_enable_device(pdev);
+	if (ret)
+		goto out;
 
 	/* Configure DMA attributes. */
-		if (pci_set_dma_mask(pdev, (u64) 0xffffffffffffffffULL) &&
-		    pci_set_dma_mask(pdev, (u64) 0xffffffff))
-				continue;
+	if (pci_set_dma_mask(pdev, (u64) 0xffffffffffffffff)) {
+		ret = pci_set_dma_mask(pdev, (u64) 0xffffffff);
+		if (ret) {
+			printk(KERN_ERR PFX "No usable DMA configuration\n");
+			goto out_disable;
+		}
+	}
+
+	ret = -ENOMEM;
 
 	dev = alloc_etherdev(sizeof(DEV_NET));
 	if (!dev) {
-			printk(KERN_ERR "Unable to allocate etherdev "
-			       "structure!\n");
-			break;
+		printk(KERN_ERR "Unable to allocate etherdev structure!\n");
+		goto out_disable;
 	}
 
 	pNet = dev->priv;
-		pNet->pAC = kmalloc(sizeof(SK_AC), GFP_KERNEL);
-		if (pNet->pAC == NULL){
-			kfree(dev);
-			printk(KERN_ERR "Unable to allocate adapter "
-			       "structure!\n");
-			break;
+
+	pAC = kmalloc(sizeof(*pAC), GFP_KERNEL);
+	if (pAC == NULL){
+		printk(KERN_ERR "Unable to allocate adapter structure!\n");
+		goto out_free_dev;
 	}
 
-		memset(pNet->pAC, 0, sizeof(SK_AC));
-		pAC = pNet->pAC;
+	memset(pAC, 0, sizeof(SK_AC));
+	pNet->pAC = pAC;
 	pAC->PciDev = *pdev;
 	pAC->PciDevId = pdev->device;
 	pAC->dev[0] = dev;
@@ -453,32 +491,20 @@ static int __init skge_probe (void)
 
 	SET_MODULE_OWNER(dev);
 	SET_NETDEV_DEV(dev, &pdev->dev);
-		dev->open =		&SkGeOpen;
-		dev->stop =		&SkGeClose;
-		dev->hard_start_xmit =	&SkGeXmit;
-		dev->get_stats =	&SkGeStats;
-		dev->set_multicast_list = &SkGeSetRxMode;
-		dev->set_mac_address =	&SkGeSetMacAddr;
-		dev->do_ioctl =		&SkGeIoctl;
-		dev->change_mtu =	&SkGeChangeMtu;
-
-		if(!proc_root_initialized) {
-			pSkRootDir = create_proc_entry(SK_Root_Dir_entry,
-				S_IFDIR | S_IWUSR | S_IRUGO | S_IXUGO, proc_net);
-			pSkRootDir->owner = THIS_MODULE;
-			proc_root_initialized = 1;
-		}
+	ret = SkGeDevInit(dev);
+	if (ret < 0)
+		goto out_free_priv;
 
 	/*
 	 * Dummy value.
 	 */
 	dev->base_addr = 42;
 	pci_set_master(pdev);
-		base_address = pci_resource_start (pdev, 0);
+	base_address = pci_resource_start(pdev, 0);
 
 #ifdef SK_BIG_ENDIAN
 	/*
-		 * On big endian machines, we use the adapter's aibility of
+	 * On big endian machines, we use the adapter's ability of
 	 * reading the descriptors as big endian.
 	 */
 	{
@@ -494,20 +520,17 @@ static int __init skge_probe (void)
 	 */
 
 	pAC->IoBase = (char*)ioremap(base_address, 0x4000);
-		if (!pAC->IoBase){
-			printk(KERN_ERR "%s:  Unable to map I/O register, "
-			       "SK 98xx No. %i will be disabled.\n",
-			       dev->name, boards_found);
-			kfree(dev);
-			break;
+	if (!pAC->IoBase) {
+		printk(KERN_ERR PFX "unable to map I/O register. "
+		       "SK 98xx device disabled.\n");
+		ret = -EIO;
+		goto out_dev_uninit;
 	}
-		pAC->Index = boards_found;
+	pAC->Index = boards_found++;
 
-		if (SkGeBoardInit(dev, pAC)) {
-			FreeResources(dev);
-			kfree(dev);
-			continue;
-		}
+	ret = SkGeBoardInit(dev, pAC);
+	if (ret < 0)
+		goto out_free_resources;
 
 	memcpy((caddr_t) &dev->dev_addr,
 		(caddr_t) &pAC->Addr.Net[0].CurrentMacAddress, 6);
@@ -515,92 +538,57 @@ static int __init skge_probe (void)
 	pNet->PortNr = 0;
 	pNet->NetNr = 0;
 
-		if (register_netdev(dev) != 0) {
-			printk(KERN_ERR "Unable to register etherdev\n");
-			sk98lin_root_dev = pAC->Next;
-			remove_proc_entry(dev->name, pSkRootDir);
-			FreeResources(dev);
-			kfree(dev);
-			continue;
-		}
-
-		pNet->proc = create_proc_entry(dev->name, 
-						S_IFREG | 0444, pSkRootDir);
-		if (pNet->proc) {
-			pNet->proc->data = dev;
-			pNet->proc->owner = THIS_MODULE;
-			pNet->proc->proc_fops = &sk_proc_fops;
-		}
-
-		boards_found++;
-
 	/* More then one port found */
 	if ((pAC->GIni.GIMacsFound == 2 ) && (pAC->RlmtNets == 2)) {
-			dev = alloc_etherdev(sizeof(DEV_NET));
-			if (!dev) {
-				printk(KERN_ERR "Unable to allocate etherdev "
-					"structure!\n");
-				break;
+		struct net_device *sec_dev;
+
+		sec_dev = alloc_etherdev(sizeof(DEV_NET));
+		if (!sec_dev) {
+			printk(KERN_ERR PFX
+				"Unable to allocate etherdev structure!\n");
+			ret = -ENOMEM;
+			goto out_free_resources;
 		}
 
-			pAC->dev[1] = dev;
-			pNet = dev->priv;
+		pAC->dev[1] = sec_dev;
+		pNet = sec_dev->priv;
 		pNet->PortNr = 1;
 		pNet->NetNr = 1;
 		pNet->pAC = pAC;
 		pNet->Mtu = 1500;
 		pNet->Up = 0;
 
-			dev->open =		&SkGeOpen;
-			dev->stop =		&SkGeClose;
-			dev->hard_start_xmit =	&SkGeXmit;
-			dev->get_stats =	&SkGeStats;
-			dev->set_multicast_list = &SkGeSetRxMode;
-			dev->set_mac_address =	&SkGeSetMacAddr;
-			dev->do_ioctl =		&SkGeIoctl;
-			dev->change_mtu =	&SkGeChangeMtu;
+		ret = SkGeDevInit(sec_dev);
+		if (ret < 0)
+			goto out_free_secondary_dev;
 
-			memcpy((caddr_t) &dev->dev_addr,
-			(caddr_t) &pAC->Addr.Net[1].CurrentMacAddress, 6);
+		memcpy((caddr_t) &sec_dev->dev_addr,
+			(caddr_t) &pAC->Addr.Net[0].CurrentMacAddress, 6);
 
-			printk("%s: %s\n", dev->name, pAC->DeviceStr);
+		printk("%s: %s\n", sec_dev->name, pAC->DeviceStr);
 		printk("      PrefPort:B  RlmtMode:Dual Check Link State\n");
-
-			if (register_netdev(dev) != 0) {
-				printk(KERN_ERR "Unable to register etherdev\n");
-				kfree(dev);
-				break;
 	}
+	pci_set_drvdata(pdev, dev);
 
-			pNet->proc = create_proc_entry(dev->name, 
-						S_IFREG | 0444, pSkRootDir);
-			if (pNet->proc) {
-				pNet->proc->data = dev;
-				pNet->proc->owner = THIS_MODULE;
-				pNet->proc->proc_fops = &sk_proc_fops;
-			}
-		
-		}
-
-
-		/*
-		 * This is bollocks, but we need to tell the net-init
-		 * code that it shall go for the next device.
-		 */
-#ifndef MODULE
-		dev->base_addr = 0;
-#endif
-	}
-
-	/*
-	 * If we're at this point we're going through skge_probe() for
-	 * the first time.  Return success (0) if we've initialized 1
-	 * or more boards. Otherwise, return failure (-ENODEV).
-	 */
+	ret = 0;
+out:
+	return ret;
 
-	return boards_found;
-} /* skge_probe */
+out_free_secondary_dev:
+	kfree(pAC->dev[1]);
+out_free_resources:
+	FreeResources(dev);
+out_dev_uninit:
+	SkGeDevCleanUp(dev);
+out_free_priv:
+	kfree(pAC);
+out_free_dev:
+	kfree(dev);
+out_disable:
+	pci_disable_device(pdev);
+	goto out;
 
+} /* skge_init_one */
 
 /*****************************************************************************
  *
@@ -718,39 +706,9 @@ static char *RlmtMode[SK_MAX_CARD_PARAM] = {"", };
 static int debug = 0; /* not used */
 static int options[SK_MAX_CARD_PARAM] = {0, }; /* not used */
 
-
 /*****************************************************************************
  *
- * 	skge_init_module - module initialization function
- *
- * Description:
- *	Very simple, only call skge_probe and return approriate result.
- *
- * Returns:
- *	0, if everything is ok
- *	!=0, on error
- */
-static int __init skge_init_module(void)
-{
-	int cards;
-	sk98lin_root_dev = NULL;
-	
-	/* just to avoid warnings ... */
-	debug = 0;
-	options[0] = 0;
-
-	cards = skge_probe();
-	if (cards == 0) {
-		printk("No adapter found\n");
-	}
-	return cards ? 0 : -ENODEV;
-} /* skge_init_module */
-
-spinlock_t sk_devs_lock = SPIN_LOCK_UNLOCKED;
-
-/*****************************************************************************
- *
- * 	skge_cleanup_module - module unload function
+ * 	skge_remove_one - remove a single instance of a SK-98xx adapter
  *
  * Description:
  *	Disable adapter if it is still running, free resources,
@@ -758,28 +716,25 @@ spinlock_t sk_devs_lock = SPIN_LOCK_UNLOCKED;
  *
  * Returns: N/A
  */
-static void __exit skge_cleanup_module(void)
+static void __devexit skge_remove_one(struct pci_dev *pdev)
 {
-DEV_NET		*pNet;
-SK_AC		*pAC;
-struct net_device *next;
-unsigned long Flags;
-SK_EVPARA EvPara;
+	struct net_device *dev = pci_get_drvdata(pdev);
+	DEV_NET	*pNet = dev->priv;
+	SK_AC *pAC = pNet->pAC;
+	unsigned long Flags;
+	SK_EVPARA EvPara;
 
-	while (sk98lin_root_dev) {
-		pNet = (DEV_NET*) sk98lin_root_dev->priv;
-		pAC = pNet->pAC;
-		next = pAC->Next;
 
-		netif_stop_queue(sk98lin_root_dev);
+	netif_stop_queue(dev);
 	SkGeYellowLED(pAC, pAC->IoBase, 0);
 	if (pNet->proc) {
 		spin_lock(&sk_devs_lock);
 		pNet->proc->data = NULL;
 		spin_unlock(&sk_devs_lock);
+		remove_proc_entry(dev->name, pSkRootDir);
 	}
 
-		if(pAC->BoardLevel == 2) {
+	if (pAC->BoardLevel == 2) {
 		/* board is still alive */
 		spin_lock_irqsave(&pAC->SlowPathLock, Flags);
 		EvPara.Para32[0] = 0;
@@ -797,43 +752,29 @@ SK_EVPARA EvPara;
 		/* We do NOT check here, if IRQ was pending, of course*/
 	}
 
-		if(pAC->BoardLevel == 1) {
+	if (pAC->BoardLevel == 1) {
 		/* board is still alive */
 		SkGeDeInit(pAC, pAC->IoBase); 
 		pAC->BoardLevel = 0;
 	}
 
-		if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 2){
-			pNet = (DEV_NET*) pAC->dev[1]->priv;
-			if (pNet->proc) {
-				spin_lock(&sk_devs_lock);
-				pNet->proc->data = NULL;
-				spin_unlock(&sk_devs_lock);
-			}
-			unregister_netdev(pAC->dev[1]);
+	if ((pAC->GIni.GIMacsFound == 2) && pAC->RlmtNets == 2) {
+		SkGeDevCleanUp(pAC->dev[1]);
 		kfree(pAC->dev[1]);
 	}
 
-		FreeResources(sk98lin_root_dev);
+	FreeResources(dev);
 
-		sk98lin_root_dev->get_stats = NULL;
+	dev->get_stats = NULL;
 	/* 
 	 * otherwise unregister_netdev calls get_stats with
 	 * invalid IO ...  :-(
 	 */
-		unregister_netdev(sk98lin_root_dev);
-		kfree(sk98lin_root_dev);
+	unregister_netdev(dev);
+	kfree(dev);
 	kfree(pAC);
-		sk98lin_root_dev = next;
-	}
-
-	/* clear proc-dir */
-	remove_proc_entry(pSkRootDir->name, proc_net);
-
-} /* skge_cleanup_module */
-
-module_init(skge_init_module);
-module_exit(skge_cleanup_module);
+	boards_found--;
+} /* skge_remove_one */
 
 /*****************************************************************************
  *
@@ -968,12 +909,6 @@ int	Ret;			/* return code of request_irq */
 
 	SkGeYellowLED(pAC, pAC->IoBase, 1);
 
-	/*
-	 * Register the device here
-	 */
-	pAC->Next = sk98lin_root_dev;
-	sk98lin_root_dev = dev;
-
 	return (0);
 } /* SkGeBoardInit */
 
@@ -4097,9 +4032,62 @@ int	l;
 
 #endif /* DEBUG */
 
+static struct pci_device_id skge_pci_tbl[] __devinitdata = {
+	{ PCI_VENDOR_ID_SYSKONNECT, PCI_DEVICE_ID_SYSKONNECT_GE,
+		PCI_ANY_ID, PCI_ANY_ID, },
+	{ 0,}
+};
+MODULE_DEVICE_TABLE(pci, skge_pci_tbl);
+
+static struct pci_driver skge_driver = {
+	.name		= DRV_MODULE_NAME,
+	.id_table	= skge_pci_tbl,
+	.probe		= skge_init_one,
+	.remove		= __devexit_p(skge_remove_one),
+};
+
+/*****************************************************************************
+ *
+ * 	skge_init - module initialization function
+ *
+ * Description:
+ *	root /proc directory allocation and pci driver invocation.
+ *
+ * Returns:
+ *	0, if everything is ok
+ *	!=0, on error
+ */
+static int __init skge_init(void)
+{
+	int ret = -ENOMEM;
+	
+	/* just to avoid warnings ... */
+	debug = 0;
+	options[0] = 0;
+
+	pSkRootDir = create_proc_entry(DRV_MODULE_NAME,
+			S_IFDIR | S_IWUSR | S_IRUGO | S_IXUGO, proc_net);
+	if (pSkRootDir) {
+		pSkRootDir->owner = THIS_MODULE;
+		ret = pci_module_init(&skge_driver);
+		if (ret)
+			remove_proc_entry(pSkRootDir->name, proc_net);
+	}
+	return ret;
+} /* skge_init */
+
+
+static void __exit skge_cleanup(void)
+{
+	remove_proc_entry(pSkRootDir->name, proc_net);
+	pci_unregister_driver(&skge_driver);
+}
+
+module_init(skge_init);
+module_exit(skge_cleanup);
+
 /*
  * Local variables:
  * compile-command: "make"
  * End:
  */
-

drivers/net/wan/sdla_chdlc.c

@@ -996,13 +996,11 @@ static int if_open(struct net_device* dev)
 	
 	set_bit(0,&chdlc_priv_area->config_chdlc);
 	chdlc_priv_area->config_chdlc_timeout=jiffies;
-	del_timer(&chdlc_priv_area->poll_delay_timer);
 
 	/* Start the CHDLC configuration after 1sec delay.
 	 * This will give the interface initilization time
 	 * to finish its configuration */
-	chdlc_priv_area->poll_delay_timer.expires=jiffies+HZ;
-	add_timer(&chdlc_priv_area->poll_delay_timer);
+	mod_timer(&chdlc_priv_area->poll_delay_timer, jiffies + HZ);
 	return err;
 }
 

drivers/net/wan/sdla_fr.c

@@ -4163,9 +4163,7 @@ static void trigger_fr_arp(struct net_device *dev)
 {
 	fr_channel_t* chan = dev->priv;
 
-	del_timer(&chan->fr_arp_timer);
-	chan->fr_arp_timer.expires = jiffies + (chan->inarp_interval * HZ);
-	add_timer(&chan->fr_arp_timer);
+	mod_timer(&chan->fr_arp_timer, jiffies + chan->inarp_interval * HZ);
 	return;
 }
 

drivers/net/wan/sdla_ppp.c

@@ -762,9 +762,7 @@ static int if_open(struct net_device *dev)
 	/* Start the PPP configuration after 1sec delay.
 	 * This will give the interface initilization time
 	 * to finish its configuration */
-	del_timer(&ppp_priv_area->poll_delay_timer);
-	ppp_priv_area->poll_delay_timer.expires = jiffies+HZ;
-	add_timer(&ppp_priv_area->poll_delay_timer);
+	mod_timer(&ppp_priv_area->poll_delay_timer, jiffies + HZ);
 	return 0;
 }
 

drivers/net/wan/sdla_x25.c

@@ -1235,9 +1235,7 @@ static int if_open(struct net_device* dev)
 			connect(card);
 			S508_S514_unlock(card, &smp_flags);
 
-			del_timer(&card->u.x.x25_timer);
-			card->u.x.x25_timer.expires=jiffies+HZ;
-			add_timer(&card->u.x.x25_timer);
+			mod_timer(&card->u.x.x25_timer, jiffies + HZ);
 		}
 	}
 	/* Device is not up until the we are in connected state */