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