src/southbridge/intel/lynxpoint/hda_verb.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * Copyright (C) 2008 Advanced Micro Devices, Inc.
   5  * Copyright (C) 2008-2009 coresystems GmbH
   6  * Copyright (C) 2011 Google Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; version 2 of the License.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #include <console/console.h>
  19 #include <arch/io.h>
  20 #include <delay.h>
  21 #include "pch.h"
  22 #include "hda_verb.h"
  23
  24 /**
  25  * Set bits in a register and wait for status
  26  */
  27 static int set_bits(void *port, u32 mask, u32 val)
  28 {
  29         u32 reg32;
  30         int count;
  31
  32         /* Write (val & mask) to port */
  33         val &= mask;
  34         reg32 = read32(port);
  35         reg32 &= ~mask;
  36         reg32 |= val;
  37         write32(port, reg32);
  38
  39         /* Wait for readback of register to
  40          * match what was just written to it
  41          */
  42         count = 50;
  43         do {
  44                 /* Wait 1ms based on BKDG wait time */
  45                 mdelay(1);
  46                 reg32 = read32(port);
  47                 reg32 &= mask;
  48         } while ((reg32 != val) && --count);
  49
  50         /* Timeout occurred */
  51         if (!count)
  52                 return -1;
  53         return 0;
  54 }
  55
  56 /**
  57  * Probe for supported codecs
  58  */
  59 int hda_codec_detect(u8 *base)
  60 {
  61         u8 reg8;
  62
  63         /* Set Bit 0 to 1 to exit reset state (BAR + 0x8)[0] */
  64         if (set_bits(base + HDA_GCTL_REG, HDA_GCTL_CRST, HDA_GCTL_CRST) < 0)
  65                 goto no_codec;
  66
  67         /* Write back the value once reset bit is set. */
  68         write16(base + HDA_GCAP_REG, read16(base + HDA_GCAP_REG));
  69
  70         /* Read in Codec location (BAR + 0xe)[2..0]*/
  71         reg8 = read8(base + HDA_STATESTS_REG);
  72         reg8 &= 0x0f;
  73         if (!reg8)
  74                 goto no_codec;
  75
  76         return reg8;
  77
  78 no_codec:
  79         /* Codec Not found */
  80         /* Put HDA back in reset (BAR + 0x8) [0] */
  81         set_bits(base + HDA_GCTL_REG, HDA_GCTL_CRST, 0);
  82         printk(BIOS_DEBUG, "HDA: No codec!\n");
  83         return 0;
  84 }
  85
  86 /**
  87  * Wait 50usec for the codec to indicate it is ready
  88  * no response would imply that the codec is non-operative
  89  */
  90 static int hda_wait_for_ready(u8 *base)
  91 {
  92         /* Use a 50 usec timeout - the Linux kernel uses the
  93          * same duration */
  94
  95         int timeout = 50;
  96
  97         while (timeout--) {
  98                 u32 reg32 = read32(base +  HDA_ICII_REG);
  99                 if (!(reg32 & HDA_ICII_BUSY))
 100                         return 0;
 101                 udelay(1);
 102         }
 103
 104         return -1;
 105 }
 106
 107 /**
 108  * Wait 50usec for the codec to indicate that it accepted
 109  * the previous command.  No response would imply that the code
 110  * is non-operative
 111  */
 112 static int hda_wait_for_valid(u8 *base)
 113 {
 114         u32 reg32;
 115
 116         /* Send the verb to the codec */
 117         reg32 = read32(base + HDA_ICII_REG);
 118         reg32 |= HDA_ICII_BUSY | HDA_ICII_VALID;
 119         write32(base + HDA_ICII_REG, reg32);
 120
 121         /* Use a 50 usec timeout - the Linux kernel uses the
 122          * same duration */
 123
 124         int timeout = 50;
 125         while (timeout--) {
 126                 reg32 = read32(base + HDA_ICII_REG);
 127                 if ((reg32 & (HDA_ICII_VALID | HDA_ICII_BUSY)) ==
 128                         HDA_ICII_VALID)
 129                         return 0;
 130                 udelay(1);
 131         }
 132
 133         return -1;
 134 }
 135
 136 /**
 137  * Find a specific entry within a verb table
 138  *
 139  * @param verb_table_bytes:     verb table size in bytes
 140  * @param verb_table_data:      verb table data
 141  * @param viddid:               vendor/device to search for
 142  * @param **verb:               pointer to entry within table
 143  *
 144  * Returns size of the entry within the verb table,
 145  * Returns 0 if the entry is not found
 146  *
 147  * The HDA verb table is composed of dwords. A set of 4 dwords is
 148  * grouped together to form a "jack" descriptor.
 149  *   Bits 31:28 - Codec Address
 150  *   Bits 27:20 - NID
 151  *   Bits 19:8  - Verb ID
 152  *   Bits 7:0   - Payload
 153  *
 154  * coreboot groups different codec verb tables into a single table
 155  * and prefixes each with a specific header consisting of 3
 156  * dword entries:
 157  *   1 - Codec Vendor/Device ID
 158  *   2 - Subsystem ID
 159  *   3 - Number of jacks (groups of 4 dwords) for this codec
 160  */
 161 static u32 hda_find_verb(u32 verb_table_bytes,
 162                          const u32 *verb_table_data,
 163                          u32 viddid, const u32 **verb)
 164 {
 165         int idx=0;
 166
 167         while (idx < (verb_table_bytes / sizeof(u32))) {
 168                 u32 verb_size = 4 * verb_table_data[idx+2]; // in u32
 169                 if (verb_table_data[idx] != viddid) {
 170                         idx += verb_size + 3; // skip verb + header
 171                         continue;
 172                 }
 173                 *verb = &verb_table_data[idx+3];
 174                 return verb_size;
 175         }
 176
 177         /* Not all codecs need to load another verb */
 178         return 0;
 179 }
 180
 181 /**
 182  * Write a supplied verb table
 183  */
 184 int hda_codec_write(u8 *base, u32 size, const u32 *data)
 185 {
 186         int i;
 187
 188         for (i = 0; i < size; i++) {
 189                 if (hda_wait_for_ready(base) < 0)
 190                         return -1;
 191
 192                 write32(base + HDA_IC_REG, data[i]);
 193
 194                 if (hda_wait_for_valid(base) < 0)
 195                         return -1;
 196         }
 197
 198         return 0;
 199 }
 200
 201 /**
 202  * Initialize codec, then find the verb table and write it
 203  */
 204 int hda_codec_init(u8 *base, int addr, int verb_size, const u32 *verb_data)
 205 {
 206         const u32 *verb;
 207         u32 reg32, size;
 208         int rc;
 209
 210         printk(BIOS_DEBUG, "HDA: Initializing codec #%d\n", addr);
 211
 212         if (!verb_size || !verb_data) {
 213                 printk(BIOS_DEBUG, "HDA: No verb list!\n");
 214                 return -1;
 215         }
 216
 217         /* 1 */
 218         if (hda_wait_for_ready(base) < 0) {
 219                 printk(BIOS_DEBUG, "  codec not ready.\n");
 220                 return -1;
 221         }
 222
 223         reg32 = (addr << 28) | 0x000f0000;
 224         write32(base + HDA_IC_REG, reg32);
 225
 226         if (hda_wait_for_valid(base) < 0) {
 227                 printk(BIOS_DEBUG, "  codec not valid.\n");
 228                 return -1;
 229         }
 230
 231         /* 2 */
 232         reg32 = read32(base + HDA_IR_REG);
 233         printk(BIOS_DEBUG, "HDA: codec viddid: %08x\n", reg32);
 234
 235         size = hda_find_verb(verb_size, verb_data, reg32, &verb);
 236         if (!size) {
 237                 printk(BIOS_DEBUG, "HDA: No verb table entry found\n");
 238                 return -1;
 239         }
 240
 241         /* 3 */
 242         rc = hda_codec_write(base, size, verb);
 243
 244         if (rc < 0)
 245                 printk(BIOS_DEBUG, "HDA: verb not loaded\n");
 246         else
 247                 printk(BIOS_DEBUG, "HDA: verb loaded.\n");
 248
 249         return rc;
 250 }