rdev->allowed_protocols = RC_BIT_ALL_IR_DECODER;
        rdev->open             = picolcd_cir_open;
        rdev->close            = picolcd_cir_close;
-       rdev->input_name       = data->hdev->name;
+       rdev->device_name      = data->hdev->name;
        rdev->input_phys       = data->hdev->phys;
        rdev->input_id.bustype = data->hdev->bus;
        rdev->input_id.vendor  = data->hdev->vendor;
 
                return ERR_PTR(-ENOMEM);
        }
 
-       snprintf(adap->input_name, sizeof(adap->input_name),
+       snprintf(adap->device_name, sizeof(adap->device_name),
                 "RC for %s", name);
        snprintf(adap->input_phys, sizeof(adap->input_phys),
                 "%s/input0", name);
 
-       adap->rc->input_name = adap->input_name;
+       adap->rc->device_name = adap->device_name;
        adap->rc->input_phys = adap->input_phys;
        adap->rc->input_id.bustype = BUS_CEC;
        adap->rc->input_id.vendor = 0;
 
        strlcpy(coredev->ir.phys, coredev->devpath, sizeof(coredev->ir.phys));
        strlcat(coredev->ir.phys, "/ir0", sizeof(coredev->ir.phys));
 
-       dev->input_name = coredev->ir.name;
+       dev->device_name = coredev->ir.name;
        dev->input_phys = coredev->ir.phys;
        dev->dev.parent = coredev->device;
 
        dev->driver_name = MODULE_NAME;
 
        pr_debug("Input device (IR) %s is set for key events\n",
-                dev->input_name);
+                dev->device_name);
 
        err = rc_register_device(dev);
        if (err < 0) {
 
         */
        rc->input_id.bustype = BUS_I2C;
        rc->input_phys       = ir->phys;
-       rc->input_name       = ir->name;
+       rc->device_name      = ir->name;
 
        /*
         * Initialize the other fields of rc_dev
 
        snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0",
                 pci_name(btv->c.pci));
 
-       rc->input_name = ir->name;
+       rc->device_name = ir->name;
        rc->input_phys = ir->phys;
        rc->input_id.bustype = BUS_PCI;
        rc->input_id.version = 1;
 
        }
 
        kernel_ir->rc = rc;
-       rc->input_name = kernel_ir->name;
+       rc->device_name = kernel_ir->name;
        rc->input_phys = kernel_ir->phys;
        rc->input_id.bustype = BUS_PCI;
        rc->input_id.version = 1;
 
        snprintf(ir->name, sizeof(ir->name), "cx88 IR (%s)", core->board.name);
        snprintf(ir->phys, sizeof(ir->phys), "pci-%s/ir0", pci_name(pci));
 
-       dev->input_name = ir->name;
+       dev->device_name = ir->name;
        dev->input_phys = ir->phys;
        dev->input_id.bustype = BUS_PCI;
        dev->input_id.version = 1;
 
 
        dev->driver_name = MODULE_NAME;
        dev->map_name = RC_MAP_DM1105_NEC;
-       dev->input_name = "DVB on-card IR receiver";
+       dev->device_name = "DVB on-card IR receiver";
        dev->input_phys = dm1105->ir.input_phys;
        dev->input_id.bustype = BUS_PCI;
        dev->input_id.version = 1;
 
        struct work_struct      uart_work;
 
        struct rc_dev           *rc;
-       char                    input_name[80];
+       char                    device_name[80];
        char                    input_phys[80];
        char                    *rc_map_name;
 };
 
                goto out;
        }
 
-       snprintf(mantis->input_name, sizeof(mantis->input_name),
+       snprintf(mantis->device_name, sizeof(mantis->device_name),
                 "Mantis %s IR receiver", mantis->hwconfig->model_name);
        snprintf(mantis->input_phys, sizeof(mantis->input_phys),
                 "pci-%s/ir0", pci_name(mantis->pdev));
 
-       dev->input_name         = mantis->input_name;
+       dev->device_name        = mantis->device_name;
        dev->input_phys         = mantis->input_phys;
        dev->input_id.bustype   = BUS_PCI;
        dev->input_id.vendor    = mantis->vendor_id;
 
        if (raw_decode)
                rc->driver_type = RC_DRIVER_IR_RAW;
 
-       rc->input_name = ir->name;
+       rc->device_name = ir->name;
        rc->input_phys = ir->phys;
        rc->input_id.bustype = BUS_PCI;
        rc->input_id.version = 1;
 
                return -ENOMEM;
 
        /* init input device */
-       snprintf(ir->input_name, sizeof(ir->input_name), "IR (%s)",
+       snprintf(ir->device_name, sizeof(ir->device_name), "IR (%s)",
                 dev->info->name);
        snprintf(ir->input_phys, sizeof(ir->input_phys), "pci-%s/ir0",
                 pci_name(dev->pci_dev));
 
        rc_dev->driver_name = "SMI_PCIe";
        rc_dev->input_phys = ir->input_phys;
-       rc_dev->input_name = ir->input_name;
+       rc_dev->device_name = ir->device_name;
        rc_dev->input_id.bustype = BUS_PCI;
        rc_dev->input_id.version = 1;
        rc_dev->input_id.vendor = dev->pci_dev->subsystem_vendor;
 
        struct smi_dev *dev;
        struct rc_dev *rc_dev;
        char input_phys[64];
-       char input_name[64];
+       char device_name[64];
        struct work_struct work;
        u8 irData[256];
 
 
                 "pci-%s/ir0", pci_name(saa->pci));
 
        dev->driver_name = MODULE_NAME;
-       dev->input_name = budget_ci->ir.name;
+       dev->device_name = budget_ci->ir.name;
        dev->input_phys = budget_ci->ir.phys;
        dev->input_id.bustype = BUS_PCI;
        dev->input_id.version = 1;
 
        rdev->open = ati_remote_rc_open;
        rdev->close = ati_remote_rc_close;
 
-       rdev->input_name = ati_remote->rc_name;
+       rdev->device_name = ati_remote->rc_name;
        rdev->input_phys = ati_remote->rc_phys;
 
        usb_to_input_id(ati_remote->udev, &rdev->input_id);
 
        rdev->s_idle = ene_set_idle;
        rdev->driver_name = ENE_DRIVER_NAME;
        rdev->map_name = RC_MAP_RC6_MCE;
-       rdev->input_name = "ENE eHome Infrared Remote Receiver";
+       rdev->device_name = "ENE eHome Infrared Remote Receiver";
 
        if (dev->hw_learning_and_tx_capable) {
                rdev->s_learning_mode = ene_set_learning_mode;
                rdev->s_tx_carrier = ene_set_tx_carrier;
                rdev->s_tx_duty_cycle = ene_set_tx_duty_cycle;
                rdev->s_carrier_report = ene_set_carrier_report;
-               rdev->input_name = "ENE eHome Infrared Remote Transceiver";
+               rdev->device_name = "ENE eHome Infrared Remote Transceiver";
        }
 
        dev->rdev = rdev;
 
        rdev->allowed_protocols = RC_BIT_ALL_IR_DECODER;
        rdev->open = fintek_open;
        rdev->close = fintek_close;
-       rdev->input_name = FINTEK_DESCRIPTION;
+       rdev->device_name = FINTEK_DESCRIPTION;
        rdev->input_phys = "fintek/cir0";
        rdev->input_id.bustype = BUS_HOST;
        rdev->input_id.vendor = VENDOR_ID_FINTEK;
 
        }
 
        rcdev->priv = gpio_dev;
