Merge git://www.linux-watchdog.org/linux-watchdog

Documentation/devicetree/bindings/gpio/men-a021-wdt.txt Documentation/devicetree/bindings/watchdog/men-a021-wdt.txt

+21

Documentation/devicetree/bindings/watchdog/dw_wdt.txt

··· 1 + Synopsys Designware Watchdog Timer 2 + 3 + Required Properties: 4 + 5 + - compatible : Should contain "snps,dw-wdt" 6 + - reg : Base address and size of the watchdog timer registers. 7 + - clocks : phandle + clock-specifier for the clock that drives the 8 + watchdog timer. 9 + 10 + Optional Properties: 11 + 12 + - interrupts : The interrupt used for the watchdog timeout warning. 13 + 14 + Example: 15 + 16 + watchdog0: wd@ffd02000 { 17 + compatible = "snps,dw-wdt"; 18 + reg = <0xffd02000 0x1000>; 19 + interrupts = <0 171 4>; 20 + clocks = <&per_base_clk>; 21 + };

+15

Documentation/devicetree/bindings/watchdog/moxa,moxart-watchdog.txt

··· 1 + MOXA ART Watchdog timer 2 + 3 + Required properties: 4 + 5 + - compatible : Must be "moxa,moxart-watchdog" 6 + - reg : Should contain registers location and length 7 + - clocks : Should contain phandle for the clock that drives the counter 8 + 9 + Example: 10 + 11 + watchdog: watchdog@98500000 { 12 + compatible = "moxa,moxart-watchdog"; 13 + reg = <0x98500000 0x10>; 14 + clocks = <&coreclk>; 15 + };

+19

Documentation/devicetree/bindings/watchdog/rt2880-wdt.txt

··· 1 + Ralink Watchdog Timers 2 + 3 + Required properties: 4 + - compatible: must be "ralink,rt2880-wdt" 5 + - reg: physical base address of the controller and length of the register range 6 + 7 + Optional properties: 8 + - interrupt-parent: phandle to the INTC device node 9 + - interrupts: Specify the INTC interrupt number 10 + 11 + Example: 12 + 13 + watchdog@120 { 14 + compatible = "ralink,rt2880-wdt"; 15 + reg = <0x120 0x10>; 16 + 17 + interrupt-parent = <&intc>; 18 + interrupts = <1>; 19 + };

+14

Documentation/devicetree/bindings/watchdog/sirfsoc_wdt.txt

··· 1 + SiRFSoC Timer and Watchdog Timer(WDT) Controller 2 + 3 + Required properties: 4 + - compatible: "sirf,prima2-tick" 5 + - reg: Address range of tick timer/WDT register set 6 + - interrupts: interrupt number to the cpu 7 + 8 + Example: 9 + 10 + timer@b0020000 { 11 + compatible = "sirf,prima2-tick"; 12 + reg = <0xb0020000 0x1000>; 13 + interrupts = <0>; 14 + };

+1

arch/arm/configs/prima2_defconfig

··· 39 39 CONFIG_SPI_SIRF=y 40 40 CONFIG_SPI_SPIDEV=y 41 41 # CONFIG_HWMON is not set 42 + CONFIG_WATCHDOG=y 42 43 CONFIG_USB_GADGET=y 43 44 CONFIG_USB_MASS_STORAGE=m 44 45 CONFIG_MMC=y

+27

drivers/watchdog/Kconfig

··· 392 392 To compile this driver as a module, choose M here: the 393 393 module will be called retu_wdt. 394 394 395 + config MOXART_WDT 396 + tristate "MOXART watchdog" 397 + depends on ARCH_MOXART 398 + help 399 + Say Y here to include Watchdog timer support for the watchdog 400 + existing on the MOXA ART SoC series platforms. 401 + 402 + To compile this driver as a module, choose M here: the 403 + module will be called moxart_wdt. 404 + 405 + config SIRFSOC_WATCHDOG 406 + tristate "SiRFSOC watchdog" 407 + depends on ARCH_SIRF 408 + select WATCHDOG_CORE 409 + default y 410 + help 411 + Support for CSR SiRFprimaII and SiRFatlasVI watchdog. When 412 + the watchdog triggers the system will be reset. 413 + 395 414 # AVR32 Architecture 396 415 397 416 config AT32AP700X_WDT ··· 885 866 config W83627HF_WDT 886 867 tristate "W83627HF/W83627DHG Watchdog Timer" 887 868 depends on X86 869 + select WATCHDOG_CORE 888 870 ---help--- 889 871 This is the driver for the hardware watchdog on the W83627HF chipset 890 872 as used in Advantech PC-9578 and Tyan S2721-533 motherboards ··· 1144 1124 depends on LANTIQ 1145 1125 help 1146 1126 Hardware driver for the Lantiq SoC Watchdog Timer. 1127 + 1128 + config RALINK_WDT 1129 + tristate "Ralink SoC watchdog" 1130 + select WATCHDOG_CORE 1131 + depends on RALINK 1132 + help 1133 + Hardware driver for the Ralink SoC Watchdog Timer. 1147 1134 1148 1135 # PARISC Architecture 1149 1136

+3

drivers/watchdog/Makefile

··· 55 55 obj-$(CONFIG_UX500_WATCHDOG) += ux500_wdt.o 56 56 obj-$(CONFIG_RETU_WATCHDOG) += retu_wdt.o 57 57 obj-$(CONFIG_BCM2835_WDT) += bcm2835_wdt.o 58 + obj-$(CONFIG_MOXART_WDT) += moxart_wdt.o 59 + obj-$(CONFIG_SIRFSOC_WATCHDOG) += sirfsoc_wdt.o 58 60 59 61 # AVR32 Architecture 60 62 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o ··· 136 134 obj-$(CONFIG_OCTEON_WDT) += octeon-wdt.o 137 135 octeon-wdt-y := octeon-wdt-main.o octeon-wdt-nmi.o 138 136 obj-$(CONFIG_LANTIQ_WDT) += lantiq_wdt.o 137 + obj-$(CONFIG_RALINK_WDT) += rt2880_wdt.o 139 138 140 139 # PARISC Architecture 141 140

+1 -3

drivers/watchdog/acquirewdt.c

··· 60 60 #include <linux/types.h> /* For standard types (like size_t) */ 61 61 #include <linux/errno.h> /* For the -ENODEV/... values */ 62 62 #include <linux/kernel.h> /* For printk/panic/... */ 63 - #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV 64 - (WATCHDOG_MINOR) */ 63 + #include <linux/miscdevice.h> /* For struct miscdevice */ 65 64 #include <linux/watchdog.h> /* For the watchdog specific items */ 66 65 #include <linux/fs.h> /* For file operations */ 67 66 #include <linux/ioport.h> /* For io-port access */ ··· 336 337 MODULE_AUTHOR("David Woodhouse"); 337 338 MODULE_DESCRIPTION("Acquire Inc. Single Board Computer Watchdog Timer driver"); 338 339 MODULE_LICENSE("GPL"); 339 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/advantechwdt.c

··· 345 345 MODULE_LICENSE("GPL"); 346 346 MODULE_AUTHOR("Marek Michalkiewicz <marekm@linux.org.pl>"); 347 347 MODULE_DESCRIPTION("Advantech Single Board Computer WDT driver"); 348 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/alim1535_wdt.c

··· 452 452 MODULE_AUTHOR("Alan Cox"); 453 453 MODULE_DESCRIPTION("ALi M1535 PMU Watchdog Timer driver"); 454 454 MODULE_LICENSE("GPL"); 455 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/alim7101_wdt.c

··· 425 425 MODULE_AUTHOR("Steve Hill"); 426 426 MODULE_DESCRIPTION("ALi M7101 PMU Computer Watchdog Timer driver"); 427 427 MODULE_LICENSE("GPL"); 428 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/ar7_wdt.c

··· 46 46 MODULE_AUTHOR("Nicolas Thill <nico@openwrt.org>"); 47 47 MODULE_DESCRIPTION(LONGNAME); 48 48 MODULE_LICENSE("GPL"); 49 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 50 49 51 50 static int margin = 60; 52 51 module_param(margin, int, 0);

-1

drivers/watchdog/at32ap700x_wdt.c

··· 434 434 MODULE_AUTHOR("Hans-Christian Egtvedt <egtvedt@samfundet.no>"); 435 435 MODULE_DESCRIPTION("Watchdog driver for Atmel AT32AP700X"); 436 436 MODULE_LICENSE("GPL"); 437 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+1 -2

drivers/watchdog/at91rm9200_wdt.c

··· 269 269 .driver = { 270 270 .name = "at91_wdt", 271 271 .owner = THIS_MODULE, 272 - .of_match_table = of_match_ptr(at91_wdt_dt_ids), 272 + .of_match_table = at91_wdt_dt_ids, 273 273 }, 274 274 }; 275 275 ··· 297 297 MODULE_AUTHOR("Andrew Victor"); 298 298 MODULE_DESCRIPTION("Watchdog driver for Atmel AT91RM9200"); 299 299 MODULE_LICENSE("GPL"); 300 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 301 300 MODULE_ALIAS("platform:at91_wdt");

-1

drivers/watchdog/ath79_wdt.c

··· 329 329 MODULE_AUTHOR("Imre Kaloz <kaloz@openwrt.org"); 330 330 MODULE_LICENSE("GPL v2"); 331 331 MODULE_ALIAS("platform:" DRIVER_NAME); 332 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/bcm2835_wdt.c

··· 186 186 MODULE_AUTHOR("Lubomir Rintel <lkundrak@v3.sk>"); 187 187 MODULE_DESCRIPTION("Driver for Broadcom BCM2835 watchdog timer"); 188 188 MODULE_LICENSE("GPL"); 189 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/bcm63xx_wdt.c

··· 317 317 MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>"); 318 318 MODULE_DESCRIPTION("Driver for the Broadcom BCM63xx SoC watchdog"); 319 319 MODULE_LICENSE("GPL"); 320 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 321 320 MODULE_ALIAS("platform:bcm63xx-wdt");

-1

drivers/watchdog/bfin_wdt.c

··· 465 465 MODULE_AUTHOR("Michele d'Amico, Mike Frysinger <vapier@gentoo.org>"); 466 466 MODULE_DESCRIPTION("Blackfin Watchdog Device Driver"); 467 467 MODULE_LICENSE("GPL"); 468 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 469 468 470 469 module_param(timeout, uint, 0); 471 470 MODULE_PARM_DESC(timeout,

-1

drivers/watchdog/cpu5wdt.c

··· 289 289 MODULE_DESCRIPTION("sma cpu5 watchdog driver"); 290 290 MODULE_SUPPORTED_DEVICE("sma cpu5 watchdog"); 291 291 MODULE_LICENSE("GPL"); 292 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 293 292 294 293 module_param(port, int, 0); 295 294 MODULE_PARM_DESC(port, "base address of watchdog card, default is 0x91");

-1

drivers/watchdog/davinci_wdt.c

··· 267 267 __MODULE_STRING(DEFAULT_HEARTBEAT)); 268 268 269 269 MODULE_LICENSE("GPL"); 270 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 271 270 MODULE_ALIAS("platform:watchdog");

+20 -16

drivers/watchdog/dw_wdt.c

