public-mirrors/linux
1
0
Fork 0
mirror of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-09-18 22:14:16 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

watchdog: iTCO_wdt: Use pdev for platform device and pci_dev for pci device

Browse source 
Use pdev for struct platform_device, pci_dev for struct pci_dev, and dev
for struct device variables to improve consistency.

Remove 'struct platform_device *dev;' from struct iTCO_wdt_private since
it was unused.

Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
Mika Westerberg <mika.westerberg@linux.intel.com>
Signed-off-by: Guenter Roeck <linux@roeck-us.net>
This commit is contained in:
Guenter Roeck 2017-01-02 09:27:36 -08:00
parent c7bbcc87ac
commit 78e45696d5
1 changed files with 26 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
drivers/watchdog/iTCO_wdt.c
View file

@ -102,9 +102,8 @@ struct iTCO_wdt_private {
unsigned long __iomem *gcs_pmc; unsigned long __iomem *gcs_pmc;
/* the lock for io operations */ /* the lock for io operations */
spinlock_t io_lock; spinlock_t io_lock;
struct platform_device *dev;
/* the PCI-device */ /* the PCI-device */
struct pci_dev *pdev; struct pci_dev *pci_dev;
/* whether or not the watchdog has been suspended */ /* whether or not the watchdog has been suspended */
bool suspended; bool suspended;
}; };
@ -181,9 +180,9 @@ static void iTCO_wdt_set_NO_REBOOT_bit(struct iTCO_wdt_private *p)
val32 |= no_reboot_bit(p); val32 |= no_reboot_bit(p);
writel(val32, p->gcs_pmc); writel(val32, p->gcs_pmc);
} else if (p->iTCO_version == 1) { } else if (p->iTCO_version == 1) {
pci_read_config_dword(p->pdev, 0xd4, &val32); pci_read_config_dword(p->pci_dev, 0xd4, &val32);
val32 |= no_reboot_bit(p); val32 |= no_reboot_bit(p);
pci_write_config_dword(p->pdev, 0xd4, val32); pci_write_config_dword(p->pci_dev, 0xd4, val32);
} }
} }
@ -200,11 +199,11 @@ static int iTCO_wdt_unset_NO_REBOOT_bit(struct iTCO_wdt_private *p)
val32 = readl(p->gcs_pmc); val32 = readl(p->gcs_pmc);
} else if (p->iTCO_version == 1) { } else if (p->iTCO_version == 1) {
pci_read_config_dword(p->pdev, 0xd4, &val32); pci_read_config_dword(p->pci_dev, 0xd4, &val32);
val32 &= ~enable_bit; val32 &= ~enable_bit;
pci_write_config_dword(p->pdev, 0xd4, val32); pci_write_config_dword(p->pci_dev, 0xd4, val32);
pci_read_config_dword(p->pdev, 0xd4, &val32); pci_read_config_dword(p->pci_dev, 0xd4, &val32);
} }
if (val32 & enable_bit) if (val32 & enable_bit)
@ -401,9 +400,10 @@ static const struct watchdog_ops iTCO_wdt_ops = {
* Init & exit routines * Init & exit routines
*/ */
static int iTCO_wdt_probe(struct platform_device *dev) static int iTCO_wdt_probe(struct platform_device *pdev)
{ {
struct itco_wdt_platform_data *pdata = dev_get_platdata(&dev->dev); struct device *dev = &pdev->dev;
struct itco_wdt_platform_data *pdata = dev_get_platdata(dev);
struct iTCO_wdt_private *p; struct iTCO_wdt_private *p;
unsigned long val32; unsigned long val32;
int ret; int ret;
@ -411,33 +411,32 @@ static int iTCO_wdt_probe(struct platform_device *dev)
if (!pdata) if (!pdata)
return -ENODEV; return -ENODEV;
p = devm_kzalloc(&dev->dev, sizeof(*p), GFP_KERNEL); p = devm_kzalloc(dev, sizeof(*p), GFP_KERNEL);
if (!p) if (!p)
return -ENOMEM; return -ENOMEM;
spin_lock_init(&p->io_lock); spin_lock_init(&p->io_lock);
p->tco_res = platform_get_resource(dev, IORESOURCE_IO, ICH_RES_IO_TCO); p->tco_res = platform_get_resource(pdev, IORESOURCE_IO, ICH_RES_IO_TCO);
if (!p->tco_res) if (!p->tco_res)
return -ENODEV; return -ENODEV;
p->smi_res = platform_get_resource(dev, IORESOURCE_IO, ICH_RES_IO_SMI); p->smi_res = platform_get_resource(pdev, IORESOURCE_IO, ICH_RES_IO_SMI);
if (!p->smi_res) if (!p->smi_res)
return -ENODEV; return -ENODEV;
p->iTCO_version = pdata->version; p->iTCO_version = pdata->version;
p->dev = dev; p->pci_dev = to_pci_dev(dev->parent);
p->pdev = to_pci_dev(dev->dev.parent);
/* /*
* Get the Memory-Mapped GCS or PMC register, we need it for the * Get the Memory-Mapped GCS or PMC register, we need it for the
* NO_REBOOT flag (TCO v2 and v3). * NO_REBOOT flag (TCO v2 and v3).
*/ */
if (p->iTCO_version >= 2) { if (p->iTCO_version >= 2) {
p->gcs_pmc_res = platform_get_resource(dev, p->gcs_pmc_res = platform_get_resource(pdev,
IORESOURCE_MEM, IORESOURCE_MEM,
ICH_RES_MEM_GCS_PMC); ICH_RES_MEM_GCS_PMC);
p->gcs_pmc = devm_ioremap_resource(&dev->dev, p->gcs_pmc_res); p->gcs_pmc = devm_ioremap_resource(dev, p->gcs_pmc_res);
if (IS_ERR(p->gcs_pmc)) if (IS_ERR(p->gcs_pmc))
return PTR_ERR(p->gcs_pmc); return PTR_ERR(p->gcs_pmc);
} }
@ -453,9 +452,9 @@ static int iTCO_wdt_probe(struct platform_device *dev)
iTCO_wdt_set_NO_REBOOT_bit(p); iTCO_wdt_set_NO_REBOOT_bit(p);
/* The TCO logic uses the TCO_EN bit in the SMI_EN register */ /* The TCO logic uses the TCO_EN bit in the SMI_EN register */
if (!devm_request_region(&dev->dev, p->smi_res->start, if (!devm_request_region(dev, p->smi_res->start,
resource_size(p->smi_res), resource_size(p->smi_res),
dev->name)) { pdev->name)) {
pr_err("I/O address 0x%04llx already in use, device disabled\n", pr_err("I/O address 0x%04llx already in use, device disabled\n",
(u64)SMI_EN(p)); (u64)SMI_EN(p));
return -EBUSY; return -EBUSY;
@ -470,9 +469,9 @@ static int iTCO_wdt_probe(struct platform_device *dev)
outl(val32, SMI_EN(p)); outl(val32, SMI_EN(p));
} }
if (!devm_request_region(&dev->dev, p->tco_res->start, if (!devm_request_region(dev, p->tco_res->start,
resource_size(p->tco_res), resource_size(p->tco_res),
dev->name)) { pdev->name)) {
pr_err("I/O address 0x%04llx already in use, device disabled\n", pr_err("I/O address 0x%04llx already in use, device disabled\n",
(u64)TCOBASE(p)); (u64)TCOBASE(p));
return -EBUSY; return -EBUSY;
@ -505,10 +504,10 @@ static int iTCO_wdt_probe(struct platform_device *dev)
p->wddev.bootstatus = 0; p->wddev.bootstatus = 0;
p->wddev.timeout = WATCHDOG_TIMEOUT; p->wddev.timeout = WATCHDOG_TIMEOUT;
watchdog_set_nowayout(&p->wddev, nowayout); watchdog_set_nowayout(&p->wddev, nowayout);
p->wddev.parent = &dev->dev; p->wddev.parent = dev;
watchdog_set_drvdata(&p->wddev, p); watchdog_set_drvdata(&p->wddev, p);
platform_set_drvdata(dev, p); platform_set_drvdata(pdev, p);
/* Make sure the watchdog is not running */ /* Make sure the watchdog is not running */
iTCO_wdt_stop(&p->wddev); iTCO_wdt_stop(&p->wddev);
@ -521,7 +520,7 @@ static int iTCO_wdt_probe(struct platform_device *dev)
WATCHDOG_TIMEOUT); WATCHDOG_TIMEOUT);
} }
ret = devm_watchdog_register_device(&dev->dev, &p->wddev); ret = devm_watchdog_register_device(dev, &p->wddev);
if (ret != 0) { if (ret != 0) {
pr_err("cannot register watchdog device (err=%d)\n", ret); pr_err("cannot register watchdog device (err=%d)\n", ret);
return ret; return ret;
@ -533,9 +532,9 @@ static int iTCO_wdt_probe(struct platform_device *dev)
return 0; return 0;
} }
static int iTCO_wdt_remove(struct platform_device *dev) static int iTCO_wdt_remove(struct platform_device *pdev)
{ {
struct iTCO_wdt_private *p = platform_get_drvdata(dev); struct iTCO_wdt_private *p = platform_get_drvdata(pdev);
/* Stop the timer before we leave */ /* Stop the timer before we leave */
if (!nowayout) if (!nowayout)
@ -544,9 +543,9 @@ static int iTCO_wdt_remove(struct platform_device *dev)
return 0; return 0;
} }
static void iTCO_wdt_shutdown(struct platform_device *dev) static void iTCO_wdt_shutdown(struct platform_device *pdev)
{ {
struct iTCO_wdt_private *p = platform_get_drvdata(dev); struct iTCO_wdt_private *p = platform_get_drvdata(pdev);
iTCO_wdt_stop(&p->wddev); iTCO_wdt_stop(&p->wddev);
} }