-       rcdev->input_name = GPIO_IR_DEVICE_NAME;
+       rcdev->device_name = GPIO_IR_DEVICE_NAME;
        rcdev->input_phys = GPIO_IR_DEVICE_NAME "/input0";
        rcdev->input_id.bustype = BUS_HOST;
        rcdev->input_id.vendor = 0x0001;
 
        if (!rc)
                goto fail;
 
-       rc->input_name = DRIVER_DESC;
+       rc->device_name = DRIVER_DESC;
        rc->input_phys = ir->phys;
        usb_to_input_id(udev, &rc->input_id);
        rc->dev.parent = &intf->dev;
 
 
        usb_make_path(ir->udev, ir->phys, sizeof(ir->phys));
 
-       rc->input_name = ir->name;
+       rc->device_name = ir->name;
        rc->input_phys = ir->phys;
        usb_to_input_id(ir->udev, &rc->input_id);
        rc->dev.parent = &intf->dev;
 
        rdev->priv = priv;
        rdev->map_name = RC_MAP_EMPTY;
        rdev->allowed_protocols = img_ir_allowed_protos(priv);
-       rdev->input_name = "IMG Infrared Decoder";
+       rdev->device_name = "IMG Infrared Decoder";
        rdev->s_filter = img_ir_set_normal_filter;
        rdev->s_wakeup_filter = img_ir_set_wakeup_filter;
 
 
        }
        rdev->priv = priv;
        rdev->map_name = RC_MAP_EMPTY;