··· 29 29 #include <linux/miscdevice.h> 30 30 #include <linux/module.h> 31 31 #include <linux/moduleparam.h> 32 + #include <linux/of.h> 32 33 #include <linux/pm.h> 33 34 #include <linux/platform_device.h> 34 35 #include <linux/spinlock.h> ··· 204 203 205 204 switch (cmd) { 206 205 case WDIOC_GETSUPPORT: 207 - return copy_to_user((struct watchdog_info *)arg, &dw_wdt_ident, 206 + return copy_to_user((void __user *)arg, &dw_wdt_ident, 208 207 sizeof(dw_wdt_ident)) ? -EFAULT : 0; 209 208 210 209 case WDIOC_GETSTATUS: 211 210 case WDIOC_GETBOOTSTATUS: 212 - return put_user(0, (int *)arg); 211 + return put_user(0, (int __user *)arg); 213 212 214 213 case WDIOC_KEEPALIVE: 215 214 dw_wdt_set_next_heartbeat(); ··· 253 252 return 0; 254 253 } 255 254 256 - #ifdef CONFIG_PM 255 + #ifdef CONFIG_PM_SLEEP 257 256 static int dw_wdt_suspend(struct device *dev) 258 257 { 259 - clk_disable(dw_wdt.clk); 258 + clk_disable_unprepare(dw_wdt.clk); 260 259 261 260 return 0; 262 261 } 263 262 264 263 static int dw_wdt_resume(struct device *dev) 265 264 { 266 - int err = clk_enable(dw_wdt.clk); 265 + int err = clk_prepare_enable(dw_wdt.clk); 267 266 268 267 if (err) 269 268 return err; ··· 272 271 273 272 return 0; 274 273 } 274 + #endif /* CONFIG_PM_SLEEP */ 275 275 276 - static const struct dev_pm_ops dw_wdt_pm_ops = { 277 - .suspend = dw_wdt_suspend, 278 - .resume = dw_wdt_resume, 279 - }; 280 - #endif /* CONFIG_PM */ 276 + static SIMPLE_DEV_PM_OPS(dw_wdt_pm_ops, dw_wdt_suspend, dw_wdt_resume); 281 277 282 278 static const struct file_operations wdt_fops = { 283 279 .owner = THIS_MODULE, ··· 307 309 if (IS_ERR(dw_wdt.clk)) 308 310 return PTR_ERR(dw_wdt.clk); 309 311 310 - ret = clk_enable(dw_wdt.clk); 312 + ret = clk_prepare_enable(dw_wdt.clk); 311 313 if (ret) 312 314 return ret; 313 315 ··· 324 326 return 0; 325 327 326 328 out_disable_clk: 327 - clk_disable(dw_wdt.clk); 329 + clk_disable_unprepare(dw_wdt.clk); 328 330 329 331 return ret; 330 332 } ··· 333 335 { 334 336 misc_deregister(&dw_wdt_miscdev); 335 337 336 - clk_disable(dw_wdt.clk); 338 + clk_disable_unprepare(dw_wdt.clk); 337 339 338 340 return 0; 339 341 } 342 + 343 + #ifdef CONFIG_OF 344 + static const struct of_device_id dw_wdt_of_match[] = { 345 + { .compatible = "snps,dw-wdt", }, 346 + { /* sentinel */ } 347 + }; 348 + MODULE_DEVICE_TABLE(of, dw_wdt_of_match); 349 + #endif 340 350 341 351 static struct platform_driver dw_wdt_driver = { 342 352 .probe = dw_wdt_drv_probe, ··· 352 346 .driver = { 353 347 .name = "dw_wdt", 354 348 .owner = THIS_MODULE, 355 - #ifdef CONFIG_PM 349 + .of_match_table = of_match_ptr(dw_wdt_of_match), 356 350 .pm = &dw_wdt_pm_ops, 357 - #endif /* CONFIG_PM */ 358 351 }, 359 352 }; 360 353 ··· 362 357 MODULE_AUTHOR("Jamie Iles"); 363 358 MODULE_DESCRIPTION("Synopsys DesignWare Watchdog Driver"); 364 359 MODULE_LICENSE("GPL"); 365 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/ep93xx_wdt.c

··· 179 179 MODULE_DESCRIPTION("EP93xx Watchdog"); 180 180 MODULE_LICENSE("GPL"); 181 181 MODULE_VERSION(WDT_VERSION); 182 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/eurotechwdt.c

··· 477 477 MODULE_AUTHOR("Rodolfo Giometti"); 478 478 MODULE_DESCRIPTION("Driver for Eurotech CPU-1220/1410 on board watchdog"); 479 479 MODULE_LICENSE("GPL"); 480 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/gef_wdt.c

··· 331 331 MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com>"); 332 332 MODULE_DESCRIPTION("GE watchdog driver"); 333 333 MODULE_LICENSE("GPL"); 334 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 335 334 MODULE_ALIAS("platform:gef_wdt");

-1

drivers/watchdog/geodewdt.c

··· 297 297 MODULE_AUTHOR("Advanced Micro Devices, Inc"); 298 298 MODULE_DESCRIPTION("Geode GX/LX Watchdog Driver"); 299 299 MODULE_LICENSE("GPL"); 300 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/hpwdt.c

··· 881 881 MODULE_DESCRIPTION("hp watchdog driver"); 882 882 MODULE_LICENSE("GPL"); 883 883 MODULE_VERSION(HPWDT_VERSION); 884 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 885 884 886 885 module_param(soft_margin, int, 0); 887 886 MODULE_PARM_DESC(soft_margin, "Watchdog timeout in seconds");

-1

drivers/watchdog/i6300esb.c

··· 497 497 MODULE_AUTHOR("Ross Biro and David Härdeman"); 498 498 MODULE_DESCRIPTION("Watchdog driver for Intel 6300ESB chipsets"); 499 499 MODULE_LICENSE("GPL"); 500 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+1 -4

drivers/watchdog/iTCO_wdt.c

··· 56 56 #include <linux/types.h> /* For standard types (like size_t) */ 57 57 #include <linux/errno.h> /* For the -ENODEV/... values */ 58 58 #include <linux/kernel.h> /* For printk/panic/... */ 59 - #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV 60 - (WATCHDOG_MINOR) */ 61 59 #include <linux/watchdog.h> /* For the watchdog specific items */ 62 60 #include <linux/init.h> /* For __init/__exit/... */ 63 61 #include <linux/fs.h> /* For file operations */ ··· 392 394 { 393 395 int ret = -ENODEV; 394 396 unsigned long val32; 395 - struct lpc_ich_info *ich_info = dev->dev.platform_data; 397 + struct lpc_ich_info *ich_info = dev_get_platdata(&dev->dev); 396 398 397 399 if (!ich_info) 398 400 goto out; ··· 580 582 MODULE_DESCRIPTION("Intel TCO WatchDog Timer Driver"); 581 583 MODULE_VERSION(DRV_VERSION); 582 584 MODULE_LICENSE("GPL"); 583 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 584 585 MODULE_ALIAS("platform:" DRV_NAME);

-1

drivers/watchdog/ib700wdt.c

··· 382 382 MODULE_AUTHOR("Charles Howes <chowes@vsol.net>"); 383 383 MODULE_DESCRIPTION("IB700 SBC watchdog driver"); 384 384 MODULE_LICENSE("GPL"); 385 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 386 385 387 386 /* end of ib700wdt.c */

-1

drivers/watchdog/ibmasr.c

··· 419 419 MODULE_DESCRIPTION("IBM Automatic Server Restart driver"); 420 420 MODULE_AUTHOR("Andrey Panin"); 421 421 MODULE_LICENSE("GPL"); 422 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/ie6xx_wdt.c

··· 344 344 MODULE_AUTHOR("Alexander Stein <alexander.stein@systec-electronic.com>"); 345 345 MODULE_DESCRIPTION("Intel Atom E6xx Watchdog Device Driver"); 346 346 MODULE_LICENSE("GPL"); 347 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 348 347 MODULE_ALIAS("platform:" DRIVER_NAME);

+1 -1

drivers/watchdog/imx2_wdt.c

··· 322 322 { .compatible = "fsl,imx21-wdt", }, 323 323 { /* sentinel */ } 324 324 }; 325 + MODULE_DEVICE_TABLE(of, imx2_wdt_dt_ids); 325 326 326 327 static struct platform_driver imx2_wdt_driver = { 327 328 .remove = __exit_p(imx2_wdt_remove), ··· 339 338 MODULE_AUTHOR("Wolfram Sang"); 340 339 MODULE_DESCRIPTION("Watchdog driver for IMX2 and later"); 341 340 MODULE_LICENSE("GPL v2"); 342 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 343 341 MODULE_ALIAS("platform:" DRIVER_NAME);

-1

drivers/watchdog/indydog.c

··· 214 214 MODULE_AUTHOR("Guido Guenther <agx@sigxcpu.org>"); 215 215 MODULE_DESCRIPTION("Hardware Watchdog Device for SGI IP22"); 216 216 MODULE_LICENSE("GPL"); 217 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/intel_scu_watchdog.c

··· 564 564 MODULE_AUTHOR("Intel Corporation"); 565 565 MODULE_DESCRIPTION("Intel SCU Watchdog Device Driver"); 566 566 MODULE_LICENSE("GPL"); 567 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 568 567 MODULE_VERSION(WDT_VER);

-1

drivers/watchdog/iop_wdt.c

··· 259 259 MODULE_AUTHOR("Curt E Bruns <curt.e.bruns@intel.com>"); 260 260 MODULE_DESCRIPTION("iop watchdog timer driver"); 261 261 MODULE_LICENSE("GPL"); 262 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/it8712f_wdt.c

··· 41 41 MODULE_AUTHOR("Jorge Boncompte - DTI2 <jorge@dti2.net>"); 42 42 MODULE_DESCRIPTION("IT8712F Watchdog Driver"); 43 43 MODULE_LICENSE("GPL"); 44 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 45 44 46 45 static int max_units = 255; 47 46 static int margin = 60; /* in seconds */

-1

drivers/watchdog/it87_wdt.c

··· 772 772 MODULE_AUTHOR("Oliver Schuster"); 773 773 MODULE_DESCRIPTION("Hardware Watchdog Device Driver for IT87xx EC-LPC I/O"); 774 774 MODULE_LICENSE("GPL"); 775 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-2

drivers/watchdog/ixp4xx_wdt.c

··· 208 208 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started"); 209 209 210 210 MODULE_LICENSE("GPL"); 211 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 212 -

-1

drivers/watchdog/jz4740_wdt.c

··· 222 222 MODULE_AUTHOR("Paul Cercueil <paul@crapouillou.net>"); 223 223 MODULE_DESCRIPTION("jz4740 Watchdog Driver"); 224 224 MODULE_LICENSE("GPL"); 225 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 226 225 MODULE_ALIAS("platform:jz4740-wdt");

+2 -3

drivers/watchdog/kempld_wdt.c

··· 67 67 PRESCALER_12, 68 68 }; 69 69 70 - const u32 kempld_prescaler[] = { 70 + static const u32 kempld_prescaler[] = { 71 71 [PRESCALER_21] = (1 << 21) - 1, 72 72 [PRESCALER_17] = (1 << 17) - 1, 73 73 [PRESCALER_12] = (1 << 12) - 1, ··· 361 361 ret = kempld_wdt_keepalive(wdd); 362 362 break; 363 363 case WDIOC_GETPRETIMEOUT: 364 - ret = put_user(wdt_data->pretimeout, (int *)arg); 364 + ret = put_user(wdt_data->pretimeout, (int __user *)arg); 365 365 break; 366 366 } 367 367 ··· 578 578 MODULE_DESCRIPTION("KEM PLD Watchdog Driver"); 579 579 MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>"); 580 580 MODULE_LICENSE("GPL"); 581 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/ks8695_wdt.c

··· 323 323 MODULE_AUTHOR("Andrew Victor"); 324 324 MODULE_DESCRIPTION("Watchdog driver for KS8695"); 325 325 MODULE_LICENSE("GPL"); 326 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 327 326 MODULE_ALIAS("platform:ks8695_wdt");

-1

drivers/watchdog/lantiq_wdt.c

··· 249 249 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>"); 250 250 MODULE_DESCRIPTION("Lantiq SoC Watchdog"); 251 251 MODULE_LICENSE("GPL"); 252 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/m54xx_wdt.c

··· 223 223 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started"); 224 224 225 225 MODULE_LICENSE("GPL"); 226 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/machzwd.c

··· 92 92 MODULE_AUTHOR("Fernando Fuganti <fuganti@conectiva.com.br>"); 93 93 MODULE_DESCRIPTION("MachZ ZF-Logic Watchdog driver"); 94 94 MODULE_LICENSE("GPL"); 95 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 96 95 97 96 static bool nowayout = WATCHDOG_NOWAYOUT; 98 97 module_param(nowayout, bool, 0);

-1

drivers/watchdog/max63xx_wdt.c

··· 258 258 "(max6373/74 only, default=0)"); 259 259 260 260 MODULE_LICENSE("GPL"); 261 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/mixcomwd.c

··· 315 315 MODULE_DESCRIPTION("MixCom Watchdog driver"); 316 316 MODULE_VERSION(VERSION); 317 317 MODULE_LICENSE("GPL"); 318 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+165

