[BACK]Return to wdc.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / dev / ic

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/dev/ic/wdc.c between version 1.164 and 1.165

version 1.164, 2003/12/30 17:18:11 version 1.165, 2004/01/01 17:18:53
Line 146  const struct ata_bustype wdc_ata_bustype
Line 146  const struct ata_bustype wdc_ata_bustype
 int wdcprobe1 __P((struct channel_softc*, int));  int wdcprobe1 __P((struct channel_softc*, int));
 static void  __wdcerror   __P((struct channel_softc*, char *));  static void  __wdcerror   __P((struct channel_softc*, char *));
 static int   __wdcwait_reset  __P((struct channel_softc *, int, int));  static int   __wdcwait_reset  __P((struct channel_softc *, int, int));
 void  __wdccommand_done __P((struct channel_softc *, struct wdc_xfer *));  void  __wdccommand_done __P((struct channel_softc *, struct ata_xfer *));
 void  __wdccommand_start __P((struct channel_softc *, struct wdc_xfer *));  void  __wdccommand_start __P((struct channel_softc *, struct ata_xfer *));
 int   __wdccommand_intr __P((struct channel_softc *, struct wdc_xfer *, int));  int   __wdccommand_intr __P((struct channel_softc *, struct ata_xfer *, int));
 int   __wdcwait __P((struct channel_softc *, int, int, int));  int   __wdcwait __P((struct channel_softc *, int, int, int));
 void wdc_finish_attach __P((struct device *));  void wdc_finish_attach __P((struct device *));
 void wdc_channel_attach __P((struct channel_softc *));  void wdc_channel_attach __P((struct channel_softc *));
Line 661  wdcattach(struct channel_softc *chp)
Line 661  wdcattach(struct channel_softc *chp)
         if (chp->wdc->drv_probe == NULL)          if (chp->wdc->drv_probe == NULL)
                 chp->wdc->drv_probe = wdc_drvprobe;                  chp->wdc->drv_probe = wdc_drvprobe;
         if (inited == 0) {          if (inited == 0) {
                 /* Initialize the wdc_xfer pool. */                  /* Initialize the ata_xfer pool. */
                 pool_init(&wdc_xfer_pool, sizeof(struct wdc_xfer), 0,                  pool_init(&wdc_xfer_pool, sizeof(struct ata_xfer), 0,
                     0, 0, "wdcspl", NULL);                      0, 0, "wdcspl", NULL);
                 inited++;                  inited++;
         }          }
         TAILQ_INIT(&chp->ch_queue->sc_xfer);          TAILQ_INIT(&chp->ch_queue->queue_xfer);
         chp->ch_queue->queue_freeze = 0;          chp->ch_queue->queue_freeze = 0;
   
         chp->atabus = config_found(&chp->wdc->sc_dev, chp, atabusprint);          chp->atabus = config_found(&chp->wdc->sc_dev, chp, atabusprint);
