--- initial
+++ final
@@ -1,109 +1,108 @@
 static int ite_probe(struct pnp_dev *pdev, const struct pnp_device_id *dev_id) {
   const struct ite_dev_params *dev_desc = NULL;
   struct ite_dev *itdev = NULL;
   struct rc_dev *rdev = NULL;
   int ret = -ENOMEM;
   int model_no;
   int io_rsrc_no;
   ite_dbg("%s called", __func__);
   itdev = kzalloc(sizeof(struct ite_dev), GFP_KERNEL);
   if (!itdev) return ret;
   /* input device for IR remote (and tx) */
-  rdev = rc_allocate_device();
+  rdev = rc_allocate_device(RC_DRIVER_IR_RAW);
   if (!rdev) goto exit_free_dev_rdev;
   itdev->rdev = rdev;
   ret = -ENODEV;
   /* get the model number */
   model_no = (int)dev_id->driver_data;
   ite_pr(KERN_NOTICE, "Auto-detected model: %s\n", ite_dev_descs[model_no].model);
   if (model_number >= 0 && model_number < ARRAY_SIZE(ite_dev_descs)) {
     model_no = model_number;
     ite_pr(KERN_NOTICE, "The model has been fixed by a module parameter.");
   }
   ite_pr(KERN_NOTICE, "Using model: %s\n", ite_dev_descs[model_no].model);
   /* get the description for the device */
   dev_desc = &ite_dev_descs[model_no];
   io_rsrc_no = dev_desc->io_rsrc_no;
   /* validate pnp resources */
   if (!pnp_port_valid(pdev, io_rsrc_no) || pnp_port_len(pdev, io_rsrc_no) != dev_desc->io_region_size) {
     dev_err(&pdev->dev, "IR PNP Port not valid!\n");
     goto exit_free_dev_rdev;
   }
   if (!pnp_irq_valid(pdev, 0)) {
     dev_err(&pdev->dev, "PNP IRQ not valid!\n");
     goto exit_free_dev_rdev;
   }
   /* store resource values */
   itdev->cir_addr = pnp_port_start(pdev, io_rsrc_no);
   itdev->cir_irq = pnp_irq(pdev, 0);
   /* initialize spinlocks */
   spin_lock_init(&itdev->lock);
   /* initialize raw event */
   init_ir_raw_event(&itdev->rawir);
   /* set driver data into the pnp device */
   pnp_set_drvdata(pdev, itdev);
   itdev->pdev = pdev;
   /* initialize waitqueues for transmission */
   init_waitqueue_head(&itdev->tx_queue);
   init_waitqueue_head(&itdev->tx_ended);
   /* copy model-specific parameters */
   itdev->params = *dev_desc;
   /* apply any overrides */
   if (sample_period > 0) itdev->params.sample_period = sample_period;
   if (tx_carrier_freq > 0) itdev->params.tx_carrier_freq = tx_carrier_freq;
   if (tx_duty_cycle > 0 && tx_duty_cycle <= 100) itdev->params.tx_duty_cycle = tx_duty_cycle;
   if (rx_low_carrier_freq > 0) itdev->params.rx_low_carrier_freq = rx_low_carrier_freq;
   if (rx_high_carrier_freq > 0) itdev->params.rx_high_carrier_freq = rx_high_carrier_freq;
   /* print out parameters */
   ite_pr(KERN_NOTICE, "TX-capable: %d\n", (int)itdev->params.hw_tx_capable);
   ite_pr(KERN_NOTICE, "Sample period (ns): %ld\n", (long)itdev->params.sample_period);
   ite_pr(KERN_NOTICE, "TX carrier frequency (Hz): %d\n", (int)itdev->params.tx_carrier_freq);
   ite_pr(KERN_NOTICE, "TX duty cycle (%%): %d\n", (int)itdev->params.tx_duty_cycle);
   ite_pr(KERN_NOTICE, "RX low carrier frequency (Hz): %d\n", (int)itdev->params.rx_low_carrier_freq);
   ite_pr(KERN_NOTICE, "RX high carrier frequency (Hz): %d\n", (int)itdev->params.rx_high_carrier_freq);
   /* set up hardware initial state */
   itdev->params.init_hardware(itdev);
   /* set up ir-core props */
   rdev->priv = itdev;
-  rdev->driver_type = RC_DRIVER_IR_RAW;
   rdev->allowed_protocols = RC_BIT_ALL_IR_DECODER;
   rdev->open = ite_open;
   rdev->close = ite_close;
   rdev->s_idle = ite_s_idle;
   rdev->s_rx_carrier_range = ite_set_rx_carrier_range;
   rdev->min_timeout = ITE_MIN_IDLE_TIMEOUT;
   rdev->max_timeout = ITE_MAX_IDLE_TIMEOUT;
   rdev->timeout = ITE_IDLE_TIMEOUT;
   rdev->rx_resolution = ITE_BAUDRATE_DIVISOR * itdev->params.sample_period;
   rdev->tx_resolution = ITE_BAUDRATE_DIVISOR * itdev->params.sample_period;
   /* set up transmitter related values if needed */
   if (itdev->params.hw_tx_capable) {
     rdev->tx_ir = ite_tx_ir;
     rdev->s_tx_carrier = ite_set_tx_carrier;
     rdev->s_tx_duty_cycle = ite_set_tx_duty_cycle;
   }
   rdev->input_name = dev_desc->model;
   rdev->input_id.bustype = BUS_HOST;
   rdev->input_id.vendor = PCI_VENDOR_ID_ITE;
   rdev->input_id.product = 0;
   rdev->input_id.version = 0;
   rdev->driver_name = ITE_DRIVER_NAME;
   rdev->map_name = RC_MAP_RC6_MCE;
   ret = rc_register_device(rdev);
   if (ret) goto exit_free_dev_rdev;
   ret = -EBUSY;
   /* now claim resources */
   if (!request_region(itdev->cir_addr, dev_desc->io_region_size, ITE_DRIVER_NAME)) goto exit_unregister_device;
   if (request_irq(itdev->cir_irq, ite_cir_isr, IRQF_SHARED, ITE_DRIVER_NAME, (void *)itdev)) goto exit_release_cir_addr;
   ite_pr(KERN_NOTICE, "driver has been successfully loaded\n");
   return 0;
 exit_release_cir_addr:
   release_region(itdev->cir_addr, itdev->params.io_region_size);
 exit_unregister_device:
   rc_unregister_device(rdev);
   rdev = NULL;
 exit_free_dev_rdev:
   rc_free_device(rdev);
   kfree(itdev);
   return ret;
 }<sep>@@
expression rdev,e;
@@
-       rdev = rc_allocate_device();
+       rdev = rc_allocate_device(e);
	...
-       rdev->driver_type      = e;