drivers/watchdog/moxart_wdt.c

··· 1 + /* 2 + * MOXA ART SoCs watchdog driver. 3 + * 4 + * Copyright (C) 2013 Jonas Jensen 5 + * 6 + * Jonas Jensen <jonas.jensen@gmail.com> 7 + * 8 + * This file is licensed under the terms of the GNU General Public 9 + * License version 2. This program is licensed "as is" without any 10 + * warranty of any kind, whether express or implied. 11 + */ 12 + 13 + #include <linux/clk.h> 14 + #include <linux/io.h> 15 + #include <linux/module.h> 16 + #include <linux/err.h> 17 + #include <linux/kernel.h> 18 + #include <linux/platform_device.h> 19 + #include <linux/watchdog.h> 20 + #include <linux/moduleparam.h> 21 + 22 + #define REG_COUNT 0x4 23 + #define REG_MODE 0x8 24 + #define REG_ENABLE 0xC 25 + 26 + struct moxart_wdt_dev { 27 + struct watchdog_device dev; 28 + void __iomem *base; 29 + unsigned int clock_frequency; 30 + }; 31 + 32 + static int heartbeat; 33 + 34 + static int moxart_wdt_stop(struct watchdog_device *wdt_dev) 35 + { 36 + struct moxart_wdt_dev *moxart_wdt = watchdog_get_drvdata(wdt_dev); 37 + 38 + writel(0, moxart_wdt->base + REG_ENABLE); 39 + 40 + return 0; 41 + } 42 + 43 + static int moxart_wdt_start(struct watchdog_device *wdt_dev) 44 + { 45 + struct moxart_wdt_dev *moxart_wdt = watchdog_get_drvdata(wdt_dev); 46 + 47 + writel(moxart_wdt->clock_frequency * wdt_dev->timeout, 48 + moxart_wdt->base + REG_COUNT); 49 + writel(0x5ab9, moxart_wdt->base + REG_MODE); 50 + writel(0x03, moxart_wdt->base + REG_ENABLE); 51 + 52 + return 0; 53 + } 54 + 55 + static int moxart_wdt_set_timeout(struct watchdog_device *wdt_dev, 56 + unsigned int timeout) 57 + { 58 + wdt_dev->timeout = timeout; 59 + 60 + return 0; 61 + } 62 + 63 + static const struct watchdog_info moxart_wdt_info = { 64 + .identity = "moxart-wdt", 65 + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | 66 + WDIOF_MAGICCLOSE, 67 + }; 68 + 69 + static const struct watchdog_ops moxart_wdt_ops = { 70 + .owner = THIS_MODULE, 71 + .start = moxart_wdt_start, 72 + .stop = moxart_wdt_stop, 73 + .set_timeout = moxart_wdt_set_timeout, 74 + }; 75 + 76 + static int moxart_wdt_probe(struct platform_device *pdev) 77 + { 78 + struct moxart_wdt_dev *moxart_wdt; 79 + struct device *dev = &pdev->dev; 80 + struct device_node *node = dev->of_node; 81 + struct resource *res; 82 + struct clk *clk; 83 + int err; 84 + unsigned int max_timeout; 85 + bool nowayout = WATCHDOG_NOWAYOUT; 86 + 87 + moxart_wdt = devm_kzalloc(dev, sizeof(*moxart_wdt), GFP_KERNEL); 88 + if (!moxart_wdt) 89 + return -ENOMEM; 90 + 91 + platform_set_drvdata(pdev, moxart_wdt); 92 + 93 + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 94 + moxart_wdt->base = devm_ioremap_resource(dev, res); 95 + if (IS_ERR(moxart_wdt->base)) 96 + return PTR_ERR(moxart_wdt->base); 97 + 98 + clk = of_clk_get(node, 0); 99 + if (IS_ERR(clk)) { 100 + pr_err("%s: of_clk_get failed\n", __func__); 101 + return PTR_ERR(clk); 102 + } 103 + 104 + moxart_wdt->clock_frequency = clk_get_rate(clk); 105 + if (moxart_wdt->clock_frequency == 0) { 106 + pr_err("%s: incorrect clock frequency\n", __func__); 107 + return -EINVAL; 108 + } 109 + 110 + max_timeout = UINT_MAX / moxart_wdt->clock_frequency; 111 + 112 + moxart_wdt->dev.info = &moxart_wdt_info; 113 + moxart_wdt->dev.ops = &moxart_wdt_ops; 114 + moxart_wdt->dev.timeout = max_timeout; 115 + moxart_wdt->dev.min_timeout = 1; 116 + moxart_wdt->dev.max_timeout = max_timeout; 117 + moxart_wdt->dev.parent = dev; 118 + 119 + watchdog_init_timeout(&moxart_wdt->dev, heartbeat, dev); 120 + watchdog_set_nowayout(&moxart_wdt->dev, nowayout); 121 + 122 + watchdog_set_drvdata(&moxart_wdt->dev, moxart_wdt); 123 + 124 + err = watchdog_register_device(&moxart_wdt->dev); 125 + if (err) 126 + return err; 127 + 128 + dev_dbg(dev, "Watchdog enabled (heartbeat=%d sec, nowayout=%d)\n", 129 + moxart_wdt->dev.timeout, nowayout); 130 + 131 + return 0; 132 + } 133 + 134 + static int moxart_wdt_remove(struct platform_device *pdev) 135 + { 136 + struct moxart_wdt_dev *moxart_wdt = platform_get_drvdata(pdev); 137 + 138 + moxart_wdt_stop(&moxart_wdt->dev); 139 + watchdog_unregister_device(&moxart_wdt->dev); 140 + 141 + return 0; 142 + } 143 + 144 + static const struct of_device_id moxart_watchdog_match[] = { 145 + { .compatible = "moxa,moxart-watchdog" }, 146 + { }, 147 + }; 148 + 149 + static struct platform_driver moxart_wdt_driver = { 150 + .probe = moxart_wdt_probe, 151 + .remove = moxart_wdt_remove, 152 + .driver = { 153 + .name = "moxart-watchdog", 154 + .owner = THIS_MODULE, 155 + .of_match_table = moxart_watchdog_match, 156 + }, 157 + }; 158 + module_platform_driver(moxart_wdt_driver); 159 + 160 + module_param(heartbeat, int, 0); 161 + MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds"); 162 + 163 + MODULE_DESCRIPTION("MOXART watchdog driver"); 164 + MODULE_LICENSE("GPL"); 165 + MODULE_AUTHOR("Jonas Jensen <jonas.jensen@gmail.com>");

-1

drivers/watchdog/mpc8xxx_wdt.c

··· 330 330 MODULE_DESCRIPTION("Driver for watchdog timer in MPC8xx/MPC83xx/MPC86xx " 331 331 "uProcessors"); 332 332 MODULE_LICENSE("GPL"); 333 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/mtx-1_wdt.c

··· 257 257 MODULE_AUTHOR("Michael Stickel, Florian Fainelli"); 258 258 MODULE_DESCRIPTION("Driver for the MTX-1 watchdog"); 259 259 MODULE_LICENSE("GPL"); 260 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 261 260 MODULE_ALIAS("platform:mtx1-wdt");

+1 -2

drivers/watchdog/mv64x60_wdt.c

··· 255 255 256 256 static int mv64x60_wdt_probe(struct platform_device *dev) 257 257 { 258 - struct mv64x60_wdt_pdata *pdata = dev->dev.platform_data; 258 + struct mv64x60_wdt_pdata *pdata = dev_get_platdata(&dev->dev); 259 259 struct resource *r; 260 260 int timeout = 10; 261 261 ··· 323 323 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>"); 324 324 MODULE_DESCRIPTION("MV64x60 watchdog driver"); 325 325 MODULE_LICENSE("GPL"); 326 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 327 326 MODULE_ALIAS("platform:" MV64x60_WDT_NAME);

-1

drivers/watchdog/nuc900_wdt.c

··· 307 307 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>"); 308 308 MODULE_DESCRIPTION("Watchdog driver for NUC900"); 309 309 MODULE_LICENSE("GPL"); 310 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 311 310 MODULE_ALIAS("platform:nuc900-wdt");

-1

drivers/watchdog/nv_tco.c

··· 513 513 MODULE_AUTHOR("Mike Waychison"); 514 514 MODULE_DESCRIPTION("TCO timer driver for NV chipsets"); 515 515 MODULE_LICENSE("GPL"); 516 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/of_xilinx_wdt.c

··· 405 405 MODULE_AUTHOR("Alejandro Cabrera <aldaya@gmail.com>"); 406 406 MODULE_DESCRIPTION("Xilinx Watchdog driver"); 407 407 MODULE_LICENSE("GPL v2"); 408 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+19 -19

drivers/watchdog/omap_wdt.c

··· 68 68 void __iomem *base = wdev->base; 69 69 70 70 /* wait for posted write to complete */ 71 - while ((__raw_readl(base + OMAP_WATCHDOG_WPS)) & 0x08) 71 + while ((readl_relaxed(base + OMAP_WATCHDOG_WPS)) & 0x08) 72 72 cpu_relax(); 73 73 74 74 wdev->wdt_trgr_pattern = ~wdev->wdt_trgr_pattern; 75 - __raw_writel(wdev->wdt_trgr_pattern, (base + OMAP_WATCHDOG_TGR)); 75 + writel_relaxed(wdev->wdt_trgr_pattern, (base + OMAP_WATCHDOG_TGR)); 76 76 77 77 /* wait for posted write to complete */ 78 - while ((__raw_readl(base + OMAP_WATCHDOG_WPS)) & 0x08) 78 + while ((readl_relaxed(base + OMAP_WATCHDOG_WPS)) & 0x08) 79 79 cpu_relax(); 80 80 /* reloaded WCRR from WLDR */ 81 81 } ··· 85 85 void __iomem *base = wdev->base; 86 86 87 87 /* Sequence to enable the watchdog */ 88 - __raw_writel(0xBBBB, base + OMAP_WATCHDOG_SPR); 89 - while ((__raw_readl(base + OMAP_WATCHDOG_WPS)) & 0x10) 88 + writel_relaxed(0xBBBB, base + OMAP_WATCHDOG_SPR); 89 + while ((readl_relaxed(base + OMAP_WATCHDOG_WPS)) & 0x10) 90 90 cpu_relax(); 91 91 92 - __raw_writel(0x4444, base + OMAP_WATCHDOG_SPR); 93 - while ((__raw_readl(base + OMAP_WATCHDOG_WPS)) & 0x10) 92 + writel_relaxed(0x4444, base + OMAP_WATCHDOG_SPR); 93 + while ((readl_relaxed(base + OMAP_WATCHDOG_WPS)) & 0x10) 94 94 cpu_relax(); 95 95 } 96 96 ··· 99 99 void __iomem *base = wdev->base; 100 100 101 101 /* sequence required to disable watchdog */ 102 - __raw_writel(0xAAAA, base + OMAP_WATCHDOG_SPR); /* TIMER_MODE */ 103 - while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x10) 102 + writel_relaxed(0xAAAA, base + OMAP_WATCHDOG_SPR); /* TIMER_MODE */ 103 + while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x10) 104 104 cpu_relax(); 105 105 106 - __raw_writel(0x5555, base + OMAP_WATCHDOG_SPR); /* TIMER_MODE */ 107 - while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x10) 106 + writel_relaxed(0x5555, base + OMAP_WATCHDOG_SPR); /* TIMER_MODE */ 107 + while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x10) 108 108 cpu_relax(); 109 109 } 110 110 ··· 115 115 void __iomem *base = wdev->base; 116 116 117 117 /* just count up at 32 KHz */ 118 - while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x04) 118 + while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x04) 119 119 cpu_relax(); 120 120 121 - __raw_writel(pre_margin, base + OMAP_WATCHDOG_LDR); 122 - while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x04) 121 + writel_relaxed(pre_margin, base + OMAP_WATCHDOG_LDR); 122 + while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x04) 123 123 cpu_relax(); 124 124 } 125 125 ··· 135 135 pm_runtime_get_sync(wdev->dev); 136 136 137 137 /* initialize prescaler */ 138 - while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x01) 138 + while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x01) 139 139 cpu_relax(); 140 140 141 - __raw_writel((1 << 5) | (PTV << 2), base + OMAP_WATCHDOG_CNTRL); 142 - while (__raw_readl(base + OMAP_WATCHDOG_WPS) & 0x01) 141 + writel_relaxed((1 << 5) | (PTV << 2), base + OMAP_WATCHDOG_CNTRL); 142 + while (readl_relaxed(base + OMAP_WATCHDOG_WPS) & 0x01) 143 143 cpu_relax(); 144 144 145 145 omap_wdt_set_timer(wdev, wdog->timeout); ··· 205 205 206 206 static int omap_wdt_probe(struct platform_device *pdev) 207 207 { 208 - struct omap_wd_timer_platform_data *pdata = pdev->dev.platform_data; 208 + struct omap_wd_timer_platform_data *pdata = dev_get_platdata(&pdev->dev); 209 209 struct watchdog_device *omap_wdt; 210 210 struct resource *res, *mem; 211 211 struct omap_wdt_dev *wdev; ··· 275 275 } 276 276 277 277 pr_info("OMAP Watchdog Timer Rev 0x%02x: initial timeout %d sec\n", 278 - __raw_readl(wdev->base + OMAP_WATCHDOG_REV) & 0xFF, 278 + readl_relaxed(wdev->base + OMAP_WATCHDOG_REV) & 0xFF, 279 279 omap_wdt->timeout); 280 280 281 281 pm_runtime_put_sync(wdev->dev);

