Root/
1 | /* cpwd.c - driver implementation for hardware watchdog |
2 | * timers found on Sun Microsystems CP1400 and CP1500 boards. |
3 | * |
4 | * This device supports both the generic Linux watchdog |
5 | * interface and Solaris-compatible ioctls as best it is |
6 | * able. |
7 | * |
8 | * NOTE: CP1400 systems appear to have a defective intr_mask |
9 | * register on the PLD, preventing the disabling of |
10 | * timer interrupts. We use a timer to periodically |
11 | * reset 'stopped' watchdogs on affected platforms. |
12 | * |
13 | * Copyright (c) 2000 Eric Brower (ebrower@usa.net) |
14 | * Copyright (C) 2008 David S. Miller <davem@davemloft.net> |
15 | */ |
16 | |
17 | #include <linux/kernel.h> |
18 | #include <linux/module.h> |
19 | #include <linux/fs.h> |
20 | #include <linux/errno.h> |
21 | #include <linux/major.h> |
22 | #include <linux/init.h> |
23 | #include <linux/miscdevice.h> |
24 | #include <linux/interrupt.h> |
25 | #include <linux/ioport.h> |
26 | #include <linux/timer.h> |
27 | #include <linux/slab.h> |
28 | #include <linux/smp_lock.h> |
29 | #include <linux/io.h> |
30 | #include <linux/of.h> |
31 | #include <linux/of_device.h> |
32 | #include <linux/uaccess.h> |
33 | |
34 | #include <asm/irq.h> |
35 | #include <asm/watchdog.h> |
36 | |
37 | #define DRIVER_NAME "cpwd" |
38 | #define PFX DRIVER_NAME ": " |
39 | |
40 | #define WD_OBPNAME "watchdog" |
41 | #define WD_BADMODEL "SUNW,501-5336" |
42 | #define WD_BTIMEOUT (jiffies + (HZ * 1000)) |
43 | #define WD_BLIMIT 0xFFFF |
44 | |
45 | #define WD0_MINOR 212 |
46 | #define WD1_MINOR 213 |
47 | #define WD2_MINOR 214 |
48 | |
49 | /* Internal driver definitions. */ |
50 | #define WD0_ID 0 |
51 | #define WD1_ID 1 |
52 | #define WD2_ID 2 |
53 | #define WD_NUMDEVS 3 |
54 | |
55 | #define WD_INTR_OFF 0 |
56 | #define WD_INTR_ON 1 |
57 | |
58 | #define WD_STAT_INIT 0x01 /* Watchdog timer is initialized */ |
59 | #define WD_STAT_BSTOP 0x02 /* Watchdog timer is brokenstopped */ |
60 | #define WD_STAT_SVCD 0x04 /* Watchdog interrupt occurred */ |
61 | |
62 | /* Register value definitions |
63 | */ |
64 | #define WD0_INTR_MASK 0x01 /* Watchdog device interrupt masks */ |
65 | #define WD1_INTR_MASK 0x02 |
66 | #define WD2_INTR_MASK 0x04 |
67 | |
68 | #define WD_S_RUNNING 0x01 /* Watchdog device status running */ |
69 | #define WD_S_EXPIRED 0x02 /* Watchdog device status expired */ |
70 | |
71 | struct cpwd { |
72 | void __iomem *regs; |
73 | spinlock_t lock; |
74 | |
75 | unsigned int irq; |
76 | |
77 | unsigned long timeout; |
78 | bool enabled; |
79 | bool reboot; |
80 | bool broken; |
81 | bool initialized; |
82 | |
83 | struct { |
84 | struct miscdevice misc; |
85 | void __iomem *regs; |
86 | u8 intr_mask; |
87 | u8 runstatus; |
88 | u16 timeout; |
89 | } devs[WD_NUMDEVS]; |
90 | }; |
91 | |
92 | static struct cpwd *cpwd_device; |
93 | |
94 | /* Sun uses Altera PLD EPF8820ATC144-4 |
95 | * providing three hardware watchdogs: |
96 | * |
97 | * 1) RIC - sends an interrupt when triggered |
98 | * 2) XIR - asserts XIR_B_RESET when triggered, resets CPU |
99 | * 3) POR - asserts POR_B_RESET when triggered, resets CPU, backplane, board |
100 | * |
101 | *** Timer register block definition (struct wd_timer_regblk) |
102 | * |
103 | * dcntr and limit registers (halfword access): |
104 | * ------------------- |
105 | * | 15 | ...| 1 | 0 | |
106 | * ------------------- |
107 | * |- counter val -| |
108 | * ------------------- |
109 | * dcntr - Current 16-bit downcounter value. |
110 | * When downcounter reaches '0' watchdog expires. |
111 | * Reading this register resets downcounter with |
112 | * 'limit' value. |
113 | * limit - 16-bit countdown value in 1/10th second increments. |
114 | * Writing this register begins countdown with input value. |
115 | * Reading from this register does not affect counter. |
116 | * NOTES: After watchdog reset, dcntr and limit contain '1' |
117 | * |
118 | * status register (byte access): |
119 | * --------------------------- |
120 | * | 7 | ... | 2 | 1 | 0 | |
121 | * --------------+------------ |
122 | * |- UNUSED -| EXP | RUN | |
123 | * --------------------------- |
124 | * status- Bit 0 - Watchdog is running |
125 | * Bit 1 - Watchdog has expired |
126 | * |
127 | *** PLD register block definition (struct wd_pld_regblk) |
128 | * |
129 | * intr_mask register (byte access): |
130 | * --------------------------------- |
131 | * | 7 | ... | 3 | 2 | 1 | 0 | |
132 | * +-------------+------------------ |
133 | * |- UNUSED -| WD3 | WD2 | WD1 | |
134 | * --------------------------------- |
135 | * WD3 - 1 == Interrupt disabled for watchdog 3 |
136 | * WD2 - 1 == Interrupt disabled for watchdog 2 |
137 | * WD1 - 1 == Interrupt disabled for watchdog 1 |
138 | * |
139 | * pld_status register (byte access): |
140 | * UNKNOWN, MAGICAL MYSTERY REGISTER |
141 | * |
142 | */ |
143 | #define WD_TIMER_REGSZ 16 |
144 | #define WD0_OFF 0 |
145 | #define WD1_OFF (WD_TIMER_REGSZ * 1) |
146 | #define WD2_OFF (WD_TIMER_REGSZ * 2) |
147 | #define PLD_OFF (WD_TIMER_REGSZ * 3) |
148 | |
149 | #define WD_DCNTR 0x00 |
150 | #define WD_LIMIT 0x04 |
151 | #define WD_STATUS 0x08 |
152 | |
153 | #define PLD_IMASK (PLD_OFF + 0x00) |
154 | #define PLD_STATUS (PLD_OFF + 0x04) |
155 | |
156 | static struct timer_list cpwd_timer; |
157 | |
158 | static int wd0_timeout; |
159 | static int wd1_timeout; |
160 | static int wd2_timeout; |
161 | |
162 | module_param(wd0_timeout, int, 0); |
163 | MODULE_PARM_DESC(wd0_timeout, "Default watchdog0 timeout in 1/10secs"); |
164 | module_param(wd1_timeout, int, 0); |
165 | MODULE_PARM_DESC(wd1_timeout, "Default watchdog1 timeout in 1/10secs"); |
166 | module_param(wd2_timeout, int, 0); |
167 | MODULE_PARM_DESC(wd2_timeout, "Default watchdog2 timeout in 1/10secs"); |
168 | |
169 | MODULE_AUTHOR("Eric Brower <ebrower@usa.net>"); |
170 | MODULE_DESCRIPTION("Hardware watchdog driver for Sun Microsystems CP1400/1500"); |
171 | MODULE_LICENSE("GPL"); |
172 | MODULE_SUPPORTED_DEVICE("watchdog"); |
173 | |
174 | static void cpwd_writew(u16 val, void __iomem *addr) |
175 | { |
176 | writew(cpu_to_le16(val), addr); |
177 | } |
178 | static u16 cpwd_readw(void __iomem *addr) |
179 | { |
180 | u16 val = readw(addr); |
181 | |
182 | return le16_to_cpu(val); |
183 | } |
184 | |
185 | static void cpwd_writeb(u8 val, void __iomem *addr) |
186 | { |
187 | writeb(val, addr); |
188 | } |
189 | |
190 | static u8 cpwd_readb(void __iomem *addr) |
191 | { |
192 | return readb(addr); |
193 | } |
194 | |
195 | /* Enable or disable watchdog interrupts |
196 | * Because of the CP1400 defect this should only be |
197 | * called during initialzation or by wd_[start|stop]timer() |
198 | * |
199 | * index - sub-device index, or -1 for 'all' |
200 | * enable - non-zero to enable interrupts, zero to disable |
201 | */ |
202 | static void cpwd_toggleintr(struct cpwd *p, int index, int enable) |
203 | { |
204 | unsigned char curregs = cpwd_readb(p->regs + PLD_IMASK); |
205 | unsigned char setregs = |
206 | (index == -1) ? |
207 | (WD0_INTR_MASK | WD1_INTR_MASK | WD2_INTR_MASK) : |
208 | (p->devs[index].intr_mask); |
209 | |
210 | if (enable == WD_INTR_ON) |
211 | curregs &= ~setregs; |
212 | else |
213 | curregs |= setregs; |
214 | |
215 | cpwd_writeb(curregs, p->regs + PLD_IMASK); |
216 | } |
217 | |
218 | /* Restarts timer with maximum limit value and |
219 | * does not unset 'brokenstop' value. |
220 | */ |
221 | static void cpwd_resetbrokentimer(struct cpwd *p, int index) |
222 | { |
223 | cpwd_toggleintr(p, index, WD_INTR_ON); |
224 | cpwd_writew(WD_BLIMIT, p->devs[index].regs + WD_LIMIT); |
225 | } |
226 | |
227 | /* Timer method called to reset stopped watchdogs-- |
228 | * because of the PLD bug on CP1400, we cannot mask |
229 | * interrupts within the PLD so me must continually |
230 | * reset the timers ad infinitum. |
231 | */ |
232 | static void cpwd_brokentimer(unsigned long data) |
233 | { |
234 | struct cpwd *p = (struct cpwd *) data; |
235 | int id, tripped = 0; |
236 | |
237 | /* kill a running timer instance, in case we |
238 | * were called directly instead of by kernel timer |
239 | */ |
240 | if (timer_pending(&cpwd_timer)) |
241 | del_timer(&cpwd_timer); |
242 | |
243 | for (id = 0; id < WD_NUMDEVS; id++) { |
244 | if (p->devs[id].runstatus & WD_STAT_BSTOP) { |
245 | ++tripped; |
246 | cpwd_resetbrokentimer(p, id); |
247 | } |
248 | } |
249 | |
250 | if (tripped) { |
251 | /* there is at least one timer brokenstopped-- reschedule */ |
252 | cpwd_timer.expires = WD_BTIMEOUT; |
253 | add_timer(&cpwd_timer); |
254 | } |
255 | } |
256 | |
257 | /* Reset countdown timer with 'limit' value and continue countdown. |
258 | * This will not start a stopped timer. |
259 | */ |
260 | static void cpwd_pingtimer(struct cpwd *p, int index) |
261 | { |
262 | if (cpwd_readb(p->devs[index].regs + WD_STATUS) & WD_S_RUNNING) |
263 | cpwd_readw(p->devs[index].regs + WD_DCNTR); |
264 | } |
265 | |
266 | /* Stop a running watchdog timer-- the timer actually keeps |
267 | * running, but the interrupt is masked so that no action is |
268 | * taken upon expiration. |
269 | */ |
270 | static void cpwd_stoptimer(struct cpwd *p, int index) |
271 | { |
272 | if (cpwd_readb(p->devs[index].regs + WD_STATUS) & WD_S_RUNNING) { |
273 | cpwd_toggleintr(p, index, WD_INTR_OFF); |
274 | |
275 | if (p->broken) { |
276 | p->devs[index].runstatus |= WD_STAT_BSTOP; |
277 | cpwd_brokentimer((unsigned long) p); |
278 | } |
279 | } |
280 | } |
281 | |
282 | /* Start a watchdog timer with the specified limit value |
283 | * If the watchdog is running, it will be restarted with |
284 | * the provided limit value. |
285 | * |
286 | * This function will enable interrupts on the specified |
287 | * watchdog. |
288 | */ |
289 | static void cpwd_starttimer(struct cpwd *p, int index) |
290 | { |
291 | if (p->broken) |
292 | p->devs[index].runstatus &= ~WD_STAT_BSTOP; |
293 | |
294 | p->devs[index].runstatus &= ~WD_STAT_SVCD; |
295 | |
296 | cpwd_writew(p->devs[index].timeout, p->devs[index].regs + WD_LIMIT); |
297 | cpwd_toggleintr(p, index, WD_INTR_ON); |
298 | } |
299 | |
300 | static int cpwd_getstatus(struct cpwd *p, int index) |
301 | { |
302 | unsigned char stat = cpwd_readb(p->devs[index].regs + WD_STATUS); |
303 | unsigned char intr = cpwd_readb(p->devs[index].regs + PLD_IMASK); |
304 | unsigned char ret = WD_STOPPED; |
305 | |
306 | /* determine STOPPED */ |
307 | if (!stat) |
308 | return ret; |
309 | |
310 | /* determine EXPIRED vs FREERUN vs RUNNING */ |
311 | else if (WD_S_EXPIRED & stat) { |
312 | ret = WD_EXPIRED; |
313 | } else if (WD_S_RUNNING & stat) { |
314 | if (intr & p->devs[index].intr_mask) { |
315 | ret = WD_FREERUN; |
316 | } else { |
317 | /* Fudge WD_EXPIRED status for defective CP1400-- |
318 | * IF timer is running |
319 | * AND brokenstop is set |
320 | * AND an interrupt has been serviced |
321 | * we are WD_EXPIRED. |
322 | * |
323 | * IF timer is running |
324 | * AND brokenstop is set |
325 | * AND no interrupt has been serviced |
326 | * we are WD_FREERUN. |
327 | */ |
328 | if (p->broken && |
329 | (p->devs[index].runstatus & WD_STAT_BSTOP)) { |
330 | if (p->devs[index].runstatus & WD_STAT_SVCD) { |
331 | ret = WD_EXPIRED; |
332 | } else { |
333 | /* we could as well pretend |
334 | * we are expired */ |
335 | ret = WD_FREERUN; |
336 | } |
337 | } else { |
338 | ret = WD_RUNNING; |
339 | } |
340 | } |
341 | } |
342 | |
343 | /* determine SERVICED */ |
344 | if (p->devs[index].runstatus & WD_STAT_SVCD) |
345 | ret |= WD_SERVICED; |
346 | |
347 | return ret; |
348 | } |
349 | |
350 | static irqreturn_t cpwd_interrupt(int irq, void *dev_id) |
351 | { |
352 | struct cpwd *p = dev_id; |
353 | |
354 | /* Only WD0 will interrupt-- others are NMI and we won't |
355 | * see them here.... |
356 | */ |
357 | spin_lock_irq(&p->lock); |
358 | |
359 | cpwd_stoptimer(p, WD0_ID); |
360 | p->devs[WD0_ID].runstatus |= WD_STAT_SVCD; |
361 | |
362 | spin_unlock_irq(&p->lock); |
363 | |
364 | return IRQ_HANDLED; |
365 | } |
366 | |
367 | static int cpwd_open(struct inode *inode, struct file *f) |
368 | { |
369 | struct cpwd *p = cpwd_device; |
370 | |
371 | lock_kernel(); |
372 | switch (iminor(inode)) { |
373 | case WD0_MINOR: |
374 | case WD1_MINOR: |
375 | case WD2_MINOR: |
376 | break; |
377 | |
378 | default: |
379 | unlock_kernel(); |
380 | return -ENODEV; |
381 | } |
382 | |
383 | /* Register IRQ on first open of device */ |
384 | if (!p->initialized) { |
385 | if (request_irq(p->irq, &cpwd_interrupt, |
386 | IRQF_SHARED, DRIVER_NAME, p)) { |
387 | printk(KERN_ERR PFX "Cannot register IRQ %d\n", |
388 | p->irq); |
389 | unlock_kernel(); |
390 | return -EBUSY; |
391 | } |
392 | p->initialized = true; |
393 | } |
394 | |
395 | unlock_kernel(); |
396 | |
397 | return nonseekable_open(inode, f); |
398 | } |
399 | |
400 | static int cpwd_release(struct inode *inode, struct file *file) |
401 | { |
402 | return 0; |
403 | } |
404 | |
405 | static long cpwd_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
406 | { |
407 | static const struct watchdog_info info = { |
408 | .options = WDIOF_SETTIMEOUT, |
409 | .firmware_version = 1, |
410 | .identity = DRIVER_NAME, |
411 | }; |
412 | void __user *argp = (void __user *)arg; |
413 | struct inode *inode = file->f_path.dentry->d_inode; |
414 | int index = iminor(inode) - WD0_MINOR; |
415 | struct cpwd *p = cpwd_device; |
416 | int setopt = 0; |
417 | |
418 | switch (cmd) { |
419 | /* Generic Linux IOCTLs */ |
420 | case WDIOC_GETSUPPORT: |
421 | if (copy_to_user(argp, &info, sizeof(struct watchdog_info))) |
422 | return -EFAULT; |
423 | break; |
424 | |
425 | case WDIOC_GETSTATUS: |
426 | case WDIOC_GETBOOTSTATUS: |
427 | if (put_user(0, (int __user *)argp)) |
428 | return -EFAULT; |
429 | break; |
430 | |
431 | case WDIOC_KEEPALIVE: |
432 | cpwd_pingtimer(p, index); |
433 | break; |
434 | |
435 | case WDIOC_SETOPTIONS: |
436 | if (copy_from_user(&setopt, argp, sizeof(unsigned int))) |
437 | return -EFAULT; |
438 | |
439 | if (setopt & WDIOS_DISABLECARD) { |
440 | if (p->enabled) |
441 | return -EINVAL; |
442 | cpwd_stoptimer(p, index); |
443 | } else if (setopt & WDIOS_ENABLECARD) { |
444 | cpwd_starttimer(p, index); |
445 | } else { |
446 | return -EINVAL; |
447 | } |
448 | break; |
449 | |
450 | /* Solaris-compatible IOCTLs */ |
451 | case WIOCGSTAT: |
452 | setopt = cpwd_getstatus(p, index); |
453 | if (copy_to_user(argp, &setopt, sizeof(unsigned int))) |
454 | return -EFAULT; |
455 | break; |
456 | |
457 | case WIOCSTART: |
458 | cpwd_starttimer(p, index); |
459 | break; |
460 | |
461 | case WIOCSTOP: |
462 | if (p->enabled) |
463 | return -EINVAL; |
464 | |
465 | cpwd_stoptimer(p, index); |
466 | break; |
467 | |
468 | default: |
469 | return -EINVAL; |
470 | } |
471 | |
472 | return 0; |
473 | } |
474 | |
475 | static long cpwd_compat_ioctl(struct file *file, unsigned int cmd, |
476 | unsigned long arg) |
477 | { |
478 | int rval = -ENOIOCTLCMD; |
479 | |
480 | switch (cmd) { |
481 | /* solaris ioctls are specific to this driver */ |
482 | case WIOCSTART: |
483 | case WIOCSTOP: |
484 | case WIOCGSTAT: |
485 | lock_kernel(); |
486 | rval = cpwd_ioctl(file, cmd, arg); |
487 | unlock_kernel(); |
488 | break; |
489 | |
490 | /* everything else is handled by the generic compat layer */ |
491 | default: |
492 | break; |
493 | } |
494 | |
495 | return rval; |
496 | } |
497 | |
498 | static ssize_t cpwd_write(struct file *file, const char __user *buf, |
499 | size_t count, loff_t *ppos) |
500 | { |
501 | struct inode *inode = file->f_path.dentry->d_inode; |
502 | struct cpwd *p = cpwd_device; |
503 | int index = iminor(inode); |
504 | |
505 | if (count) { |
506 | cpwd_pingtimer(p, index); |
507 | return 1; |
508 | } |
509 | |
510 | return 0; |
511 | } |
512 | |
513 | static ssize_t cpwd_read(struct file *file, char __user *buffer, |
514 | size_t count, loff_t *ppos) |
515 | { |
516 | return -EINVAL; |
517 | } |
518 | |
519 | static const struct file_operations cpwd_fops = { |
520 | .owner = THIS_MODULE, |
521 | .unlocked_ioctl = cpwd_ioctl, |
522 | .compat_ioctl = cpwd_compat_ioctl, |
523 | .open = cpwd_open, |
524 | .write = cpwd_write, |
525 | .read = cpwd_read, |
526 | .release = cpwd_release, |
527 | }; |
528 | |
529 | static int __devinit cpwd_probe(struct of_device *op, |
530 | const struct of_device_id *match) |
531 | { |
532 | struct device_node *options; |
533 | const char *str_prop; |
534 | const void *prop_val; |
535 | int i, err = -EINVAL; |
536 | struct cpwd *p; |
537 | |
538 | if (cpwd_device) |
539 | return -EINVAL; |
540 | |
541 | p = kzalloc(sizeof(*p), GFP_KERNEL); |
542 | err = -ENOMEM; |
543 | if (!p) { |
544 | printk(KERN_ERR PFX "Unable to allocate struct cpwd.\n"); |
545 | goto out; |
546 | } |
547 | |
548 | p->irq = op->irqs[0]; |
549 | |
550 | spin_lock_init(&p->lock); |
551 | |
552 | p->regs = of_ioremap(&op->resource[0], 0, |
553 | 4 * WD_TIMER_REGSZ, DRIVER_NAME); |
554 | if (!p->regs) { |
555 | printk(KERN_ERR PFX "Unable to map registers.\n"); |
556 | goto out_free; |
557 | } |
558 | |
559 | options = of_find_node_by_path("/options"); |
560 | err = -ENODEV; |
561 | if (!options) { |
562 | printk(KERN_ERR PFX "Unable to find /options node.\n"); |
563 | goto out_iounmap; |
564 | } |
565 | |
566 | prop_val = of_get_property(options, "watchdog-enable?", NULL); |
567 | p->enabled = (prop_val ? true : false); |
568 | |
569 | prop_val = of_get_property(options, "watchdog-reboot?", NULL); |
570 | p->reboot = (prop_val ? true : false); |
571 | |
572 | str_prop = of_get_property(options, "watchdog-timeout", NULL); |
573 | if (str_prop) |
574 | p->timeout = simple_strtoul(str_prop, NULL, 10); |
575 | |
576 | /* CP1400s seem to have broken PLD implementations-- the |
577 | * interrupt_mask register cannot be written, so no timer |
578 | * interrupts can be masked within the PLD. |
579 | */ |
580 | str_prop = of_get_property(op->node, "model", NULL); |
581 | p->broken = (str_prop && !strcmp(str_prop, WD_BADMODEL)); |
582 | |
583 | if (!p->enabled) |
584 | cpwd_toggleintr(p, -1, WD_INTR_OFF); |
585 | |
586 | for (i = 0; i < WD_NUMDEVS; i++) { |
587 | static const char *cpwd_names[] = { "RIC", "XIR", "POR" }; |
588 | static int *parms[] = { &wd0_timeout, |
589 | &wd1_timeout, |
590 | &wd2_timeout }; |
591 | struct miscdevice *mp = &p->devs[i].misc; |
592 | |
593 | mp->minor = WD0_MINOR + i; |
594 | mp->name = cpwd_names[i]; |
595 | mp->fops = &cpwd_fops; |
596 | |
597 | p->devs[i].regs = p->regs + (i * WD_TIMER_REGSZ); |
598 | p->devs[i].intr_mask = (WD0_INTR_MASK << i); |
599 | p->devs[i].runstatus &= ~WD_STAT_BSTOP; |
600 | p->devs[i].runstatus |= WD_STAT_INIT; |
601 | p->devs[i].timeout = p->timeout; |
602 | if (*parms[i]) |
603 | p->devs[i].timeout = *parms[i]; |
604 | |
605 | err = misc_register(&p->devs[i].misc); |
606 | if (err) { |
607 | printk(KERN_ERR "Could not register misc device for " |
608 | "dev %d\n", i); |
609 | goto out_unregister; |
610 | } |
611 | } |
612 | |
613 | if (p->broken) { |
614 | init_timer(&cpwd_timer); |
615 | cpwd_timer.function = cpwd_brokentimer; |
616 | cpwd_timer.data = (unsigned long) p; |
617 | cpwd_timer.expires = WD_BTIMEOUT; |
618 | |
619 | printk(KERN_INFO PFX "PLD defect workaround enabled for " |
620 | "model " WD_BADMODEL ".\n"); |
621 | } |
622 | |
623 | dev_set_drvdata(&op->dev, p); |
624 | cpwd_device = p; |
625 | err = 0; |
626 | |
627 | out: |
628 | return err; |
629 | |
630 | out_unregister: |
631 | for (i--; i >= 0; i--) |
632 | misc_deregister(&p->devs[i].misc); |
633 | |
634 | out_iounmap: |
635 | of_iounmap(&op->resource[0], p->regs, 4 * WD_TIMER_REGSZ); |
636 | |
637 | out_free: |
638 | kfree(p); |
639 | goto out; |
640 | } |
641 | |
642 | static int __devexit cpwd_remove(struct of_device *op) |
643 | { |
644 | struct cpwd *p = dev_get_drvdata(&op->dev); |
645 | int i; |
646 | |
647 | for (i = 0; i < 4; i++) { |
648 | misc_deregister(&p->devs[i].misc); |
649 | |
650 | if (!p->enabled) { |
651 | cpwd_stoptimer(p, i); |
652 | if (p->devs[i].runstatus & WD_STAT_BSTOP) |
653 | cpwd_resetbrokentimer(p, i); |
654 | } |
655 | } |
656 | |
657 | if (p->broken) |
658 | del_timer_sync(&cpwd_timer); |
659 | |
660 | if (p->initialized) |
661 | free_irq(p->irq, p); |
662 | |
663 | of_iounmap(&op->resource[0], p->regs, 4 * WD_TIMER_REGSZ); |
664 | kfree(p); |
665 | |
666 | cpwd_device = NULL; |
667 | |
668 | return 0; |
669 | } |
670 | |
671 | static const struct of_device_id cpwd_match[] = { |
672 | { |
673 | .name = "watchdog", |
674 | }, |
675 | {}, |
676 | }; |
677 | MODULE_DEVICE_TABLE(of, cpwd_match); |
678 | |
679 | static struct of_platform_driver cpwd_driver = { |
680 | .name = DRIVER_NAME, |
681 | .match_table = cpwd_match, |
682 | .probe = cpwd_probe, |
683 | .remove = __devexit_p(cpwd_remove), |
684 | }; |
685 | |
686 | static int __init cpwd_init(void) |
687 | { |
688 | return of_register_driver(&cpwd_driver, &of_bus_type); |
689 | } |
690 | |
691 | static void __exit cpwd_exit(void) |
692 | { |
693 | of_unregister_driver(&cpwd_driver); |
694 | } |
695 | |
696 | module_init(cpwd_init); |
697 | module_exit(cpwd_exit); |
698 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9