-       rdev->input_name = "IMG Infrared Decoder Raw";
+       rdev->device_name = "IMG Infrared Decoder Raw";
 
        /* Register raw decoder */
        error = rc_register_device(rdev);
 
                      sizeof(ictx->phys_rdev));
        strlcat(ictx->phys_rdev, "/input0", sizeof(ictx->phys_rdev));
 
-       rdev->input_name = ictx->name_rdev;
+       rdev->device_name = ictx->name_rdev;
        rdev->input_phys = ictx->phys_rdev;
        usb_to_input_id(ictx->usbdev_intf0, &rdev->input_id);
        rdev->dev.parent = ictx->dev;
 
        rdev->driver_name = IR_HIX5HD2_NAME;
        map_name = of_get_property(node, "linux,rc-map-name", NULL);
        rdev->map_name = map_name ?: RC_MAP_EMPTY;
-       rdev->input_name = IR_HIX5HD2_NAME;
+       rdev->device_name = IR_HIX5HD2_NAME;
        rdev->input_phys = IR_HIX5HD2_NAME "/input0";
        rdev->input_id.bustype = BUS_HOST;
        rdev->input_id.vendor = 0x0001;
 
        idata->rc->tx_ir           = ir_spi_tx;
        idata->rc->s_tx_carrier    = ir_spi_set_tx_carrier;
        idata->rc->s_tx_duty_cycle = ir_spi_set_duty_cycle;
+       idata->rc->device_name     = "IR SPI";
        idata->rc->driver_name     = IR_SPI_DRIVER_NAME;
        idata->rc->priv            = idata;
        idata->spi                 = spi;
 
                rdev->s_tx_duty_cycle = ite_set_tx_duty_cycle;
        }
 
-       rdev->input_name = dev_desc->model;
+       rdev->device_name = dev_desc->model;
        rdev->input_id.bustype = BUS_HOST;
        rdev->input_id.vendor = PCI_VENDOR_ID_ITE;
        rdev->input_id.product = 0;
 
 
        usb_make_path(ir->usbdev, ir->phys, sizeof(ir->phys));
 
-       rc->input_name = ir->name;
+       rc->device_name = ir->name;
        rc->input_phys = ir->phys;
        usb_to_input_id(ir->usbdev, &rc->input_id);
        rc->dev.parent = dev;
 
        }
 
        ir->rc->priv = ir;
-       ir->rc->input_name = DRIVER_NAME;
+       ir->rc->device_name = DRIVER_NAME;
        ir->rc->input_phys = DRIVER_NAME "/input0";
        ir->rc->input_id.bustype = BUS_HOST;
        map_name = of_get_property(node, "linux,rc-map-name", NULL);
 
        }
 
        ir->rc->priv = ir;
-       ir->rc->input_name = MTK_IR_DEV;
+       ir->rc->device_name = MTK_IR_DEV;
        ir->rc->input_phys = MTK_IR_DEV "/input0";
        ir->rc->input_id.bustype = BUS_HOST;
        ir->rc->input_id.vendor = 0x0001;
 
        rdev->tx_ir = nvt_tx_ir;
        rdev->s_tx_carrier = nvt_set_tx_carrier;
        rdev->s_wakeup_filter = nvt_ir_raw_set_wakeup_filter;
-       rdev->input_name = "Nuvoton w836x7hg Infrared Remote Transceiver";
+       rdev->device_name = "Nuvoton w836x7hg Infrared Remote Transceiver";
        rdev->input_phys = "nuvoton/cir0";
        rdev->input_id.bustype = BUS_HOST;
        rdev->input_id.vendor = PCI_VENDOR_ID_WINBOND2;
 
                return -ENOMEM;
        }
 
