--- initial
+++ final
@@ -1,154 +1,151 @@
 static int ena_probe(struct pci_dev *pdev, const struct pci_device_id *ent) {
   struct ena_com_dev_get_features_ctx get_feat_ctx;
   static int version_printed;
   struct net_device *netdev;
   struct ena_adapter *adapter;
   struct ena_com_dev *ena_dev = NULL;
   static int adapters_found;
   int io_queue_num, bars, rc;
   int queue_size;
   u16 tx_sgl_size = 0;
   u16 rx_sgl_size = 0;
   bool wd_state;
   dev_dbg(&pdev->dev, "%s\n", __func__);
   if (version_printed++ == 0) dev_info(&pdev->dev, "%s", version);
   rc = pci_enable_device_mem(pdev);
   if (rc) {
     dev_err(&pdev->dev, "pci_enable_device_mem() failed!\n");
     return rc;
   }
   pci_set_master(pdev);
   ena_dev = vzalloc(sizeof(*ena_dev));
   if (!ena_dev) {
     rc = -ENOMEM;
     goto err_disable_device;
   }
   bars = pci_select_bars(pdev, IORESOURCE_MEM) & ENA_BAR_MASK;
   rc = pci_request_selected_regions(pdev, bars, DRV_MODULE_NAME);
   if (rc) {
     dev_err(&pdev->dev, "pci_request_selected_regions failed %d\n", rc);
     goto err_free_ena_dev;
   }
   ena_dev->reg_bar = ioremap(pci_resource_start(pdev, ENA_REG_BAR), pci_resource_len(pdev, ENA_REG_BAR));
   if (!ena_dev->reg_bar) {
     dev_err(&pdev->dev, "failed to remap regs bar\n");
     rc = -EFAULT;
     goto err_free_region;
   }
   ena_dev->dmadev = &pdev->dev;
   rc = ena_device_init(ena_dev, pdev, &get_feat_ctx, &wd_state);
   if (rc) {
     dev_err(&pdev->dev, "ena device init failed\n");
     if (rc == -ETIME) rc = -EPROBE_DEFER;
     goto err_free_region;
   }
   ena_set_push_mode(pdev, ena_dev, &get_feat_ctx);
   if (ena_dev->tx_mem_queue_type == ENA_ADMIN_PLACEMENT_POLICY_DEV) {
     ena_dev->mem_bar = ioremap_wc(pci_resource_start(pdev, ENA_MEM_BAR), pci_resource_len(pdev, ENA_MEM_BAR));
     if (!ena_dev->mem_bar) {
       rc = -EFAULT;
       goto err_device_destroy;
     }
   }
   /* initial Tx interrupt delay, Assumes 1 usec granularity.
    * Updated during device initialization with the real granularity
    */
   ena_dev->intr_moder_tx_interval = ENA_INTR_INITIAL_TX_INTERVAL_USECS;
   io_queue_num = ena_calc_io_queue_num(pdev, ena_dev, &get_feat_ctx);
   queue_size = ena_calc_queue_size(pdev, ena_dev, &tx_sgl_size, &rx_sgl_size, &get_feat_ctx);
   if ((queue_size <= 0) || (io_queue_num <= 0)) {
     rc = -EFAULT;
     goto err_device_destroy;
   }
   dev_info(&pdev->dev, "creating %d io queues. queue size: %d\n", io_queue_num, queue_size);
   /* dev zeroed in init_etherdev */
   netdev = alloc_etherdev_mq(sizeof(struct ena_adapter), io_queue_num);
   if (!netdev) {
     dev_err(&pdev->dev, "alloc_etherdev_mq failed\n");
     rc = -ENOMEM;
     goto err_device_destroy;
   }
   SET_NETDEV_DEV(netdev, &pdev->dev);
   adapter = netdev_priv(netdev);
   pci_set_drvdata(pdev, adapter);
   adapter->ena_dev = ena_dev;
   adapter->netdev = netdev;
   adapter->pdev = pdev;
   ena_set_conf_feat_params(adapter, &get_feat_ctx);
   adapter->msg_enable = netif_msg_init(debug, DEFAULT_MSG_ENABLE);
   adapter->tx_ring_size = queue_size;
   adapter->rx_ring_size = queue_size;
   adapter->max_tx_sgl_size = tx_sgl_size;
   adapter->max_rx_sgl_size = rx_sgl_size;
   adapter->num_queues = io_queue_num;
   adapter->last_monitored_tx_qid = 0;
   adapter->rx_copybreak = ENA_DEFAULT_RX_COPYBREAK;
   adapter->wd_state = wd_state;
   snprintf(adapter->name, ENA_NAME_MAX_LEN, "ena_%d", adapters_found);
   rc = ena_com_init_interrupt_moderation(adapter->ena_dev);
   if (rc) {
     dev_err(&pdev->dev, "Failed to query interrupt moderation feature\n");
     goto err_netdev_destroy;
   }
   ena_init_io_rings(adapter);
   netdev->netdev_ops = &ena_netdev_ops;
   netdev->watchdog_timeo = TX_TIMEOUT;
   ena_set_ethtool_ops(netdev);
   netdev->priv_flags |= IFF_UNICAST_FLT;
   u64_stats_init(&adapter->syncp);
   rc = ena_enable_msix_and_set_admin_interrupts(adapter, io_queue_num);
   if (rc) {
     dev_err(&pdev->dev, "Failed to enable and set the admin interrupts\n");
     goto err_worker_destroy;
   }
   rc = ena_rss_init_default(adapter);
   if (rc && (rc != -EPERM)) {
     dev_err(&pdev->dev, "Cannot init RSS rc: %d\n", rc);
     goto err_free_msix;
   }
   ena_config_debug_area(adapter);
   memcpy(adapter->netdev->perm_addr, adapter->mac_addr, netdev->addr_len);
   netif_carrier_off(netdev);
   rc = register_netdev(netdev);
   if (rc) {
     dev_err(&pdev->dev, "Cannot register net device\n");
     goto err_rss;
   }
   INIT_WORK(&adapter->suspend_io_task, ena_device_io_suspend);
   INIT_WORK(&adapter->resume_io_task, ena_device_io_resume);
   INIT_WORK(&adapter->reset_task, ena_fw_reset_device);
   adapter->last_keep_alive_jiffies = jiffies;
-  init_timer(&adapter->timer_service);
-  adapter->timer_service.expires = round_jiffies(jiffies + HZ);
-  adapter->timer_service.function = ena_timer_service;
-  adapter->timer_service.data = (unsigned long)adapter;
-  add_timer(&adapter->timer_service);
+  setup_timer(&adapter->timer_service, ena_timer_service, (unsigned long)adapter);
+  mod_timer(&adapter->timer_service, round_jiffies(jiffies + HZ));
   dev_info(&pdev->dev, "%s found at mem %lx, mac addr %pM Queues %d\n", DEVICE_NAME, (long)pci_resource_start(pdev, 0), netdev->dev_addr, io_queue_num);
   set_bit(ENA_FLAG_DEVICE_RUNNING, &adapter->flags);
   adapters_found++;
   return 0;
 err_rss:
   ena_com_delete_debug_area(ena_dev);
   ena_com_rss_destroy(ena_dev);
 err_free_msix:
   ena_com_dev_reset(ena_dev);
   ena_free_mgmnt_irq(adapter);
   ena_disable_msix(adapter);
 err_worker_destroy:
   ena_com_destroy_interrupt_moderation(ena_dev);
   del_timer(&adapter->timer_service);
   cancel_work_sync(&adapter->suspend_io_task);
   cancel_work_sync(&adapter->resume_io_task);
 err_netdev_destroy:
   free_netdev(netdev);
 err_device_destroy:
   ena_com_delete_host_info(ena_dev);
   ena_com_admin_destroy(ena_dev);
 err_free_region:
   ena_release_bars(ena_dev, pdev);
 err_free_ena_dev:
   vfree(ena_dev);
 err_disable_device:
   pci_disable_device(pdev);
   return rc;
 }<sep>@@
expression E0;
expression E1;
expression E2,e2;
@@
- init_timer(&E0);
+ setup_timer(&E0, E1, E2);
  ... when != E0.data = e2;
- E0.function = E1;
  ... when != init_timer(&E0);
- E0.data = E2;



@@
expression E0,v;
@@

-	E0.expires = v;
	...
-	add_timer(&E0);
+	mod_timer(&E0, v);