+1 -2

drivers/watchdog/orion_wdt.c

··· 207 207 .driver = { 208 208 .owner = THIS_MODULE, 209 209 .name = "orion_wdt", 210 - .of_match_table = of_match_ptr(orion_wdt_of_match_table), 210 + .of_match_table = orion_wdt_of_match_table, 211 211 }, 212 212 }; 213 213 ··· 225 225 226 226 MODULE_LICENSE("GPL"); 227 227 MODULE_ALIAS("platform:orion_wdt"); 228 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-2

drivers/watchdog/pc87413_wdt.c

··· 580 580 MODULE_DESCRIPTION("PC87413 WDT driver"); 581 581 MODULE_LICENSE("GPL"); 582 582 583 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 584 - 585 583 module_param(io, int, 0); 586 584 MODULE_PARM_DESC(io, MODNAME " I/O port (default: " 587 585 __MODULE_STRING(IO_DEFAULT) ").");

+1 -3

drivers/watchdog/pcwd.c

··· 61 61 #include <linux/delay.h> /* For mdelay function */ 62 62 #include <linux/timer.h> /* For timer related operations */ 63 63 #include <linux/jiffies.h> /* For jiffies stuff */ 64 - #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */ 64 + #include <linux/miscdevice.h> /* For struct miscdevice */ 65 65 #include <linux/watchdog.h> /* For the watchdog specific items */ 66 66 #include <linux/reboot.h> /* For kernel_power_off() */ 67 67 #include <linux/init.h> /* For __init/__exit/... */ ··· 1011 1011 MODULE_DESCRIPTION("Berkshire ISA-PC Watchdog driver"); 1012 1012 MODULE_VERSION(WATCHDOG_VERSION); 1013 1013 MODULE_LICENSE("GPL"); 1014 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 1015 - MODULE_ALIAS_MISCDEV(TEMP_MINOR);

+1 -3

drivers/watchdog/pcwd_pci.c

··· 40 40 #include <linux/errno.h> /* For the -ENODEV/... values */ 41 41 #include <linux/kernel.h> /* For printk/panic/... */ 42 42 #include <linux/delay.h> /* For mdelay function */ 43 - #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */ 43 + #include <linux/miscdevice.h> /* For struct miscdevice */ 44 44 #include <linux/watchdog.h> /* For the watchdog specific items */ 45 45 #include <linux/notifier.h> /* For notifier support */ 46 46 #include <linux/reboot.h> /* For reboot_notifier stuff */ ··· 820 820 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>"); 821 821 MODULE_DESCRIPTION("Berkshire PCI-PC Watchdog driver"); 822 822 MODULE_LICENSE("GPL"); 823 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 824 - MODULE_ALIAS_MISCDEV(TEMP_MINOR);

+10 -6

drivers/watchdog/pcwd_usb.c

··· 32 32 #include <linux/errno.h> /* For the -ENODEV/... values */ 33 33 #include <linux/kernel.h> /* For printk/panic/... */ 34 34 #include <linux/delay.h> /* For mdelay function */ 35 - #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR) */ 35 + #include <linux/miscdevice.h> /* For struct miscdevice */ 36 36 #include <linux/watchdog.h> /* For the watchdog specific items */ 37 37 #include <linux/notifier.h> /* For notifier support */ 38 38 #include <linux/reboot.h> /* For reboot_notifier stuff */ ··· 72 72 MODULE_AUTHOR(DRIVER_AUTHOR); 73 73 MODULE_DESCRIPTION(DRIVER_DESC); 74 74 MODULE_LICENSE(DRIVER_LICENSE); 75 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 76 - MODULE_ALIAS_MISCDEV(TEMP_MINOR); 77 75 78 76 /* Module Parameters */ 79 77 module_param(debug, int, 0); ··· 233 235 unsigned char cmd, unsigned char *msb, unsigned char *lsb) 234 236 { 235 237 int got_response, count; 236 - unsigned char buf[6]; 238 + unsigned char *buf; 237 239 238 240 /* We will not send any commands if the USB PCWD device does 239 241 * not exist */ 240 242 if ((!usb_pcwd) || (!usb_pcwd->exists)) 241 243 return -1; 244 + 245 + buf = kmalloc(6, GFP_KERNEL); 246 + if (buf == NULL) 247 + return 0; 242 248 243 249 /* The USB PC Watchdog uses a 6 byte report format. 244 250 * The board currently uses only 3 of the six bytes of the report. */ ··· 258 256 259 257 if (usb_control_msg(usb_pcwd->udev, usb_sndctrlpipe(usb_pcwd->udev, 0), 260 258 HID_REQ_SET_REPORT, HID_DT_REPORT, 261 - 0x0200, usb_pcwd->interface_number, buf, sizeof(buf), 262 - USB_COMMAND_TIMEOUT) != sizeof(buf)) { 259 + 0x0200, usb_pcwd->interface_number, buf, 6, 260 + USB_COMMAND_TIMEOUT) != 6) { 263 261 dbg("usb_pcwd_send_command: error in usb_control_msg for " 264 262 "cmd 0x%x 0x%x 0x%x\n", cmd, *msb, *lsb); 265 263 } ··· 278 276 *msb = usb_pcwd->cmd_data_msb; 279 277 *lsb = usb_pcwd->cmd_data_lsb; 280 278 } 279 + 280 + kfree(buf); 281 281 282 282 return got_response; 283 283 }

-2

drivers/watchdog/pika_wdt.c

··· 299 299 MODULE_AUTHOR("Sean MacLennan <smaclennan@pikatech.com>"); 300 300 MODULE_DESCRIPTION("PIKA FPGA based Watchdog Timer"); 301 301 MODULE_LICENSE("GPL"); 302 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 303 -

-1

drivers/watchdog/pnx4008_wdt.c

··· 233 233 "Set to 1 to keep watchdog running after device release"); 234 234 235 235 MODULE_LICENSE("GPL"); 236 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 237 236 MODULE_ALIAS("platform:pnx4008-watchdog");

-1

drivers/watchdog/pnx833x_wdt.c

··· 278 278 MODULE_AUTHOR("Daniel Laird/Andre McCurdy"); 279 279 MODULE_DESCRIPTION("Hardware Watchdog Device for PNX833x"); 280 280 MODULE_LICENSE("GPL"); 281 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+1 -3

drivers/watchdog/rc32434_wdt.c

··· 25 25 #include <linux/errno.h> /* For the -ENODEV/... values */ 26 26 #include <linux/kernel.h> /* For printk/panic/... */ 27 27 #include <linux/fs.h> /* For file operations */ 28 - #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV 29 - (WATCHDOG_MINOR) */ 28 + #include <linux/miscdevice.h> /* For struct miscdevice */ 30 29 #include <linux/watchdog.h> /* For the watchdog specific items */ 31 30 #include <linux/init.h> /* For __init/__exit/... */ 32 31 #include <linux/platform_device.h> /* For platform_driver framework */ ··· 328 329 "Florian Fainelli <florian@openwrt.org>"); 329 330 MODULE_DESCRIPTION("Driver for the IDT RC32434 SoC watchdog"); 330 331 MODULE_LICENSE("GPL"); 331 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+1 -2

drivers/watchdog/rdc321x_wdt.c

