#include <linux/parport.h>
#include <linux/ctype.h>
#include <linux/poll.h>
-#include <asm/uaccess.h>
+#include <linux/major.h>
#include <linux/ppdev.h>
#include <linux/smp_lock.h>
#include <linux/device.h>
+#include <asm/uaccess.h>
#define PP_VERSION "ppdev: user-space parallel port driver"
#define CHRDEV "ppdev"
port->ops->enable_irq (port);
}
-static ssize_t pp_read (struct file * file, char * buf, size_t count,
+static ssize_t pp_read (struct file * file, char __user * buf, size_t count,
loff_t * ppos)
{
unsigned int minor = iminor(file->f_dentry->d_inode);
return bytes_read;
}
-static ssize_t pp_write (struct file * file, const char * buf, size_t count,
- loff_t * ppos)
+static ssize_t pp_write (struct file * file, const char __user * buf,
+ size_t count, loff_t * ppos)
{
unsigned int minor = iminor(file->f_dentry->d_inode);
struct pp_struct *pp = file->private_data;
unsigned int minor = iminor(inode);
struct pp_struct *pp = file->private_data;
struct parport * port;
+ void __user *argp = (void __user *)arg;
/* First handle the cases that don't take arguments. */
switch (cmd) {
case PPSETMODE:
{
int mode;
- if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
+ if (copy_from_user (&mode, argp, sizeof (mode)))
return -EFAULT;
/* FIXME: validate mode */
pp->state.mode = mode;
} else {
mode = pp->state.mode;
}
- if (copy_to_user ((int *)arg, &mode, sizeof (mode))) {
+ if (copy_to_user (argp, &mode, sizeof (mode))) {
return -EFAULT;
}
return 0;
case PPSETPHASE:
{
int phase;
- if (copy_from_user (&phase, (int *) arg, sizeof (phase))) {
+ if (copy_from_user (&phase, argp, sizeof (phase))) {
return -EFAULT;
}
/* FIXME: validate phase */
} else {
phase = pp->state.phase;
}
- if (copy_to_user ((int *)arg, &phase, sizeof (phase))) {
+ if (copy_to_user (argp, &phase, sizeof (phase))) {
return -EFAULT;
}
return 0;
return -ENODEV;
modes = port->modes;
- if (copy_to_user ((unsigned int *)arg, &modes, sizeof (modes))) {
+ if (copy_to_user (argp, &modes, sizeof (modes))) {
return -EFAULT;
}
return 0;
{
int uflags;
- if (copy_from_user (&uflags, (int *)arg, sizeof (uflags))) {
+ if (copy_from_user (&uflags, argp, sizeof (uflags))) {
return -EFAULT;
}
pp->flags &= ~PP_FLAGMASK;
int uflags;
uflags = pp->flags & PP_FLAGMASK;
- if (copy_to_user ((int *)arg, &uflags, sizeof (uflags))) {
+ if (copy_to_user (argp, &uflags, sizeof (uflags))) {
return -EFAULT;
}
return 0;
case PPRSTATUS:
reg = parport_read_status (port);
- if (copy_to_user ((unsigned char *) arg, ®, sizeof (reg)))
+ if (copy_to_user (argp, ®, sizeof (reg)))
return -EFAULT;
return 0;
case PPRDATA:
reg = parport_read_data (port);
- if (copy_to_user ((unsigned char *) arg, ®, sizeof (reg)))
+ if (copy_to_user (argp, ®, sizeof (reg)))
return -EFAULT;
return 0;
case PPRCONTROL:
reg = parport_read_control (port);
- if (copy_to_user ((unsigned char *) arg, ®, sizeof (reg)))
+ if (copy_to_user (argp, ®, sizeof (reg)))
return -EFAULT;
return 0;
case PPYIELD:
return 0;
case PPWCONTROL:
- if (copy_from_user (®, (unsigned char *) arg, sizeof (reg)))
+ if (copy_from_user (®, argp, sizeof (reg)))
return -EFAULT;
parport_write_control (port, reg);
return 0;
case PPWDATA:
- if (copy_from_user (®, (unsigned char *) arg, sizeof (reg)))
+ if (copy_from_user (®, argp, sizeof (reg)))
return -EFAULT;
parport_write_data (port, reg);
return 0;
case PPFCONTROL:
- if (copy_from_user (&mask, (unsigned char *) arg,
+ if (copy_from_user (&mask, argp,
sizeof (mask)))
return -EFAULT;
- if (copy_from_user (®, 1 + (unsigned char *) arg,
+ if (copy_from_user (®, 1 + (unsigned char __user *) arg,
sizeof (reg)))
return -EFAULT;
parport_frob_control (port, mask, reg);
return 0;
case PPDATADIR:
- if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
+ if (copy_from_user (&mode, argp, sizeof (mode)))
return -EFAULT;
if (mode)
port->ops->data_reverse (port);
return 0;
case PPNEGOT:
- if (copy_from_user (&mode, (int *) arg, sizeof (mode)))
+ if (copy_from_user (&mode, argp, sizeof (mode)))
return -EFAULT;
switch ((ret = parport_negotiate (port, mode))) {
case 0: break;
return ret;
case PPWCTLONIRQ:
- if (copy_from_user (®, (unsigned char *) arg,
- sizeof (reg)))
+ if (copy_from_user (®, argp, sizeof (reg)))
return -EFAULT;
/* Remember what to set the control lines to, for next
case PPCLRIRQ:
ret = atomic_read (&pp->irqc);
- if (copy_to_user ((int *) arg, &ret, sizeof (ret)))
+ if (copy_to_user (argp, &ret, sizeof (ret)))
return -EFAULT;
atomic_sub (ret, &pp->irqc);
return 0;
case PPSETTIME:
- if (copy_from_user (&par_timeout, (struct timeval *)arg,
- sizeof(struct timeval))) {
+ if (copy_from_user (&par_timeout, argp, sizeof(struct timeval))) {
return -EFAULT;
}
/* Convert to jiffies, place in pp->pdev->timeout */
to_jiffies = pp->pdev->timeout;
par_timeout.tv_sec = to_jiffies / HZ;
par_timeout.tv_usec = (to_jiffies % (long)HZ) * (1000000/HZ);
- if (copy_to_user ((struct timeval *)arg, &par_timeout,
- sizeof(struct timeval))) {
+ if (copy_to_user (argp, &par_timeout, sizeof(struct timeval)))
return -EFAULT;
- }
return 0;
default:
return mask;
}
-static struct class_simple *ppdev_class;
+static struct class *ppdev_class;
static struct file_operations pp_fops = {
.owner = THIS_MODULE,
static void pp_attach(struct parport *port)
{
- class_simple_device_add(ppdev_class, MKDEV(PP_MAJOR, port->number),
+ class_device_create(ppdev_class, NULL, MKDEV(PP_MAJOR, port->number),
NULL, "parport%d", port->number);
}
static void pp_detach(struct parport *port)
{
- class_simple_device_remove(MKDEV(PP_MAJOR, port->number));
+ class_device_destroy(ppdev_class, MKDEV(PP_MAJOR, port->number));
}
static struct parport_driver pp_driver = {
PP_MAJOR);
return -EIO;
}
- ppdev_class = class_simple_create(THIS_MODULE, CHRDEV);
+ ppdev_class = class_create(THIS_MODULE, CHRDEV);
if (IS_ERR(ppdev_class)) {
err = PTR_ERR(ppdev_class);
goto out_chrdev;
for (i = 0; i < PARPORT_MAX; i++)
devfs_remove("parports/%d", i);
devfs_remove("parports");
- class_simple_destroy(ppdev_class);
+ class_destroy(ppdev_class);
out_chrdev:
unregister_chrdev(PP_MAJOR, CHRDEV);
out:
devfs_remove("parports/%d", i);
parport_unregister_driver(&pp_driver);
devfs_remove("parports");
- class_simple_destroy(ppdev_class);
+ class_destroy(ppdev_class);
unregister_chrdev (PP_MAJOR, CHRDEV);
}