Line 722  wdcdetach(struct device *self, int flags
Line 722  wdcdetach(struct device *self, int flags
 void  void
 wdcstart(struct channel_softc *chp)  wdcstart(struct channel_softc *chp)
 {  {
         struct wdc_xfer *xfer;          struct ata_xfer *xfer;
   
 #ifdef WDC_DIAGNOSTIC  #ifdef WDC_DIAGNOSTIC
         int spl1, spl2;          int spl1, spl2;
Line 738  wdcstart(struct channel_softc *chp)
Line 738  wdcstart(struct channel_softc *chp)
 #endif /* WDC_DIAGNOSTIC */  #endif /* WDC_DIAGNOSTIC */
   
         /* is there a xfer ? */          /* is there a xfer ? */
         if ((xfer = chp->ch_queue->sc_xfer.tqh_first) == NULL)          if ((xfer = TAILQ_FIRST(&chp->ch_queue->queue_xfer)) == NULL)
                 return;                  return;
   
         /* adjust chp, in case we have a shared queue */          /* adjust chp, in case we have a shared queue */
         chp = xfer->chp;          chp = xfer->c_chp;
   
         if ((chp->ch_flags & WDCF_ACTIVE) != 0 ) {          if ((chp->ch_flags & WDCF_ACTIVE) != 0 ) {
                 return; /* channel aleady active */                  return; /* channel aleady active */
Line 759  wdcstart(struct channel_softc *chp)
Line 759  wdcstart(struct channel_softc *chp)
                         return;                          return;
   
         WDCDEBUG_PRINT(("wdcstart: xfer %p channel %d drive %d\n", xfer,          WDCDEBUG_PRINT(("wdcstart: xfer %p channel %d drive %d\n", xfer,
             chp->channel, xfer->drive), DEBUG_XFERS);              chp->channel, xfer->c_drive), DEBUG_XFERS);
         chp->ch_flags |= WDCF_ACTIVE;          chp->ch_flags |= WDCF_ACTIVE;
         if (chp->ch_drive[xfer->drive].drive_flags & DRIVE_RESET) {          if (chp->ch_drive[xfer->c_drive].drive_flags & DRIVE_RESET) {
                 chp->ch_drive[xfer->drive].drive_flags &= ~DRIVE_RESET;                  chp->ch_drive[xfer->c_drive].drive_flags &= ~DRIVE_RESET;
                 chp->ch_drive[xfer->drive].state = 0;                  chp->ch_drive[xfer->c_drive].state = 0;
         }          }
         if (chp->wdc->cap & WDC_CAPABILITY_NOIRQ)          if (chp->wdc->cap & WDC_CAPABILITY_NOIRQ)
                 KASSERT(xfer->c_flags & C_POLL);                  KASSERT(xfer->c_flags & C_POLL);
Line 793  int
Line 793  int
 wdcintr(void *arg)  wdcintr(void *arg)
 {  {
         struct channel_softc *chp = arg;          struct channel_softc *chp = arg;
         struct wdc_xfer *xfer;          struct ata_xfer *xfer;
         int ret;          int ret;
   
         if ((chp->wdc->sc_dev.dv_flags & DVF_ACTIVE) == 0) {          if ((chp->wdc->sc_dev.dv_flags & DVF_ACTIVE) == 0) {
Line 810  wdcintr(void *arg)
Line 810  wdcintr(void *arg)
         }          }
   
         WDCDEBUG_PRINT(("wdcintr\n"), DEBUG_INTR);          WDCDEBUG_PRINT(("wdcintr\n"), DEBUG_INTR);
         xfer = chp->ch_queue->sc_xfer.tqh_first;          xfer = TAILQ_FIRST(&chp->ch_queue->queue_xfer);
         if (chp->ch_flags & WDCF_DMA_WAIT) {          if (chp->ch_flags & WDCF_DMA_WAIT) {
                 chp->wdc->dma_status =                  chp->wdc->dma_status =
                     (*chp->wdc->dma_finish)(chp->wdc->dma_arg, chp->channel,                      (*chp->wdc->dma_finish)(chp->wdc->dma_arg, chp->channel,
                         xfer->drive, 0);                          xfer->c_drive, 0);
                 if (chp->wdc->dma_status & WDC_DMAST_NOIRQ) {                  if (chp->wdc->dma_status & WDC_DMAST_NOIRQ) {
                         /* IRQ not for us, not detected by DMA engine */                          /* IRQ not for us, not detected by DMA engine */
                         return 0;                          return 0;
Line 1035  __wdcwait(struct channel_softc *chp, int
Line 1035  __wdcwait(struct channel_softc *chp, int
 #ifdef WDCNDELAY_DEBUG  #ifdef WDCNDELAY_DEBUG
         /* After autoconfig, there should be no long delays. */          /* After autoconfig, there should be no long delays. */
         if (!cold && time > WDCNDELAY_DEBUG) {          if (!cold && time > WDCNDELAY_DEBUG) {
                 struct wdc_xfer *xfer = chp->ch_queue->sc_xfer.tqh_first;                  struct ata_xfer *xfer = TAILQ_FIRST(&chp->ch_queue->queue_xfer);
                 if (xfer == NULL)                  if (xfer == NULL)
                         printf("%s channel %d: warning: busy-wait took %dus\n",                          printf("%s channel %d: warning: busy-wait took %dus\n",
                             chp->wdc->sc_dev.dv_xname, chp->channel,                              chp->wdc->sc_dev.dv_xname, chp->channel,
Line 1102  wdcwait(struct channel_softc *chp, int m
Line 1102  wdcwait(struct channel_softc *chp, int m
  * Busy-wait for DMA to complete   * Busy-wait for DMA to complete
  */   */
 int  int
 wdc_dmawait(struct channel_softc *chp, struct wdc_xfer *xfer, int timeout)  wdc_dmawait(struct channel_softc *chp, struct ata_xfer *xfer, int timeout)
 {  {
         int time;          int time;
         for (time = 0;  time < timeout * 1000 / WDCDELAY; time++) {          for (time = 0;  time < timeout * 1000 / WDCDELAY; time++) {
                 chp->wdc->dma_status =                  chp->wdc->dma_status =
                     (*chp->wdc->dma_finish)(chp->wdc->dma_arg,                      (*chp->wdc->dma_finish)(chp->wdc->dma_arg,
                         chp->channel, xfer->drive, 0);                          chp->channel, xfer->c_drive, 0);
                 if ((chp->wdc->dma_status & WDC_DMAST_NOIRQ) == 0)                  if ((chp->wdc->dma_status & WDC_DMAST_NOIRQ) == 0)
                         return 0;                          return 0;
                 delay(WDCDELAY);                  delay(WDCDELAY);
         }          }
         /* timeout, force a DMA halt */          /* timeout, force a DMA halt */
         chp->wdc->dma_status = (*chp->wdc->dma_finish)(chp->wdc->dma_arg,          chp->wdc->dma_status = (*chp->wdc->dma_finish)(chp->wdc->dma_arg,
             chp->channel, xfer->drive, 1);              chp->channel, xfer->c_drive, 1);
         return 1;          return 1;
 }  }
   
Line 1123  void
Line 1123  void
 wdctimeout(void *arg)  wdctimeout(void *arg)
 {  {
         struct channel_softc *chp = (struct channel_softc *)arg;          struct channel_softc *chp = (struct channel_softc *)arg;
         struct wdc_xfer *xfer = chp->ch_queue->sc_xfer.tqh_first;          struct ata_xfer *xfer = TAILQ_FIRST(&chp->ch_queue->queue_xfer);
         int s;          int s;
   
         WDCDEBUG_PRINT(("wdctimeout\n"), DEBUG_FUNCS);          WDCDEBUG_PRINT(("wdctimeout\n"), DEBUG_FUNCS);
Line 1138  wdctimeout(void *arg)
Line 1138  wdctimeout(void *arg)
                 if (chp->ch_flags & WDCF_DMA_WAIT) {                  if (chp->ch_flags & WDCF_DMA_WAIT) {
                         chp->wdc->dma_status =                          chp->wdc->dma_status =
                             (*chp->wdc->dma_finish)(chp->wdc->dma_arg,                              (*chp->wdc->dma_finish)(chp->wdc->dma_arg,
                                 chp->channel, xfer->drive, 1);                                  chp->channel, xfer->c_drive, 1);
                         chp->ch_flags &= ~WDCF_DMA_WAIT;                          chp->ch_flags &= ~WDCF_DMA_WAIT;
                 }                  }
                 /*                  /*
Line 1442  int
Line 1442  int
 wdc_exec_command(struct ata_drive_datas *drvp, struct wdc_command *wdc_c)  wdc_exec_command(struct ata_drive_datas *drvp, struct wdc_command *wdc_c)
 {  {
         struct channel_softc *chp = drvp->chnl_softc;          struct channel_softc *chp = drvp->chnl_softc;
         struct wdc_xfer *xfer;          struct ata_xfer *xfer;
         int s, ret;          int s, ret;
   
         WDCDEBUG_PRINT(("wdc_exec_command %s:%d:%d\n",          WDCDEBUG_PRINT(("wdc_exec_command %s:%d:%d\n",
Line 1460  wdc_exec_command(struct ata_drive_datas 
Line 1460  wdc_exec_command(struct ata_drive_datas 
                 wdc_c->flags |= AT_POLL;                  wdc_c->flags |= AT_POLL;
         if (wdc_c->flags & AT_POLL)          if (wdc_c->flags & AT_POLL)
                 xfer->c_flags |= C_POLL;                  xfer->c_flags |= C_POLL;
         xfer->drive = drvp->drive;          xfer->c_drive = drvp->drive;
         xfer->databuf = wdc_c->data;          xfer->c_databuf = wdc_c->data;
         xfer->c_bcount = wdc_c->bcount;          xfer->c_bcount = wdc_c->bcount;
         xfer->cmd = wdc_c;          xfer->c_cmd = wdc_c;
         xfer->c_start = __wdccommand_start;          xfer->c_start = __wdccommand_start;
         xfer->c_intr = __wdccommand_intr;          xfer->c_intr = __wdccommand_intr;
         xfer->c_kill_xfer = __wdccommand_done;          xfer->c_kill_xfer = __wdccommand_done;
Line 1492  wdc_exec_command(struct ata_drive_datas 
Line 1492  wdc_exec_command(struct ata_drive_datas 
 }  }
   
 void  void
 __wdccommand_start(struct channel_softc *chp, struct wdc_xfer *xfer)  __wdccommand_start(struct channel_softc *chp, struct ata_xfer *xfer)
 {  {
         int drive = xfer->drive;          int drive = xfer->c_drive;
         struct wdc_command *wdc_c = xfer->cmd;          struct wdc_command *wdc_c = xfer->c_cmd;
   
         WDCDEBUG_PRINT(("__wdccommand_start %s:%d:%d\n",          WDCDEBUG_PRINT(("__wdccommand_start %s:%d:%d\n",
             chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive),              chp->wdc->sc_dev.dv_xname, chp->channel, xfer->c_drive),
             DEBUG_FUNCS);              DEBUG_FUNCS);
   
         if (chp->wdc->cap & WDC_CAPABILITY_SELECT)          if (chp->wdc->cap & WDC_CAPABILITY_SELECT)
Line 1539  __wdccommand_start(struct channel_softc 
Line 1539  __wdccommand_start(struct channel_softc 
 }  }
   
 int  int
 __wdccommand_intr(struct channel_softc *chp, struct wdc_xfer *xfer, int irq)  __wdccommand_intr(struct channel_softc *chp, struct ata_xfer *xfer, int irq)
 {  {
         struct wdc_command *wdc_c = xfer->cmd;          struct wdc_command *wdc_c = xfer->c_cmd;
         int bcount = wdc_c->bcount;          int bcount = wdc_c->bcount;
         char *data = wdc_c->data;          char *data = wdc_c->data;
         int wflags;          int wflags;
Line 1555  __wdccommand_intr(struct channel_softc *
Line 1555  __wdccommand_intr(struct channel_softc *
   
  again:   again:
         WDCDEBUG_PRINT(("__wdccommand_intr %s:%d:%d\n",          WDCDEBUG_PRINT(("__wdccommand_intr %s:%d:%d\n",
             chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive), DEBUG_INTR);              chp->wdc->sc_dev.dv_xname, chp->channel, xfer->c_drive),
               DEBUG_INTR);
         /*          /*
          * after a ATAPI_SOFT_RESET, the device will have released the bus.           * after a ATAPI_SOFT_RESET, the device will have released the bus.
          * Reselect again, it doesn't hurt for others commands, and the time           * Reselect again, it doesn't hurt for others commands, and the time
Line 1563  __wdccommand_intr(struct channel_softc *
Line 1564  __wdccommand_intr(struct channel_softc *
          * wdc_exec_command() isn't called often (mosly for autoconfig)           * wdc_exec_command() isn't called often (mosly for autoconfig)
          */           */
         bus_space_write_1(chp->cmd_iot, chp->cmd_iohs[wd_sdh], 0,          bus_space_write_1(chp->cmd_iot, chp->cmd_iohs[wd_sdh], 0,
             WDSD_IBM | (xfer->drive << 4));              WDSD_IBM | (xfer->c_drive << 4));
         if ((wdc_c->flags & AT_XFDONE) != 0) {          if ((wdc_c->flags & AT_XFDONE) != 0) {
                 /*                  /*
                  * We have completed a data xfer. The drive should now be                   * We have completed a data xfer. The drive should now be
Line 1592  __wdccommand_intr(struct channel_softc *
Line 1593  __wdccommand_intr(struct channel_softc *
                         wdc_c->flags |= AT_TIMEOU;                          wdc_c->flags |= AT_TIMEOU;
                         goto out;                          goto out;
                 }                  }
                 if (chp->ch_drive[xfer->drive].drive_flags & DRIVE_CAP32) {                  if (chp->ch_drive[xfer->c_drive].drive_flags & DRIVE_CAP32) {
                         bus_space_read_multi_4(chp->data32iot, chp->data32ioh,                          bus_space_read_multi_4(chp->data32iot, chp->data32ioh,
                             0, (u_int32_t*)data, bcount >> 2);                              0, (u_int32_t*)data, bcount >> 2);
                         data += bcount & 0xfffffffc;                          data += bcount & 0xfffffffc;
Line 1610  __wdccommand_intr(struct channel_softc *
Line 1611  __wdccommand_intr(struct channel_softc *
                         wdc_c->flags |= AT_TIMEOU;                          wdc_c->flags |= AT_TIMEOU;
                         goto out;                          goto out;
                 }                  }
                 if (chp->ch_drive[xfer->drive].drive_flags & DRIVE_CAP32) {                  if (chp->ch_drive[xfer->c_drive].drive_flags & DRIVE_CAP32) {
                         bus_space_write_multi_4(chp->data32iot, chp->data32ioh,                          bus_space_write_multi_4(chp->data32iot, chp->data32ioh,
                             0, (u_int32_t*)data, bcount >> 2);                              0, (u_int32_t*)data, bcount >> 2);
                         data += bcount & 0xfffffffc;                          data += bcount & 0xfffffffc;
Line 1636  __wdccommand_intr(struct channel_softc *
Line 1637  __wdccommand_intr(struct channel_softc *
 }  }
   
 void  void
 __wdccommand_done(struct channel_softc *chp, struct wdc_xfer *xfer)  __wdccommand_done(struct channel_softc *chp, struct ata_xfer *xfer)
 {  {
         struct wdc_command *wdc_c = xfer->cmd;          struct wdc_command *wdc_c = xfer->c_cmd;
   
         WDCDEBUG_PRINT(("__wdccommand_done %s:%d:%d\n",          WDCDEBUG_PRINT(("__wdccommand_done %s:%d:%d\n",
             chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive), DEBUG_FUNCS);              chp->wdc->sc_dev.dv_xname, chp->channel, xfer->c_drive),
               DEBUG_FUNCS);
   
         callout_stop(&chp->ch_callout);          callout_stop(&chp->ch_callout);
   
Line 1790  wdccommandshort(struct channel_softc *ch
Line 1792  wdccommandshort(struct channel_softc *ch
   
 /* Add a command to the queue and start controller. Must be called at splbio */  /* Add a command to the queue and start controller. Must be called at splbio */
 void  void
 wdc_exec_xfer(struct channel_softc *chp, struct wdc_xfer *xfer)  wdc_exec_xfer(struct channel_softc *chp, struct ata_xfer *xfer)
 {  {
   
         WDCDEBUG_PRINT(("wdc_exec_xfer %p channel %d drive %d\n", xfer,          WDCDEBUG_PRINT(("wdc_exec_xfer %p channel %d drive %d\n", xfer,
             chp->channel, xfer->drive), DEBUG_XFERS);              chp->channel, xfer->c_drive), DEBUG_XFERS);
   
         /* complete xfer setup */          /* complete xfer setup */
         xfer->chp = chp;          xfer->c_chp = chp;
   
         /*          /*
          * If we are a polled command, and the list is not empty,           * If we are a polled command, and the list is not empty,
Line 1805  wdc_exec_xfer(struct channel_softc *chp,
Line 1807  wdc_exec_xfer(struct channel_softc *chp,
          * to complete, we're going to reboot soon anyway.           * to complete, we're going to reboot soon anyway.
          */           */
         if ((xfer->c_flags & C_POLL) != 0 &&          if ((xfer->c_flags & C_POLL) != 0 &&
             chp->ch_queue->sc_xfer.tqh_first != NULL) {              TAILQ_FIRST(&chp->ch_queue->queue_xfer) != NULL) {
                 TAILQ_INIT(&chp->ch_queue->sc_xfer);                  TAILQ_INIT(&chp->ch_queue->queue_xfer);
         }          }
         /* insert at the end of command list */          /* insert at the end of command list */
         TAILQ_INSERT_TAIL(&chp->ch_queue->sc_xfer,xfer , c_xferchain);          TAILQ_INSERT_TAIL(&chp->ch_queue->queue_xfer, xfer, c_xferchain);
         WDCDEBUG_PRINT(("wdcstart from wdc_exec_xfer, flags 0x%x\n",          WDCDEBUG_PRINT(("wdcstart from wdc_exec_xfer, flags 0x%x\n",
             chp->ch_flags), DEBUG_XFERS);              chp->ch_flags), DEBUG_XFERS);
         wdcstart(chp);          wdcstart(chp);
 }  }
   
 struct wdc_xfer *  struct ata_xfer *
 wdc_get_xfer(int flags)  wdc_get_xfer(int flags)
 {  {
         struct wdc_xfer *xfer;          struct ata_xfer *xfer;
         int s;          int s;
   
         s = splbio();          s = splbio();
Line 1826  wdc_get_xfer(int flags)
Line 1828  wdc_get_xfer(int flags)
             ((flags & WDC_NOSLEEP) != 0 ? PR_NOWAIT : PR_WAITOK));              ((flags & WDC_NOSLEEP) != 0 ? PR_NOWAIT : PR_WAITOK));
         splx(s);          splx(s);
         if (xfer != NULL) {          if (xfer != NULL) {
                 memset(xfer, 0, sizeof(struct wdc_xfer));                  memset(xfer, 0, sizeof(struct ata_xfer));
         }          }
         return xfer;          return xfer;
 }  }
   
 void  void
 wdc_free_xfer(struct channel_softc *chp, struct wdc_xfer *xfer)  wdc_free_xfer(struct channel_softc *chp, struct ata_xfer *xfer)
 {  {
         struct wdc_softc *wdc = chp->wdc;          struct wdc_softc *wdc = chp->wdc;
         int s;          int s;
Line 1841  wdc_free_xfer(struct channel_softc *chp,
Line 1843  wdc_free_xfer(struct channel_softc *chp,
                 (*wdc->free_hw)(chp);                  (*wdc->free_hw)(chp);
         s = splbio();          s = splbio();
         chp->ch_flags &= ~WDCF_ACTIVE;          chp->ch_flags &= ~WDCF_ACTIVE;
         TAILQ_REMOVE(&chp->ch_queue->sc_xfer, xfer, c_xferchain);          TAILQ_REMOVE(&chp->ch_queue->queue_xfer, xfer, c_xferchain);
         pool_put(&wdc_xfer_pool, xfer);          pool_put(&wdc_xfer_pool, xfer);
         splx(s);          splx(s);
 }  }
Line 1854  wdc_free_xfer(struct channel_softc *chp,
Line 1856  wdc_free_xfer(struct channel_softc *chp,
 void  void
 wdc_kill_pending(struct channel_softc *chp)  wdc_kill_pending(struct channel_softc *chp)
 {  {
         struct wdc_xfer *xfer;          struct ata_xfer *xfer;
   
         while ((xfer = TAILQ_FIRST(&chp->ch_queue->sc_xfer)) != NULL) {          while ((xfer = TAILQ_FIRST(&chp->ch_queue->queue_xfer)) != NULL) {
                 chp = xfer->chp;                  chp = xfer->c_chp;
                 (*xfer->c_kill_xfer)(chp, xfer);                  (*xfer->c_kill_xfer)(chp, xfer);
         }          }
 }  }
Line 1865  wdc_kill_pending(struct channel_softc *c
Line 1867  wdc_kill_pending(struct channel_softc *c
 static void  static void
 __wdcerror(struct channel_softc *chp, char *msg)  __wdcerror(struct channel_softc *chp, char *msg)
 {  {
         struct wdc_xfer *xfer = chp->ch_queue->sc_xfer.tqh_first;          struct ata_xfer *xfer = TAILQ_FIRST(&chp->ch_queue->queue_xfer);
   
         if (xfer == NULL)          if (xfer == NULL)
                 printf("%s:%d: %s\n", chp->wdc->sc_dev.dv_xname, chp->channel,                  printf("%s:%d: %s\n", chp->wdc->sc_dev.dv_xname, chp->channel,
                     msg);                      msg);
         else          else
                 printf("%s:%d:%d: %s\n", chp->wdc->sc_dev.dv_xname,                  printf("%s:%d:%d: %s\n", chp->wdc->sc_dev.dv_xname,
                     chp->channel, xfer->drive, msg);                      chp->channel, xfer->c_drive, msg);
 }  }
   
 /*  /*
Legend:
Removed from v.1.164  
changed lines
  Added in v.1.165
CVSweb <webmaster@jp.NetBSD.org>