Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog
* git://git.kernel.org/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog:
watchdog: softdog.c: enhancement to optionally invoke panic instead of reboot on timer expiry
watchdog: fix nv_tco section mismatch
watchdog: sp5100_tco.c: Check if firmware has set correct value in tcobase.
watchdog: Convert release_resource to release_region/release_mem_region
watchdog: s3c2410_wdt.c: Convert release_resource to release_region/release_mem_region
+67
-56
+10
-12
drivers/watchdog/davinci_wdt.c
+10
-12
drivers/watchdog/davinci_wdt.c
···
202
202
static int __devinit davinci_wdt_probe(struct platform_device *pdev)
203
203
{
204
204
int ret = 0, size;
205
-
struct resource *res;
206
205
struct device *dev = &pdev->dev;
207
206
208
207
wdt_clk = clk_get(dev, NULL);
···
215
216
216
217
dev_info(dev, "heartbeat %d sec\n", heartbeat);
217
218
218
-
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
219
-
if (res == NULL) {
219
+
wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
220
+
if (wdt_mem == NULL) {
220
221
dev_err(dev, "failed to get memory region resource\n");
221
222
return -ENOENT;
222
223
}
223
224
224
-
size = resource_size(res);
225
-
wdt_mem = request_mem_region(res->start, size, pdev->name);
226
-
227
-
if (wdt_mem == NULL) {
225
+
size = resource_size(wdt_mem);
226
+
if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
228
227
dev_err(dev, "failed to get memory region\n");
229
228
return -ENOENT;
230
229
}
231
230
232
-
wdt_base = ioremap(res->start, size);
231
+
wdt_base = ioremap(wdt_mem->start, size);
233
232
if (!wdt_base) {
234
233
dev_err(dev, "failed to map memory region\n");
234
+
release_mem_region(wdt_mem->start, size);
235
+
wdt_mem = NULL;
235
236
return -ENOMEM;
236
237
}
237
238
238
239
ret = misc_register(&davinci_wdt_miscdev);
239
240
if (ret < 0) {
240
241
dev_err(dev, "cannot register misc device\n");
241
-
release_resource(wdt_mem);
242
-
kfree(wdt_mem);
242
+
release_mem_region(wdt_mem->start, size);
243
+
wdt_mem = NULL;
243
244
} else {
244
245
set_bit(WDT_DEVICE_INITED, &wdt_status);
245
246
}
···
252
253
{
253
254
misc_deregister(&davinci_wdt_miscdev);
254
255
if (wdt_mem) {
255
-
release_resource(wdt_mem);
256
-
kfree(wdt_mem);
256
+
release_mem_region(wdt_mem->start, resource_size(wdt_mem));
257
257
wdt_mem = NULL;
258
258
}
259
259
+8
-12
drivers/watchdog/max63xx_wdt.c
+8
-12
drivers/watchdog/max63xx_wdt.c
···
270
270
{
271
271
int ret = 0;
272
272
int size;
273
-
struct resource *res;
274
273
struct device *dev = &pdev->dev;
275
274
struct max63xx_timeout *table;
276
275
···
293
294
294
295
max63xx_pdev = pdev;
295
296
296
-
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
297
-
if (res == NULL) {
297
+
wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
298
+
if (wdt_mem == NULL) {
298
299
dev_err(dev, "failed to get memory region resource\n");
299
300
return -ENOENT;
300
301
}
301
302
302
-
size = resource_size(res);
303
-
wdt_mem = request_mem_region(res->start, size, pdev->name);
304
-
305
-
if (wdt_mem == NULL) {
303
+
size = resource_size(wdt_mem);
304
+
if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
306
305
dev_err(dev, "failed to get memory region\n");
307
306
return -ENOENT;
308
307
}
309
308
310
-
wdt_base = ioremap(res->start, size);
309
+
wdt_base = ioremap(wdt_mem->start, size);
311
310
if (!wdt_base) {
312
311
dev_err(dev, "failed to map memory region\n");
313
312
ret = -ENOMEM;
···
323
326
out_unmap:
324
327
iounmap(wdt_base);
325
328
out_request:
326
-
release_resource(wdt_mem);
327
-
kfree(wdt_mem);
329
+
release_mem_region(wdt_mem->start, size);
330
+
wdt_mem = NULL;
328
331
329
332
return ret;
330
333
}
···
333
336
{
334
337
misc_deregister(&max63xx_wdt_miscdev);
335
338
if (wdt_mem) {
336
-
release_resource(wdt_mem);
337
-
kfree(wdt_mem);
339
+
release_mem_region(wdt_mem->start, resource_size(wdt_mem));
338
340
wdt_mem = NULL;
339
341
}
340
342
+1
-1
drivers/watchdog/nv_tco.c
+1
-1
drivers/watchdog/nv_tco.c
+13
-15
drivers/watchdog/pnx4008_wdt.c
+13
-15
drivers/watchdog/pnx4008_wdt.c
···
254
254
static int __devinit pnx4008_wdt_probe(struct platform_device *pdev)
255
255
{
256
256
int ret = 0, size;
257
-
struct resource *res;
258
257
259
258
if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
260
259
heartbeat = DEFAULT_HEARTBEAT;
···
261
262
printk(KERN_INFO MODULE_NAME
262
263
"PNX4008 Watchdog Timer: heartbeat %d sec\n", heartbeat);
263
264
264
-
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
265
-
if (res == NULL) {
265
+
wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
266
+
if (wdt_mem == NULL) {
266
267
printk(KERN_INFO MODULE_NAME
267
268
"failed to get memory region resouce\n");
268
269
return -ENOENT;
269
270
}
270
271
271
-
size = resource_size(res);
272
-
wdt_mem = request_mem_region(res->start, size, pdev->name);
272
+
size = resource_size(wdt_mem);
273
273
274
-
if (wdt_mem == NULL) {
274
+
if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
275
275
printk(KERN_INFO MODULE_NAME "failed to get memory region\n");
276
276
return -ENOENT;
277
277
}
278
-
wdt_base = (void __iomem *)IO_ADDRESS(res->start);
278
+
wdt_base = (void __iomem *)IO_ADDRESS(wdt_mem->start);
279
279
280
280
wdt_clk = clk_get(&pdev->dev, NULL);
281
281
if (IS_ERR(wdt_clk)) {
282
282
ret = PTR_ERR(wdt_clk);
283
-
release_resource(wdt_mem);
284
-
kfree(wdt_mem);
283
+
release_mem_region(wdt_mem->start, size);
284
+
wdt_mem = NULL;
285
285
goto out;
286
286
}
287
287
288
288
ret = clk_enable(wdt_clk);
289
289
if (ret) {
290
-
release_resource(wdt_mem);
291
-
kfree(wdt_mem);
290
+
release_mem_region(wdt_mem->start, size);
291
+
wdt_mem = NULL;
292
+
clk_put(wdt_clk);
292
293
goto out;
293
294
}
294
295
295
296
ret = misc_register(&pnx4008_wdt_miscdev);
296
297
if (ret < 0) {
297
298
printk(KERN_ERR MODULE_NAME "cannot register misc device\n");
298
-
release_resource(wdt_mem);
299
-
kfree(wdt_mem);
299
+
release_mem_region(wdt_mem->start, size);
300
+
wdt_mem = NULL;
300
301
clk_disable(wdt_clk);
301
302
clk_put(wdt_clk);
302
303
} else {
···
319
320
clk_put(wdt_clk);
320
321
321
322
if (wdt_mem) {
322
-
release_resource(wdt_mem);
323
-
kfree(wdt_mem);
323
+
release_mem_region(wdt_mem->start, resource_size(wdt_mem));
324
324
wdt_mem = NULL;
325
325
}
326
326
return 0;
+8
-11
drivers/watchdog/s3c2410_wdt.c
+8
-11
drivers/watchdog/s3c2410_wdt.c
···
402
402
403
403
static int __devinit s3c2410wdt_probe(struct platform_device *pdev)
404
404
{
405
-
struct resource *res;
406
405
struct device *dev;
407
406
unsigned int wtcon;
408
407
int started = 0;
···
415
416
416
417
/* get the memory region for the watchdog timer */
417
418
418
-
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
419
-
if (res == NULL) {
419
+
wdt_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
420
+
if (wdt_mem == NULL) {
420
421
dev_err(dev, "no memory resource specified\n");
421
422
return -ENOENT;
422
423
}
423
424
424
-
size = resource_size(res);
425
-
wdt_mem = request_mem_region(res->start, size, pdev->name);
426
-
if (wdt_mem == NULL) {
425
+
size = resource_size(wdt_mem);
426
+
if (!request_mem_region(wdt_mem->start, size, pdev->name)) {
427
427
dev_err(dev, "failed to get memory region\n");
428
428
return -EBUSY;
429
429
}
430
430
431
-
wdt_base = ioremap(res->start, size);
431
+
wdt_base = ioremap(wdt_mem->start, size);
432
432
if (wdt_base == NULL) {
433
433
dev_err(dev, "failed to ioremap() region\n");
434
434
ret = -EINVAL;
···
522
524
iounmap(wdt_base);
523
525
524
526
err_req:
525
-
release_resource(wdt_mem);
526
-
kfree(wdt_mem);
527
+
release_mem_region(wdt_mem->start, size);
528
+
wdt_mem = NULL;
527
529
528
530
return ret;
529
531
}
···
543
545
544
546
iounmap(wdt_base);
545
547
546
-
release_resource(wdt_mem);
547
-
kfree(wdt_mem);
548
+
release_mem_region(wdt_mem->start, resource_size(wdt_mem));
548
549
wdt_mem = NULL;
549
550
return 0;
550
551
}
+13
-3
drivers/watchdog/softdog.c
+13
-3
drivers/watchdog/softdog.c
···
48
48
#include <linux/init.h>
49
49
#include <linux/jiffies.h>
50
50
#include <linux/uaccess.h>
51
+
#include <linux/kernel.h>
51
52
52
53
#define PFX "SoftDog: "
53
54
···
76
75
"Softdog action, set to 1 to ignore reboots, 0 to reboot "
77
76
"(default depends on ONLY_TESTING)");
78
77
78
+
static int soft_panic;
79
+
module_param(soft_panic, int, 0);
80
+
MODULE_PARM_DESC(soft_panic,
81
+
"Softdog action, set to 1 to panic, 0 to reboot (default=0)");
82
+
79
83
/*
80
84
* Our timer
81
85
*/
···
104
98
105
99
if (soft_noboot)
106
100
printk(KERN_CRIT PFX "Triggered - Reboot ignored.\n");
107
-
else {
101
+
else if (soft_panic) {
102
+
printk(KERN_CRIT PFX "Initiating panic.\n");
103
+
panic("Software Watchdog Timer expired.");
104
+
} else {
108
105
printk(KERN_CRIT PFX "Initiating system reboot.\n");
109
106
emergency_restart();
110
107
printk(KERN_CRIT PFX "Reboot didn't ?????\n");
···
276
267
};
277
268
278
269
static char banner[] __initdata = KERN_INFO "Software Watchdog Timer: 0.07 "
279
-
"initialized. soft_noboot=%d soft_margin=%d sec (nowayout= %d)\n";
270
+
"initialized. soft_noboot=%d soft_margin=%d sec soft_panic=%d "
271
+
"(nowayout= %d)\n";
280
272
281
273
static int __init watchdog_init(void)
282
274
{
···
308
298
return ret;
309
299
}
310
300
311
-
printk(banner, soft_noboot, soft_margin, nowayout);
301
+
printk(banner, soft_noboot, soft_margin, soft_panic, nowayout);
312
302
313
303
return 0;
314
304
}
+14
-2
drivers/watchdog/sp5100_tco.c
+14
-2
drivers/watchdog/sp5100_tco.c
···
42
42
#define PFX TCO_MODULE_NAME ": "
43
43
44
44
/* internal variables */
45
+
static u32 tcobase_phys;
45
46
static void __iomem *tcobase;
46
47
static unsigned int pm_iobase;
47
48
static DEFINE_SPINLOCK(tco_lock); /* Guards the hardware */
···
306
305
/* Low three bits of BASE0 are reserved. */
307
306
val = val << 8 | (inb(SP5100_IO_PM_DATA_REG) & 0xf8);
308
307
308
+
if (!request_mem_region_exclusive(val, SP5100_WDT_MEM_MAP_SIZE,
309
+
"SP5100 TCO")) {
310
+
printk(KERN_ERR PFX "mmio address 0x%04x already in use\n",
311
+
val);
312
+
goto unreg_region;
313
+
}
314
+
tcobase_phys = val;
315
+
309
316
tcobase = ioremap(val, SP5100_WDT_MEM_MAP_SIZE);
310
317
if (tcobase == 0) {
311
318
printk(KERN_ERR PFX "failed to get tcobase address\n");
312
-
goto unreg_region;
319
+
goto unreg_mem_region;
313
320
}
314
321
315
322
/* Enable watchdog decode bit */
···
355
346
/* Done */
356
347
return 1;
357
348
358
-
iounmap(tcobase);
349
+
unreg_mem_region:
350
+
release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
359
351
unreg_region:
360
352
release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
361
353
exit:
···
411
401
412
402
exit:
413
403
iounmap(tcobase);
404
+
release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
414
405
release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
415
406
return ret;
416
407
}
···
425
414
/* Deregister */
426
415
misc_deregister(&sp5100_tco_miscdev);
427
416
iounmap(tcobase);
417
+
release_mem_region(tcobase_phys, SP5100_WDT_MEM_MAP_SIZE);
428
418
release_region(pm_iobase, SP5100_PM_IOPORTS_SIZE);
429
419
}
430
420