[WATCHDOG] pcwd_usb.c generic HID include file
[linux-2.6.git] / drivers / char / watchdog / pcwd_usb.c
1 /*
2  *      Berkshire USB-PC Watchdog Card Driver
3  *
4  *      (c) Copyright 2004 Wim Van Sebroeck <wim@iguana.be>.
5  *
6  *      Based on source code of the following authors:
7  *        Ken Hollis <kenji@bitgate.com>,
8  *        Alan Cox <alan@redhat.com>,
9  *        Matt Domsch <Matt_Domsch@dell.com>,
10  *        Rob Radez <rob@osinvestor.com>,
11  *        Greg Kroah-Hartman <greg@kroah.com>
12  *
13  *      This program is free software; you can redistribute it and/or
14  *      modify it under the terms of the GNU General Public License
15  *      as published by the Free Software Foundation; either version
16  *      2 of the License, or (at your option) any later version.
17  *
18  *      Neither Wim Van Sebroeck nor Iguana vzw. admit liability nor
19  *      provide warranty for any of this software. This material is
20  *      provided "AS-IS" and at no charge.
21  *
22  *      Thanks also to Simon Machell at Berkshire Products Inc. for
23  *      providing the test hardware. More info is available at
24  *      http://www.berkprod.com/ or http://www.pcwatchdog.com/
25  */
26
27 #include <linux/kernel.h>
28 #include <linux/errno.h>
29 #include <linux/init.h>
30 #include <linux/slab.h>
31 #include <linux/module.h>
32 #include <linux/moduleparam.h>
33 #include <linux/types.h>
34 #include <linux/delay.h>
35 #include <linux/miscdevice.h>
36 #include <linux/watchdog.h>
37 #include <linux/notifier.h>
38 #include <linux/reboot.h>
39 #include <linux/fs.h>
40 #include <linux/smp_lock.h>
41 #include <linux/completion.h>
42 #include <asm/uaccess.h>
43 #include <linux/usb.h>
44 #include <linux/mutex.h>
45 #include <linux/hid.h>          /* For HID_REQ_SET_REPORT & HID_DT_REPORT */
46
47
48 #ifdef CONFIG_USB_DEBUG
49         static int debug = 1;
50 #else
51         static int debug;
52 #endif
53
54 /* Use our own dbg macro */
55 #undef dbg
56 #define dbg(format, arg...) do { if (debug) printk(KERN_DEBUG PFX format "\n" , ## arg); } while (0)
57
58
59 /* Module and Version Information */
60 #define DRIVER_VERSION "1.01"
61 #define DRIVER_DATE "15 Mar 2005"
62 #define DRIVER_AUTHOR "Wim Van Sebroeck <wim@iguana.be>"
63 #define DRIVER_DESC "Berkshire USB-PC Watchdog driver"
64 #define DRIVER_LICENSE "GPL"
65 #define DRIVER_NAME "pcwd_usb"
66 #define PFX DRIVER_NAME ": "
67
68 MODULE_AUTHOR(DRIVER_AUTHOR);
69 MODULE_DESCRIPTION(DRIVER_DESC);
70 MODULE_LICENSE(DRIVER_LICENSE);
71 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
72 MODULE_ALIAS_MISCDEV(TEMP_MINOR);
73
74 /* Module Parameters */
75 module_param(debug, int, 0);
76 MODULE_PARM_DESC(debug, "Debug enabled or not");
77
78 #define WATCHDOG_HEARTBEAT 2    /* 2 sec default heartbeat */
79 static int heartbeat = WATCHDOG_HEARTBEAT;
80 module_param(heartbeat, int, 0);
81 MODULE_PARM_DESC(heartbeat, "Watchdog heartbeat in seconds. (0<heartbeat<65536, default=" __MODULE_STRING(WATCHDOG_HEARTBEAT) ")");
82
83 static int nowayout = WATCHDOG_NOWAYOUT;
84 module_param(nowayout, int, 0);
85 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default=CONFIG_WATCHDOG_NOWAYOUT)");
86
87 /* The vendor and product id's for the USB-PC Watchdog card */
88 #define USB_PCWD_VENDOR_ID      0x0c98
89 #define USB_PCWD_PRODUCT_ID     0x1140
90
91 /* table of devices that work with this driver */
92 static struct usb_device_id usb_pcwd_table [] = {
93         { USB_DEVICE(USB_PCWD_VENDOR_ID, USB_PCWD_PRODUCT_ID) },
94         { }                                     /* Terminating entry */
95 };
96 MODULE_DEVICE_TABLE (usb, usb_pcwd_table);
97
98 /* according to documentation max. time to process a command for the USB
99  * watchdog card is 100 or 200 ms, so we give it 250 ms to do it's job */
100 #define USB_COMMAND_TIMEOUT     250
101
102 /* Watchdog's internal commands */
103 #define CMD_READ_TEMP                   0x02    /* Read Temperature; Re-trigger Watchdog */
104 #define CMD_TRIGGER                     CMD_READ_TEMP
105 #define CMD_GET_STATUS                  0x04    /* Get Status Information */
106 #define CMD_GET_FIRMWARE_VERSION        0x08    /* Get Firmware Version */
107 #define CMD_GET_DIP_SWITCH_SETTINGS     0x0c    /* Get Dip Switch Settings */
108 #define CMD_READ_WATCHDOG_TIMEOUT       0x18    /* Read Current Watchdog Time */
109 #define CMD_WRITE_WATCHDOG_TIMEOUT      0x19    /* Write Current Watchdog Time */
110 #define CMD_ENABLE_WATCHDOG             0x30    /* Enable / Disable Watchdog */
111 #define CMD_DISABLE_WATCHDOG            CMD_ENABLE_WATCHDOG
112
113 /* We can only use 1 card due to the /dev/watchdog restriction */
114 static int cards_found;
115
116 /* some internal variables */
117 static unsigned long is_active;
118 static char expect_release;
119
120 /* Structure to hold all of our device specific stuff */
121 struct usb_pcwd_private {
122         struct usb_device *     udev;                   /* save off the usb device pointer */
123         struct usb_interface *  interface;              /* the interface for this device */
124
125         unsigned int            interface_number;       /* the interface number used for cmd's */
126
127         unsigned char *         intr_buffer;            /* the buffer to intr data */
128         dma_addr_t              intr_dma;               /* the dma address for the intr buffer */
129         size_t                  intr_size;              /* the size of the intr buffer */
130         struct urb *            intr_urb;               /* the urb used for the intr pipe */
131
132         unsigned char           cmd_command;            /* The command that is reported back */
133         unsigned char           cmd_data_msb;           /* The data MSB that is reported back */
134         unsigned char           cmd_data_lsb;           /* The data LSB that is reported back */
135         atomic_t                cmd_received;           /* true if we received a report after a command */
136
137         int                     exists;                 /* Wether or not the device exists */
138         struct semaphore        sem;                    /* locks this structure */
139 };
140 static struct usb_pcwd_private *usb_pcwd_device;
141
142 /* prevent races between open() and disconnect() */
143 static DEFINE_MUTEX(disconnect_mutex);
144
145 /* local function prototypes */
146 static int usb_pcwd_probe       (struct usb_interface *interface, const struct usb_device_id *id);
147 static void usb_pcwd_disconnect (struct usb_interface *interface);
148
149 /* usb specific object needed to register this driver with the usb subsystem */
150 static struct usb_driver usb_pcwd_driver = {
151         .name =         DRIVER_NAME,
152         .probe =        usb_pcwd_probe,
153         .disconnect =   usb_pcwd_disconnect,
154         .id_table =     usb_pcwd_table,
155 };
156
157
158 static void usb_pcwd_intr_done(struct urb *urb)
159 {
160         struct usb_pcwd_private *usb_pcwd = (struct usb_pcwd_private *)urb->context;
161         unsigned char *data = usb_pcwd->intr_buffer;
162         int retval;
163
164         switch (urb->status) {
165         case 0:                 /* success */
166                 break;
167         case -ECONNRESET:       /* unlink */
168         case -ENOENT:
169         case -ESHUTDOWN:
170                 /* this urb is terminated, clean up */
171                 dbg("%s - urb shutting down with status: %d", __FUNCTION__, urb->status);
172                 return;
173         /* -EPIPE:  should clear the halt */
174         default:                /* error */
175                 dbg("%s - nonzero urb status received: %d", __FUNCTION__, urb->status);
176                 goto resubmit;
177         }
178
179         dbg("received following data cmd=0x%02x msb=0x%02x lsb=0x%02x",
180                 data[0], data[1], data[2]);
181
182         usb_pcwd->cmd_command  = data[0];
183         usb_pcwd->cmd_data_msb = data[1];
184         usb_pcwd->cmd_data_lsb = data[2];
185
186         /* notify anyone waiting that the cmd has finished */
187         atomic_set (&usb_pcwd->cmd_received, 1);
188
189 resubmit:
190         retval = usb_submit_urb (urb, GFP_ATOMIC);
191         if (retval)
192                 printk(KERN_ERR PFX "can't resubmit intr, usb_submit_urb failed with result %d\n",
193                         retval);
194 }
195
196 static int usb_pcwd_send_command(struct usb_pcwd_private *usb_pcwd, unsigned char cmd,
197         unsigned char *msb, unsigned char *lsb)
198 {
199         int got_response, count;
200         unsigned char buf[6];
201
202         /* We will not send any commands if the USB PCWD device does not exist */
203         if ((!usb_pcwd) || (!usb_pcwd->exists))
204                 return -1;
205
206         /* The USB PC Watchdog uses a 6 byte report format. The board currently uses
207          * only 3 of the six bytes of the report. */
208         buf[0] = cmd;                   /* Byte 0 = CMD */
209         buf[1] = *msb;                  /* Byte 1 = Data MSB */
210         buf[2] = *lsb;                  /* Byte 2 = Data LSB */
211         buf[3] = buf[4] = buf[5] = 0;   /* All other bytes not used */
212
213         dbg("sending following data cmd=0x%02x msb=0x%02x lsb=0x%02x",
214                 buf[0], buf[1], buf[2]);
215
216         atomic_set (&usb_pcwd->cmd_received, 0);
217
218         if (usb_control_msg(usb_pcwd->udev, usb_sndctrlpipe(usb_pcwd->udev, 0),
219                         HID_REQ_SET_REPORT, HID_DT_REPORT,
220                         0x0200, usb_pcwd->interface_number, buf, sizeof(buf),
221                         USB_COMMAND_TIMEOUT) != sizeof(buf)) {
222                 dbg("usb_pcwd_send_command: error in usb_control_msg for cmd 0x%x 0x%x 0x%x\n", cmd, *msb, *lsb);
223         }
224         /* wait till the usb card processed the command,
225          * with a max. timeout of USB_COMMAND_TIMEOUT */
226         got_response = 0;
227         for (count = 0; (count < USB_COMMAND_TIMEOUT) && (!got_response); count++) {
228                 mdelay(1);
229                 if (atomic_read (&usb_pcwd->cmd_received))
230                         got_response = 1;
231         }
232
233         if ((got_response) && (cmd == usb_pcwd->cmd_command)) {
234                 /* read back response */
235                 *msb = usb_pcwd->cmd_data_msb;
236                 *lsb = usb_pcwd->cmd_data_lsb;
237         }
238
239         return got_response;
240 }
241
242 static int usb_pcwd_start(struct usb_pcwd_private *usb_pcwd)
243 {
244         unsigned char msb = 0x00;
245         unsigned char lsb = 0x00;
246         int retval;
247
248         /* Enable Watchdog */
249         retval = usb_pcwd_send_command(usb_pcwd, CMD_ENABLE_WATCHDOG, &msb, &lsb);
250
251         if ((retval == 0) || (lsb == 0)) {
252                 printk(KERN_ERR PFX "Card did not acknowledge enable attempt\n");
253                 return -1;
254         }
255
256         return 0;
257 }
258
259 static int usb_pcwd_stop(struct usb_pcwd_private *usb_pcwd)
260 {
261         unsigned char msb = 0xA5;
262         unsigned char lsb = 0xC3;
263         int retval;
264
265         /* Disable Watchdog */
266         retval = usb_pcwd_send_command(usb_pcwd, CMD_DISABLE_WATCHDOG, &msb, &lsb);
267
268         if ((retval == 0) || (lsb != 0)) {
269                 printk(KERN_ERR PFX "Card did not acknowledge disable attempt\n");
270                 return -1;
271         }
272
273         return 0;
274 }
275
276 static int usb_pcwd_keepalive(struct usb_pcwd_private *usb_pcwd)
277 {
278         unsigned char dummy;
279
280         /* Re-trigger Watchdog */
281         usb_pcwd_send_command(usb_pcwd, CMD_TRIGGER, &dummy, &dummy);
282
283         return 0;
284 }
285
286 static int usb_pcwd_set_heartbeat(struct usb_pcwd_private *usb_pcwd, int t)
287 {
288         unsigned char msb = t / 256;
289         unsigned char lsb = t % 256;
290
291         if ((t < 0x0001) || (t > 0xFFFF))
292                 return -EINVAL;
293
294         /* Write new heartbeat to watchdog */
295         usb_pcwd_send_command(usb_pcwd, CMD_WRITE_WATCHDOG_TIMEOUT, &msb, &lsb);
296
297         heartbeat = t;
298         return 0;
299 }
300
301 static int usb_pcwd_get_temperature(struct usb_pcwd_private *usb_pcwd, int *temperature)
302 {
303         unsigned char msb, lsb;
304
305         usb_pcwd_send_command(usb_pcwd, CMD_READ_TEMP, &msb, &lsb);
306
307         /*
308          * Convert celsius to fahrenheit, since this was
309          * the decided 'standard' for this return value.
310          */
311         *temperature = (lsb * 9 / 5) + 32;
312
313         return 0;
314 }
315
316 static int usb_pcwd_get_timeleft(struct usb_pcwd_private *usb_pcwd, int *time_left)
317 {
318         unsigned char msb, lsb;
319
320         /* Read the time that's left before rebooting */
321         /* Note: if the board is not yet armed then we will read 0xFFFF */
322         usb_pcwd_send_command(usb_pcwd, CMD_READ_WATCHDOG_TIMEOUT, &msb, &lsb);
323
324         *time_left = (msb << 8) + lsb;
325
326         return 0;
327 }
328
329 /*
330  *      /dev/watchdog handling
331  */
332
333 static ssize_t usb_pcwd_write(struct file *file, const char __user *data,
334                               size_t len, loff_t *ppos)
335 {
336         /* See if we got the magic character 'V' and reload the timer */
337         if (len) {
338                 if (!nowayout) {
339                         size_t i;
340
341                         /* note: just in case someone wrote the magic character
342                          * five months ago... */
343                         expect_release = 0;
344
345                         /* scan to see whether or not we got the magic character */
346                         for (i = 0; i != len; i++) {
347                                 char c;
348                                 if(get_user(c, data+i))
349                                         return -EFAULT;
350                                 if (c == 'V')
351                                         expect_release = 42;
352                         }
353                 }
354
355                 /* someone wrote to us, we should reload the timer */
356                 usb_pcwd_keepalive(usb_pcwd_device);
357         }
358         return len;
359 }
360
361 static int usb_pcwd_ioctl(struct inode *inode, struct file *file,
362                           unsigned int cmd, unsigned long arg)
363 {
364         void __user *argp = (void __user *)arg;
365         int __user *p = argp;
366         static struct watchdog_info ident = {
367                 .options =              WDIOF_KEEPALIVEPING |
368                                         WDIOF_SETTIMEOUT |
369                                         WDIOF_MAGICCLOSE,
370                 .firmware_version =     1,
371                 .identity =             DRIVER_NAME,
372         };
373
374         switch (cmd) {
375                 case WDIOC_GETSUPPORT:
376                         return copy_to_user(argp, &ident,
377                                 sizeof (ident)) ? -EFAULT : 0;
378
379                 case WDIOC_GETSTATUS:
380                 case WDIOC_GETBOOTSTATUS:
381                         return put_user(0, p);
382
383                 case WDIOC_GETTEMP:
384                 {
385                         int temperature;
386
387                         if (usb_pcwd_get_temperature(usb_pcwd_device, &temperature))
388                                 return -EFAULT;
389
390                         return put_user(temperature, p);
391                 }
392
393                 case WDIOC_KEEPALIVE:
394                         usb_pcwd_keepalive(usb_pcwd_device);
395                         return 0;
396
397                 case WDIOC_SETOPTIONS:
398                 {
399                         int new_options, retval = -EINVAL;
400
401                         if (get_user (new_options, p))
402                                 return -EFAULT;
403
404                         if (new_options & WDIOS_DISABLECARD) {
405                                 usb_pcwd_stop(usb_pcwd_device);
406                                 retval = 0;
407                         }
408
409                         if (new_options & WDIOS_ENABLECARD) {
410                                 usb_pcwd_start(usb_pcwd_device);
411                                 retval = 0;
412                         }
413
414                         return retval;
415                 }
416
417                 case WDIOC_SETTIMEOUT:
418                 {
419                         int new_heartbeat;
420
421                         if (get_user(new_heartbeat, p))
422                                 return -EFAULT;
423
424                         if (usb_pcwd_set_heartbeat(usb_pcwd_device, new_heartbeat))
425                             return -EINVAL;
426
427                         usb_pcwd_keepalive(usb_pcwd_device);
428                         /* Fall */
429                 }
430
431                 case WDIOC_GETTIMEOUT:
432                         return put_user(heartbeat, p);
433
434                 case WDIOC_GETTIMELEFT:
435                 {
436                         int time_left;
437
438                         if (usb_pcwd_get_timeleft(usb_pcwd_device, &time_left))
439                                 return -EFAULT;
440
441                         return put_user(time_left, p);
442                 }
443
444                 default:
445                         return -ENOTTY;
446         }
447 }
448
449 static int usb_pcwd_open(struct inode *inode, struct file *file)
450 {
451         /* /dev/watchdog can only be opened once */
452         if (test_and_set_bit(0, &is_active))
453                 return -EBUSY;
454
455         /* Activate */
456         usb_pcwd_start(usb_pcwd_device);
457         usb_pcwd_keepalive(usb_pcwd_device);
458         return nonseekable_open(inode, file);
459 }
460
461 static int usb_pcwd_release(struct inode *inode, struct file *file)
462 {
463         /*
464          *      Shut off the timer.
465          */
466         if (expect_release == 42) {
467                 usb_pcwd_stop(usb_pcwd_device);
468         } else {
469                 printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
470                 usb_pcwd_keepalive(usb_pcwd_device);
471         }
472         expect_release = 0;
473         clear_bit(0, &is_active);
474         return 0;
475 }
476
477 /*
478  *      /dev/temperature handling
479  */
480
481 static ssize_t usb_pcwd_temperature_read(struct file *file, char __user *data,
482                                 size_t len, loff_t *ppos)
483 {
484         int temperature;
485
486         if (usb_pcwd_get_temperature(usb_pcwd_device, &temperature))
487                 return -EFAULT;
488
489         if (copy_to_user(data, &temperature, 1))
490                 return -EFAULT;
491
492         return 1;
493 }
494
495 static int usb_pcwd_temperature_open(struct inode *inode, struct file *file)
496 {
497         return nonseekable_open(inode, file);
498 }
499
500 static int usb_pcwd_temperature_release(struct inode *inode, struct file *file)
501 {
502         return 0;
503 }
504
505 /*
506  *      Notify system
507  */
508
509 static int usb_pcwd_notify_sys(struct notifier_block *this, unsigned long code, void *unused)
510 {
511         if (code==SYS_DOWN || code==SYS_HALT) {
512                 /* Turn the WDT off */
513                 usb_pcwd_stop(usb_pcwd_device);
514         }
515
516         return NOTIFY_DONE;
517 }
518
519 /*
520  *      Kernel Interfaces
521  */
522
523 static const struct file_operations usb_pcwd_fops = {
524         .owner =        THIS_MODULE,
525         .llseek =       no_llseek,
526         .write =        usb_pcwd_write,
527         .ioctl =        usb_pcwd_ioctl,
528         .open =         usb_pcwd_open,
529         .release =      usb_pcwd_release,
530 };
531
532 static struct miscdevice usb_pcwd_miscdev = {
533         .minor =        WATCHDOG_MINOR,
534         .name =         "watchdog",
535         .fops =         &usb_pcwd_fops,
536 };
537
538 static const struct file_operations usb_pcwd_temperature_fops = {
539         .owner =        THIS_MODULE,
540         .llseek =       no_llseek,
541         .read =         usb_pcwd_temperature_read,
542         .open =         usb_pcwd_temperature_open,
543         .release =      usb_pcwd_temperature_release,
544 };
545
546 static struct miscdevice usb_pcwd_temperature_miscdev = {
547         .minor =        TEMP_MINOR,
548         .name =         "temperature",
549         .fops =         &usb_pcwd_temperature_fops,
550 };
551
552 static struct notifier_block usb_pcwd_notifier = {
553         .notifier_call =        usb_pcwd_notify_sys,
554 };
555
556 /**
557  *      usb_pcwd_delete
558  */
559 static inline void usb_pcwd_delete (struct usb_pcwd_private *usb_pcwd)
560 {
561         usb_free_urb(usb_pcwd->intr_urb);
562         if (usb_pcwd->intr_buffer != NULL)
563                 usb_buffer_free(usb_pcwd->udev, usb_pcwd->intr_size,
564                                 usb_pcwd->intr_buffer, usb_pcwd->intr_dma);
565         kfree (usb_pcwd);
566 }
567
568 /**
569  *      usb_pcwd_probe
570  *
571  *      Called by the usb core when a new device is connected that it thinks
572  *      this driver might be interested in.
573  */
574 static int usb_pcwd_probe(struct usb_interface *interface, const struct usb_device_id *id)
575 {
576         struct usb_device *udev = interface_to_usbdev(interface);
577         struct usb_host_interface *iface_desc;
578         struct usb_endpoint_descriptor *endpoint;
579         struct usb_pcwd_private *usb_pcwd = NULL;
580         int pipe, maxp;
581         int retval = -ENOMEM;
582         int got_fw_rev;
583         unsigned char fw_rev_major, fw_rev_minor;
584         char fw_ver_str[20];
585         unsigned char option_switches, dummy;
586
587         cards_found++;
588         if (cards_found > 1) {
589                 printk(KERN_ERR PFX "This driver only supports 1 device\n");
590                 return -ENODEV;
591         }
592
593         /* get the active interface descriptor */
594         iface_desc = interface->cur_altsetting;
595
596         /* check out that we have a HID device */
597         if (!(iface_desc->desc.bInterfaceClass == USB_CLASS_HID)) {
598                 printk(KERN_ERR PFX "The device isn't a Human Interface Device\n");
599                 return -ENODEV;
600         }
601
602         /* check out the endpoint: it has to be Interrupt & IN */
603         endpoint = &iface_desc->endpoint[0].desc;
604
605         if (!((endpoint->bEndpointAddress & USB_DIR_IN) &&
606              ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
607                                 == USB_ENDPOINT_XFER_INT))) {
608                 /* we didn't find a Interrupt endpoint with direction IN */
609                 printk(KERN_ERR PFX "Couldn't find an INTR & IN endpoint\n");
610                 return -ENODEV;
611         }
612
613         /* get a handle to the interrupt data pipe */
614         pipe = usb_rcvintpipe(udev, endpoint->bEndpointAddress);
615         maxp = usb_maxpacket(udev, pipe, usb_pipeout(pipe));
616
617         /* allocate memory for our device and initialize it */
618         usb_pcwd = kmalloc (sizeof(struct usb_pcwd_private), GFP_KERNEL);
619         if (usb_pcwd == NULL) {
620                 printk(KERN_ERR PFX "Out of memory\n");
621                 goto error;
622         }
623         memset (usb_pcwd, 0x00, sizeof (*usb_pcwd));
624
625         usb_pcwd_device = usb_pcwd;
626
627         init_MUTEX (&usb_pcwd->sem);
628         usb_pcwd->udev = udev;
629         usb_pcwd->interface = interface;
630         usb_pcwd->interface_number = iface_desc->desc.bInterfaceNumber;
631         usb_pcwd->intr_size = (le16_to_cpu(endpoint->wMaxPacketSize) > 8 ? le16_to_cpu(endpoint->wMaxPacketSize) : 8);
632
633         /* set up the memory buffer's */
634         if (!(usb_pcwd->intr_buffer = usb_buffer_alloc(udev, usb_pcwd->intr_size, GFP_ATOMIC, &usb_pcwd->intr_dma))) {
635                 printk(KERN_ERR PFX "Out of memory\n");
636                 goto error;
637         }
638
639         /* allocate the urb's */
640         usb_pcwd->intr_urb = usb_alloc_urb(0, GFP_KERNEL);
641         if (!usb_pcwd->intr_urb) {
642                 printk(KERN_ERR PFX "Out of memory\n");
643                 goto error;
644         }
645
646         /* initialise the intr urb's */
647         usb_fill_int_urb(usb_pcwd->intr_urb, udev, pipe,
648                         usb_pcwd->intr_buffer, usb_pcwd->intr_size,
649                         usb_pcwd_intr_done, usb_pcwd, endpoint->bInterval);
650         usb_pcwd->intr_urb->transfer_dma = usb_pcwd->intr_dma;
651         usb_pcwd->intr_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
652
653         /* register our interrupt URB with the USB system */
654         if (usb_submit_urb(usb_pcwd->intr_urb, GFP_KERNEL)) {
655                 printk(KERN_ERR PFX "Problem registering interrupt URB\n");
656                 retval = -EIO; /* failure */
657                 goto error;
658         }
659
660         /* The device exists and can be communicated with */
661         usb_pcwd->exists = 1;
662
663         /* disable card */
664         usb_pcwd_stop(usb_pcwd);
665
666         /* Get the Firmware Version */
667         got_fw_rev = usb_pcwd_send_command(usb_pcwd, CMD_GET_FIRMWARE_VERSION, &fw_rev_major, &fw_rev_minor);
668         if (got_fw_rev) {
669                 sprintf(fw_ver_str, "%u.%02u", fw_rev_major, fw_rev_minor);
670         } else {
671                 sprintf(fw_ver_str, "<card no answer>");
672         }
673
674         printk(KERN_INFO PFX "Found card (Firmware: %s) with temp option\n",
675                 fw_ver_str);
676
677         /* Get switch settings */
678         usb_pcwd_send_command(usb_pcwd, CMD_GET_DIP_SWITCH_SETTINGS, &dummy, &option_switches);
679
680         printk(KERN_INFO PFX "Option switches (0x%02x): Temperature Reset Enable=%s, Power On Delay=%s\n",
681                 option_switches,
682                 ((option_switches & 0x10) ? "ON" : "OFF"),
683                 ((option_switches & 0x08) ? "ON" : "OFF"));
684
685         /* Check that the heartbeat value is within it's range ; if not reset to the default */
686         if (usb_pcwd_set_heartbeat(usb_pcwd, heartbeat)) {
687                 usb_pcwd_set_heartbeat(usb_pcwd, WATCHDOG_HEARTBEAT);
688                 printk(KERN_INFO PFX "heartbeat value must be 0<heartbeat<65536, using %d\n",
689                         WATCHDOG_HEARTBEAT);
690         }
691
692         retval = register_reboot_notifier(&usb_pcwd_notifier);
693         if (retval != 0) {
694                 printk(KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
695                         retval);
696                 goto error;
697         }
698
699         retval = misc_register(&usb_pcwd_temperature_miscdev);
700         if (retval != 0) {
701                 printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
702                         TEMP_MINOR, retval);
703                 goto err_out_unregister_reboot;
704         }
705
706         retval = misc_register(&usb_pcwd_miscdev);
707         if (retval != 0) {
708                 printk(KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
709                         WATCHDOG_MINOR, retval);
710                 goto err_out_misc_deregister;
711         }
712
713         /* we can register the device now, as it is ready */
714         usb_set_intfdata (interface, usb_pcwd);
715
716         printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
717                 heartbeat, nowayout);
718
719         return 0;
720
721 err_out_misc_deregister:
722         misc_deregister(&usb_pcwd_temperature_miscdev);
723 err_out_unregister_reboot:
724         unregister_reboot_notifier(&usb_pcwd_notifier);
725 error:
726         if (usb_pcwd)
727                 usb_pcwd_delete(usb_pcwd);
728         usb_pcwd_device = NULL;
729         return retval;
730 }
731
732
733 /**
734  *      usb_pcwd_disconnect
735  *
736  *      Called by the usb core when the device is removed from the system.
737  *
738  *      This routine guarantees that the driver will not submit any more urbs
739  *      by clearing dev->udev.
740  */
741 static void usb_pcwd_disconnect(struct usb_interface *interface)
742 {
743         struct usb_pcwd_private *usb_pcwd;
744
745         /* prevent races with open() */
746         mutex_lock(&disconnect_mutex);
747
748         usb_pcwd = usb_get_intfdata (interface);
749         usb_set_intfdata (interface, NULL);
750
751         down (&usb_pcwd->sem);
752
753         /* Stop the timer before we leave */
754         if (!nowayout)
755                 usb_pcwd_stop(usb_pcwd);
756
757         /* We should now stop communicating with the USB PCWD device */
758         usb_pcwd->exists = 0;
759
760         /* Deregister */
761         misc_deregister(&usb_pcwd_miscdev);
762         misc_deregister(&usb_pcwd_temperature_miscdev);
763         unregister_reboot_notifier(&usb_pcwd_notifier);
764
765         up (&usb_pcwd->sem);
766
767         /* Delete the USB PCWD device */
768         usb_pcwd_delete(usb_pcwd);
769
770         cards_found--;
771
772         mutex_unlock(&disconnect_mutex);
773
774         printk(KERN_INFO PFX "USB PC Watchdog disconnected\n");
775 }
776
777
778
779 /**
780  *      usb_pcwd_init
781  */
782 static int __init usb_pcwd_init(void)
783 {
784         int result;
785
786         /* register this driver with the USB subsystem */
787         result = usb_register(&usb_pcwd_driver);
788         if (result) {
789                 printk(KERN_ERR PFX "usb_register failed. Error number %d\n",
790                     result);
791                 return result;
792         }
793
794         printk(KERN_INFO PFX DRIVER_DESC " v" DRIVER_VERSION " (" DRIVER_DATE ")\n");
795         return 0;
796 }
797
798
799 /**
800  *      usb_pcwd_exit
801  */
802 static void __exit usb_pcwd_exit(void)
803 {
804         /* deregister this driver with the USB subsystem */
805         usb_deregister(&usb_pcwd_driver);
806 }
807
808
809 module_init (usb_pcwd_init);
810 module_exit (usb_pcwd_exit);