]> pilppa.org Git - linux-2.6-omap-h63xx.git/blobdiff - drivers/input/evdev.c
Merge watchdog driver updates
[linux-2.6-omap-h63xx.git] / drivers / input / evdev.c
index c1c220fcb7630eef17a807f9717ec0471a41a0f2..f8b278d3559bc2b3553d8949192ee1ce6494bc78 100644 (file)
@@ -160,6 +160,8 @@ struct input_event_compat {
 #  define COMPAT_TEST IS_IA32_PROCESS(ia64_task_regs(current))
 #elif defined(CONFIG_ARCH_S390)
 #  define COMPAT_TEST test_thread_flag(TIF_31BIT)
+#elif defined(CONFIG_MIPS)
+#  define COMPAT_TEST (current->thread.mflags & MF_32BIT_ADDR)
 #else
 #  define COMPAT_TEST test_thread_flag(TIF_32BIT)
 #endif
@@ -236,7 +238,7 @@ static ssize_t evdev_read_compat(struct file * file, char __user * buffer, size_
                event_compat.value = event->value;
 
                if (copy_to_user(buffer + retval, &event_compat,
-                        sizeof(struct input_event_compat))) return -EFAULT;
+                       sizeof(struct input_event_compat))) return -EFAULT;
                list->tail = (list->tail + 1) & (EVDEV_BUFFER_SIZE - 1);
                retval += sizeof(struct input_event_compat);
        }
@@ -272,7 +274,7 @@ static ssize_t evdev_read(struct file * file, char __user * buffer, size_t count
 
        while (list->head != list->tail && retval + sizeof(struct input_event) <= count) {
                if (copy_to_user(buffer + retval, list->buffer + list->tail,
-                        sizeof(struct input_event))) return -EFAULT;
+                       sizeof(struct input_event))) return -EFAULT;
                list->tail = (list->tail + 1) & (EVDEV_BUFFER_SIZE - 1);
                retval += sizeof(struct input_event);
        }
@@ -320,6 +322,7 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                        if (t < 0 || t >= dev->keycodemax || !dev->keycodesize) return -EINVAL;
                        if (get_user(v, ip + 1)) return -EFAULT;
                        if (v < 0 || v > KEY_MAX) return -EINVAL;
+                       if (v >> (dev->keycodesize * 8)) return -EINVAL;
                        u = SET_INPUT_KEYCODE(dev, t, v);
                        clear_bit(u, dev->keybit);
                        set_bit(v, dev->keybit);
@@ -371,105 +374,112 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 
                default:
 
-                       if (_IOC_TYPE(cmd) != 'E' || _IOC_DIR(cmd) != _IOC_READ)
+                       if (_IOC_TYPE(cmd) != 'E')
                                return -EINVAL;
 
-                       if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {
-
-                               long *bits;
-                               int len;
-
-                               switch (_IOC_NR(cmd) & EV_MAX) {
-                                       case      0: bits = dev->evbit;  len = EV_MAX;  break;
-                                       case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
-                                       case EV_REL: bits = dev->relbit; len = REL_MAX; break;
-                                       case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
-                                       case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
-                                       case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
-                                       case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
-                                       case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
-                                       default: return -EINVAL;
+                       if (_IOC_DIR(cmd) == _IOC_READ) {
+
+                               if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {
+
+                                       long *bits;
+                                       int len;
+
+                                       switch (_IOC_NR(cmd) & EV_MAX) {
+                                               case      0: bits = dev->evbit;  len = EV_MAX;  break;
+                                               case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
+                                               case EV_REL: bits = dev->relbit; len = REL_MAX; break;
+                                               case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
+                                               case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
+                                               case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
+                                               case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
+                                               case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
+                                               default: return -EINVAL;
+                                       }
+                                       len = NBITS(len) * sizeof(long);
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, bits, len) ? -EFAULT : len;
                                }
-                               len = NBITS(len) * sizeof(long);
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, bits, len) ? -EFAULT : len;
-                       }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0))) {
-                               int len;
-                               len = NBITS(KEY_MAX) * sizeof(long);
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->key, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0))) {
+                                       int len;
+                                       len = NBITS(KEY_MAX) * sizeof(long);
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->key, len) ? -EFAULT : len;
+                               }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0))) {
-                               int len;
-                               len = NBITS(LED_MAX) * sizeof(long);
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->led, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0))) {
+                                       int len;
+                                       len = NBITS(LED_MAX) * sizeof(long);
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->led, len) ? -EFAULT : len;
+                               }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0))) {
-                               int len;
-                               len = NBITS(SND_MAX) * sizeof(long);
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->snd, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0))) {
+                                       int len;
+                                       len = NBITS(SND_MAX) * sizeof(long);
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->snd, len) ? -EFAULT : len;
+                               }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {
-                               int len;
-                               if (!dev->name) return -ENOENT;
-                               len = strlen(dev->name) + 1;
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->name, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {
+                                       int len;
+                                       if (!dev->name) return -ENOENT;
+                                       len = strlen(dev->name) + 1;
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->name, len) ? -EFAULT : len;
+                               }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) {
-                               int len;
-                               if (!dev->phys) return -ENOENT;
-                               len = strlen(dev->phys) + 1;
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->phys, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) {
+                                       int len;
+                                       if (!dev->phys) return -ENOENT;
+                                       len = strlen(dev->phys) + 1;
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->phys, len) ? -EFAULT : len;
+                               }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) {
-                               int len;
-                               if (!dev->uniq) return -ENOENT;
-                               len = strlen(dev->uniq) + 1;
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->uniq, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) {
+                                       int len;
+                                       if (!dev->uniq) return -ENOENT;
+                                       len = strlen(dev->uniq) + 1;
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->uniq, len) ? -EFAULT : len;
+                               }
 
