Use a void * argument to callout handlers instead of timeout_t casts.

[jhb]

Test Plan

• make tinderbox

[jhb]

This is a split out portion of D22601 which I plan to abandon in favor of a new typedef.

head/sys/dev/ahci/ahci.c

 static int ahci_ch_resume(device_t dev);
 static void ahci_ch_pm(void *arg);
 static void ahci_ch_intr(void *arg);
 static void ahci_ch_intr_direct(void *arg);
 static void ahci_ch_intr_main(struct ahci_channel *ch, uint32_t istatus);
 static void ahci_begin_transaction(struct ahci_channel *ch, union ccb *ccb);
 static void ahci_dmasetprd(void *arg, bus_dma_segment_t *segs, int nsegs, int error);
 static void ahci_execute_transaction(struct ahci_slot *slot);
-static void ahci_timeout(struct ahci_slot *slot);
+static void ahci_timeout(void *arg);
 static void ahci_end_transaction(struct ahci_slot *slot, enum ahci_err_type et);
 static int ahci_setup_fis(struct ahci_channel *ch, struct ahci_cmd_tab *ctp, union ccb *ccb, int tag);
 static void ahci_dmainit(device_t dev);
 static void ahci_dmasetupc_cb(void *xsc, bus_dma_segment_t *segs, int nsegs, int error);
 static void ahci_dmafini(device_t dev);
 static void ahci_slotsalloc(device_t dev);
 static void ahci_slotsfree(device_t dev);
 static void ahci_reset(struct ahci_channel *ch);
#endif
                 /* Kick controller into sane state and enable FBS. */
                 if (softreset == 2)
                         ch->eslots |= (1 << slot->slot);
                 ahci_end_transaction(slot, et);
                 return;
         }
         /* Start command execution timeout */
         callout_reset_sbt(&slot->timeout, SBT_1MS * ccb->ccb_h.timeout / 2,
-            0, (timeout_t*)ahci_timeout, slot, 0);
+            0, ahci_timeout, slot, 0);
         return;
 }
 
 /* Must be called with channel locked. */
 static void
 ahci_process_timeout(struct ahci_channel *ch)
 {
         int i;
for (i = 0; i < ch->numslots; i++) {
 
                 /* Do we have a running request on slot? */
                 if (slot->state < AHCI_SLOT_RUNNING)
                         continue;
                 if ((ch->toslots & (1 << i)) == 0)
                         continue;
                 callout_reset_sbt(&slot->timeout,
                             SBT_1MS * slot->ccb->ccb_h.timeout / 2, 0,
-                    (timeout_t*)ahci_timeout, slot, 0);
+                    ahci_timeout, slot, 0);
         }
 }
 
 /* Locked by callout mechanism. */
 static void
-ahci_timeout(struct ahci_slot *slot)
+ahci_timeout(void *arg)
 {
+        struct ahci_slot *slot = arg;
         struct ahci_channel *ch = slot->ch;
         device_t dev = ch->dev;
         uint32_t sstatus;
         int ccs;
         int i;
 
         /* Check for stale timeout. */
         if (slot->state < AHCI_SLOT_RUNNING)
if ((sstatus & (1 << slot->slot)) != 0 || ccs == slot->slot ||
                         slot->state = AHCI_SLOT_EXECUTING;
                 else if ((ch->rslots & (1 << ccs)) == 0) {
                         ch->wrongccs = 1;
                         slot->state = AHCI_SLOT_EXECUTING;
                 }
 
                 callout_reset_sbt(&slot->timeout,
                         SBT_1MS * slot->ccb->ccb_h.timeout / 2, 0,
-                    (timeout_t*)ahci_timeout, slot, 0);
+                    ahci_timeout, slot, 0);
                 return;
         }
 
         device_printf(dev, "Timeout on slot %d port %d\n",
             slot->slot, slot->ccb->ccb_h.target_id & 0x0f);
         device_printf(dev, "is %08x cs %08x ss %08x rs %08x tfd %02x "
             "serr %08x cmd %08x\n",
             ATA_INL(ch->r_mem, AHCI_P_IS), ATA_INL(ch->r_mem, AHCI_P_CI),

head/sys/dev/ata/ata-all.h

 int ata_getparam(struct ata_device *atadev, int init);
 void ata_default_registers(device_t dev);
 void ata_udelay(int interval);
 const char *ata_cmd2str(struct ata_request *request);
 const char *ata_mode2str(int mode);
 void ata_setmode(device_t dev);
 void ata_print_cable(device_t dev, u_int8_t *who);
 int ata_atapi(device_t dev, int target);
-void ata_timeout(struct ata_request *);
+void ata_timeout(void *);
 
 /* ata-lowlevel.c: */
 void ata_generic_hw(device_t dev);
 int ata_begin_transaction(struct ata_request *);
 int ata_end_transaction(struct ata_request *);
 void ata_generic_reset(device_t dev);
 int ata_generic_command(struct ata_request *request);
 

head/sys/dev/ata/ata-all.c

 ata_atapi(device_t dev, int target)
 {
     struct ata_channel *ch = device_get_softc(dev);
 
     return (ch->devices & (ATA_ATAPI_MASTER << target));
 }
 
 void
-ata_timeout(struct ata_request *request)
+ata_timeout(void *arg)
 {
+        struct ata_request *request;
         struct ata_channel *ch;
 
+        request = arg;
         ch = device_get_softc(request->parent);
         //request->flags |= ATA_R_DEBUG;
         ATA_DEBUG_RQ(request, "timeout");
 
         /*
          * If we have an ATA_ACTIVE request running, we flag the request
          * ATA_R_TIMEOUT so ata_cam_end_transaction() will handle it correctly.
          * Also, NULL out the running request so we wont loose the race with

head/sys/dev/ata/ata-lowlevel.c

 begin_finished:
     if (ch->dma.unload) {
         ch->dma.unload(request);
     }
     return ATA_OP_FINISHED;
 
 begin_continue:
     callout_reset(&request->callout, request->timeout * hz,
-                  (timeout_t*)ata_timeout, request);
+                  ata_timeout, request);
     return ATA_OP_CONTINUES;
 }
 
 /* must be called with ATA channel locked and state_mtx held */
 int
 ata_end_transaction(struct ata_request *request)
 {
     struct ata_channel *ch = device_get_softc(request->parent);