Ignore:
Timestamp:
Mar 6, 2021, 7:44:15 PM (4 years ago)
Author:
David Azarewicz
Message:

Debugging support changes.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/os2ahci/ahci.c

    r207 r209  
    202202  if ((ai->cap & HOST_CAP_NCQ) && (ai->flags & AHCI_HFLAG_NO_NCQ))
    203203  {
    204     DPRINTF(1,"controller can't do NCQ, turning off CAP_NCQ\n");
     204    DPRINTF(DBG_INIT, DBG_PREFIX": controller can't do NCQ, turning off CAP_NCQ\n");
    205205    ai->cap &= ~HOST_CAP_NCQ;
    206206  }
     
    208208  if (!(ai->cap & HOST_CAP_NCQ) && (ai->flags & AHCI_HFLAG_YES_NCQ))
    209209  {
    210     DPRINTF(1,"controller can do NCQ, turning on CAP_NCQ\n");
     210    DPRINTF(DBG_INIT, DBG_PREFIX": controller can do NCQ, turning on CAP_NCQ\n");
    211211    ai->cap |= HOST_CAP_NCQ;
    212212  }
     
    214214  if ((ai->cap & HOST_CAP_PMP) && (ai->flags & AHCI_HFLAG_NO_PMP))
    215215  {
    216     DPRINTF(1,"controller can't do PMP, turning off CAP_PMP\n");
     216    DPRINTF(DBG_INIT, DBG_PREFIX": controller can't do PMP, turning off CAP_PMP\n");
    217217    ai->cap |= HOST_CAP_PMP;
    218218  }
     
    220220  if ((ai->cap & HOST_CAP_SNTF) && (ai->flags & AHCI_HFLAG_NO_SNTF))
    221221  {
    222     DPRINTF(1,"controller can't do SNTF, turning off CAP_SNTF\n");
     222    DPRINTF(DBG_INIT, DBG_PREFIX": controller can't do SNTF, turning off CAP_SNTF\n");
    223223    ai->cap &= ~HOST_CAP_SNTF;
    224224  }
     
    226226  if (ai->pci_vendor == PCI_VENDOR_ID_JMICRON && ai->pci_device == 0x2361 && ai->port_map != 1)
    227227  {
    228     DPRINTF(1,"JMB361 has only one port, port_map 0x%x -> 0x%x\n", ai->port_map, 1);
     228    DPRINTF(DBG_INIT, DBG_PREFIX": JMB361 has only one port, port_map 0x%x -> 0x%x\n", ai->port_map, 1);
    229229    ai->port_map = 1;
    230230    ai->hw_ports = 1;
     
    249249    /* more ports in port_map than in HOST_CAP & 0x1f */
    250250    ports = ai->hw_ports;
    251     DPRINTF(0,"implemented port map (0x%x) contains more ports than hw_ports (%d), using hw_ports\n", ai->port_map, ports);
     251    DPRINTF(DBG_INIT, DBG_PREFIX": implemented port map (0x%x) contains more ports than hw_ports (%d), using hw_ports\n", ai->port_map, ports);
    252252    ai->port_map = (1UL << ports) - 1UL;
    253253  }
     
    274274  }
    275275
    276   DPRINTF(3,__func__": BIOS AHCI mode is %d\n", ai->bios_config[HOST_CTL / sizeof(u32)] & HOST_AHCI_EN);
     276  DPRINTF(DBG_DETAILED, DBG_PREFIX": BIOS AHCI mode is %d\n", ai->bios_config[HOST_CTL / sizeof(u32)] & HOST_AHCI_EN);
    277277
    278278  if ((ai->bios_config[HOST_CTL / sizeof(u32)] & HOST_AHCI_EN) == 0 && ai->pci_vendor == PCI_VENDOR_ID_INTEL)
     
    284284  }
    285285
    286   DUMP_HOST_REGS(6,ai,1);
     286  DUMP_HOST_REGS(DBG_DETAILED, ai, 1);
    287287
    288288  return(0);
     
    296296int ahci_restore_bios_config(AD_INFO *ai)
    297297{
    298   DPRINTF(3,__func__": restoring AHCI BIOS configuration on adapter %d\n", ad_no(ai));
     298  DPRINTF(DBG_DETAILED, DBG_PREFIX": restoring AHCI BIOS configuration on adapter %d\n", ad_no(ai));
    299299
    300300  /* Restore saved BIOS configuration; please note that HOST_CTL is restored
     
    354354int ahci_restore_initial_config(AD_INFO *ai)
    355355{
    356   DPRINTF(3,__func__": restoring initial configuration on adapter %d\n", ad_no(ai));
     356  DPRINTF(DBG_DETAILED, DBG_PREFIX": restoring initial configuration on adapter %d\n", ad_no(ai));
    357357
    358358  /* restore saved BIOS configuration */
     
    379379    TIMER Timer;
    380380
    381     DPRINTF(2,"controller reset starting on adapter %d\n", ad_no(ai));
     381    DPRINTF(DBG_ATTACH, DBG_PREFIX": controller reset starting on adapter %d\n", ad_no(ai));
    382382
    383383    /* we must be in AHCI mode, before using anything AHCI-specific, such as HOST_RESET. */
     
    414414      u32 tmp16 = 0;
    415415
    416       DPRINTF(1,"ahci_reset_controller: intel detected\n");
     416      DPRINTF(DBG_ATTACH, DBG_PREFIX": ahci_reset_controller: intel detected\n");
    417417      /* configure PCS */
    418418      PciReadConfig(ai->bus, ai->dev_func, 0x92, sizeof(u16), &tmp16);
    419419      if ((tmp16 & ai->port_map) != ai->port_map) {
    420         DPRINTF(3,"ahci_reset_controller: updating PCS %x/%x\n", tmp16, ai->port_map);
     420        DPRINTF(DBG_ATTACH, DBG_PREFIX": ahci_reset_controller: updating PCS %x/%x\n", tmp16, ai->port_map);
    421421        tmp16 |= ai->port_map;
    422422        PciWriteConfig(ai->bus, ai->dev_func, 0x92, sizeof(u16), tmp16);
     
    535535  int i;
    536536
    537   DPRINTF(2,__func__": completing initialization of adapter #%d\n", ad_no(ai));
     537  DPRINTF(DBG_INIT, DBG_PREFIX": completing initialization of adapter #%d\n", ad_no(ai));
    538538
    539539  if (!ai->int_set)
     
    559559      if (i >= MAX_IRQ_HANDLERS) return -1; /* no more handlers available */
    560560
    561       DPRINTF(2,"registering interrupt %d pin=%d\n", ai->irq, ai->irq_pin);
     561      DPRINTF(DBG_INIT, DBG_PREFIX": registering interrupt %d pin=%d\n", ai->irq, ai->irq_pin);
    562562
    563563      rc = Dev32Help_SetIRQ(ahci_intr, ai->irq, p, ai->irq);
     
    592592      if (init_reset)
    593593      {
    594         DPRINTF(3,__func__": resetting port %d\n", p);
     594        DPRINTF(DBG_INIT, DBG_PREFIX": resetting port %d\n", p);
    595595        ahci_reset_port(ai, p, 1);
    596596      }
    597597      else
    598598      {
    599         DPRINTF(3,__func__": restarting port #%d\n", p);
     599        DPRINTF(DBG_INIT, DBG_PREFIX": restarting port #%d\n", p);
    600600        ahci_stop_port(ai, p);
    601601        ahci_start_port(ai, p, 1);
     
    615615  /* pci_enable_int(ai->bus, ai->dev_func); */
    616616
    617   DPRINTF(2,__func__": done\n");
     617  DPRINTF(DBG_INIT|DBG_FUNCEND, DBG_PREFIX": END\n");
    618618  return(0);
    619619}
     
    644644         AP_END)) break;
    645645
    646     DHEXDUMP(5, pSector0, 512, "Sector0:\n");
     646    DHEXDUMP(DBG_DETAILED, pSector0, 512, "Sector0:\n");
    647647
    648648    /* check for wiped disk */
     
    722722  }
    723723
    724   DPRINTF(2,"found device %d.%d.%d: removable=%d dev_type=%d atapi=%d ncq_max=%d\n",
     724  DPRINTF(DBG_ATTACH, DBG_PREFIX": found device %d.%d.%d: removable=%d dev_type=%d atapi=%d ncq_max=%d\n",
    725725          ad_no(ai), p, d,
    726726          ai->ports[p].devs[d].removable,
     
    804804
    805805  /* perform port scan */
    806   DPRINTF(1,__func__": scanning ports on adapter %d\n", ad_no(ai));
     806  DPRINTF(DBG_ATTACH, DBG_PREFIX": scanning ports on adapter %d\n", ad_no(ai));
    807807  for (p = 0; p < AHCI_MAX_PORTS; p++)
    808808  {
     
    812812    // DAZ allocate port structure here
    813813
    814     DPRINTF(3,__func__": Wait till not busy on port %d\n", p);
     814    DPRINTF(DBG_ATTACH, DBG_PREFIX": Wait till not busy on port %d\n", p);
    815815    /* wait until all active commands have completed on this port */
    816816    TimerInit(&Timer, 250);
     
    832832    else
    833833    {
    834       DPRINTF(3,__func__": (re)starting port %d\n", p);
     834      DPRINTF(DBG_ATTACH, DBG_PREFIX": (re)starting port %d\n", p);
    835835      ahci_stop_port(ai, p);
    836836      rc = ahci_start_port(ai, p, 0);
     
    840840    {
    841841      /* this port seems to have a device attached and ready for commands */
    842       DPRINTF(2,__func__": port %d seems to be attached to a device; probing...\n", p);
     842      DPRINTF(DBG_ATTACH, DBG_PREFIX": port %d seems to be attached to a device; probing...\n", p);
    843843
    844844      #ifdef DAZ_NEW_CODE
     
    871871    {
    872872      /* we have a valid IDENTIFY or IDENTIFY_PACKET response */
    873       DHEXDUMP(5,id_buf, ATA_ID_WORDS * sizeof(u16), "ATA_IDENTIFY%s results:\n", (is_ata) ? "" : "_PACKET");
     873      DHEXDUMP(DBG_DETAILED,id_buf, ATA_ID_WORDS * sizeof(u16), "ATA_IDENTIFY%s results:\n", (is_ata) ? "" : "_PACKET");
    874874      ahci_setup_device(ai, p, 0, id_buf);
    875875      if (!IsUsableDisk(ai, p, 0)) ai->ports[p].devs[0].ignored = 1;
     
    915915  TIMER Timer;
    916916
    917   DPRINTF(3,__func__": resetting port %d.%d\n", ad_no(ai), p);
    918   DUMP_PORT_REGS(3,ai,p);
     917  DPRINTF(DBG_ATTACH, DBG_PREFIX": resetting port %d.%d\n", ad_no(ai), p);
     918  DUMP_PORT_REGS(DBG_DETAILED,ai,p);
    919919
    920920  /* stop port engines (we don't care whether there is an error doing so) */
     
    932932
    933933  /* set link speed and power management options */
    934   DPRINTF(3,__func__": setting link speed and power management options\n");
     934  DPRINTF(DBG_DETAILED, DBG_PREFIX": setting link speed and power management options\n");
    935935  tmp = readl(port_mmio + PORT_SCR_CTL) & ~0x00000fffUL;
    936936  tmp |= (link_speed[ad_no(ai)][p] & 0x0f) << 4;
     
    939939
    940940  /* issue COMRESET on the port */
    941   DPRINTF(3,__func__": issuing COMRESET on port %d\n", p);
     941  DPRINTF(DBG_DETAILED, DBG_PREFIX": issuing COMRESET on port %d\n", p);
    942942  writel(port_mmio + PORT_SCR_CTL, tmp | 1);
    943943  readl(port_mmio + PORT_SCR_CTL);  /* flush */
     
    950950
    951951  /* wait for communication to be re-established after port reset */
    952   DPRINTF(3,"Wait for communication...\n");
     952  DPRINTF(DBG_DETAILED, DBG_PREFIX": Wait for communication...\n");
    953953  TimerInit(&Timer, 500);
    954954  while (((tmp = readl(port_mmio + PORT_SCR_STAT)) & 3) != 3)
     
    956956    if (TimerCheckAndBlock(&Timer))
    957957    {
    958       DPRINTF(2,"no device present after resetting port #%d (PORT_SCR_STAT = 0x%x)\n", p, tmp);
     958      DPRINTF(DBG_ATTACH, DBG_PREFIX": no device present after resetting port #%d (PORT_SCR_STAT = 0x%x)\n", p, tmp);
    959959      return(-1);
    960960    }
     
    966966
    967967  /* start port so we can receive the COMRESET FIS */
    968   DPRINTF(3,__func__": starting port %d again\n", p);
     968  DPRINTF(DBG_DETAILED, DBG_PREFIX": starting port %d again\n", p);
    969969  ahci_start_port(ai, p, ei);
    970970
     
    975975    if (TimerCheckAndBlock(&Timer))
    976976    {
    977       DPRINTF(0,"device not ready on port #%d (PORT_TFDATA = 0x%x)\n", p, tmp);
     977      DPRINTF(0, DBG_PREFIX": device not ready on port #%d (PORT_TFDATA = 0x%x)\n", p, tmp);
    978978      ahci_stop_port(ai, p);
    979979      return(-1);
    980980    }
    981981  }
    982   DPRINTF(3,__func__": PORT_TFDATA = 0x%x\n", readl(port_mmio + PORT_TFDATA));
     982  DPRINTF(DBG_ATTACH|DBG_FUNCEND, DBG_PREFIX": END PORT_TFDATA = 0x%x\n", readl(port_mmio + PORT_TFDATA));
    983983
    984984  return(0);
     
    993993  u32 status;
    994994
    995   DPRINTF(3,__func__": %d.%d\n", ad_no(ai), p);
     995  DPRINTF(DBG_ATTACH, DBG_PREFIX": %d.%d\n", ad_no(ai), p);
    996996  /* check whether device presence is detected and link established */
    997997
    998998  status = readl(port_mmio + PORT_SCR_STAT);
    999   DPRINTF(3,__func__": PORT_SCR_STAT = 0x%x\n", status);
     999  DPRINTF(DBG_DETAILED, DBG_PREFIX": PORT_SCR_STAT = 0x%x\n", status);
    10001000  if ((status & 0xf) != 3) return(-1);
    10011001
    10021002  /* clear SError, if any */
    10031003  status = readl(port_mmio + PORT_SCR_ERR);
    1004   DPRINTF(3,__func__": PORT_SCR_ERR  = 0x%x\n", status);
     1004  DPRINTF(DBG_DETAILED, DBG_PREFIX": PORT_SCR_ERR  = 0x%x\n", status);
    10051005  writel(port_mmio + PORT_SCR_ERR, status);
    10061006
     
    10901090  int rc;
    10911091
    1092   DPRINTF(3,__func__": %d.%d\n", ad_no(ai), p);
     1092  DPRINTF(DBG_ATTACH, DBG_PREFIX": %d.%d\n", ad_no(ai), p);
    10931093
    10941094  /* disable port interrupts */
     
    12331233  }
    12341234
    1235   DPRINTF(7,"---------- "__func__": iorb=%x\n", vIorb);
     1235  DPRINTF(DBG_DETAILED, DBG_PREFIX": ---------- iorb=%x\n", vIorb);
    12361236
    12371237  /* Enable AHCI mode; apparently, the AHCI mode may end up becoming
     
    12591259      cmd_max = ai->cmd_max;
    12601260    }
    1261     DPRINTF(8,__func__": NCQ command; cmd_max = %d->%d\n", ai->cmd_max, cmd_max);
     1261    DPRINTF(DBG_DETAILED, DBG_PREFIX": NCQ command; cmd_max = %d->%d\n", ai->cmd_max, cmd_max);
    12621262  }
    12631263
     
    13121312        aws->cmd_slot = port->cmd_slot;
    13131313
    1314         DPRINTF(7,__func__": Issuing command Slot=%d cmds=%x\n", port->cmd_slot, *cmds);
     1314        DPRINTF(DBG_DETAILED, DBG_PREFIX": Issuing command Slot=%d cmds=%x\n", port->cmd_slot, *cmds);
    13151315        if (aws->is_ncq)
    13161316        {
     
    14051405  {
    14061406    /* successfully prepared cmd; issue cmd and wait for completion */
    1407     DPRINTF(3,"---------- "__func__" executing polled cmd on slot 0...");
     1407    DPRINTF(DBG_DETAILED, DBG_PREFIX": ---------- executing polled cmd on slot 0...");
    14081408    writel(port_mmio + PORT_CMD_ISSUE, 1);
    14091409    TimerInit(&Timer, timeout);
     
    14171417    if (rc)
    14181418    {
    1419       DPRINTF(3," timeout for IORB %x port=%x", vIorb, p);
     1419      DPRINTF(DBG_DETAILED, " timeout for IORB %x port=%x", vIorb, p);
    14201420      iorb_seterr(pIorb, IOERR_ADAPTER_TIMEOUT);
    14211421    }
    14221422    else if (readl(port_mmio + PORT_SCR_ERR) != 0 || readl(port_mmio + PORT_TFDATA) & 0x89)
    14231423    {
    1424       DPRINTF(3," polled cmd error for IORB %x", vIorb);
     1424      DPRINTF(DBG_DETAILED, " polled cmd error for IORB %x", vIorb);
    14251425      iorb_seterr(pIorb, IOERR_DEVICE_NONSPECIFIC);
    14261426      ahci_reset_port(ai, iorb_unit_port(pIorb), 0);
     
    14381438      }
    14391439    }
    1440     DPRINTF(3,"\n");
     1440    DPRINTF(DBG_DETAILED, "\n");
    14411441  }
    14421442
     
    14761476  if (readl(port_mmio + PORT_CMD_ISSUE) & 1)
    14771477  {
    1478     DPRINTF(3,__func__": port %d slot 0 is not idle; not executing polled cmd\n", p);
     1478    DPRINTF(0, DBG_PREFIX": port %d slot 0 is not idle; not executing polled cmd\n", p);
    14791479    return(-1);
    14801480  }
     
    14851485
    14861486  /* start command execution for slot 0 */
    1487   DPRINTF(3,"---------- "__func__" executing polled cmd...");
     1487  DPRINTF(DBG_DETAILED, DBG_PREFIX": ---------- executing polled cmd...");
    14881488  writel(port_mmio + PORT_CMD_ISSUE, 1);
    14891489
     
    14961496    if (rc)
    14971497    {
    1498       DPRINTF(2," Timeout");
     1498      DPRINTF(DBG_DETAILED, " Timeout");
    14991499      break;
    15001500    }
     
    15041504  if (tmp & PORT_ERR_FAIL_BITS)
    15051505  {
    1506     DPRINTF(2," SERR = 0x%08lx", tmp);
     1506    DPRINTF(DBG_DETAILED, " SERR = 0x%08lx", tmp);
    15071507    rc = 1;
    15081508  }
     
    15101510  if (((tmp = readl(port_mmio + PORT_TFDATA)) & 0x89) != 0)
    15111511  {
    1512     DPRINTF(2," TFDATA = 0x%08lx", tmp);
     1512    DPRINTF(DBG_DETAILED, " TFDATA = 0x%08lx", tmp);
    15131513    rc = 1;
    15141514  }
     
    15161516  if (rc)
    15171517  {
    1518     DPRINTF(3,"failed\n");
     1518    DPRINTF(DBG_DETAILED, "failed\n");
    15191519    ahci_reset_port(ai, p, 0);
    15201520    return(-1);
    15211521  }
    1522   DPRINTF(3,"success\n");
     1522  DPRINTF(DBG_DETAILED, "success\n");
    15231523  return(0);
    15241524}
     
    15371537  if (!ai->ports[p].devs[d].atapi)
    15381538  {
    1539     DPRINTF(2,__func__": flushing cache on %d.%d.%d\n", ad_no(ai), p, d);
     1539    DPRINTF(DBG_INIT, DBG_PREFIX": flushing cache on %d.%d.%d\n", ad_no(ai), p, d);
    15401540    return(ahci_exec_polled_cmd(ai, p, d, 30000,
    15411541           ai->ports[p].devs[d].lba48 ? ATA_CMD_FLUSH_EXT : ATA_CMD_FLUSH, AP_END));
     
    15541554int ahci_set_dev_idle(AD_INFO *ai, int p, int d, int idle)
    15551555{
    1556   DPRINTF(3,__func__": sending IDLE=%d command to port %d\n", idle, p);
     1556  DPRINTF(DBG_FUNCBEG, DBG_PREFIX": sending IDLE=%d command to port %d\n", idle, p);
    15571557  return ahci_exec_polled_cmd(ai, p, d, 500, ATA_CMD_IDLE, AP_COUNT, idle ? 1 : 0, AP_END);
    15581558}
     
    16121612    if ((u32)&irq_stat < 0xf000)
    16131613    {
    1614       DPRINTF(0,__func__": IRQ stack running low; arming engine context hook\n");
     1614      DPRINTF(DBG_DETAILED, DBG_PREFIX": IRQ stack running low; arming engine context hook\n");
    16151615      /* Rousseau:
    16161616       * A context hook cannot be re-armed before it has completed.
     
    16891689    active_cmds = readl(port_mmio + PORT_SCR_ACT);
    16901690    done_mask = ai->ports[p].ncq_cmds ^ active_cmds;
    1691     DPRINTF(7,"[ncq_cmds]: active_cmds=0x%08x done_mask=0x%08x\n", active_cmds, done_mask);
     1691    DPRINTF(DBG_DETAILED, DBG_PREFIX": [ncq_cmds]: active_cmds=0x%08x done_mask=0x%08x\n", active_cmds, done_mask);
    16921692  }
    16931693  else
     
    16951695    active_cmds = readl(port_mmio + PORT_CMD_ISSUE);
    16961696    done_mask = ai->ports[p].reg_cmds ^ active_cmds;
    1697     DPRINTF(7,"[reg_cmds]: active_cmds=0x%08x  done_mask=0x%08x\n", active_cmds, done_mask);
     1697    DPRINTF(DBG_DETAILED, DBG_PREFIX": [reg_cmds]: active_cmds=0x%08x  done_mask=0x%08x\n", active_cmds, done_mask);
    16981698  }
    16991699
     
    17751775    #ifdef DEBUG
    17761776    u32 *unk = (u32 *) (port_dma_base(ai, p)->rx_fis + RX_FIS_UNK);
    1777     DPRINTF(0,"warning: unknown FIS %08lx %08lx %08lx %08lx\n", unk[0], unk[1], unk[2], unk[3]);
     1777    dprintf(0,"warning: unknown FIS %08lx %08lx %08lx %08lx\n", unk[0], unk[1], unk[2], unk[3]);
    17781778    #endif
    17791779    reset_port = 1;
     
    18031803  dprintf(0,"port #%d interrupt error status: 0x%08x; restarting port\n", p, irq_stat);
    18041804  #else
    1805   if (!ai->ports[p].devs[0].atapi || D32g_DbgLevel)
     1805  if (!ai->ports[p].devs[0].atapi)
    18061806  {
    18071807    dprintf(0,"port #%d interrupt error status: 0x%08x; restarting port\n", p, irq_stat);
     
    18231823void ahci_get_geometry(IORBH FAR16DATA *vIorb, IORBH *pIorb)
    18241824{
    1825   DPRINTF(7,"ahci_get_geometry(%d.%d.%d)\n", iorb_unit_adapter(pIorb),
     1825  DPRINTF(DBG_FUNCBEG, DBG_PREFIX": ahci_get_geometry(%d.%d.%d)\n", iorb_unit_adapter(pIorb),
    18261826          iorb_unit_port(pIorb), iorb_unit_device(pIorb));
    18271827
     
    18341834void ahci_unit_ready(IORBH FAR16DATA *vIorb, IORBH *pIorb)
    18351835{
    1836   DPRINTF(7,"ahci_unit_ready(%d.%d.%d)\n", iorb_unit_adapter(pIorb),
     1836  DPRINTF(DBG_FUNCBEG, DBG_PREFIX": ahci_unit_ready(%d.%d.%d)\n", iorb_unit_adapter(pIorb),
    18371837          iorb_unit_port(pIorb), iorb_unit_device(pIorb));
    18381838
     
    18451845void ahci_read(IORBH FAR16DATA *vIorb, IORBH *pIorb)
    18461846{
    1847   DPRINTF(7,"ahci_read(%d.%d.%d, %d, %d)\n", iorb_unit_adapter(vIorb),
     1847  DPRINTF(DBG_FUNCBEG, DBG_PREFIX": ahci_read(%d.%d.%d, %d, %d)\n", iorb_unit_adapter(vIorb),
    18481848          iorb_unit_port(pIorb), iorb_unit_device(pIorb),
    18491849          ((IORB_EXECUTEIO *) pIorb)->RBA,
     
    18581858void ahci_verify(IORBH FAR16DATA *vIorb, IORBH *pIorb)
    18591859{
    1860   DPRINTF(7,"ahci_verify(%d.%d.%d, %d, %d)\n", iorb_unit_adapter(pIorb),
     1860  DPRINTF(DBG_FUNCBEG, DBG_PREFIX": ahci_verify(%d.%d.%d, %d, %d)\n", iorb_unit_adapter(pIorb),
    18611861          iorb_unit_port(pIorb), iorb_unit_device(pIorb),
    18621862          ((IORB_EXECUTEIO *)pIorb)->RBA,
     
    18711871void ahci_write(IORBH FAR16DATA *vIorb, IORBH *pIorb)
    18721872{
    1873   DPRINTF(7,"ahci_write(%d.%d.%d, %d, %d)\n", iorb_unit_adapter(pIorb),
     1873  DPRINTF(DBG_FUNCBEG, DBG_PREFIX": ahci_write(%d.%d.%d, %d, %d)\n", iorb_unit_adapter(pIorb),
    18741874          iorb_unit_port(pIorb), iorb_unit_device(pIorb),
    18751875          ((IORB_EXECUTEIO *)pIorb)->RBA,
     
    18881888  int d = iorb_unit_device(pIorb);
    18891889
    1890   DHEXDUMP(5,Far16ToFlat(((IORB_ADAPTER_PASSTHRU *)pIorb)->f16ControllerCmd),
     1890  DHEXDUMP(DBG_DETAILED ,Far16ToFlat(((IORB_ADAPTER_PASSTHRU *)pIorb)->f16ControllerCmd),
    18911891        ((IORB_ADAPTER_PASSTHRU *)pIorb)->ControllerCmdLen,
    18921892        "ahci_execute_cdb(%d.%d.%d): ", a, p, d);
     
    19141914  int d = iorb_unit_device(pIorb);
    19151915
    1916   DHEXDUMP(5,Far16ToFlat(((IORB_ADAPTER_PASSTHRU *)pIorb)->f16ControllerCmd),
     1916  DHEXDUMP(DBG_DETAILED, Far16ToFlat(((IORB_ADAPTER_PASSTHRU *)pIorb)->f16ControllerCmd),
    19171917        ((IORB_ADAPTER_PASSTHRU *)pIorb)->ControllerCmdLen,
    19181918        "ahci_execute_ata(%d.%d.%d): ", a, p, d);
Note: See TracChangeset for help on using the changeset viewer.