-                       if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
+                               if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
 
-                               int t = _IOC_NR(cmd) & ABS_MAX;
+                                       int t = _IOC_NR(cmd) & ABS_MAX;
 
-                               abs.value = dev->abs[t];
-                               abs.minimum = dev->absmin[t];
-                               abs.maximum = dev->absmax[t];
-                               abs.fuzz = dev->absfuzz[t];
-                               abs.flat = dev->absflat[t];
+                                       abs.value = dev->abs[t];
+                                       abs.minimum = dev->absmin[t];
+                                       abs.maximum = dev->absmax[t];
+                                       abs.fuzz = dev->absfuzz[t];
+                                       abs.flat = dev->absflat[t];
 
-                               if (copy_to_user(p, &abs, sizeof(struct input_absinfo)))
-                                       return -EFAULT;
+                                       if (copy_to_user(p, &abs, sizeof(struct input_absinfo)))
+                                               return -EFAULT;
+
+                                       return 0;
+                               }
 
-                               return 0;
                        }
 
-                       if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
+                       if (_IOC_DIR(cmd) == _IOC_WRITE) {
 
-                               int t = _IOC_NR(cmd) & ABS_MAX;
+                               if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
 
-                               if (copy_from_user(&abs, p, sizeof(struct input_absinfo)))
-                                       return -EFAULT;
+                                       int t = _IOC_NR(cmd) & ABS_MAX;
+
+                                       if (copy_from_user(&abs, p, sizeof(struct input_absinfo)))
+                                               return -EFAULT;
 
-                               dev->abs[t] = abs.value;
-                               dev->absmin[t] = abs.minimum;
-                               dev->absmax[t] = abs.maximum;
-                               dev->absfuzz[t] = abs.fuzz;
-                               dev->absflat[t] = abs.flat;
+                                       dev->abs[t] = abs.value;
+                                       dev->absmin[t] = abs.minimum;
+                                       dev->absmax[t] = abs.maximum;
+                                       dev->absfuzz[t] = abs.fuzz;
+                                       dev->absflat[t] = abs.flat;
 
-                               return 0;
+                                       return 0;
+                               }
                        }
        }
        return -EINVAL;
@@ -484,6 +494,28 @@ static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 #define LONG_COMPAT(x) ((x)/BITS_PER_LONG_COMPAT)
 #define test_bit_compat(bit, array) ((array[LONG_COMPAT(bit)] >> OFF_COMPAT(bit)) & 1)
 