··· 231 231 struct resource *r; 232 232 struct rdc321x_wdt_pdata *pdata; 233 233 234 - pdata = pdev->dev.platform_data; 234 + pdata = dev_get_platdata(&pdev->dev); 235 235 if (!pdata) { 236 236 dev_err(&pdev->dev, "no platform data supplied\n"); 237 237 return -ENODEV; ··· 298 298 MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>"); 299 299 MODULE_DESCRIPTION("RDC321x watchdog driver"); 300 300 MODULE_LICENSE("GPL"); 301 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+207

drivers/watchdog/rt2880_wdt.c

··· 1 + /* 2 + * Ralink RT288x/RT3xxx/MT76xx built-in hardware watchdog timer 3 + * 4 + * Copyright (C) 2011 Gabor Juhos <juhosg@openwrt.org> 5 + * Copyright (C) 2013 John Crispin <blogic@openwrt.org> 6 + * 7 + * This driver was based on: drivers/watchdog/softdog.c 8 + * 9 + * This program is free software; you can redistribute it and/or modify it 10 + * under the terms of the GNU General Public License version 2 as published 11 + * by the Free Software Foundation. 12 + */ 13 + 14 + #include <linux/clk.h> 15 + #include <linux/reset.h> 16 + #include <linux/module.h> 17 + #include <linux/kernel.h> 18 + #include <linux/watchdog.h> 19 + #include <linux/miscdevice.h> 20 + #include <linux/moduleparam.h> 21 + #include <linux/platform_device.h> 22 + 23 + #include <asm/mach-ralink/ralink_regs.h> 24 + 25 + #define SYSC_RSTSTAT 0x38 26 + #define WDT_RST_CAUSE BIT(1) 27 + 28 + #define RALINK_WDT_TIMEOUT 30 29 + #define RALINK_WDT_PRESCALE 65536 30 + 31 + #define TIMER_REG_TMR1LOAD 0x00 32 + #define TIMER_REG_TMR1CTL 0x08 33 + 34 + #define TMRSTAT_TMR1RST BIT(5) 35 + 36 + #define TMR1CTL_ENABLE BIT(7) 37 + #define TMR1CTL_MODE_SHIFT 4 38 + #define TMR1CTL_MODE_MASK 0x3 39 + #define TMR1CTL_MODE_FREE_RUNNING 0x0 40 + #define TMR1CTL_MODE_PERIODIC 0x1 41 + #define TMR1CTL_MODE_TIMEOUT 0x2 42 + #define TMR1CTL_MODE_WDT 0x3 43 + #define TMR1CTL_PRESCALE_MASK 0xf 44 + #define TMR1CTL_PRESCALE_65536 0xf 45 + 46 + static struct clk *rt288x_wdt_clk; 47 + static unsigned long rt288x_wdt_freq; 48 + static void __iomem *rt288x_wdt_base; 49 + 50 + static bool nowayout = WATCHDOG_NOWAYOUT; 51 + module_param(nowayout, bool, 0); 52 + MODULE_PARM_DESC(nowayout, 53 + "Watchdog cannot be stopped once started (default=" 54 + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 55 + 56 + static inline void rt_wdt_w32(unsigned reg, u32 val) 57 + { 58 + iowrite32(val, rt288x_wdt_base + reg); 59 + } 60 + 61 + static inline u32 rt_wdt_r32(unsigned reg) 62 + { 63 + return ioread32(rt288x_wdt_base + reg); 64 + } 65 + 66 + static int rt288x_wdt_ping(struct watchdog_device *w) 67 + { 68 + rt_wdt_w32(TIMER_REG_TMR1LOAD, w->timeout * rt288x_wdt_freq); 69 + 70 + return 0; 71 + } 72 + 73 + static int rt288x_wdt_start(struct watchdog_device *w) 74 + { 75 + u32 t; 76 + 77 + t = rt_wdt_r32(TIMER_REG_TMR1CTL); 78 + t &= ~(TMR1CTL_MODE_MASK << TMR1CTL_MODE_SHIFT | 79 + TMR1CTL_PRESCALE_MASK); 80 + t |= (TMR1CTL_MODE_WDT << TMR1CTL_MODE_SHIFT | 81 + TMR1CTL_PRESCALE_65536); 82 + rt_wdt_w32(TIMER_REG_TMR1CTL, t); 83 + 84 + rt288x_wdt_ping(w); 85 + 86 + t = rt_wdt_r32(TIMER_REG_TMR1CTL); 87 + t |= TMR1CTL_ENABLE; 88 + rt_wdt_w32(TIMER_REG_TMR1CTL, t); 89 + 90 + return 0; 91 + } 92 + 93 + static int rt288x_wdt_stop(struct watchdog_device *w) 94 + { 95 + u32 t; 96 + 97 + rt288x_wdt_ping(w); 98 + 99 + t = rt_wdt_r32(TIMER_REG_TMR1CTL); 100 + t &= ~TMR1CTL_ENABLE; 101 + rt_wdt_w32(TIMER_REG_TMR1CTL, t); 102 + 103 + return 0; 104 + } 105 + 106 + static int rt288x_wdt_set_timeout(struct watchdog_device *w, unsigned int t) 107 + { 108 + w->timeout = t; 109 + rt288x_wdt_ping(w); 110 + 111 + return 0; 112 + } 113 + 114 + static int rt288x_wdt_bootcause(void) 115 + { 116 + if (rt_sysc_r32(SYSC_RSTSTAT) & WDT_RST_CAUSE) 117 + return WDIOF_CARDRESET; 118 + 119 + return 0; 120 + } 121 + 122 + static struct watchdog_info rt288x_wdt_info = { 123 + .identity = "Ralink Watchdog", 124 + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, 125 + }; 126 + 127 + static struct watchdog_ops rt288x_wdt_ops = { 128 + .owner = THIS_MODULE, 129 + .start = rt288x_wdt_start, 130 + .stop = rt288x_wdt_stop, 131 + .ping = rt288x_wdt_ping, 132 + .set_timeout = rt288x_wdt_set_timeout, 133 + }; 134 + 135 + static struct watchdog_device rt288x_wdt_dev = { 136 + .info = &rt288x_wdt_info, 137 + .ops = &rt288x_wdt_ops, 138 + .min_timeout = 1, 139 + }; 140 + 141 + static int rt288x_wdt_probe(struct platform_device *pdev) 142 + { 143 + struct resource *res; 144 + int ret; 145 + 146 + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 147 + rt288x_wdt_base = devm_ioremap_resource(&pdev->dev, res); 148 + if (IS_ERR(rt288x_wdt_base)) 149 + return PTR_ERR(rt288x_wdt_base); 150 + 151 + rt288x_wdt_clk = devm_clk_get(&pdev->dev, NULL); 152 + if (IS_ERR(rt288x_wdt_clk)) 153 + return PTR_ERR(rt288x_wdt_clk); 154 + 155 + device_reset(&pdev->dev); 156 + 157 + rt288x_wdt_freq = clk_get_rate(rt288x_wdt_clk) / RALINK_WDT_PRESCALE; 158 + 159 + rt288x_wdt_dev.dev = &pdev->dev; 160 + rt288x_wdt_dev.bootstatus = rt288x_wdt_bootcause(); 161 + 162 + rt288x_wdt_dev.max_timeout = (0xfffful / rt288x_wdt_freq); 163 + rt288x_wdt_dev.timeout = rt288x_wdt_dev.max_timeout; 164 + 165 + watchdog_set_nowayout(&rt288x_wdt_dev, nowayout); 166 + 167 + ret = watchdog_register_device(&rt288x_wdt_dev); 168 + if (!ret) 169 + dev_info(&pdev->dev, "Initialized\n"); 170 + 171 + return 0; 172 + } 173 + 174 + static int rt288x_wdt_remove(struct platform_device *pdev) 175 + { 176 + watchdog_unregister_device(&rt288x_wdt_dev); 177 + 178 + return 0; 179 + } 180 + 181 + static void rt288x_wdt_shutdown(struct platform_device *pdev) 182 + { 183 + rt288x_wdt_stop(&rt288x_wdt_dev); 184 + } 185 + 186 + static const struct of_device_id rt288x_wdt_match[] = { 187 + { .compatible = "ralink,rt2880-wdt" }, 188 + {}, 189 + }; 190 + MODULE_DEVICE_TABLE(of, rt288x_wdt_match); 191 + 192 + static struct platform_driver rt288x_wdt_driver = { 193 + .probe = rt288x_wdt_probe, 194 + .remove = rt288x_wdt_remove, 195 + .shutdown = rt288x_wdt_shutdown, 196 + .driver = { 197 + .name = KBUILD_MODNAME, 198 + .owner = THIS_MODULE, 199 + .of_match_table = rt288x_wdt_match, 200 + }, 201 + }; 202 + 203 + module_platform_driver(rt288x_wdt_driver); 204 + 205 + MODULE_DESCRIPTION("MediaTek/Ralink RT288x/RT3xxx hardware watchdog driver"); 206 + MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org"); 207 + MODULE_LICENSE("GPL v2");

-2

drivers/watchdog/s3c2410_wdt.c

··· 29 29 #include <linux/moduleparam.h> 30 30 #include <linux/types.h> 31 31 #include <linux/timer.h> 32 - #include <linux/miscdevice.h> /* for MODULE_ALIAS_MISCDEV */ 33 32 #include <linux/watchdog.h> 34 33 #include <linux/init.h> 35 34 #include <linux/platform_device.h> ··· 538 539 "Dimitry Andric <dimitry.andric@tomtom.com>"); 539 540 MODULE_DESCRIPTION("S3C2410 Watchdog Device Driver"); 540 541 MODULE_LICENSE("GPL"); 541 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 542 542 MODULE_ALIAS("platform:s3c2410-wdt");

-1

drivers/watchdog/sa1100_wdt.c

··· 193 193 MODULE_PARM_DESC(margin, "Watchdog margin in seconds (default 60s)"); 194 194 195 195 MODULE_LICENSE("GPL"); 196 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/sb_wdog.c

··· 341 341 "Watchdog timeout in microseconds (max/default 8388607 or 8.3ish secs)"); 342 342 343 343 MODULE_LICENSE("GPL"); 344 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 345 344 346 345 /* 347 346 * example code that can be put in a platform code area to utilize the

-1

drivers/watchdog/sbc60xxwdt.c

··· 387 387 MODULE_AUTHOR("Jakob Oestergaard <jakob@unthought.net>"); 388 388 MODULE_DESCRIPTION("60xx Single Board Computer Watchdog Timer driver"); 389 389 MODULE_LICENSE("GPL"); 390 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-2

drivers/watchdog/sbc7240_wdt.c

··· 309 309 MODULE_DESCRIPTION("Watchdog device driver for single board" 310 310 " computers EPIC Nano 7240 from iEi"); 311 311 MODULE_LICENSE("GPL"); 312 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 313 -

-1

drivers/watchdog/sbc8360.c

··· 404 404 MODULE_DESCRIPTION("SBC8360 watchdog driver"); 405 405 MODULE_LICENSE("GPL"); 406 406 MODULE_VERSION("1.01"); 407 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 408 407 409 408 /* end of sbc8360.c */

-1

drivers/watchdog/sbc_epx_c3.c

··· 220 220 "so only use it if you are *sure* you are running on this specific " 221 221 "SBC system from Winsystems! It writes to IO ports 0x1ee and 0x1ef!"); 222 222 MODULE_LICENSE("GPL"); 223 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-2

drivers/watchdog/sbc_fitpc2_wdt.c

··· 263 263 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started"); 264 264 265 265 MODULE_LICENSE("GPL"); 266 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 267 -

-1

drivers/watchdog/sc1200wdt.c

··· 476 476 MODULE_DESCRIPTION( 477 477 "Driver for National Semiconductor PC87307/PC97307 watchdog component"); 478 478 MODULE_LICENSE("GPL"); 479 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/sc520_wdt.c

··· 433 433 MODULE_DESCRIPTION( 434 434 "Driver for watchdog timer in AMD \"Elan\" SC520 uProcessor"); 435 435 MODULE_LICENSE("GPL"); 436 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+1 -4

drivers/watchdog/sch311x_wdt.c

··· 26 26 #include <linux/types.h> /* For standard types (like size_t) */ 27 27 #include <linux/errno.h> /* For the -ENODEV/... values */ 28 28 #include <linux/kernel.h> /* For printk/... */ 29 - #include <linux/miscdevice.h> /* For MODULE_ALIAS_MISCDEV 30 - (WATCHDOG_MINOR) */ 29 + #include <linux/miscdevice.h> /* For struct miscdevice */ 31 30 #include <linux/watchdog.h> /* For the watchdog specific items */ 32 31 #include <linux/init.h> /* For __init/__exit/... */ 33 32 #include <linux/fs.h> /* For file operations */ ··· 544 545 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>"); 545 546 MODULE_DESCRIPTION("SMSC SCH311x WatchDog Timer Driver"); 546 547 MODULE_LICENSE("GPL"); 547 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 548 -

-1

drivers/watchdog/scx200_wdt.c

··· 37 37 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>"); 38 38 MODULE_DESCRIPTION("NatSemi SCx200 Watchdog Driver"); 39 39 MODULE_LICENSE("GPL"); 40 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 41 40 42 41 static int margin = 60; /* in seconds */ 43 42 module_param(margin, int, 0);

-1

drivers/watchdog/shwdt.c