-       rc->input_name          = "rc-core loopback device";
+       rc->device_name         = "rc-core loopback device";
        rc->input_phys          = "rc-core/virtual";
        rc->input_id.bustype    = BUS_VIRTUAL;
        rc->input_id.version    = 1;
 
 
        if (keycode != KEY_RESERVED)
                IR_dprintk(1, "%s: scancode 0x%04x keycode 0x%02x\n",
-                          dev->input_name, scancode, keycode);
+                          dev->device_name, scancode, keycode);
 
        return keycode;
 }
                dev->last_keycode = keycode;
 
                IR_dprintk(1, "%s: key down event, key 0x%04x, protocol 0x%04x, scancode 0x%08x\n",
-                          dev->input_name, keycode, protocol, scancode);
+                          dev->device_name, keycode, protocol, scancode);
                input_report_key(dev->input_dev, keycode, 1);
 
                led_trigger_event(led_feedback, LED_FULL);
        dev->input_dev->dev.parent = &dev->dev;
        memcpy(&dev->input_dev->id, &dev->input_id, sizeof(dev->input_id));
        dev->input_dev->phys = dev->input_phys;
-       dev->input_dev->name = dev->input_name;
+       dev->input_dev->name = dev->device_name;
 
        return 0;
 
 
        path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
        dev_info(&dev->dev, "%s as %s\n",
-               dev->input_name ?: "Unspecified device", path ?: "N/A");
+                dev->device_name ?: "Unspecified device", path ?: "N/A");
        kfree(path);
 
        if (dev->driver_type != RC_DRIVER_IR_RAW_TX) {
 
 
        usb_make_path(rr3->udev, rr3->phys, sizeof(rr3->phys));
 
-       rc->input_name = rr3->name;
+       rc->device_name = rr3->name;
        rc->input_phys = rr3->phys;
        usb_to_input_id(rr3->udev, &rc->input_id);
        rc->dev.parent = dev;
 
 
        switch (type) {
        case IR_HOMEBREW:
-               rcdev->input_name = "Serial IR type home-brew";
+               rcdev->device_name = "Serial IR type home-brew";
                break;
        case IR_IRDEO:
-               rcdev->input_name = "Serial IR type IRdeo";
+               rcdev->device_name = "Serial IR type IRdeo";
                break;
        case IR_IRDEO_REMOTE:
-               rcdev->input_name = "Serial IR type IRdeo remote";
+               rcdev->device_name = "Serial IR type IRdeo remote";
                break;
        case IR_ANIMAX:
-               rcdev->input_name = "Serial IR type AnimaX";
+               rcdev->device_name = "Serial IR type AnimaX";
                break;
        case IR_IGOR:
-               rcdev->input_name = "Serial IR type IgorPlug";
+               rcdev->device_name = "Serial IR type IgorPlug";
                break;
        }
 
 
        if (!rcdev)
                return -ENOMEM;
 
-       rcdev->input_name = "SIR IrDA port";
+       rcdev->device_name = "SIR IrDA port";
        rcdev->input_phys = KBUILD_MODNAME "/input0";
        rcdev->input_id.bustype = BUS_HOST;
        rcdev->input_id.vendor = 0x0001;
 
        rdev->close = st_rc_close;
        rdev->driver_name = IR_ST_NAME;
        rdev->map_name = RC_MAP_EMPTY;
-       rdev->input_name = "ST Remote Control Receiver";
+       rdev->device_name = "ST Remote Control Receiver";
 
        ret = rc_register_device(rdev);
        if (ret < 0)
 
        usb_make_path(sz->usbdev, sz->phys, sizeof(sz->phys));
        strlcat(sz->phys, "/input0", sizeof(sz->phys));
 
-       rdev->input_name = sz->name;
+       rdev->device_name = sz->name;
        rdev->input_phys = sz->phys;
        usb_to_input_id(sz->usbdev, &rdev->input_id);
        rdev->dev.parent = dev;
 
        }
 
        ir->rc->priv = ir;