+#ifdef __BIG_ENDIAN
+#define bit_to_user(bit, max) \
+do { \
+       int i; \
+       int len = NBITS_COMPAT((max)) * sizeof(compat_long_t); \
+       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd); \
+       for (i = 0; i < len / sizeof(compat_long_t); i++) \
+               if (copy_to_user((compat_long_t*) p + i, \
+                                (compat_long_t*) (bit) + i + 1 - ((i % 2) << 1), \
+                                sizeof(compat_long_t))) \
+                       return -EFAULT; \
+       return len; \
+} while (0)
+#else
+#define bit_to_user(bit, max) \
+do { \
+       int len = NBITS_COMPAT((max)) * sizeof(compat_long_t); \
+       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd); \
+       return copy_to_user(p, (bit), len) ? -EFAULT : len; \
+} while (0)
+#endif
+
 static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
 {
        struct evdev_list *list = file->private_data;
@@ -491,9 +523,6 @@ static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned lon
        struct input_dev *dev = evdev->handle.dev;
        struct input_absinfo abs;
        void __user *p = compat_ptr(arg);
-#ifdef __BIG_ENDIAN
-       int i;
-#endif
 
        if (!evdev->exist) return -ENODEV;
 
@@ -511,141 +540,96 @@ static long evdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned lon
 
                default:
 
-                       if (_IOC_TYPE(cmd) != 'E' || _IOC_DIR(cmd) != _IOC_READ)
+                       if (_IOC_TYPE(cmd) != 'E')
                                return -EINVAL;
 
-                       if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {
-
-                               long *bits;
-                               int len;
-
-                               switch (_IOC_NR(cmd) & EV_MAX) {
-                                       case      0: bits = dev->evbit;  len = EV_MAX;  break;
-                                       case EV_KEY: bits = dev->keybit; len = KEY_MAX; break;
-                                       case EV_REL: bits = dev->relbit; len = REL_MAX; break;
-                                       case EV_ABS: bits = dev->absbit; len = ABS_MAX; break;
-                                       case EV_MSC: bits = dev->mscbit; len = MSC_MAX; break;
-                                       case EV_LED: bits = dev->ledbit; len = LED_MAX; break;
-                                       case EV_SND: bits = dev->sndbit; len = SND_MAX; break;
-                                       case EV_FF:  bits = dev->ffbit;  len = FF_MAX;  break;
-                                       default: return -EINVAL;
+                       if (_IOC_DIR(cmd) == _IOC_READ) {
+
+                               if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0,0))) {
+                                       long *bits;
+                                       int max;
+
+                                       switch (_IOC_NR(cmd) & EV_MAX) {
+                                               case      0: bits = dev->evbit;  max = EV_MAX;  break;
+                                               case EV_KEY: bits = dev->keybit; max = KEY_MAX; break;
+                                               case EV_REL: bits = dev->relbit; max = REL_MAX; break;
+                                               case EV_ABS: bits = dev->absbit; max = ABS_MAX; break;
+                                               case EV_MSC: bits = dev->mscbit; max = MSC_MAX; break;
+                                               case EV_LED: bits = dev->ledbit; max = LED_MAX; break;
+                                               case EV_SND: bits = dev->sndbit; max = SND_MAX; break;
+                                               case EV_FF:  bits = dev->ffbit;  max = FF_MAX;  break;
+                                               default: return -EINVAL;
+                                       }
+                                       bit_to_user(bits, max);
                                }
-                               len = NBITS_COMPAT(len) * sizeof(compat_long_t);
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-#ifdef __BIG_ENDIAN
-                               for (i = 0; i < len / sizeof(compat_long_t); i++)
-                                       if (copy_to_user((compat_long_t*) p + i,
-                                                        (compat_long_t*) bits + i + 1 - ((i % 2) << 1),
-                                                        sizeof(compat_long_t)))
-                                               return -EFAULT;
-                               return len;
-#else
-                               return copy_to_user(p, bits, len) ? -EFAULT : len;
-#endif
-                       }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0))) {
-                               int len;
-                               len = NBITS_COMPAT(KEY_MAX) * sizeof(compat_long_t);
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-#ifdef __BIG_ENDIAN
-                               for (i = 0; i < len / sizeof(compat_long_t); i++)
-                                       if (copy_to_user((compat_long_t*) p + i,
-                                                        (compat_long_t*) dev->key + i + 1 - ((i % 2) << 1),
-                                                        sizeof(compat_long_t)))
-                                               return -EFAULT;
-                               return len;
-#else
-                               return copy_to_user(p, dev->key, len) ? -EFAULT : len;
-#endif
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGKEY(0)))
+                                       bit_to_user(dev->key, KEY_MAX);
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0))) {
-                               int len;
-                               len = NBITS_COMPAT(LED_MAX) * sizeof(compat_long_t);
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-#ifdef __BIG_ENDIAN
-                               for (i = 0; i < len / sizeof(compat_long_t); i++)
-                                       if (copy_to_user((compat_long_t*) p + i,
-                                                        (compat_long_t*) dev->led + i + 1 - ((i % 2) << 1),
-                                                        sizeof(compat_long_t)))
-                                               return -EFAULT;
-                               return len;
-#else
-                               return copy_to_user(p, dev->led, len) ? -EFAULT : len;
-#endif
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGLED(0)))
+                                       bit_to_user(dev->led, LED_MAX);
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0))) {
-                               int len;
-                               len = NBITS_COMPAT(SND_MAX) * sizeof(compat_long_t);
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-#ifdef __BIG_ENDIAN
-                               for (i = 0; i < len / sizeof(compat_long_t); i++)
-                                       if (copy_to_user((compat_long_t*) p + i,
-                                                        (compat_long_t*) dev->snd + i + 1 - ((i % 2) << 1),
-                                                        sizeof(compat_long_t)))
-                                               return -EFAULT;
-                               return len;
-#else
-                               return copy_to_user(p, dev->snd, len) ? -EFAULT : len;
-#endif
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGSND(0)))
+                                       bit_to_user(dev->snd, SND_MAX);
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {
-                               int len;
-                               if (!dev->name) return -ENOENT;
-                               len = strlen(dev->name) + 1;
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->name, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGNAME(0))) {
+                                       int len;
+                                       if (!dev->name) return -ENOENT;
+                                       len = strlen(dev->name) + 1;
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->name, len) ? -EFAULT : len;
+                               }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) {
-                               int len;
-                               if (!dev->phys) return -ENOENT;
-                               len = strlen(dev->phys) + 1;
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->phys, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGPHYS(0))) {
+                                       int len;
+                                       if (!dev->phys) return -ENOENT;
+                                       len = strlen(dev->phys) + 1;
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->phys, len) ? -EFAULT : len;
+                               }
 