··· 343 343 MODULE_DESCRIPTION("SuperH watchdog driver"); 344 344 MODULE_LICENSE("GPL"); 345 345 MODULE_ALIAS("platform:" DRV_NAME); 346 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 347 346 348 347 module_param(clock_division_ratio, int, 0); 349 348 MODULE_PARM_DESC(clock_division_ratio,

+226

drivers/watchdog/sirfsoc_wdt.c

··· 1 + /* 2 + * Watchdog driver for CSR SiRFprimaII and SiRFatlasVI 3 + * 4 + * Copyright (c) 2013 Cambridge Silicon Radio Limited, a CSR plc group company. 5 + * 6 + * Licensed under GPLv2 or later. 7 + */ 8 + 9 + #include <linux/module.h> 10 + #include <linux/watchdog.h> 11 + #include <linux/platform_device.h> 12 + #include <linux/moduleparam.h> 13 + #include <linux/of.h> 14 + #include <linux/io.h> 15 + #include <linux/uaccess.h> 16 + 17 + #define CLOCK_FREQ 1000000 18 + 19 + #define SIRFSOC_TIMER_COUNTER_LO 0x0000 20 + #define SIRFSOC_TIMER_MATCH_0 0x0008 21 + #define SIRFSOC_TIMER_INT_EN 0x0024 22 + #define SIRFSOC_TIMER_WATCHDOG_EN 0x0028 23 + #define SIRFSOC_TIMER_LATCH 0x0030 24 + #define SIRFSOC_TIMER_LATCHED_LO 0x0034 25 + 26 + #define SIRFSOC_TIMER_WDT_INDEX 5 27 + 28 + #define SIRFSOC_WDT_MIN_TIMEOUT 30 /* 30 secs */ 29 + #define SIRFSOC_WDT_MAX_TIMEOUT (10 * 60) /* 10 mins */ 30 + #define SIRFSOC_WDT_DEFAULT_TIMEOUT 30 /* 30 secs */ 31 + 32 + static unsigned int timeout = SIRFSOC_WDT_DEFAULT_TIMEOUT; 33 + static bool nowayout = WATCHDOG_NOWAYOUT; 34 + 35 + module_param(timeout, uint, 0); 36 + module_param(nowayout, bool, 0); 37 + 38 + MODULE_PARM_DESC(timeout, "Default watchdog timeout (in seconds)"); 39 + MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=" 40 + __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); 41 + 42 + static unsigned int sirfsoc_wdt_gettimeleft(struct watchdog_device *wdd) 43 + { 44 + u32 counter, match; 45 + void __iomem *wdt_base; 46 + int time_left; 47 + 48 + wdt_base = watchdog_get_drvdata(wdd); 49 + counter = readl(wdt_base + SIRFSOC_TIMER_COUNTER_LO); 50 + match = readl(wdt_base + 51 + SIRFSOC_TIMER_MATCH_0 + (SIRFSOC_TIMER_WDT_INDEX << 2)); 52 + 53 + time_left = match - counter; 54 + 55 + return time_left / CLOCK_FREQ; 56 + } 57 + 58 + static int sirfsoc_wdt_updatetimeout(struct watchdog_device *wdd) 59 + { 60 + u32 counter, timeout_ticks; 61 + void __iomem *wdt_base; 62 + 63 + timeout_ticks = wdd->timeout * CLOCK_FREQ; 64 + wdt_base = watchdog_get_drvdata(wdd); 65 + 66 + /* Enable the latch before reading the LATCH_LO register */ 67 + writel(1, wdt_base + SIRFSOC_TIMER_LATCH); 68 + 69 + /* Set the TO value */ 70 + counter = readl(wdt_base + SIRFSOC_TIMER_LATCHED_LO); 71 + 72 + counter += timeout_ticks; 73 + 74 + writel(counter, wdt_base + 75 + SIRFSOC_TIMER_MATCH_0 + (SIRFSOC_TIMER_WDT_INDEX << 2)); 76 + 77 + return 0; 78 + } 79 + 80 + static int sirfsoc_wdt_enable(struct watchdog_device *wdd) 81 + { 82 + void __iomem *wdt_base = watchdog_get_drvdata(wdd); 83 + sirfsoc_wdt_updatetimeout(wdd); 84 + 85 + /* 86 + * NOTE: If interrupt is not enabled 87 + * then WD-Reset doesn't get generated at all. 88 + */ 89 + writel(readl(wdt_base + SIRFSOC_TIMER_INT_EN) 90 + | (1 << SIRFSOC_TIMER_WDT_INDEX), 91 + wdt_base + SIRFSOC_TIMER_INT_EN); 92 + writel(1, wdt_base + SIRFSOC_TIMER_WATCHDOG_EN); 93 + 94 + return 0; 95 + } 96 + 97 + static int sirfsoc_wdt_disable(struct watchdog_device *wdd) 98 + { 99 + void __iomem *wdt_base = watchdog_get_drvdata(wdd); 100 + 101 + writel(0, wdt_base + SIRFSOC_TIMER_WATCHDOG_EN); 102 + writel(readl(wdt_base + SIRFSOC_TIMER_INT_EN) 103 + & (~(1 << SIRFSOC_TIMER_WDT_INDEX)), 104 + wdt_base + SIRFSOC_TIMER_INT_EN); 105 + 106 + return 0; 107 + } 108 + 109 + static int sirfsoc_wdt_settimeout(struct watchdog_device *wdd, unsigned int to) 110 + { 111 + wdd->timeout = to; 112 + sirfsoc_wdt_updatetimeout(wdd); 113 + 114 + return 0; 115 + } 116 + 117 + #define OPTIONS (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE) 118 + 119 + static const struct watchdog_info sirfsoc_wdt_ident = { 120 + .options = OPTIONS, 121 + .firmware_version = 0, 122 + .identity = "SiRFSOC Watchdog", 123 + }; 124 + 125 + static struct watchdog_ops sirfsoc_wdt_ops = { 126 + .owner = THIS_MODULE, 127 + .start = sirfsoc_wdt_enable, 128 + .stop = sirfsoc_wdt_disable, 129 + .get_timeleft = sirfsoc_wdt_gettimeleft, 130 + .ping = sirfsoc_wdt_updatetimeout, 131 + .set_timeout = sirfsoc_wdt_settimeout, 132 + }; 133 + 134 + static struct watchdog_device sirfsoc_wdd = { 135 + .info = &sirfsoc_wdt_ident, 136 + .ops = &sirfsoc_wdt_ops, 137 + .timeout = SIRFSOC_WDT_DEFAULT_TIMEOUT, 138 + .min_timeout = SIRFSOC_WDT_MIN_TIMEOUT, 139 + .max_timeout = SIRFSOC_WDT_MAX_TIMEOUT, 140 + }; 141 + 142 + static int sirfsoc_wdt_probe(struct platform_device *pdev) 143 + { 144 + struct resource *res; 145 + int ret; 146 + void __iomem *base; 147 + 148 + res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 149 + base = devm_ioremap_resource(&pdev->dev, res); 150 + if (IS_ERR(base)) 151 + return PTR_ERR(base); 152 + 153 + watchdog_set_drvdata(&sirfsoc_wdd, base); 154 + 155 + watchdog_init_timeout(&sirfsoc_wdd, timeout, &pdev->dev); 156 + watchdog_set_nowayout(&sirfsoc_wdd, nowayout); 157 + 158 + ret = watchdog_register_device(&sirfsoc_wdd); 159 + if (ret) 160 + return ret; 161 + 162 + platform_set_drvdata(pdev, &sirfsoc_wdd); 163 + 164 + return 0; 165 + } 166 + 167 + static void sirfsoc_wdt_shutdown(struct platform_device *pdev) 168 + { 169 + struct watchdog_device *wdd = platform_get_drvdata(pdev); 170 + 171 + sirfsoc_wdt_disable(wdd); 172 + } 173 + 174 + static int sirfsoc_wdt_remove(struct platform_device *pdev) 175 + { 176 + sirfsoc_wdt_shutdown(pdev); 177 + return 0; 178 + } 179 + 180 + #ifdef CONFIG_PM_SLEEP 181 + static int sirfsoc_wdt_suspend(struct device *dev) 182 + { 183 + return 0; 184 + } 185 + 186 + static int sirfsoc_wdt_resume(struct device *dev) 187 + { 188 + struct watchdog_device *wdd = dev_get_drvdata(dev); 189 + 190 + /* 191 + * NOTE: Since timer controller registers settings are saved 192 + * and restored back by the timer-prima2.c, so we need not 193 + * update WD settings except refreshing timeout. 194 + */ 195 + sirfsoc_wdt_updatetimeout(wdd); 196 + 197 + return 0; 198 + } 199 + #endif 200 + 201 + static SIMPLE_DEV_PM_OPS(sirfsoc_wdt_pm_ops, 202 + sirfsoc_wdt_suspend, sirfsoc_wdt_resume); 203 + 204 + static const struct of_device_id sirfsoc_wdt_of_match[] = { 205 + { .compatible = "sirf,prima2-tick"}, 206 + {}, 207 + }; 208 + MODULE_DEVICE_TABLE(of, sirfsoc_wdt_of_match); 209 + 210 + static struct platform_driver sirfsoc_wdt_driver = { 211 + .driver = { 212 + .name = "sirfsoc-wdt", 213 + .owner = THIS_MODULE, 214 + .pm = &sirfsoc_wdt_pm_ops, 215 + .of_match_table = of_match_ptr(sirfsoc_wdt_of_match), 216 + }, 217 + .probe = sirfsoc_wdt_probe, 218 + .remove = sirfsoc_wdt_remove, 219 + .shutdown = sirfsoc_wdt_shutdown, 220 + }; 221 + module_platform_driver(sirfsoc_wdt_driver); 222 + 223 + MODULE_DESCRIPTION("SiRF SoC watchdog driver"); 224 + MODULE_AUTHOR("Xianglong Du <Xianglong.Du@csr.com>"); 225 + MODULE_LICENSE("GPL v2"); 226 + MODULE_ALIAS("platform:sirfsoc-wdt");

-2

drivers/watchdog/smsc37b787_wdt.c

··· 603 603 VERSION ")"); 604 604 MODULE_LICENSE("GPL"); 605 605 606 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 607 - 608 606 #ifdef SMSC_SUPPORT_MINUTES 609 607 module_param(unit, int, 0); 610 608 MODULE_PARM_DESC(unit,

-1

drivers/watchdog/softdog.c

··· 207 207 MODULE_AUTHOR("Alan Cox"); 208 208 MODULE_DESCRIPTION("Software Watchdog Device Driver"); 209 209 MODULE_LICENSE("GPL"); 210 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/sp5100_tco.c

··· 580 580 MODULE_AUTHOR("Priyanka Gupta"); 581 581 MODULE_DESCRIPTION("TCO timer driver for SP5100/SB800 chipset"); 582 582 MODULE_LICENSE("GPL"); 583 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/sp805_wdt.c

··· 268 268 struct sp805_wdt *wdt = amba_get_drvdata(adev); 269 269 270 270 watchdog_unregister_device(&wdt->wdd); 271 - amba_set_drvdata(adev, NULL); 272 271 watchdog_set_drvdata(&wdt->wdd, NULL); 273 272 274 273 return 0;

+2 -3

drivers/watchdog/stmp3xxx_rtc_wdt.c