-       ir->rc->input_name = SUNXI_IR_DEV;
+       ir->rc->device_name = SUNXI_IR_DEV;
        ir->rc->input_phys = "sunxi-ir/input0";
        ir->rc->input_id.bustype = BUS_HOST;
        ir->rc->input_id.vendor = 0x0001;
 
 
        usb_make_path(tt->udev, tt->phys, sizeof(tt->phys));
 
-       rc->input_name = DRIVER_DESC;
+       rc->device_name = DRIVER_DESC;
        rc->input_phys = tt->phys;
        usb_to_input_id(tt->udev, &rc->input_id);
        rc->dev.parent = &intf->dev;
 
        }
 
        data->dev->driver_name = DRVNAME;
-       data->dev->input_name = WBCIR_NAME;
+       data->dev->device_name = WBCIR_NAME;
        data->dev->input_phys = "wbcir/cir0";
        data->dev->input_id.bustype = BUS_HOST;
        data->dev->input_id.vendor = PCI_VENDOR_ID_WINBOND;
 
        usb_make_path(dev->usbdev, ir->phys, sizeof(ir->phys));
        strlcat(ir->phys, "/input0", sizeof(ir->phys));
 
-       rc->input_name = ir->name;
+       rc->device_name = ir->name;
        rc->input_phys = ir->phys;
        rc->input_id.bustype = BUS_USB;
        rc->input_id.version = 1;
 
        }
 
        dev->dev.parent = &d->udev->dev;
-       dev->input_name = d->name;
+       dev->device_name = d->name;
        usb_make_path(d->udev, d->rc_phys, sizeof(d->rc_phys));
        strlcat(d->rc_phys, "/ir0", sizeof(d->rc_phys));
        dev->input_phys = d->rc_phys;
        usb_to_input_id(d->udev, &dev->input_id);
-       /* TODO: likely RC-core should took const char * */
-       dev->driver_name = (char *) d->props->driver_name;
+       dev->driver_name = d->props->driver_name;
        dev->map_name = d->rc.map_name;
        dev->allowed_protocols = d->rc.allowed_protos;
        dev->change_protocol = d->rc.change_protocol;
 
        dev->change_protocol = d->props.rc.core.change_protocol;
        dev->allowed_protocols = d->props.rc.core.allowed_protos;
        usb_to_input_id(d->udev, &dev->input_id);
-       dev->input_name = "IR-receiver inside an USB DVB receiver";
+       dev->device_name = "IR-receiver inside an USB DVB receiver";
        dev->input_phys = d->rc_phys;
        dev->dev.parent = &d->udev->dev;
        dev->priv = d;
 
        usb_make_path(udev, ir->phys, sizeof(ir->phys));
        strlcat(ir->phys, "/input0", sizeof(ir->phys));
 
-       rc->input_name = ir->name;
+       rc->device_name = ir->name;
        rc->input_phys = ir->phys;
        rc->input_id.bustype = BUS_USB;
        rc->input_id.version = 1;
 
        rc_type = RC_BIT_UNKNOWN;
        tm6000_ir_change_protocol(rc, &rc_type);
 
-       rc->input_name = ir->name;
+       rc->device_name = ir->name;
        rc->input_phys = ir->phys;
        rc->input_id.bustype = BUS_USB;
        rc->input_id.version = 1;
 
        u16 phys_addrs[15];
        u32 sequence;
 
-       char input_name[32];
+       char device_name[32];
        char input_phys[32];
        char input_drv[32];
 };
 
  * @dev: driver model's view of this device
  * @managed_alloc: devm_rc_allocate_device was used to create rc_dev
  * @sysfs_groups: sysfs attribute groups
- * @input_name: name of the input child device
+ * @device_name: name of the rc child device
  * @input_phys: physical path to the input child device
  * @input_id: id of the input child device (struct input_id)
  * @driver_name: name of the hardware driver which registered this device
        struct device                   dev;
        bool                            managed_alloc;
        const struct attribute_group    *sysfs_groups[5];
-       const char                      *input_name;
+       const char                      *device_name;
        const char                      *input_phys;
        struct input_id                 input_id;
-       char                            *driver_name;
+       const char                      *driver_name;
        const char                      *map_name;
        struct rc_map                   rc_map;
        struct mutex                    lock;