Пример #1
0
static int acq_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
                     unsigned long arg)
{
    static struct watchdog_info ident=
    {
        WDIOF_KEEPALIVEPING, 1, "Acquire WDT"
    };

    switch(cmd)
    {
    case WDIOC_GETSUPPORT:
        if (copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident)))
            return -EFAULT;
        break;

    case WDIOC_GETSTATUS:
        if (copy_to_user((int *)arg, &acq_is_open,  sizeof(int)))
            return -EFAULT;
        break;

    case WDIOC_KEEPALIVE:
        acq_ping();
        break;

    default:
        return -ENOTTY;
    }
    return 0;
}
Пример #2
0
static ssize_t acq_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
{
	/*  Can't seek (pwrite) on this device  */
	if (ppos != &file->f_pos)
		return -ESPIPE;

	/* See if we got the magic character 'V' and reload the timer */
	if(count) {
		if (!nowayout) {
			size_t i;

			/* note: just in case someone wrote the magic character
			 * five months ago... */
			expect_close = 0;

			/* scan to see wether or not we got the magic character */
			for (i = 0; i != count; i++) {
				char c;
				if (get_user(c, buf + i))
					return -EFAULT;
				if (c == 'V')
					expect_close = 42;
			}
		}

		/* Well, anyhow someone wrote to us, we should return that favour */
		acq_ping();
	}
	return count;
}
Пример #3
0
static ssize_t acq_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
{
	/*  Can't seek (pwrite) on this device  */
	if (ppos != &file->f_pos)
		return -ESPIPE;

	if(count)
	{
		if (!nowayout)
		{
			size_t i;

			expect_close = 0;

			for (i = 0; i != count; i++) {
				char c;
				if (get_user(c, buf + i))
					return -EFAULT;
				if (c == 'V')
					expect_close = 1;
			}
		}

		acq_ping();
		return 1;
	}
	return 0;
}
Пример #4
0
static ssize_t acq_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
{
    /*  Can't seek (pwrite) on this device  */
    if (ppos != &file->f_pos)
        return -ESPIPE;

    if(count)
    {
        acq_ping();
        return 1;
    }
    return 0;
}
Пример #5
0
static int acq_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
	unsigned long arg)
{
	static struct watchdog_info ident =
	{
		.options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
		.firmware_version = 1,
		.identity = "Acquire WDT",
	};

	switch(cmd)
	{
	case WDIOC_GETSUPPORT:
	  return copy_to_user((struct watchdog_info *)arg, &ident, sizeof(ident)) ? -EFAULT : 0;

	case WDIOC_GETSTATUS:
	case WDIOC_GETBOOTSTATUS:
	  return put_user(0, (int *)arg);

	case WDIOC_KEEPALIVE:
	  acq_ping();
	  return 0;

	case WDIOC_GETTIMEOUT:
	  return put_user(WATCHDOG_TIMEOUT, (int *)arg);

	case WDIOC_SETOPTIONS:
	{
	    int options, retval = -EINVAL;

	    if (get_user(options, (int *)arg))
	      return -EFAULT;

	    if (options & WDIOS_DISABLECARD)
	    {
	      acq_stop();
	      retval = 0;
	    }

	    if (options & WDIOS_ENABLECARD)
	    {
	      acq_ping();
	      retval = 0;
	    }

	    return retval;
	}

	default:
	  return -ENOIOCTLCMD;
	}
}

static int acq_open(struct inode *inode, struct file *file)
{
	if (test_and_set_bit(0, &acq_is_open))
		return -EBUSY;

	if (nowayout)
		__module_get(THIS_MODULE);

	/* Activate */
	acq_ping();
	return 0;
}

static int acq_close(struct inode *inode, struct file *file)
{
	if (expect_close == 42) {
		acq_stop();
	} else {
		printk(KERN_CRIT PFX "Unexpected close, not stopping watchdog!\n");
		acq_ping();
	}
	clear_bit(0, &acq_is_open);
	expect_close = 0;
	return 0;
}

/*
 *	Notifier for system down
 */

static int acq_notify_sys(struct notifier_block *this, unsigned long code,
	void *unused)
{
	if(code==SYS_DOWN || code==SYS_HALT) {
		/* Turn the WDT off */
		acq_stop();
	}
	return NOTIFY_DONE;
}

/*
 *	Kernel Interfaces
 */

static struct file_operations acq_fops = {
	.owner		= THIS_MODULE,
	.llseek		= no_llseek,
	.write		= acq_write,
	.ioctl		= acq_ioctl,
	.open		= acq_open,
	.release	= acq_close,
};

static struct miscdevice acq_miscdev=
{
	.minor = WATCHDOG_MINOR,
	.name = "watchdog",
	.fops = &acq_fops,
};

/*
 *	The WDT card needs to learn about soft shutdowns in order to
 *	turn the timebomb registers off.
 */

static struct notifier_block acq_notifier =
{
	.notifier_call = acq_notify_sys,
	.next = NULL,
	.priority = 0,
};

static int __init acq_init(void)
{
	int ret;

	printk(KERN_INFO "WDT driver for Acquire single board computer initialising.\n");

	if (wdt_stop != wdt_start) {
		if (!request_region(wdt_stop, 1, WATCHDOG_NAME)) {
			printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
				wdt_stop);
			ret = -EIO;
			goto out;
		}
	}

	if (!request_region(wdt_start, 1, WATCHDOG_NAME)) {
		printk (KERN_ERR PFX "I/O address 0x%04x already in use\n",
			wdt_start);
		ret = -EIO;
		goto unreg_stop;
	}

        ret = register_reboot_notifier(&acq_notifier);
        if (ret != 0) {
                printk (KERN_ERR PFX "cannot register reboot notifier (err=%d)\n",
                        ret);
                goto unreg_regions;
        }
                                                                                                 
        ret = misc_register(&acq_miscdev);
        if (ret != 0) {
                printk (KERN_ERR PFX "cannot register miscdev on minor=%d (err=%d)\n",
                        WATCHDOG_MINOR, ret);
                goto unreg_reboot;
        }
                                                                                                 
        printk (KERN_INFO PFX "initialized. (nowayout=%d)\n",
                nowayout);
                                                                                                 
out:
        return ret;
unreg_reboot:
        unregister_reboot_notifier(&acq_notifier);
unreg_regions:
        release_region(wdt_start, 1);
unreg_stop:
        if (wdt_stop != wdt_start)
                release_region(wdt_stop, 1);
        goto out;
}

static void __exit acq_exit(void)
{
	misc_deregister(&acq_miscdev);
	unregister_reboot_notifier(&acq_notifier);
	if(wdt_stop != wdt_start)
		release_region(wdt_stop,1);
	release_region(wdt_start,1);
}

module_init(acq_init);
module_exit(acq_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Unkown");
MODULE_DESCRIPTION("Acquire Single Board Computer Watchdog Timer driver");