Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2786095a authored by Wim Van Sebroeck's avatar Wim Van Sebroeck
Browse files

[WATCHDOG] i6300esb.c: change platform_driver to pci_driver 



Since the intel 6300esb platform uses a dedicated PCI ID for
it's watchdog timer (00:1d.4), it's better and easier to have
this as a pci_driver.

Signed-off-by: default avatarWim Van Sebroeck <wim@iguana.be>
parent 39f3be72

drivers/watchdog/i6300esb.c

+33 −60
Original line number Diff line number Diff line
@@ -34,7 +34,6 @@ 
#include <linux/mm.h>

#include <linux/miscdevice.h>

#include <linux/watchdog.h>

#include <linux/platform_device.h>

#include <linux/init.h>

#include <linux/pci.h>

#include <linux/ioport.h>
@@ -42,7 +41,7 @@ 
#include <linux/io.h>



/* Module and version information */

#define ESB_VERSION "0.04"

#define ESB_VERSION "0.05"

#define ESB_MODULE_NAME "i6300ESB timer"

#define ESB_DRIVER_NAME ESB_MODULE_NAME ", v" ESB_VERSION

#define PFX ESB_MODULE_NAME ": "
@@ -82,7 +81,9 @@ static unsigned long timer_alive; 
static struct pci_dev *esb_pci;

static unsigned short triggered; /* The status of the watchdog upon boot */

static char esb_expect_close;

static struct platform_device *esb_platform_device;



/* We can only use 1 card due to the /dev/watchdog restriction */

static int cards_found;



/* module parameters */

/* 30 sec default heartbeat (1 < heartbeat < 2*1023) */
@@ -332,11 +333,6 @@ static struct miscdevice esb_miscdev = { 


/*

 * Data for PCI driver interface

 *

 * This data only exists for exporting the supported

 * PCI ids via MODULE_DEVICE_TABLE.  We do not actually

 * register a pci_driver, because someone else might one day

 * want to register another driver on the same PCI id.

 */

static struct pci_device_id esb_pci_tbl[] = {

	{ PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_9), },
@@ -348,29 +344,19 @@ MODULE_DEVICE_TABLE(pci, esb_pci_tbl); 
 *      Init & exit routines

 */



static unsigned char __devinit esb_getdevice(void)

static unsigned char __devinit esb_getdevice(struct pci_dev *pdev)

{

	/*

	 *      Find the PCI device

	 */



	esb_pci = pci_get_device(PCI_VENDOR_ID_INTEL,

					PCI_DEVICE_ID_INTEL_ESB_9, NULL);



	if (!esb_pci)

		return 0;



	if (pci_enable_device(esb_pci)) {

	if (pci_enable_device(pdev)) {

		printk(KERN_ERR PFX "failed to enable device\n");

		goto err_devput;

	}



	if (pci_request_region(esb_pci, 0, ESB_MODULE_NAME)) {

	if (pci_request_region(pdev, 0, ESB_MODULE_NAME)) {

		printk(KERN_ERR PFX "failed to request region\n");

		goto err_disable;

	}



	BASEADDR = pci_ioremap_bar(esb_pci, 0);

	BASEADDR = pci_ioremap_bar(pdev, 0);

	if (BASEADDR == NULL) {

		/* Something's wrong here, BASEADDR has to be set */

		printk(KERN_ERR PFX "failed to get BASEADDR\n");
@@ -378,14 +364,14 @@ static unsigned char __devinit esb_getdevice(void) 
	}



	/* Done */

	esb_pci = pdev;

	return 1;



err_release:

	pci_release_region(esb_pci, 0);

	pci_release_region(pdev, 0);

err_disable:

	pci_disable_device(esb_pci);

	pci_disable_device(pdev);

err_devput:

	pci_dev_put(esb_pci);

	return 0;

}
@@ -430,12 +416,23 @@ static void __devinit esb_initdevice(void) 
	esb_timer_set_heartbeat(heartbeat);

}



static int __devinit esb_probe(struct platform_device *dev)

static int __devinit esb_probe(struct pci_dev *pdev,

		const struct pci_device_id *ent)

{

	int ret;



	cards_found++;

	if (cards_found == 1)

		printk(KERN_INFO PFX "Intel 6300ESB WatchDog Timer Driver v%s\n",

			ESB_VERSION);



	if (cards_found > 1) {

		printk(KERN_ERR PFX "This driver only supports 1 device\n");

		return -ENODEV;

	}



	/* Check whether or not the hardware watchdog is there */

	if (!esb_getdevice() || esb_pci == NULL)

	if (!esb_getdevice(pdev) || esb_pci == NULL)

		return -ENODEV;



	/* Check that the heartbeat value is within it's range;
@@ -467,11 +464,11 @@ static int __devinit esb_probe(struct platform_device *dev) 
	iounmap(BASEADDR);

	pci_release_region(esb_pci, 0);

	pci_disable_device(esb_pci);

	pci_dev_put(esb_pci);

	esb_pci = NULL;

	return ret;

}



static int __devexit esb_remove(struct platform_device *dev)

static void __devexit esb_remove(struct pci_dev *pdev)

{

	/* Stop the timer before we leave */

	if (!nowayout)
@@ -482,54 +479,30 @@ static int __devexit esb_remove(struct platform_device *dev) 
	iounmap(BASEADDR);

	pci_release_region(esb_pci, 0);

	pci_disable_device(esb_pci);

	pci_dev_put(esb_pci);

	return 0;

	esb_pci = NULL;

}



static void esb_shutdown(struct platform_device *dev)

static void esb_shutdown(struct pci_dev *pdev)

{

	esb_timer_stop();

}



static struct platform_driver esb_platform_driver = {

static struct pci_driver esb_driver = {

	.name		= ESB_MODULE_NAME,

	.id_table	= esb_pci_tbl,

	.probe          = esb_probe,

	.remove         = __devexit_p(esb_remove),

	.shutdown       = esb_shutdown,

	.driver         = {

		.owner  = THIS_MODULE,

		.name   = ESB_MODULE_NAME,

	},

};



static int __init watchdog_init(void)

{

	int err;



	printk(KERN_INFO PFX "Intel 6300ESB WatchDog Timer Driver v%s\n",

		ESB_VERSION);



	err = platform_driver_register(&esb_platform_driver);

	if (err)

		return err;



	esb_platform_device = platform_device_register_simple(ESB_MODULE_NAME,

								-1, NULL, 0);

	if (IS_ERR(esb_platform_device)) {

		err = PTR_ERR(esb_platform_device);

		goto unreg_platform_driver;

	}



	return 0;



unreg_platform_driver:

	platform_driver_unregister(&esb_platform_driver);

	return err;

	return pci_register_driver(&esb_driver);

}



static void __exit watchdog_cleanup(void)

{

	platform_device_unregister(esb_platform_device);

	platform_driver_unregister(&esb_platform_driver);

	pci_unregister_driver(&esb_driver);

	printk(KERN_INFO PFX "Watchdog Module Unloaded.\n");

}