Use input_get_drvdata() and input_set_drvdata() instead.
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
 
 static int usb_acecad_open(struct input_dev *dev)
 {
-       struct usb_acecad *acecad = dev->private;
+       struct usb_acecad *acecad = input_get_drvdata(dev);
 
        acecad->irq->dev = acecad->usbdev;
        if (usb_submit_urb(acecad->irq, GFP_KERNEL))
 
 static void usb_acecad_close(struct input_dev *dev)
 {
-       struct usb_acecad *acecad = dev->private;
+       struct usb_acecad *acecad = input_get_drvdata(dev);
 
        usb_kill_urb(acecad->irq);
 }
        input_dev->phys = acecad->phys;
        usb_to_input_id(dev, &input_dev->id);
        input_dev->cdev.dev = &intf->dev;
-       input_dev->private = acecad;
+
+       input_set_drvdata(input_dev, acecad);
 
        input_dev->open = usb_acecad_open;
        input_dev->close = usb_acecad_close;
 
  */
 static int aiptek_open(struct input_dev *inputdev)
 {
-       struct aiptek *aiptek = inputdev->private;
+       struct aiptek *aiptek = input_get_drvdata(inputdev);
 
        aiptek->urb->dev = aiptek->usbdev;
        if (usb_submit_urb(aiptek->urb, GFP_KERNEL) != 0)
  */
 static void aiptek_close(struct input_dev *inputdev)
 {
-       struct aiptek *aiptek = inputdev->private;
+       struct aiptek *aiptek = input_get_drvdata(inputdev);
 
        usb_kill_urb(aiptek->urb);
 }
        inputdev->phys = aiptek->features.usbPath;
        usb_to_input_id(usbdev, &inputdev->id);
        inputdev->cdev.dev = &intf->dev;
-       inputdev->private = aiptek;
+
+       input_set_drvdata(inputdev, aiptek);
+
        inputdev->open = aiptek_open;
        inputdev->close = aiptek_close;
 
 
 
 static int atp_open(struct input_dev *input)
 {
-       struct atp *dev = input->private;
+       struct atp *dev = input_get_drvdata(input);
 
        if (usb_submit_urb(dev->urb, GFP_ATOMIC))
                return -EIO;
 
 static void atp_close(struct input_dev *input)
 {
-       struct atp *dev = input->private;
+       struct atp *dev = input_get_drvdata(input);
 
        usb_kill_urb(dev->urb);
        dev->open = 0;
        usb_to_input_id(dev->udev, &input_dev->id);
        input_dev->cdev.dev = &iface->dev;
 
-       input_dev->private = dev;
+       input_set_drvdata(input_dev, dev);
+
        input_dev->open = atp_open;
        input_dev->close = atp_close;
 
 
  */
 static int ati_remote_open(struct input_dev *inputdev)
 {
-       struct ati_remote *ati_remote = inputdev->private;
+       struct ati_remote *ati_remote = input_get_drvdata(inputdev);
 
        /* On first open, submit the read urb which was set up previously. */
        ati_remote->irq_urb->dev = ati_remote->udev;
  */
 static void ati_remote_close(struct input_dev *inputdev)
 {
-       struct ati_remote *ati_remote = inputdev->private;
+       struct ati_remote *ati_remote = input_get_drvdata(inputdev);
 
        usb_kill_urb(ati_remote->irq_urb);
 }
                if (ati_remote_tbl[i].type == EV_KEY)
                        set_bit(ati_remote_tbl[i].code, idev->keybit);
 
-       idev->private = ati_remote;
+       input_set_drvdata(idev, ati_remote);
+
        idev->open = ati_remote_open;
        idev->close = ati_remote_close;
 
 
 
 static int ati_remote2_open(struct input_dev *idev)
 {
-       struct ati_remote2 *ar2 = idev->private;
+       struct ati_remote2 *ar2 = input_get_drvdata(idev);
        int r;
 
        r = usb_submit_urb(ar2->urb[0], GFP_KERNEL);
 
 static void ati_remote2_close(struct input_dev *idev)
 {
-       struct ati_remote2 *ar2 = idev->private;
+       struct ati_remote2 *ar2 = input_get_drvdata(idev);
 
        usb_kill_urb(ar2->urb[0]);
        usb_kill_urb(ar2->urb[1]);
                return -ENOMEM;
 
        ar2->idev = idev;
-       idev->private = ar2;
+       input_set_drvdata(idev, ar2);
 
        idev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_REL);
        idev->keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT);
 
  */
 static int gtco_input_open(struct input_dev *inputdev)
 {
-       struct gtco *device;
-       device = inputdev->private;
+       struct gtco *device = input_get_drvdata(inputdev);
 
        device->urbinfo->dev = device->usbdev;
        if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
  */
 static void gtco_input_close(struct input_dev *inputdev)
 {
-       struct gtco *device = inputdev->private;
+       struct gtco *device = input_get_drvdata(inputdev);
 
        usb_kill_urb(device->urbinfo);
 }
  *  placed in the struct gtco structure
  *
  */
-static void  gtco_setup_caps(struct input_dev  *inputdev)
+static void gtco_setup_caps(struct input_dev *inputdev)
 {
-       struct gtco *device = inputdev->private;
+       struct gtco *device = input_get_drvdata(inputdev);
 
        /* Which events */
        inputdev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_MSC);
        /* Set input device information */
        input_dev->name = "GTCO_CalComp";
        input_dev->phys = gtco->usbpath;
-       input_dev->private = gtco;
+
+       input_set_drvdata(input_dev, gtco);
 
        /* Now set up all the input device capabilities */
        gtco_setup_caps(input_dev);
 
 
 static int kbtab_open(struct input_dev *dev)
 {
-       struct kbtab *kbtab = dev->private;
+       struct kbtab *kbtab = input_get_drvdata(dev);
 
        kbtab->irq->dev = kbtab->usbdev;
        if (usb_submit_urb(kbtab->irq, GFP_KERNEL))
 
 static void kbtab_close(struct input_dev *dev)
 {
-       struct kbtab *kbtab = dev->private;
+       struct kbtab *kbtab = input_get_drvdata(dev);
 
        usb_kill_urb(kbtab->irq);
 }
        input_dev->phys = kbtab->phys;
        usb_to_input_id(dev, &input_dev->id);
        input_dev->cdev.dev = &intf->dev;
-       input_dev->private = kbtab;
+
+       input_set_drvdata(input_dev, kbtab);
 
        input_dev->open = kbtab_open;
        input_dev->close = kbtab_close;
 
 
 static int keyspan_open(struct input_dev *dev)
 {
-       struct usb_keyspan *remote = dev->private;
+       struct usb_keyspan *remote = input_get_drvdata(dev);
 
        remote->irq_urb->dev = remote->udev;
        if (usb_submit_urb(remote->irq_urb, GFP_KERNEL))
 
 static void keyspan_close(struct input_dev *dev)
 {
-       struct usb_keyspan *remote = dev->private;
+       struct usb_keyspan *remote = input_get_drvdata(dev);
 
        usb_kill_urb(remote->irq_urb);
 }
                if (keyspan_key_table[i] != KEY_RESERVED)
                        set_bit(keyspan_key_table[i], input_dev->keybit);
 
-       input_dev->private = remote;
+       input_set_drvdata(input_dev, remote);
+
        input_dev->open = keyspan_open;
        input_dev->close = keyspan_close;
 
 
 static int powermate_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int _value)
 {
        unsigned int command = (unsigned int)_value;
-       struct powermate_device *pm = dev->private;
+       struct powermate_device *pm = input_get_drvdata(dev);
 
        if (type == EV_MSC && code == MSC_PULSELED){
                /*
        input_dev->phys = pm->phys;
        usb_to_input_id(udev, &input_dev->id);
        input_dev->cdev.dev = &intf->dev;
-       input_dev->private = pm;
+
+       input_set_drvdata(input_dev, pm);
 
        input_dev->event = powermate_input_event;
 
 
 
 static int usbtouch_open(struct input_dev *input)
 {
-       struct usbtouch_usb *usbtouch = input->private;
+       struct usbtouch_usb *usbtouch = input_get_drvdata(input);
 
        usbtouch->irq->dev = usbtouch->udev;
 
 
 static void usbtouch_close(struct input_dev *input)
 {
-       struct usbtouch_usb *usbtouch = input->private;
+       struct usbtouch_usb *usbtouch = input_get_drvdata(input);
 
        usb_kill_urb(usbtouch->irq);
 }
        input_dev->phys = usbtouch->phys;
        usb_to_input_id(udev, &input_dev->id);
        input_dev->cdev.dev = &intf->dev;
-       input_dev->private = usbtouch;
+
+       input_set_drvdata(input_dev, usbtouch);
+
        input_dev->open = usbtouch_open;
        input_dev->close = usbtouch_close;
 
 
 
 static int wacom_open(struct input_dev *dev)
 {
-       struct wacom *wacom = dev->private;
+       struct wacom *wacom = input_get_drvdata(dev);
 
        wacom->irq->dev = wacom->usbdev;
        if (usb_submit_urb(wacom->irq, GFP_KERNEL))
 
 static void wacom_close(struct input_dev *dev)
 {
-       struct wacom *wacom = dev->private;
+       struct wacom *wacom = input_get_drvdata(dev);
 
        usb_kill_urb(wacom->irq);
 }
        usb_to_input_id(dev, &input_dev->id);
 
        input_dev->cdev.dev = &intf->dev;
-       input_dev->private = wacom;
+
+       input_set_drvdata(input_dev, wacom);
+
        input_dev->open = wacom_open;
        input_dev->close = wacom_close;
 
 
 
 static int xpad_open (struct input_dev *dev)
 {
-       struct usb_xpad *xpad = dev->private;
+       struct usb_xpad *xpad = input_get_drvdata(dev);
 
        xpad->irq_in->dev = xpad->udev;
        if (usb_submit_urb(xpad->irq_in, GFP_KERNEL))
 
 static void xpad_close (struct input_dev *dev)
 {
-       struct usb_xpad *xpad = dev->private;
+       struct usb_xpad *xpad = input_get_drvdata(dev);
 
        usb_kill_urb(xpad->irq_in);
 }
        input_dev->phys = xpad->phys;
        usb_to_input_id(udev, &input_dev->id);
        input_dev->cdev.dev = &intf->dev;
-       input_dev->private = xpad;
+
+       input_set_drvdata(input_dev, xpad);
+
        input_dev->open = xpad_open;
        input_dev->close = xpad_close;
 
 
 
 static int input_open(struct input_dev *dev)
 {
-       struct yealink_dev *yld = dev->private;
+       struct yealink_dev *yld = input_get_drvdata(dev);
        int i, ret;
 
        dbg("%s", __FUNCTION__);
 
 static void input_close(struct input_dev *dev)
 {
-       struct yealink_dev *yld = dev->private;
+       struct yealink_dev *yld = input_get_drvdata(dev);
 
        usb_kill_urb(yld->urb_ctl);
        usb_kill_urb(yld->urb_irq);
        usb_to_input_id(udev, &input_dev->id);
        input_dev->cdev.dev = &intf->dev;
 
-       input_dev->private = yld;
+       input_set_drvdata(input_dev, yld);
+
        input_dev->open = input_open;
        input_dev->close = input_close;
        /* input_dev->event = input_ev; TODO */