usr.sbin/bhyve/pci_hda.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2016 Alex Teaca <iateaca@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  *
  28  */
  29
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <time.h>
  35
  36 #include "pci_hda.h"
  37 #include "bhyverun.h"
  38 #include "config.h"
  39 #include "pci_emul.h"
  40 #include "hdac_reg.h"
  41
  42 /*
  43  * HDA defines
  44  */
  45 #define PCIR_HDCTL              0x40
  46 #define INTEL_VENDORID          0x8086
  47 #define HDA_INTEL_82801G        0x27d8
  48
  49 #define HDA_IOSS_NO             0x08
  50 #define HDA_OSS_NO              0x04
  51 #define HDA_ISS_NO              0x04
  52 #define HDA_CODEC_MAX           0x0f
  53 #define HDA_LAST_OFFSET                                         \
  54         (0x2084 + ((HDA_ISS_NO) * 0x20) + ((HDA_OSS_NO) * 0x20))
  55 #define HDA_CORB_ENTRY_LEN      0x04
  56 #define HDA_RIRB_ENTRY_LEN      0x08
  57 #define HDA_BDL_ENTRY_LEN       0x10
  58 #define HDA_DMA_PIB_ENTRY_LEN   0x08
  59 #define HDA_STREAM_TAGS_CNT     0x10
  60 #define HDA_STREAM_REGS_BASE    0x80
  61 #define HDA_STREAM_REGS_LEN     0x20
  62
  63 #define HDA_DMA_ACCESS_LEN      (sizeof(uint32_t))
  64 #define HDA_BDL_MAX_LEN         0x0100
  65
  66 #define HDAC_SDSTS_FIFORDY      (1 << 5)
  67
  68 #define HDA_RIRBSTS_IRQ_MASK    (HDAC_RIRBSTS_RINTFL | HDAC_RIRBSTS_RIRBOIS)
  69 #define HDA_STATESTS_IRQ_MASK   ((1 << HDA_CODEC_MAX) - 1)
  70 #define HDA_SDSTS_IRQ_MASK                                      \
  71         (HDAC_SDSTS_DESE | HDAC_SDSTS_FIFOE | HDAC_SDSTS_BCIS)
  72
  73 /*
  74  * HDA data structures
  75  */
  76
  77 struct hda_softc;
  78
  79 typedef void (*hda_set_reg_handler)(struct hda_softc *sc, uint32_t offset,
  80                 uint32_t old);
  81
  82 struct hda_bdle {
  83         uint32_t addrl;
  84         uint32_t addrh;
  85         uint32_t len;
  86         uint32_t ioc;
  87 } __packed;
  88
  89 struct hda_bdle_desc {
  90         void *addr;
  91         uint8_t ioc;
  92         uint32_t len;
  93 };
  94
  95 struct hda_codec_cmd_ctl {
  96         const char *name;
  97         void *dma_vaddr;
  98         uint8_t run;
  99         uint16_t rp;
 100         uint16_t size;
 101         uint16_t wp;
 102 };
 103
 104 struct hda_stream_desc {
 105         uint8_t dir;
 106         uint8_t run;
 107         uint8_t stream;
 108
 109         /* bp is the no. of bytes transferred in the current bdle */
 110         uint32_t bp;
 111         /* be is the no. of bdles transferred in the bdl */
 112         uint32_t be;
 113
 114         uint32_t bdl_cnt;
 115         struct hda_bdle_desc bdl[HDA_BDL_MAX_LEN];
 116 };
 117
 118 struct hda_softc {
 119         struct pci_devinst *pci_dev;
 120         uint32_t regs[HDA_LAST_OFFSET];
 121
 122         uint8_t lintr;
 123         uint8_t rirb_cnt;
 124         uint64_t wall_clock_start;
 125
 126         struct hda_codec_cmd_ctl corb;
 127         struct hda_codec_cmd_ctl rirb;
 128
 129         uint8_t codecs_no;
 130         struct hda_codec_inst *codecs[HDA_CODEC_MAX];
 131
 132         /* Base Address of the DMA Position Buffer */
 133         void *dma_pib_vaddr;
 134
 135         struct hda_stream_desc streams[HDA_IOSS_NO];
 136         /* 2 tables for output and input */
 137         uint8_t stream_map[2][HDA_STREAM_TAGS_CNT];
 138 };
 139
 140 /*
 141  * HDA module function declarations
 142  */
 143 static inline void hda_set_reg_by_offset(struct hda_softc *sc, uint32_t offset,
 144     uint32_t value);
 145 static inline uint32_t hda_get_reg_by_offset(struct hda_softc *sc,
 146     uint32_t offset);
 147 static inline void hda_set_field_by_offset(struct hda_softc *sc,
 148     uint32_t offset, uint32_t mask, uint32_t value);
 149
 150 static struct hda_softc *hda_init(nvlist_t *nvl);
 151 static void hda_update_intr(struct hda_softc *sc);
 152 static void hda_response_interrupt(struct hda_softc *sc);
 153 static int hda_codec_constructor(struct hda_softc *sc,
 154     struct hda_codec_class *codec, const char *play, const char *rec);
 155 static struct hda_codec_class *hda_find_codec_class(const char *name);
 156
 157 static int hda_send_command(struct hda_softc *sc, uint32_t verb);
 158 static int hda_notify_codecs(struct hda_softc *sc, uint8_t run,
 159     uint8_t stream, uint8_t dir);
 160 static void hda_reset(struct hda_softc *sc);
 161 static void hda_reset_regs(struct hda_softc *sc);
 162 static void hda_stream_reset(struct hda_softc *sc, uint8_t stream_ind);
 163 static int hda_stream_start(struct hda_softc *sc, uint8_t stream_ind);
 164 static int hda_stream_stop(struct hda_softc *sc, uint8_t stream_ind);
 165 static uint32_t hda_read(struct hda_softc *sc, uint32_t offset);
 166 static int hda_write(struct hda_softc *sc, uint32_t offset, uint8_t size,
 167     uint32_t value);
 168
 169 static inline void hda_print_cmd_ctl_data(struct hda_codec_cmd_ctl *p);
 170 static int hda_corb_start(struct hda_softc *sc);
 171 static int hda_corb_run(struct hda_softc *sc);
 172 static int hda_rirb_start(struct hda_softc *sc);
 173
 174 static void *hda_dma_get_vaddr(struct hda_softc *sc, uint64_t dma_paddr,
 175     size_t len);
 176 static void hda_dma_st_dword(void *dma_vaddr, uint32_t data);
 177 static uint32_t hda_dma_ld_dword(void *dma_vaddr);
 178
 179 static inline uint8_t hda_get_stream_by_offsets(uint32_t offset,
 180     uint8_t reg_offset);
 181 static inline uint32_t hda_get_offset_stream(uint8_t stream_ind);
 182
 183 static void hda_set_gctl(struct hda_softc *sc, uint32_t offset, uint32_t old);
 184 static void hda_set_statests(struct hda_softc *sc, uint32_t offset,
 185     uint32_t old);
 186 static void hda_set_corbwp(struct hda_softc *sc, uint32_t offset, uint32_t old);
 187 static void hda_set_corbctl(struct hda_softc *sc, uint32_t offset,
 188     uint32_t old);
 189 static void hda_set_rirbctl(struct hda_softc *sc, uint32_t offset,
 190     uint32_t old);
 191 static void hda_set_rirbsts(struct hda_softc *sc, uint32_t offset,
 192     uint32_t old);
 193 static void hda_set_dpiblbase(struct hda_softc *sc, uint32_t offset,
 194     uint32_t old);
 195 static void hda_set_sdctl(struct hda_softc *sc, uint32_t offset, uint32_t old);
 196 static void hda_set_sdctl2(struct hda_softc *sc, uint32_t offset, uint32_t old);
 197 static void hda_set_sdsts(struct hda_softc *sc, uint32_t offset, uint32_t old);
 198
 199 static int hda_signal_state_change(struct hda_codec_inst *hci);
 200 static int hda_response(struct hda_codec_inst *hci, uint32_t response,
 201     uint8_t unsol);
 202 static int hda_transfer(struct hda_codec_inst *hci, uint8_t stream,
 203     uint8_t dir, uint8_t *buf, size_t count);
 204
 205 static void hda_set_pib(struct hda_softc *sc, uint8_t stream_ind, uint32_t pib);
 206 static uint64_t hda_get_clock_ns(void);
 207
 208 /*
 209  * PCI HDA function declarations
 210  */
 211 static int pci_hda_init(struct pci_devinst *pi, nvlist_t *nvl);
 212 static void pci_hda_write(struct pci_devinst *pi, int baridx, uint64_t offset,
 213     int size, uint64_t value);
 214 static uint64_t pci_hda_read(struct pci_devinst *pi, int baridx,
 215     uint64_t offset, int size);
 216 /*
 217  * HDA global data
 218  */
 219
 220 static const hda_set_reg_handler hda_set_reg_table[] = {
 221         [HDAC_GCTL] = hda_set_gctl,
 222         [HDAC_STATESTS] = hda_set_statests,
 223         [HDAC_CORBWP] = hda_set_corbwp,
 224         [HDAC_CORBCTL] = hda_set_corbctl,
 225         [HDAC_RIRBCTL] = hda_set_rirbctl,
 226         [HDAC_RIRBSTS] = hda_set_rirbsts,
 227         [HDAC_DPIBLBASE] = hda_set_dpiblbase,
 228
 229 #define HDAC_ISTREAM(n, iss, oss)                               \
 230         [_HDAC_ISDCTL(n, iss, oss)] = hda_set_sdctl,            \
 231         [_HDAC_ISDCTL(n, iss, oss) + 2] = hda_set_sdctl2,       \
 232         [_HDAC_ISDSTS(n, iss, oss)] = hda_set_sdsts,            \
 233
 234 #define HDAC_OSTREAM(n, iss, oss)                               \
 235         [_HDAC_OSDCTL(n, iss, oss)] = hda_set_sdctl,            \
 236         [_HDAC_OSDCTL(n, iss, oss) + 2] = hda_set_sdctl2,       \
 237         [_HDAC_OSDSTS(n, iss, oss)] = hda_set_sdsts,            \
 238
 239         HDAC_ISTREAM(0, HDA_ISS_NO, HDA_OSS_NO)
 240         HDAC_ISTREAM(1, HDA_ISS_NO, HDA_OSS_NO)
 241         HDAC_ISTREAM(2, HDA_ISS_NO, HDA_OSS_NO)
 242         HDAC_ISTREAM(3, HDA_ISS_NO, HDA_OSS_NO)
 243
 244         HDAC_OSTREAM(0, HDA_ISS_NO, HDA_OSS_NO)
 245         HDAC_OSTREAM(1, HDA_ISS_NO, HDA_OSS_NO)
 246         HDAC_OSTREAM(2, HDA_ISS_NO, HDA_OSS_NO)
 247         HDAC_OSTREAM(3, HDA_ISS_NO, HDA_OSS_NO)
 248 };
 249
 250 static const uint16_t hda_corb_sizes[] = {
 251         [HDAC_CORBSIZE_CORBSIZE_2]      = 2,
 252         [HDAC_CORBSIZE_CORBSIZE_16]     = 16,
 253         [HDAC_CORBSIZE_CORBSIZE_256]    = 256,
 254         [HDAC_CORBSIZE_CORBSIZE_MASK]   = 0,
 255 };
 256
 257 static const uint16_t hda_rirb_sizes[] = {
 258         [HDAC_RIRBSIZE_RIRBSIZE_2]      = 2,
 259         [HDAC_RIRBSIZE_RIRBSIZE_16]     = 16,
 260         [HDAC_RIRBSIZE_RIRBSIZE_256]    = 256,
 261         [HDAC_RIRBSIZE_RIRBSIZE_MASK]   = 0,
 262 };
 263
 264 static const struct hda_ops hops = {
 265         .signal         = hda_signal_state_change,
 266         .response       = hda_response,
 267         .transfer       = hda_transfer,
 268 };
 269
 270 static const struct pci_devemu pci_de_hda = {
 271         .pe_emu         = "hda",
 272         .pe_init        = pci_hda_init,
 273         .pe_barwrite    = pci_hda_write,
 274         .pe_barread     = pci_hda_read
 275 };
 276 PCI_EMUL_SET(pci_de_hda);
 277
 278 SET_DECLARE(hda_codec_class_set, struct hda_codec_class);
 279
 280 #if DEBUG_HDA == 1
 281 FILE *dbg;
 282 #endif
 283
 284 /*
 285  * HDA module function definitions
 286  */
 287
 288 static inline void
 289 hda_set_reg_by_offset(struct hda_softc *sc, uint32_t offset, uint32_t value)
 290 {
 291         assert(offset < HDA_LAST_OFFSET);
 292         sc->regs[offset] = value;
 293 }
 294
 295 static inline uint32_t
 296 hda_get_reg_by_offset(struct hda_softc *sc, uint32_t offset)
 297 {
 298         assert(offset < HDA_LAST_OFFSET);
 299         return sc->regs[offset];
 300 }
 301
 302 static inline void
 303 hda_set_field_by_offset(struct hda_softc *sc, uint32_t offset,
 304     uint32_t mask, uint32_t value)
 305 {
 306         uint32_t reg_value = 0;
 307
 308         reg_value = hda_get_reg_by_offset(sc, offset);
 309
 310         reg_value &= ~mask;
 311         reg_value |= (value & mask);
 312
 313         hda_set_reg_by_offset(sc, offset, reg_value);
 314 }
 315
 316 static struct hda_softc *
 317 hda_init(nvlist_t *nvl)
 318 {
 319         struct hda_softc *sc = NULL;
 320         struct hda_codec_class *codec = NULL;
 321         const char *value;
 322         char *play;
 323         char *rec;
 324         int err;
 325
 326 #if DEBUG_HDA == 1
 327         dbg = fopen(DEBUG_HDA_FILE, "w+");
 328 #endif
 329
 330         sc = calloc(1, sizeof(*sc));
 331         if (!sc)
 332                 return (NULL);
 333
 334         hda_reset_regs(sc);
 335
 336         /*
 337          * TODO search all configured codecs
 338          * For now we play with one single codec
 339          */
 340         codec = hda_find_codec_class("hda_codec");
 341         if (codec) {
 342                 value = get_config_value_node(nvl, "play");
 343                 if (value == NULL)
 344                         play = NULL;
 345                 else
 346                         play = strdup(value);
 347                 value = get_config_value_node(nvl, "rec");
 348                 if (value == NULL)
 349                         rec = NULL;
 350                 else
 351                         rec = strdup(value);
 352                 DPRINTF("play: %s rec: %s", play, rec);
 353                 if (play != NULL || rec != NULL) {
 354                         err = hda_codec_constructor(sc, codec, play, rec);
 355                         assert(!err);
 356                 }
 357                 free(play);
 358                 free(rec);
 359         }
 360
 361         return (sc);
 362 }
 363
 364 static void
 365 hda_update_intr(struct hda_softc *sc)
 366 {
 367         struct pci_devinst *pi = sc->pci_dev;
 368         uint32_t intctl = hda_get_reg_by_offset(sc, HDAC_INTCTL);
 369         uint32_t intsts = 0;
 370         uint32_t sdsts = 0;
 371         uint32_t rirbsts = 0;
 372         uint32_t wakeen = 0;
 373         uint32_t statests = 0;
 374         uint32_t off = 0;
 375         int i;
 376
 377         /* update the CIS bits */
 378         rirbsts = hda_get_reg_by_offset(sc, HDAC_RIRBSTS);
 379         if (rirbsts & (HDAC_RIRBSTS_RINTFL | HDAC_RIRBSTS_RIRBOIS))
 380                 intsts |= HDAC_INTSTS_CIS;
 381
 382         wakeen = hda_get_reg_by_offset(sc, HDAC_WAKEEN);
 383         statests = hda_get_reg_by_offset(sc, HDAC_STATESTS);
 384         if (statests & wakeen)
 385                 intsts |= HDAC_INTSTS_CIS;
 386
 387         /* update the SIS bits */
 388         for (i = 0; i < HDA_IOSS_NO; i++) {
 389                 off = hda_get_offset_stream(i);
 390                 sdsts = hda_get_reg_by_offset(sc, off + HDAC_SDSTS);
 391                 if (sdsts & HDAC_SDSTS_BCIS)
 392                         intsts |= (1 << i);
 393         }
 394
 395         /* update the GIS bit */
 396         if (intsts)
 397                 intsts |= HDAC_INTSTS_GIS;
 398
 399         hda_set_reg_by_offset(sc, HDAC_INTSTS, intsts);
 400
 401         if ((intctl & HDAC_INTCTL_GIE) && ((intsts &                    \
 402                 ~HDAC_INTSTS_GIS) & intctl)) {
 403                 if (!sc->lintr) {
 404                         pci_lintr_assert(pi);
 405                         sc->lintr = 1;
 406                 }
 407         } else {
 408                 if (sc->lintr) {
 409                         pci_lintr_deassert(pi);
 410                         sc->lintr = 0;
 411                 }
 412         }
 413 }
 414
 415 static void
 416 hda_response_interrupt(struct hda_softc *sc)
 417 {
 418         uint8_t rirbctl = hda_get_reg_by_offset(sc, HDAC_RIRBCTL);
 419
 420         if ((rirbctl & HDAC_RIRBCTL_RINTCTL) && sc->rirb_cnt) {
 421                 sc->rirb_cnt = 0;
 422                 hda_set_field_by_offset(sc, HDAC_RIRBSTS, HDAC_RIRBSTS_RINTFL,
 423                                 HDAC_RIRBSTS_RINTFL);
 424                 hda_update_intr(sc);
 425         }
 426 }
 427
 428 static int
 429 hda_codec_constructor(struct hda_softc *sc, struct hda_codec_class *codec,
 430     const char *play, const char *rec)
 431 {
 432         struct hda_codec_inst *hci = NULL;
 433
 434         if (sc->codecs_no >= HDA_CODEC_MAX)
 435                 return (-1);
 436
 437         hci = calloc(1, sizeof(struct hda_codec_inst));
 438         if (!hci)
 439                 return (-1);
 440
 441         hci->hda = sc;
 442         hci->hops = &hops;
 443         hci->cad = sc->codecs_no;
 444         hci->codec = codec;
 445
 446         sc->codecs[sc->codecs_no++] = hci;
 447
 448         if (!codec->init) {
 449                 DPRINTF("This codec does not implement the init function");
 450                 return (-1);
 451         }
 452
 453         return (codec->init(hci, play, rec));
 454 }
 455
 456 static struct hda_codec_class *
 457 hda_find_codec_class(const char *name)
 458 {
 459         struct hda_codec_class **pdpp = NULL, *pdp = NULL;
 460
 461         SET_FOREACH(pdpp, hda_codec_class_set) {
 462                 pdp = *pdpp;
 463                 if (!strcmp(pdp->name, name)) {
 464                         return (pdp);
 465                 }
 466         }
 467
 468         return (NULL);
 469 }
 470
 471 static int
 472 hda_send_command(struct hda_softc *sc, uint32_t verb)
 473 {
 474         struct hda_codec_inst *hci = NULL;
 475         struct hda_codec_class *codec = NULL;
 476         uint8_t cad = (verb >> HDA_CMD_CAD_SHIFT) & 0x0f;
 477
 478         if (cad >= sc->codecs_no)
 479                 return (-1);
 480
 481         DPRINTF("cad: 0x%x verb: 0x%x", cad, verb);
 482
 483         hci = sc->codecs[cad];
 484         assert(hci);
 485
 486         codec = hci->codec;
 487         assert(codec);
 488
 489         if (!codec->command) {
 490                 DPRINTF("This codec does not implement the command function");
 491                 return (-1);
 492         }
 493
 494         return (codec->command(hci, verb));
 495 }
 496
 497 static int
 498 hda_notify_codecs(struct hda_softc *sc, uint8_t run, uint8_t stream,
 499     uint8_t dir)
 500 {
 501         struct hda_codec_inst *hci = NULL;
 502         struct hda_codec_class *codec = NULL;
 503         int err;
 504         int i;
 505
 506         /* Notify each codec */
 507         for (i = 0; i < sc->codecs_no; i++) {
 508                 hci = sc->codecs[i];
 509                 assert(hci);
 510
 511                 codec = hci->codec;
 512                 assert(codec);
 513
 514                 if (codec->notify) {
 515                         err = codec->notify(hci, run, stream, dir);
 516                         if (!err)
 517                                 break;
 518                 }
 519         }
 520
 521         return (i == sc->codecs_no ? (-1) : 0);
 522 }
 523
 524 static void
 525 hda_reset(struct hda_softc *sc)
 526 {
 527         int i;
 528         struct hda_codec_inst *hci = NULL;
 529         struct hda_codec_class *codec = NULL;
 530
 531         hda_reset_regs(sc);
 532
 533         /* Reset each codec */
 534         for (i = 0; i < sc->codecs_no; i++) {
 535                 hci = sc->codecs[i];
 536                 assert(hci);
 537
 538                 codec = hci->codec;
 539                 assert(codec);
 540
 541                 if (codec->reset)
 542                         codec->reset(hci);
 543         }
 544
 545         sc->wall_clock_start = hda_get_clock_ns();
 546 }
 547
 548 static void
 549 hda_reset_regs(struct hda_softc *sc)
 550 {
 551         uint32_t off = 0;
 552         uint8_t i;
 553
 554         DPRINTF("Reset the HDA controller registers ...");
 555
 556         memset(sc->regs, 0, sizeof(sc->regs));
 557
 558         hda_set_reg_by_offset(sc, HDAC_GCAP,
 559                         HDAC_GCAP_64OK |
 560                         (HDA_ISS_NO << HDAC_GCAP_ISS_SHIFT) |
 561                         (HDA_OSS_NO << HDAC_GCAP_OSS_SHIFT));
 562         hda_set_reg_by_offset(sc, HDAC_VMAJ, 0x01);
 563         hda_set_reg_by_offset(sc, HDAC_OUTPAY, 0x3c);
 564         hda_set_reg_by_offset(sc, HDAC_INPAY, 0x1d);
 565         hda_set_reg_by_offset(sc, HDAC_CORBSIZE,
 566             HDAC_CORBSIZE_CORBSZCAP_256 | HDAC_CORBSIZE_CORBSIZE_256);
 567         hda_set_reg_by_offset(sc, HDAC_RIRBSIZE,
 568             HDAC_RIRBSIZE_RIRBSZCAP_256 | HDAC_RIRBSIZE_RIRBSIZE_256);
 569
 570         for (i = 0; i < HDA_IOSS_NO; i++) {
 571                 off = hda_get_offset_stream(i);
 572                 hda_set_reg_by_offset(sc, off + HDAC_SDFIFOS, HDA_FIFO_SIZE);
 573         }
 574 }
 575
 576 static void
 577 hda_stream_reset(struct hda_softc *sc, uint8_t stream_ind)
 578 {
 579         struct hda_stream_desc *st = &sc->streams[stream_ind];
 580         uint32_t off = hda_get_offset_stream(stream_ind);
 581
 582         DPRINTF("Reset the HDA stream: 0x%x", stream_ind);
 583
 584         /* Reset the Stream Descriptor registers */
 585         memset(sc->regs + HDA_STREAM_REGS_BASE + off, 0, HDA_STREAM_REGS_LEN);
 586
 587         /* Reset the Stream Descriptor */
 588         memset(st, 0, sizeof(*st));
 589
 590         hda_set_field_by_offset(sc, off + HDAC_SDSTS,
 591             HDAC_SDSTS_FIFORDY, HDAC_SDSTS_FIFORDY);
 592         hda_set_field_by_offset(sc, off + HDAC_SDCTL0,
 593             HDAC_SDCTL_SRST, HDAC_SDCTL_SRST);
 594 }
 595
 596 static int
 597 hda_stream_start(struct hda_softc *sc, uint8_t stream_ind)
 598 {
 599         struct hda_stream_desc *st = &sc->streams[stream_ind];
 600         struct hda_bdle_desc *bdle_desc = NULL;
 601         struct hda_bdle *bdle = NULL;
 602         uint32_t lvi = 0;
 603         uint32_t bdl_cnt = 0;
 604         uint64_t bdpl = 0;
 605         uint64_t bdpu = 0;
 606         uint64_t bdl_paddr = 0;
 607         void *bdl_vaddr = NULL;
 608         uint32_t bdle_sz = 0;
 609         uint64_t bdle_addrl = 0;
 610         uint64_t bdle_addrh = 0;
 611         uint64_t bdle_paddr = 0;
 612         void *bdle_vaddr = NULL;
 613         uint32_t off = hda_get_offset_stream(stream_ind);
 614         uint32_t sdctl = 0;
 615         uint8_t strm = 0;
 616         uint8_t dir = 0;
 617
 618         assert(!st->run);
 619
 620         lvi = hda_get_reg_by_offset(sc, off + HDAC_SDLVI);
 621         bdpl = hda_get_reg_by_offset(sc, off + HDAC_SDBDPL);
 622         bdpu = hda_get_reg_by_offset(sc, off + HDAC_SDBDPU);
 623
 624         bdl_cnt = lvi + 1;
 625         assert(bdl_cnt <= HDA_BDL_MAX_LEN);
 626
 627         bdl_paddr = bdpl | (bdpu << 32);
 628         bdl_vaddr = hda_dma_get_vaddr(sc, bdl_paddr,
 629             HDA_BDL_ENTRY_LEN * bdl_cnt);
 630         if (!bdl_vaddr) {
 631                 DPRINTF("Fail to get the guest virtual address");
 632                 return (-1);
 633         }
 634
 635         DPRINTF("stream: 0x%x bdl_cnt: 0x%x bdl_paddr: 0x%lx",
 636             stream_ind, bdl_cnt, bdl_paddr);
 637
 638         st->bdl_cnt = bdl_cnt;
 639
 640         bdle = (struct hda_bdle *)bdl_vaddr;
 641         for (size_t i = 0; i < bdl_cnt; i++, bdle++) {
 642                 bdle_sz = bdle->len;
 643                 assert(!(bdle_sz % HDA_DMA_ACCESS_LEN));
 644
 645                 bdle_addrl = bdle->addrl;
 646                 bdle_addrh = bdle->addrh;
 647
 648                 bdle_paddr = bdle_addrl | (bdle_addrh << 32);
 649                 bdle_vaddr = hda_dma_get_vaddr(sc, bdle_paddr, bdle_sz);
 650                 if (!bdle_vaddr) {
 651                         DPRINTF("Fail to get the guest virtual address");
 652                         return (-1);
 653                 }
 654
 655                 bdle_desc = &st->bdl[i];
 656                 bdle_desc->addr = bdle_vaddr;
 657                 bdle_desc->len = bdle_sz;
 658                 bdle_desc->ioc = bdle->ioc;
 659
 660                 DPRINTF("bdle: 0x%zx bdle_sz: 0x%x", i, bdle_sz);
 661         }
 662
 663         sdctl = hda_get_reg_by_offset(sc, off + HDAC_SDCTL0);
 664         strm = (sdctl >> 20) & 0x0f;
 665         dir = stream_ind >= HDA_ISS_NO;
 666
 667         DPRINTF("strm: 0x%x, dir: 0x%x", strm, dir);
 668
 669         sc->stream_map[dir][strm] = stream_ind;
 670         st->stream = strm;
 671         st->dir = dir;
 672         st->bp = 0;
 673         st->be = 0;
 674
 675         hda_set_pib(sc, stream_ind, 0);
 676
 677         st->run = 1;
 678
 679         hda_notify_codecs(sc, 1, strm, dir);
 680
 681         return (0);
 682 }
 683
 684 static int
 685 hda_stream_stop(struct hda_softc *sc, uint8_t stream_ind)
 686 {
 687         struct hda_stream_desc *st = &sc->streams[stream_ind];
 688         uint8_t strm = st->stream;
 689         uint8_t dir = st->dir;
 690
 691         DPRINTF("stream: 0x%x, strm: 0x%x, dir: 0x%x", stream_ind, strm, dir);
 692
 693         st->run = 0;
 694
 695         hda_notify_codecs(sc, 0, strm, dir);
 696
 697         return (0);
 698 }
 699
 700 static uint32_t
 701 hda_read(struct hda_softc *sc, uint32_t offset)
 702 {
 703         if (offset == HDAC_WALCLK)
 704                 return (24 * (hda_get_clock_ns() -                      \
 705                         sc->wall_clock_start) / 1000);
 706
 707         return (hda_get_reg_by_offset(sc, offset));
 708 }
 709
 710 static int
 711 hda_write(struct hda_softc *sc, uint32_t offset, uint8_t size, uint32_t value)
 712 {
 713         uint32_t old = hda_get_reg_by_offset(sc, offset);
 714         uint32_t masks[] = {0x00000000, 0x000000ff, 0x0000ffff,
 715                         0x00ffffff, 0xffffffff};
 716         hda_set_reg_handler set_reg_handler = NULL;
 717
 718         if (offset < nitems(hda_set_reg_table))
 719                 set_reg_handler = hda_set_reg_table[offset];
 720
 721         hda_set_field_by_offset(sc, offset, masks[size], value);
 722
 723         if (set_reg_handler)
 724                 set_reg_handler(sc, offset, old);
 725
 726         return (0);
 727 }
 728
 729 #if DEBUG_HDA == 1
 730 static inline void
 731 hda_print_cmd_ctl_data(struct hda_codec_cmd_ctl *p)
 732 {
 733         DPRINTF("%s size: %d", p->name, p->size);
 734         DPRINTF("%s dma_vaddr: %p", p->name, p->dma_vaddr);
 735         DPRINTF("%s wp: 0x%x", p->name, p->wp);
 736         DPRINTF("%s rp: 0x%x", p->name, p->rp);
 737 }
 738 #else
 739 static inline void
 740 hda_print_cmd_ctl_data(struct hda_codec_cmd_ctl *p __unused) {}
 741 #endif
 742
 743 static int
 744 hda_corb_start(struct hda_softc *sc)
 745 {
 746         struct hda_codec_cmd_ctl *corb = &sc->corb;
 747         uint8_t corbsize = 0;
 748         uint64_t corblbase = 0;
 749         uint64_t corbubase = 0;
 750         uint64_t corbpaddr = 0;
 751
 752         corb->name = "CORB";
 753
 754         corbsize = hda_get_reg_by_offset(sc, HDAC_CORBSIZE) &           \
 755                    HDAC_CORBSIZE_CORBSIZE_MASK;
 756         corb->size = hda_corb_sizes[corbsize];
 757
 758         if (!corb->size) {
 759                 DPRINTF("Invalid corb size");
 760                 return (-1);
 761         }
 762
 763         corblbase = hda_get_reg_by_offset(sc, HDAC_CORBLBASE);
 764         corbubase = hda_get_reg_by_offset(sc, HDAC_CORBUBASE);
 765
 766         corbpaddr = corblbase | (corbubase << 32);
 767         DPRINTF("CORB dma_paddr: %p", (void *)corbpaddr);
 768
 769         corb->dma_vaddr = hda_dma_get_vaddr(sc, corbpaddr,
 770                         HDA_CORB_ENTRY_LEN * corb->size);
 771         if (!corb->dma_vaddr) {
 772                 DPRINTF("Fail to get the guest virtual address");
 773                 return (-1);
 774         }
 775
 776         corb->wp = hda_get_reg_by_offset(sc, HDAC_CORBWP);
 777         corb->rp = hda_get_reg_by_offset(sc, HDAC_CORBRP);
 778
 779         corb->run = 1;
 780
 781         hda_print_cmd_ctl_data(corb);
 782
 783         return (0);
 784 }
 785
 786 static int
 787 hda_corb_run(struct hda_softc *sc)
 788 {
 789         struct hda_codec_cmd_ctl *corb = &sc->corb;
 790         uint32_t verb = 0;
 791         int err;
 792
 793         corb->wp = hda_get_reg_by_offset(sc, HDAC_CORBWP);
 794
 795         while (corb->rp != corb->wp && corb->run) {
 796                 corb->rp++;
 797                 corb->rp %= corb->size;
 798
 799                 verb = hda_dma_ld_dword((uint8_t *)corb->dma_vaddr +
 800                     HDA_CORB_ENTRY_LEN * corb->rp);
 801
 802                 err = hda_send_command(sc, verb);
 803                 assert(!err);
 804         }
 805
 806         hda_set_reg_by_offset(sc, HDAC_CORBRP, corb->rp);
 807
 808         if (corb->run)
 809                 hda_response_interrupt(sc);
 810
 811         return (0);
 812 }
 813
 814 static int
 815 hda_rirb_start(struct hda_softc *sc)
 816 {
 817         struct hda_codec_cmd_ctl *rirb = &sc->rirb;
 818         uint8_t rirbsize = 0;
 819         uint64_t rirblbase = 0;
 820         uint64_t rirbubase = 0;
 821         uint64_t rirbpaddr = 0;
 822
 823         rirb->name = "RIRB";
 824
 825         rirbsize = hda_get_reg_by_offset(sc, HDAC_RIRBSIZE) &           \
 826                    HDAC_RIRBSIZE_RIRBSIZE_MASK;
 827         rirb->size = hda_rirb_sizes[rirbsize];
 828
 829         if (!rirb->size) {
 830                 DPRINTF("Invalid rirb size");
 831                 return (-1);
 832         }
 833
 834         rirblbase = hda_get_reg_by_offset(sc, HDAC_RIRBLBASE);
 835         rirbubase = hda_get_reg_by_offset(sc, HDAC_RIRBUBASE);
 836
 837         rirbpaddr = rirblbase | (rirbubase << 32);
 838         DPRINTF("RIRB dma_paddr: %p", (void *)rirbpaddr);
 839
 840         rirb->dma_vaddr = hda_dma_get_vaddr(sc, rirbpaddr,
 841                         HDA_RIRB_ENTRY_LEN * rirb->size);
 842         if (!rirb->dma_vaddr) {
 843                 DPRINTF("Fail to get the guest virtual address");
 844                 return (-1);
 845         }
 846
 847         rirb->wp = hda_get_reg_by_offset(sc, HDAC_RIRBWP);
 848         rirb->rp = 0x0000;
 849
 850         rirb->run = 1;
 851
 852         hda_print_cmd_ctl_data(rirb);
 853
 854         return (0);
 855 }
 856
 857 static void *
 858 hda_dma_get_vaddr(struct hda_softc *sc, uint64_t dma_paddr, size_t len)
 859 {
 860         struct pci_devinst *pi = sc->pci_dev;
 861
 862         assert(pi);
 863
 864         return (paddr_guest2host(pi->pi_vmctx, (uintptr_t)dma_paddr, len));
 865 }
 866
 867 static void
 868 hda_dma_st_dword(void *dma_vaddr, uint32_t data)
 869 {
 870         *(uint32_t*)dma_vaddr = data;
 871 }
 872
 873 static uint32_t
 874 hda_dma_ld_dword(void *dma_vaddr)
 875 {
 876         return (*(uint32_t*)dma_vaddr);
 877 }
 878
 879 static inline uint8_t
 880 hda_get_stream_by_offsets(uint32_t offset, uint8_t reg_offset)
 881 {
 882         uint8_t stream_ind = (offset - reg_offset) >> 5;
 883
 884         assert(stream_ind < HDA_IOSS_NO);
 885
 886         return (stream_ind);
 887 }
 888
 889 static inline uint32_t
 890 hda_get_offset_stream(uint8_t stream_ind)
 891 {
 892         return (stream_ind << 5);
 893 }
 894
 895 static void
 896 hda_set_gctl(struct hda_softc *sc, uint32_t offset, uint32_t old __unused)
 897 {
 898         uint32_t value = hda_get_reg_by_offset(sc, offset);
 899
 900         if (!(value & HDAC_GCTL_CRST)) {
 901                 hda_reset(sc);
 902         }
 903 }
 904
 905 static void
 906 hda_set_statests(struct hda_softc *sc, uint32_t offset, uint32_t old)
 907 {
 908         uint32_t value = hda_get_reg_by_offset(sc, offset);
 909
 910         hda_set_reg_by_offset(sc, offset, old);
 911
 912         /* clear the corresponding bits written by the software (guest) */
 913         hda_set_field_by_offset(sc, offset, value & HDA_STATESTS_IRQ_MASK, 0);
 914
 915         hda_update_intr(sc);
 916 }
 917
 918 static void
 919 hda_set_corbwp(struct hda_softc *sc, uint32_t offset __unused,
 920     uint32_t old __unused)
 921 {
 922         hda_corb_run(sc);
 923 }
 924
 925 static void
 926 hda_set_corbctl(struct hda_softc *sc, uint32_t offset, uint32_t old)
 927 {
 928         uint32_t value = hda_get_reg_by_offset(sc, offset);
 929         int err;
 930         struct hda_codec_cmd_ctl *corb = NULL;
 931
 932         if (value & HDAC_CORBCTL_CORBRUN) {
 933                 if (!(old & HDAC_CORBCTL_CORBRUN)) {
 934                         err = hda_corb_start(sc);
 935                         assert(!err);
 936                 }
 937         } else {
 938                 corb = &sc->corb;
 939                 memset(corb, 0, sizeof(*corb));
 940         }
 941
 942         hda_corb_run(sc);
 943 }
 944
 945 static void
 946 hda_set_rirbctl(struct hda_softc *sc, uint32_t offset, uint32_t old __unused)
 947 {
 948         uint32_t value = hda_get_reg_by_offset(sc, offset);
 949         int err;
 950         struct hda_codec_cmd_ctl *rirb = NULL;
 951
 952         if (value & HDAC_RIRBCTL_RIRBDMAEN) {
 953                 err = hda_rirb_start(sc);
 954                 assert(!err);
 955         } else {
 956                 rirb = &sc->rirb;
 957                 memset(rirb, 0, sizeof(*rirb));
 958         }
 959 }
 960
 961 static void
 962 hda_set_rirbsts(struct hda_softc *sc, uint32_t offset, uint32_t old)
 963 {
 964         uint32_t value = hda_get_reg_by_offset(sc, offset);
 965
 966         hda_set_reg_by_offset(sc, offset, old);
 967
 968         /* clear the corresponding bits written by the software (guest) */
 969         hda_set_field_by_offset(sc, offset, value & HDA_RIRBSTS_IRQ_MASK, 0);
 970
 971         hda_update_intr(sc);
 972 }
 973
 974 static void
 975 hda_set_dpiblbase(struct hda_softc *sc, uint32_t offset, uint32_t old)
 976 {
 977         uint32_t value = hda_get_reg_by_offset(sc, offset);
 978         uint64_t dpiblbase = 0;
 979         uint64_t dpibubase = 0;
 980         uint64_t dpibpaddr = 0;
 981
 982         if ((value & HDAC_DPLBASE_DPLBASE_DMAPBE) != (old &             \
 983                                 HDAC_DPLBASE_DPLBASE_DMAPBE)) {
 984                 if (value & HDAC_DPLBASE_DPLBASE_DMAPBE) {
 985                         dpiblbase = value & HDAC_DPLBASE_DPLBASE_MASK;
 986                         dpibubase = hda_get_reg_by_offset(sc, HDAC_DPIBUBASE);
 987
 988                         dpibpaddr = dpiblbase | (dpibubase << 32);
 989                         DPRINTF("DMA Position In Buffer dma_paddr: %p",
 990                             (void *)dpibpaddr);
 991
 992                         sc->dma_pib_vaddr = hda_dma_get_vaddr(sc, dpibpaddr,
 993                                         HDA_DMA_PIB_ENTRY_LEN * HDA_IOSS_NO);
 994                         if (!sc->dma_pib_vaddr) {
 995                                 DPRINTF("Fail to get the guest \
 996                                          virtual address");
 997                                 assert(0);
 998                         }
 999                 } else {
1000                         DPRINTF("DMA Position In Buffer Reset");
1001                         sc->dma_pib_vaddr = NULL;
1002                 }
1003         }
1004 }
1005
1006 static void
1007 hda_set_sdctl(struct hda_softc *sc, uint32_t offset, uint32_t old)
1008 {
1009         uint8_t stream_ind = hda_get_stream_by_offsets(offset, HDAC_SDCTL0);
1010         uint32_t value = hda_get_reg_by_offset(sc, offset);
1011         int err;
1012
1013         DPRINTF("stream_ind: 0x%x old: 0x%x value: 0x%x",
1014             stream_ind, old, value);
1015
1016         if (value & HDAC_SDCTL_SRST) {
1017                 hda_stream_reset(sc, stream_ind);
1018         }
1019
1020         if ((value & HDAC_SDCTL_RUN) != (old & HDAC_SDCTL_RUN)) {
1021                 if (value & HDAC_SDCTL_RUN) {
1022                         err = hda_stream_start(sc, stream_ind);
1023                         assert(!err);
1024                 } else {
1025                         err = hda_stream_stop(sc, stream_ind);
1026                         assert(!err);
1027                 }
1028         }
1029 }
1030
1031 static void
1032 hda_set_sdctl2(struct hda_softc *sc, uint32_t offset, uint32_t old __unused)
1033 {
1034         uint32_t value = hda_get_reg_by_offset(sc, offset);
1035
1036         hda_set_field_by_offset(sc, offset - 2, 0x00ff0000, value << 16);
1037 }
1038
1039 static void
1040 hda_set_sdsts(struct hda_softc *sc, uint32_t offset, uint32_t old)
1041 {
1042         uint32_t value = hda_get_reg_by_offset(sc, offset);
1043
1044         hda_set_reg_by_offset(sc, offset, old);
1045
1046         /* clear the corresponding bits written by the software (guest) */
1047         hda_set_field_by_offset(sc, offset, value & HDA_SDSTS_IRQ_MASK, 0);
1048
1049         hda_update_intr(sc);
1050 }
1051
1052 static int
1053 hda_signal_state_change(struct hda_codec_inst *hci)
1054 {
1055         struct hda_softc *sc = NULL;
1056         uint32_t sdiwake = 0;
1057
1058         assert(hci);
1059         assert(hci->hda);
1060
1061         DPRINTF("cad: 0x%x", hci->cad);
1062
1063         sc = hci->hda;
1064         sdiwake = 1 << hci->cad;
1065
1066         hda_set_field_by_offset(sc, HDAC_STATESTS, sdiwake, sdiwake);
1067         hda_update_intr(sc);
1068
1069         return (0);
1070 }
1071
1072 static int
1073 hda_response(struct hda_codec_inst *hci, uint32_t response, uint8_t unsol)
1074 {
1075         struct hda_softc *sc = NULL;
1076         struct hda_codec_cmd_ctl *rirb = NULL;
1077         uint32_t response_ex = 0;
1078         uint8_t rintcnt = 0;
1079
1080         assert(hci);
1081         assert(hci->cad <= HDA_CODEC_MAX);
1082
1083         response_ex = hci->cad | unsol;
1084
1085         sc = hci->hda;
1086         assert(sc);
1087
1088         rirb = &sc->rirb;
1089
1090         if (rirb->run) {
1091                 rirb->wp++;
1092                 rirb->wp %= rirb->size;
1093
1094                 hda_dma_st_dword((uint8_t *)rirb->dma_vaddr +
1095                     HDA_RIRB_ENTRY_LEN * rirb->wp, response);
1096                 hda_dma_st_dword((uint8_t *)rirb->dma_vaddr +
1097                     HDA_RIRB_ENTRY_LEN * rirb->wp + 0x04, response_ex);
1098
1099                 hda_set_reg_by_offset(sc, HDAC_RIRBWP, rirb->wp);
1100
1101                 sc->rirb_cnt++;
1102         }
1103
1104         rintcnt = hda_get_reg_by_offset(sc, HDAC_RINTCNT);
1105         if (sc->rirb_cnt == rintcnt)
1106                 hda_response_interrupt(sc);
1107
1108         return (0);
1109 }
1110
1111 static int
1112 hda_transfer(struct hda_codec_inst *hci, uint8_t stream, uint8_t dir,
1113     uint8_t *buf, size_t count)
1114 {
1115         struct hda_softc *sc = NULL;
1116         struct hda_stream_desc *st = NULL;
1117         struct hda_bdle_desc *bdl = NULL;
1118         struct hda_bdle_desc *bdle_desc = NULL;
1119         uint8_t stream_ind = 0;
1120         uint32_t lpib = 0;
1121         uint32_t off = 0;
1122         size_t left = 0;
1123         uint8_t irq = 0;
1124
1125         assert(hci);
1126         assert(hci->hda);
1127         assert(buf);
1128         assert(!(count % HDA_DMA_ACCESS_LEN));
1129
1130         if (!stream) {
1131                 DPRINTF("Invalid stream");
1132                 return (-1);
1133         }
1134
1135         sc = hci->hda;
1136
1137         assert(stream < HDA_STREAM_TAGS_CNT);
1138         stream_ind = sc->stream_map[dir][stream];
1139
1140         if (!dir)
1141                 assert(stream_ind < HDA_ISS_NO);
1142         else
1143                 assert(stream_ind >= HDA_ISS_NO && stream_ind < HDA_IOSS_NO);
1144
1145         st = &sc->streams[stream_ind];
1146         if (!st->run) {
1147                 DPRINTF("Stream 0x%x stopped", stream);
1148                 return (-1);
1149         }
1150
1151         assert(st->stream == stream);
1152
1153         off = hda_get_offset_stream(stream_ind);
1154
1155         lpib = hda_get_reg_by_offset(sc, off + HDAC_SDLPIB);
1156
1157         bdl = st->bdl;
1158
1159         assert(st->be < st->bdl_cnt);
1160         assert(st->bp < bdl[st->be].len);
1161
1162         left = count;
1163         while (left) {
1164                 bdle_desc = &bdl[st->be];
1165
1166                 if (dir)
1167                         *(uint32_t *)buf = hda_dma_ld_dword(
1168                             (uint8_t *)bdle_desc->addr + st->bp);
1169                 else
1170                         hda_dma_st_dword((uint8_t *)bdle_desc->addr +
1171                             st->bp, *(uint32_t *)buf);
1172
1173                 buf += HDA_DMA_ACCESS_LEN;
1174                 st->bp += HDA_DMA_ACCESS_LEN;
1175                 lpib += HDA_DMA_ACCESS_LEN;
1176                 left -= HDA_DMA_ACCESS_LEN;
1177
1178                 if (st->bp == bdle_desc->len) {
1179                         st->bp = 0;
1180                         if (bdle_desc->ioc)
1181                                 irq = 1;
1182                         st->be++;
1183                         if (st->be == st->bdl_cnt) {
1184                                 st->be = 0;
1185                                 lpib = 0;
1186                         }
1187                         bdle_desc = &bdl[st->be];
1188                 }
1189         }
1190
1191         hda_set_pib(sc, stream_ind, lpib);
1192
1193         if (irq) {
1194                 hda_set_field_by_offset(sc, off + HDAC_SDSTS,
1195                                 HDAC_SDSTS_BCIS, HDAC_SDSTS_BCIS);
1196                 hda_update_intr(sc);
1197         }
1198
1199         return (0);
1200 }
1201
1202 static void
1203 hda_set_pib(struct hda_softc *sc, uint8_t stream_ind, uint32_t pib)
1204 {
1205         uint32_t off = hda_get_offset_stream(stream_ind);
1206
1207         hda_set_reg_by_offset(sc, off + HDAC_SDLPIB, pib);
1208         /* LPIB Alias */
1209         hda_set_reg_by_offset(sc, 0x2000 + off + HDAC_SDLPIB, pib);
1210         if (sc->dma_pib_vaddr)
1211                 *(uint32_t *)((uint8_t *)sc->dma_pib_vaddr + stream_ind *
1212                     HDA_DMA_PIB_ENTRY_LEN) = pib;
1213 }
1214
1215 static uint64_t hda_get_clock_ns(void)
1216 {
1217         struct timespec ts;
1218         int err;
1219
1220         err = clock_gettime(CLOCK_MONOTONIC, &ts);
1221         assert(!err);
1222
1223         return (ts.tv_sec * 1000000000LL + ts.tv_nsec);
1224 }
1225
1226 /*
1227  * PCI HDA function definitions
1228  */
1229 static int
1230 pci_hda_init(struct pci_devinst *pi, nvlist_t *nvl)
1231 {
1232         struct hda_softc *sc = NULL;
1233
1234         assert(pi != NULL);
1235
1236         pci_set_cfgdata16(pi, PCIR_VENDOR, INTEL_VENDORID);
1237         pci_set_cfgdata16(pi, PCIR_DEVICE, HDA_INTEL_82801G);
1238
1239         pci_set_cfgdata8(pi, PCIR_SUBCLASS, PCIS_MULTIMEDIA_HDA);
1240         pci_set_cfgdata8(pi, PCIR_CLASS, PCIC_MULTIMEDIA);
1241
1242         /* select the Intel HDA mode */
1243         pci_set_cfgdata8(pi, PCIR_HDCTL, 0x01);
1244
1245         /* allocate one BAR register for the Memory address offsets */
1246         pci_emul_alloc_bar(pi, 0, PCIBAR_MEM32, HDA_LAST_OFFSET);
1247
1248         /* allocate an IRQ pin for our slot */
1249         pci_lintr_request(pi);
1250
1251         sc = hda_init(nvl);
1252         if (!sc)
1253                 return (-1);
1254
1255         sc->pci_dev = pi;
1256         pi->pi_arg = sc;
1257
1258         return (0);
1259 }
1260
1261 static void
1262 pci_hda_write(struct pci_devinst *pi, int baridx, uint64_t offset, int size,
1263     uint64_t value)
1264 {
1265         struct hda_softc *sc = pi->pi_arg;
1266         int err;
1267
1268         assert(sc);
1269         assert(baridx == 0);
1270         assert(size <= 4);
1271
1272         DPRINTF("offset: 0x%lx value: 0x%lx", offset, value);
1273
1274         err = hda_write(sc, offset, size, value);
1275         assert(!err);
1276 }
1277
1278 static uint64_t
1279 pci_hda_read(struct pci_devinst *pi, int baridx, uint64_t offset, int size)
1280 {
1281         struct hda_softc *sc = pi->pi_arg;
1282         uint64_t value = 0;
1283
1284         assert(sc);
1285         assert(baridx == 0);
1286         assert(size <= 4);
1287
1288         value = hda_read(sc, offset);
1289
1290         DPRINTF("offset: 0x%lx value: 0x%lx", offset, value);
1291
1292         return (value);
1293 }