··· 30 30 static int wdt_start(struct watchdog_device *wdd) 31 31 { 32 32 struct device *dev = watchdog_get_drvdata(wdd); 33 - struct stmp3xxx_wdt_pdata *pdata = dev->platform_data; 33 + struct stmp3xxx_wdt_pdata *pdata = dev_get_platdata(dev); 34 34 35 35 pdata->wdt_set_timeout(dev->parent, wdd->timeout * WDOG_TICK_RATE); 36 36 return 0; ··· 39 39 static int wdt_stop(struct watchdog_device *wdd) 40 40 { 41 41 struct device *dev = watchdog_get_drvdata(wdd); 42 - struct stmp3xxx_wdt_pdata *pdata = dev->platform_data; 42 + struct stmp3xxx_wdt_pdata *pdata = dev_get_platdata(dev); 43 43 44 44 pdata->wdt_set_timeout(dev->parent, 0); 45 45 return 0; ··· 108 108 MODULE_DESCRIPTION("STMP3XXX RTC Watchdog Driver"); 109 109 MODULE_LICENSE("GPL v2"); 110 110 MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>"); 111 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

+1 -1

drivers/watchdog/sunxi_wdt.c

··· 217 217 .driver = { 218 218 .owner = THIS_MODULE, 219 219 .name = DRV_NAME, 220 - .of_match_table = of_match_ptr(sunxi_wdt_dt_ids) 220 + .of_match_table = sunxi_wdt_dt_ids, 221 221 }, 222 222 }; 223 223

+17 -21

drivers/watchdog/ts72xx_wdt.c

··· 192 192 dev_err(&wdt->pdev->dev, 193 193 "failed to convert timeout (%d) to register value\n", 194 194 timeout); 195 - return -EINVAL; 195 + return regval; 196 196 } 197 197 198 198 if (mutex_lock_interruptible(&wdt->lock)) ··· 305 305 306 306 switch (cmd) { 307 307 case WDIOC_GETSUPPORT: 308 - error = copy_to_user(argp, &winfo, sizeof(winfo)); 308 + if (copy_to_user(argp, &winfo, sizeof(winfo))) 309 + error = -EFAULT; 309 310 break; 310 311 311 312 case WDIOC_GETSTATUS: ··· 321 320 case WDIOC_SETOPTIONS: { 322 321 int options; 323 322 324 - if (get_user(options, p)) { 325 - error = -EFAULT; 323 + error = get_user(options, p); 324 + if (error) 326 325 break; 327 - } 328 326 329 327 error = -EINVAL; 330 328 ··· 341 341 342 342 case WDIOC_SETTIMEOUT: { 343 343 int new_timeout; 344 + int regval; 344 345 345 - if (get_user(new_timeout, p)) { 346 - error = -EFAULT; 347 - } else { 348 - int regval; 349 - 350 - regval = timeout_to_regval(new_timeout); 351 - if (regval < 0) { 352 - error = -EINVAL; 353 - } else { 354 - ts72xx_wdt_stop(wdt); 355 - wdt->regval = regval; 356 - ts72xx_wdt_start(wdt); 357 - } 358 - } 346 + error = get_user(new_timeout, p); 359 347 if (error) 360 348 break; 349 + 350 + regval = timeout_to_regval(new_timeout); 351 + if (regval < 0) { 352 + error = regval; 353 + break; 354 + } 355 + ts72xx_wdt_stop(wdt); 356 + wdt->regval = regval; 357 + ts72xx_wdt_start(wdt); 361 358 362 359 /*FALLTHROUGH*/ 363 360 } 364 361 365 362 case WDIOC_GETTIMEOUT: 366 - if (put_user(regval_to_timeout(wdt->regval), p)) 367 - error = -EFAULT; 363 + error = put_user(regval_to_timeout(wdt->regval), p); 368 364 break; 369 365 370 366 default:

-1

drivers/watchdog/txx9wdt.c

··· 176 176 177 177 MODULE_DESCRIPTION("TXx9 Watchdog Driver"); 178 178 MODULE_LICENSE("GPL"); 179 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 180 179 MODULE_ALIAS("platform:txx9wdt");

+1 -2

drivers/watchdog/ux500_wdt.c

··· 88 88 static int ux500_wdt_probe(struct platform_device *pdev) 89 89 { 90 90 int ret; 91 - struct ux500_wdt_data *pdata = pdev->dev.platform_data; 91 + struct ux500_wdt_data *pdata = dev_get_platdata(&pdev->dev); 92 92 93 93 if (pdata) { 94 94 if (pdata->timeout > 0) ··· 167 167 MODULE_AUTHOR("Jonas Aaberg <jonas.aberg@stericsson.com>"); 168 168 MODULE_DESCRIPTION("Ux500 Watchdog Driver"); 169 169 MODULE_LICENSE("GPL"); 170 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 171 170 MODULE_ALIAS("platform:ux500_wdt");

+126 -227

drivers/watchdog/w83627hf_wdt.c

··· 1 1 /* 2 2 * w83627hf/thf WDT driver 3 3 * 4 + * (c) Copyright 2013 Guenter Roeck 5 + * converted to watchdog infrastructure 6 + * 4 7 * (c) Copyright 2007 Vlad Drukker <vlad@storewiz.com> 5 8 * added support for W83627THF. 6 9 * ··· 34 31 #include <linux/module.h> 35 32 #include <linux/moduleparam.h> 36 33 #include <linux/types.h> 37 - #include <linux/miscdevice.h> 38 34 #include <linux/watchdog.h> 39 - #include <linux/fs.h> 40 35 #include <linux/ioport.h> 41 36 #include <linux/notifier.h> 42 37 #include <linux/reboot.h> 43 38 #include <linux/init.h> 44 - #include <linux/spinlock.h> 45 39 #include <linux/io.h> 46 - #include <linux/uaccess.h> 47 - 48 40 49 41 #define WATCHDOG_NAME "w83627hf/thf/hg/dhg WDT" 50 42 #define WATCHDOG_TIMEOUT 60 /* 60 sec default timeout */ 51 - 52 - static unsigned long wdt_is_open; 53 - static char expect_close; 54 - static DEFINE_SPINLOCK(io_lock); 55 43 56 44 /* You must set this - there is no sane way to probe for this board. */ 57 45 static int wdt_io = 0x2E; 58 46 module_param(wdt_io, int, 0); 59 47 MODULE_PARM_DESC(wdt_io, "w83627hf/thf WDT io port (default 0x2E)"); 60 48 61 - static int timeout = WATCHDOG_TIMEOUT; /* in seconds */ 49 + static int timeout; /* in seconds */ 62 50 module_param(timeout, int, 0); 63 51 MODULE_PARM_DESC(timeout, 64 52 "Watchdog timeout in seconds. 1 <= timeout <= 255, default=" ··· 70 76 (same as EFER) */ 71 77 #define WDT_EFDR (WDT_EFIR+1) /* Extended Function Data Register */ 72 78 73 - static void w83627hf_select_wd_register(void) 79 + #define W83627HF_LD_WDT 0x08 80 + 81 + static void superio_outb(int reg, int val) 74 82 { 75 - unsigned char c; 83 + outb(reg, WDT_EFER); 84 + outb(val, WDT_EFDR); 85 + } 86 + 87 + static inline int superio_inb(int reg) 88 + { 89 + outb(reg, WDT_EFER); 90 + return inb(WDT_EFDR); 91 + } 92 + 93 + static int superio_enter(void) 94 + { 95 + if (!request_muxed_region(wdt_io, 2, WATCHDOG_NAME)) 96 + return -EBUSY; 97 + 76 98 outb_p(0x87, WDT_EFER); /* Enter extended function mode */ 77 99 outb_p(0x87, WDT_EFER); /* Again according to manual */ 78 100 79 - outb(0x20, WDT_EFER); /* check chip version */ 80 - c = inb(WDT_EFDR); 81 - if (c == 0x82) { /* W83627THF */ 82 - outb_p(0x2b, WDT_EFER); /* select GPIO3 */ 83 - c = ((inb_p(WDT_EFDR) & 0xf7) | 0x04); /* select WDT0 */ 84 - outb_p(0x2b, WDT_EFER); 85 - outb_p(c, WDT_EFDR); /* set GPIO3 to WDT0 */ 86 - } else if (c == 0x88 || c == 0xa0) { /* W83627EHF / W83627DHG */ 87 - outb_p(0x2d, WDT_EFER); /* select GPIO5 */ 88 - c = inb_p(WDT_EFDR) & ~0x01; /* PIN77 -> WDT0# */ 89 - outb_p(0x2d, WDT_EFER); 90 - outb_p(c, WDT_EFDR); /* set GPIO5 to WDT0 */ 91 - } 92 - 93 - outb_p(0x07, WDT_EFER); /* point to logical device number reg */ 94 - outb_p(0x08, WDT_EFDR); /* select logical device 8 (GPIO2) */ 95 - outb_p(0x30, WDT_EFER); /* select CR30 */ 96 - outb_p(0x01, WDT_EFDR); /* set bit 0 to activate GPIO2 */ 101 + return 0; 97 102 } 98 103 99 - static void w83627hf_unselect_wd_register(void) 104 + static void superio_select(int ld) 105 + { 106 + superio_outb(0x07, ld); 107 + } 108 + 109 + static void superio_exit(void) 100 110 { 101 111 outb_p(0xAA, WDT_EFER); /* Leave extended function mode */ 112 + release_region(wdt_io, 2); 102 113 } 103 114 104 115 /* tyan motherboards seem to set F5 to 0x4C ? 105 116 * So explicitly init to appropriate value. */ 106 117 107 - static void w83627hf_init(void) 118 + static int w83627hf_init(struct watchdog_device *wdog) 108 119 { 120 + int ret; 109 121 unsigned char t; 110 122 111 - w83627hf_select_wd_register(); 123 + ret = superio_enter(); 124 + if (ret) 125 + return ret; 112 126 113 - outb_p(0xF6, WDT_EFER); /* Select CRF6 */ 114 - t = inb_p(WDT_EFDR); /* read CRF6 */ 127 + superio_select(W83627HF_LD_WDT); 128 + t = superio_inb(0x20); /* check chip version */ 129 + if (t == 0x82) { /* W83627THF */ 130 + t = (superio_inb(0x2b) & 0xf7); 131 + superio_outb(0x2b, t | 0x04); /* set GPIO3 to WDT0 */ 132 + } else if (t == 0x88 || t == 0xa0) { /* W83627EHF / W83627DHG */ 133 + t = superio_inb(0x2d); 134 + superio_outb(0x2d, t & ~0x01); /* set GPIO5 to WDT0 */ 135 + } 136 + 137 + /* set CR30 bit 0 to activate GPIO2 */ 138 + t = superio_inb(0x30); 139 + if (!(t & 0x01)) 140 + superio_outb(0x30, t | 0x01); 141 + 142 + t = superio_inb(0xF6); 115 143 if (t != 0) { 116 144 pr_info("Watchdog already running. Resetting timeout to %d sec\n", 117 - timeout); 118 - outb_p(timeout, WDT_EFDR); /* Write back to CRF6 */ 145 + wdog->timeout); 146 + superio_outb(0xF6, wdog->timeout); 119 147 } 120 148 121 - outb_p(0xF5, WDT_EFER); /* Select CRF5 */ 122 - t = inb_p(WDT_EFDR); /* read CRF5 */ 123 - t &= ~0x0C; /* set second mode & disable keyboard 124 - turning off watchdog */ 125 - t |= 0x02; /* enable the WDTO# output low pulse 126 - to the KBRST# pin (PIN60) */ 127 - outb_p(t, WDT_EFDR); /* Write back to CRF5 */ 149 + /* set second mode & disable keyboard turning off watchdog */ 150 + t = superio_inb(0xF5) & ~0x0C; 151 + /* enable the WDTO# output low pulse to the KBRST# pin */ 152 + t |= 0x02; 153 + superio_outb(0xF5, t); 128 154 129 - outb_p(0xF7, WDT_EFER); /* Select CRF7 */ 130 - t = inb_p(WDT_EFDR); /* read CRF7 */ 131 - t &= ~0xC0; /* disable keyboard & mouse turning off 132 - watchdog */ 133 - outb_p(t, WDT_EFDR); /* Write back to CRF7 */ 155 + /* disable keyboard & mouse turning off watchdog */ 156 + t = superio_inb(0xF7) & ~0xC0; 157 + superio_outb(0xF7, t); 134 158 135 - w83627hf_unselect_wd_register(); 136 - } 159 + superio_exit(); 137 160 138 - static void wdt_set_time(int timeout) 139 - { 140 - spin_lock(&io_lock); 141 - 142 - w83627hf_select_wd_register(); 143 - 144 - outb_p(0xF6, WDT_EFER); /* Select CRF6 */ 145 - outb_p(timeout, WDT_EFDR); /* Write Timeout counter to CRF6 */ 146 - 147 - w83627hf_unselect_wd_register(); 148 - 149 - spin_unlock(&io_lock); 150 - } 151 - 152 - static int wdt_ping(void) 153 - { 154 - wdt_set_time(timeout); 155 161 return 0; 156 162 } 157 163 158 - static int wdt_disable(void) 164 + static int wdt_set_time(unsigned int timeout) 159 165 { 160 - wdt_set_time(0); 166 + int ret; 167 + 168 + ret = superio_enter(); 169 + if (ret) 170 + return ret; 171 + 172 + superio_select(W83627HF_LD_WDT); 173 + superio_outb(0xF6, timeout); 174 + superio_exit(); 175 + 161 176 return 0; 162 177 } 163 178 164 - static int wdt_set_heartbeat(int t) 179 + static int wdt_start(struct watchdog_device *wdog) 165 180 { 166 - if (t < 1 || t > 255) 167 - return -EINVAL; 168 - timeout = t; 181 + return wdt_set_time(wdog->timeout); 182 + } 183 + 184 + static int wdt_stop(struct watchdog_device *wdog) 185 + { 186 + return wdt_set_time(0); 187 + } 188 + 189 + static int wdt_set_timeout(struct watchdog_device *wdog, unsigned int timeout) 190 + { 191 + wdog->timeout = timeout; 192 + 169 193 return 0; 170 194 } 171 195 172 - static int wdt_get_time(void) 196 + static unsigned int wdt_get_time(struct watchdog_device *wdog) 173 197 { 174 - int timeleft; 198 + unsigned int timeleft; 199 + int ret; 175 200 176 - spin_lock(&io_lock); 201 + ret = superio_enter(); 202 + if (ret) 203 + return 0; 177 204 178 - w83627hf_select_wd_register(); 179 - 180 - outb_p(0xF6, WDT_EFER); /* Select CRF6 */ 181 - timeleft = inb_p(WDT_EFDR); /* Read Timeout counter to CRF6 */ 182 - 183 - w83627hf_unselect_wd_register(); 184 - 185 - spin_unlock(&io_lock); 205 + superio_select(W83627HF_LD_WDT); 206 + timeleft = superio_inb(0xF6); 207 + superio_exit(); 186 208 187 209 return timeleft; 188 - } 189 - 190 - static ssize_t wdt_write(struct file *file, const char __user *buf, 191 - size_t count, loff_t *ppos) 192 - { 193 - if (count) { 194 - if (!nowayout) { 195 - size_t i; 196 - 197 - expect_close = 0; 198 - 199 - for (i = 0; i != count; i++) { 200 - char c; 201 - if (get_user(c, buf + i)) 202 - return -EFAULT; 203 - if (c == 'V') 204 - expect_close = 42; 205 - } 206 - } 207 - wdt_ping(); 208 - } 209 - return count; 210 - } 211 - 212 - static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 213 - { 214 - void __user *argp = (void __user *)arg; 215 - int __user *p = argp; 216 - int timeval; 217 - static const struct watchdog_info ident = { 218 - .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT | 219 - WDIOF_MAGICCLOSE, 220 - .firmware_version = 1, 221 - .identity = "W83627HF WDT", 222 - }; 223 - 224 - switch (cmd) { 225 - case WDIOC_GETSUPPORT: 226 - if (copy_to_user(argp, &ident, sizeof(ident))) 227 - return -EFAULT; 228 - break; 229 - case WDIOC_GETSTATUS: 230 - case WDIOC_GETBOOTSTATUS: 231 - return put_user(0, p); 232 - case WDIOC_SETOPTIONS: 233 - { 234 - int options, retval = -EINVAL; 235 - 236 - if (get_user(options, p)) 237 - return -EFAULT; 238 - if (options & WDIOS_DISABLECARD) { 239 - wdt_disable(); 240 - retval = 0; 241 - } 242 - if (options & WDIOS_ENABLECARD) { 243 - wdt_ping(); 244 - retval = 0; 245 - } 246 - return retval; 247 - } 248 - case WDIOC_KEEPALIVE: 249 - wdt_ping(); 250 - break; 251 - case WDIOC_SETTIMEOUT: 252 - if (get_user(timeval, p)) 253 - return -EFAULT; 254 - if (wdt_set_heartbeat(timeval)) 255 - return -EINVAL; 256 - wdt_ping(); 257 - /* Fall */ 258 - case WDIOC_GETTIMEOUT: 259 - return put_user(timeout, p); 260 - case WDIOC_GETTIMELEFT: 261 - timeval = wdt_get_time(); 262 - return put_user(timeval, p); 263 - default: 264 - return -ENOTTY; 265 - } 266 - return 0; 267 - } 268 - 269 - static int wdt_open(struct inode *inode, struct file *file) 270 - { 271 - if (test_and_set_bit(0, &wdt_is_open)) 272 - return -EBUSY; 273 - /* 274 - * Activate 275 - */ 276 - 277 - wdt_ping(); 278 - return nonseekable_open(inode, file); 279 - } 280 - 281 - static int wdt_close(struct inode *inode, struct file *file) 282 - { 283 - if (expect_close == 42) 284 - wdt_disable(); 285 - else { 286 - pr_crit("Unexpected close, not stopping watchdog!\n"); 287 - wdt_ping(); 288 - } 289 - expect_close = 0; 290 - clear_bit(0, &wdt_is_open); 291 - return 0; 292 210 } 293 211 294 212 /* 295 213 * Notifier for system down 296 214 */ 297 - 298 215 static int wdt_notify_sys(struct notifier_block *this, unsigned long code, 299 216 void *unused) 300 217 { 301 218 if (code == SYS_DOWN || code == SYS_HALT) 302 - wdt_disable(); /* Turn the WDT off */ 219 + wdt_set_time(0); /* Turn the WDT off */ 303 220 304 221 return NOTIFY_DONE; 305 222 } ··· 219 314 * Kernel Interfaces 220 315 */ 221 316 222 - static const struct file_operations wdt_fops = { 223 - .owner = THIS_MODULE, 224 - .llseek = no_llseek, 225 - .write = wdt_write, 226 - .unlocked_ioctl = wdt_ioctl, 227 - .open = wdt_open, 228 - .release = wdt_close, 317 + static struct watchdog_info wdt_info = { 318 + .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE, 319 + .identity = "W83627HF Watchdog", 229 320 }; 230 321 231 - static struct miscdevice wdt_miscdev = { 232 - .minor = WATCHDOG_MINOR, 233 - .name = "watchdog", 234 - .fops = &wdt_fops, 322 + static struct watchdog_ops wdt_ops = { 323 + .owner = THIS_MODULE, 324 + .start = wdt_start, 325 + .stop = wdt_stop, 326 + .set_timeout = wdt_set_timeout, 327 + .get_timeleft = wdt_get_time, 328 + }; 329 + 330 + static struct watchdog_device wdt_dev = { 331 + .info = &wdt_info, 332 + .ops = &wdt_ops, 333 + .timeout = WATCHDOG_TIMEOUT, 334 + .min_timeout = 1, 335 + .max_timeout = 255, 235 336 }; 236 337 237 338 /* ··· 255 344 256 345 pr_info("WDT driver for the Winbond(TM) W83627HF/THF/HG/DHG Super I/O chip initialising\n"); 257 346 258 - if (wdt_set_heartbeat(timeout)) { 259 - wdt_set_heartbeat(WATCHDOG_TIMEOUT); 260 - pr_info("timeout value must be 1 <= timeout <= 255, using %d\n", 261 - WATCHDOG_TIMEOUT); 262 - } 347 + watchdog_init_timeout(&wdt_dev, timeout, NULL); 348 + watchdog_set_nowayout(&wdt_dev, nowayout); 263 349 264 - if (!request_region(wdt_io, 1, WATCHDOG_NAME)) { 265 - pr_err("I/O address 0x%04x already in use\n", wdt_io); 266 - ret = -EIO; 267 - goto out; 350 + ret = w83627hf_init(&wdt_dev); 351 + if (ret) { 352 + pr_err("failed to initialize watchdog (err=%d)\n", ret); 353 + return ret; 268 354 } 269 - 270 - w83627hf_init(); 271 355 272 356 ret = register_reboot_notifier(&wdt_notifier); 273 357 if (ret != 0) { 274 358 pr_err("cannot register reboot notifier (err=%d)\n", ret); 275 - goto unreg_regions; 359 + return ret; 276 360 } 277 361 278 - ret = misc_register(&wdt_miscdev); 279 - if (ret != 0) { 280 - pr_err("cannot register miscdev on minor=%d (err=%d)\n", 281 - WATCHDOG_MINOR, ret); 362 + ret = watchdog_register_device(&wdt_dev); 363 + if (ret) 282 364 goto unreg_reboot; 283 - } 284 365 285 366 pr_info("initialized. timeout=%d sec (nowayout=%d)\n", 286 - timeout, nowayout); 367 + wdt_dev.timeout, nowayout); 287 368 288 - out: 289 369 return ret; 370 + 290 371 unreg_reboot: 291 372 unregister_reboot_notifier(&wdt_notifier); 292 - unreg_regions: 293 - release_region(wdt_io, 1); 294 - goto out; 373 + return ret; 295 374 } 296 375 297 376 static void __exit wdt_exit(void) 298 377 { 299 - misc_deregister(&wdt_miscdev); 378 + watchdog_unregister_device(&wdt_dev); 300 379 unregister_reboot_notifier(&wdt_notifier); 301 - release_region(wdt_io, 1); 302 380 } 303 381 304 382 module_init(wdt_init); ··· 296 396 MODULE_LICENSE("GPL"); 297 397 MODULE_AUTHOR("Pádraig Brady <P@draigBrady.com>"); 298 398 MODULE_DESCRIPTION("w83627hf/thf WDT driver"); 299 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/w83697hf_wdt.c

··· 458 458 MODULE_AUTHOR("Marcus Junker <junker@anduras.de>, " 459 459 "Samuel Tardieu <sam@rfc1149.net>"); 460 460 MODULE_DESCRIPTION("w83697hf/hg WDT driver"); 461 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/w83697ug_wdt.c

··· 395 395 MODULE_LICENSE("GPL"); 396 396 MODULE_AUTHOR("Flemming Frandsen <ff@nrvissing.net>"); 397 397 MODULE_DESCRIPTION("w83697ug/uf WDT driver"); 398 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/w83877f_wdt.c

··· 406 406 MODULE_AUTHOR("Scott and Bill Jennings"); 407 407 MODULE_DESCRIPTION("Driver for watchdog timer in w83877f chip"); 408 408 MODULE_LICENSE("GPL"); 409 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/w83977f_wdt.c

··· 527 527 MODULE_AUTHOR("Jose Goncalves <jose.goncalves@inov.pt>"); 528 528 MODULE_DESCRIPTION("Driver for watchdog timer in W83977F I/O chip"); 529 529 MODULE_LICENSE("GPL"); 530 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-1

drivers/watchdog/wafer5823wdt.c

··· 322 322 MODULE_AUTHOR("Justin Cormack"); 323 323 MODULE_DESCRIPTION("ICP Wafer 5823 Single Board Computer WDT driver"); 324 324 MODULE_LICENSE("GPL"); 325 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 326 325 327 326 /* end of wafer5823wdt.c */

+1 -1

drivers/watchdog/watchdog_core.c

··· 77 77 78 78 watchdog_check_min_max_timeout(wdd); 79 79 80 - /* try to get the tiemout module parameter first */ 80 + /* try to get the timeout module parameter first */ 81 81 if (!watchdog_timeout_invalid(wdd, timeout_parm)) { 82 82 wdd->timeout = timeout_parm; 83 83 return ret;

-2

drivers/watchdog/wdrtas.c

··· 48 48 MODULE_AUTHOR("Utz Bacher <utz.bacher@de.ibm.com>"); 49 49 MODULE_DESCRIPTION("RTAS watchdog driver"); 50 50 MODULE_LICENSE("GPL"); 51 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 52 - MODULE_ALIAS_MISCDEV(TEMP_MINOR); 53 51 54 52 static bool wdrtas_nowayout = WATCHDOG_NOWAYOUT; 55 53 static atomic_t wdrtas_miscdev_open = ATOMIC_INIT(0);

-2

drivers/watchdog/wdt.c

··· 664 664 665 665 MODULE_AUTHOR("Alan Cox"); 666 666 MODULE_DESCRIPTION("Driver for ISA ICS watchdog cards (WDT500/501)"); 667 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 668 - MODULE_ALIAS_MISCDEV(TEMP_MINOR); 669 667 MODULE_LICENSE("GPL");

-1

drivers/watchdog/wdt285.c

··· 224 224 MODULE_AUTHOR("Phil Blundell <pb@nexus.co.uk>"); 225 225 MODULE_DESCRIPTION("Footbridge watchdog driver"); 226 226 MODULE_LICENSE("GPL"); 227 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 228 227 229 228 module_param(soft_margin, int, 0); 230 229 MODULE_PARM_DESC(soft_margin, "Watchdog timeout in seconds");

-1

drivers/watchdog/wdt977.c

··· 507 507 MODULE_AUTHOR("Woody Suwalski <woodys@xandros.com>"); 508 508 MODULE_DESCRIPTION("W83977AF Watchdog driver"); 509 509 MODULE_LICENSE("GPL"); 510 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);

-2

drivers/watchdog/wdt_pci.c

··· 744 744 MODULE_AUTHOR("JP Nollmann, Alan Cox"); 745 745 MODULE_DESCRIPTION("Driver for the ICS PCI-WDT500/501 watchdog cards"); 746 746 MODULE_LICENSE("GPL"); 747 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); 748 - MODULE_ALIAS_MISCDEV(TEMP_MINOR);

+3 -5

drivers/watchdog/wm831x_wdt.c

··· 184 184 static int wm831x_wdt_probe(struct platform_device *pdev) 185 185 { 186 186 struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent); 187 - struct wm831x_pdata *chip_pdata; 187 + struct wm831x_pdata *chip_pdata = dev_get_platdata(pdev->dev.parent); 188 188 struct wm831x_watchdog_pdata *pdata; 189 189 struct wm831x_wdt_drvdata *driver_data; 190 190 struct watchdog_device *wm831x_wdt; ··· 231 231 wm831x_wdt->timeout = wm831x_wdt_cfgs[i].time; 232 232 233 233 /* Apply any configuration */ 234 - if (pdev->dev.parent->platform_data) { 235 - chip_pdata = pdev->dev.parent->platform_data; 234 + if (chip_pdata) 236 235 pdata = chip_pdata->watchdog; 237 - } else { 236 + else 238 237 pdata = NULL; 239 - } 240 238 241 239 if (pdata) { 242 240 reg &= ~(WM831X_WDOG_SECACT_MASK | WM831X_WDOG_PRIMACT_MASK |

-1

drivers/watchdog/xen_wdt.c

··· 362 362 MODULE_DESCRIPTION("Xen WatchDog Timer Driver"); 363 363 MODULE_VERSION(DRV_VERSION); 364 364 MODULE_LICENSE("GPL"); 365 - MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);