-                       if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) {
-                               int len;
-                               if (!dev->uniq) return -ENOENT;
-                               len = strlen(dev->uniq) + 1;
-                               if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
-                               return copy_to_user(p, dev->uniq, len) ? -EFAULT : len;
-                       }
+                               if (_IOC_NR(cmd) == _IOC_NR(EVIOCGUNIQ(0))) {
+                                       int len;
+                                       if (!dev->uniq) return -ENOENT;
+                                       len = strlen(dev->uniq) + 1;
+                                       if (len > _IOC_SIZE(cmd)) len = _IOC_SIZE(cmd);
+                                       return copy_to_user(p, dev->uniq, len) ? -EFAULT : len;
+                               }
 
-                       if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
+                               if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
 
-                               int t = _IOC_NR(cmd) & ABS_MAX;
+                                       int t = _IOC_NR(cmd) & ABS_MAX;
 
-                               abs.value = dev->abs[t];
-                               abs.minimum = dev->absmin[t];
-                               abs.maximum = dev->absmax[t];
-                               abs.fuzz = dev->absfuzz[t];
-                               abs.flat = dev->absflat[t];
+                                       abs.value = dev->abs[t];
+                                       abs.minimum = dev->absmin[t];
+                                       abs.maximum = dev->absmax[t];
+                                       abs.fuzz = dev->absfuzz[t];
+                                       abs.flat = dev->absflat[t];
 
-                               if (copy_to_user(p, &abs, sizeof(struct input_absinfo)))
-                                       return -EFAULT;
+                                       if (copy_to_user(p, &abs, sizeof(struct input_absinfo)))
+                                               return -EFAULT;
 
-                               return 0;
+                                       return 0;
+                               }
                        }
 
-                       if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
+                       if (_IOC_DIR(cmd) == _IOC_WRITE) {
 
-                               int t = _IOC_NR(cmd) & ABS_MAX;
+                               if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
 
-                               if (copy_from_user(&abs, p, sizeof(struct input_absinfo)))
-                                       return -EFAULT;
+                                       int t = _IOC_NR(cmd) & ABS_MAX;
 
-                               dev->abs[t] = abs.value;
-                               dev->absmin[t] = abs.minimum;
-                               dev->absmax[t] = abs.maximum;
-                               dev->absfuzz[t] = abs.fuzz;
-                               dev->absflat[t] = abs.flat;
+                                       if (copy_from_user(&abs, p, sizeof(struct input_absinfo)))
+                                               return -EFAULT;
 
-                               return 0;
+                                       dev->abs[t] = abs.value;
+                                       dev->absmin[t] = abs.minimum;
+                                       dev->absmax[t] = abs.maximum;
+                                       dev->absfuzz[t] = abs.fuzz;
+                                       dev->absflat[t] = abs.flat;
+
+                                       return 0;
+                               }
                        }
        }
        return -EINVAL;
@@ -697,9 +681,9 @@ static struct input_handle *evdev_connect(struct input_handler *handler, struct
 
        devfs_mk_cdev(MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
                        S_IFCHR|S_IRUGO|S_IWUSR, "input/event%d", minor);
-       class_simple_device_add(input_class,
-                               MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
-                               dev->dev, "event%d", minor);
+       class_device_create(input_class,
+                       MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
+                       dev->dev, "event%d", minor);
 
        return &evdev->handle;
 }
@@ -709,7 +693,8 @@ static void evdev_disconnect(struct input_handle *handle)
        struct evdev *evdev = handle->private;
        struct evdev_list *list;
 
-       class_simple_device_remove(MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + evdev->minor));
+       class_device_destroy(input_class,
+                       MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + evdev->minor));
        devfs_remove("input/event%d", evdev->minor);
        evdev->exist = 0;