1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // ALSA SoC Texas Instruments TAS2783 Audio Smart Amplifier 4 // 5 // Copyright (C) 2025 Texas Instruments Incorporated 6 // https://www.ti.com 7 // 8 // The TAS2783 driver implements a flexible and configurable 9 // algo coefficient setting for single TAS2783 chips. 10 // 11 // Author: Niranjan H Y <niranjanhy@ti.com> 12 // Author: Baojun Xu <baojun.xu@ti.com> 13 // Author: Kevin Lu <kevin-lu@ti.com> 14 15 #include <linux/unaligned.h> 16 #include <linux/crc32.h> 17 #include <linux/efi.h> 18 #include <linux/err.h> 19 #include <linux/firmware.h> 20 #include <linux/init.h> 21 #include <linux/module.h> 22 #include <sound/pcm_params.h> 23 #include <linux/pm.h> 24 #include <linux/pm_runtime.h> 25 #include <linux/regmap.h> 26 #include <linux/wait.h> 27 #include <linux/soundwire/sdw.h> 28 #include <linux/soundwire/sdw_registers.h> 29 #include <linux/soundwire/sdw_type.h> 30 #include <sound/sdw.h> 31 #include <sound/soc.h> 32 #include <sound/tlv.h> 33 #include <sound/tas2781-tlv.h> 34 35 #include "tas2783.h" 36 37 #define TIMEOUT_FW_DL_MS (3000) 38 #define FW_DL_OFFSET 36 39 #define FW_FL_HDR 12 40 #define TAS2783_PROBE_TIMEOUT 5000 41 #define TAS2783_CALI_GUID EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc, \ 42 0x09, 0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92) 43 44 static const u32 tas2783_cali_reg[] = { 45 TAS2783_CAL_R0, 46 TAS2783_CAL_INVR0, 47 TAS2783_CAL_R0LOW, 48 TAS2783_CAL_POWER, 49 TAS2783_CAL_TLIM, 50 }; 51 52 struct bin_header_t { 53 u16 vendor_id; 54 u16 version; 55 u32 file_id; 56 u32 length; 57 }; 58 59 struct calibration_data { 60 u32 is_valid; 61 unsigned long read_sz; 62 u8 data[TAS2783_CALIB_DATA_SZ]; 63 }; 64 65 struct tas2783_prv { 66 struct snd_soc_component *component; 67 struct calibration_data cali_data; 68 struct sdw_slave *sdw_peripheral; 69 enum sdw_slave_status status; 70 /* calibration */ 71 struct mutex calib_lock; 72 /* pde and firmware download */ 73 struct mutex pde_lock; 74 struct regmap *regmap; 75 struct device *dev; 76 struct class *class; 77 struct attribute_group *cal_attr_groups; 78 struct tm tm; 79 u8 rca_binaryname[64]; 80 u8 dev_name[32]; 81 bool hw_init; 82 /* wq for firmware download */ 83 wait_queue_head_t fw_wait; 84 bool fw_dl_task_done; 85 bool fw_dl_success; 86 }; 87 88 static const struct reg_default tas2783_reg_default[] = { 89 {TAS2783_AMP_LEVEL, 0x28}, 90 {TASDEV_REG_SDW(0, 0, 0x03), 0x28}, 91 {TASDEV_REG_SDW(0, 0, 0x04), 0x21}, 92 {TASDEV_REG_SDW(0, 0, 0x05), 0x41}, 93 {TASDEV_REG_SDW(0, 0, 0x06), 0x00}, 94 {TASDEV_REG_SDW(0, 0, 0x07), 0x20}, 95 {TASDEV_REG_SDW(0, 0, 0x08), 0x09}, 96 {TASDEV_REG_SDW(0, 0, 0x09), 0x02}, 97 {TASDEV_REG_SDW(0, 0, 0x0a), 0x0a}, 98 {TASDEV_REG_SDW(0, 0, 0x0c), 0x10}, 99 {TASDEV_REG_SDW(0, 0, 0x0d), 0x13}, 100 {TASDEV_REG_SDW(0, 0, 0x0e), 0xc2}, 101 {TASDEV_REG_SDW(0, 0, 0x0f), 0x40}, 102 {TASDEV_REG_SDW(0, 0, 0x10), 0x04}, 103 {TASDEV_REG_SDW(0, 0, 0x13), 0x13}, 104 {TASDEV_REG_SDW(0, 0, 0x14), 0x12}, 105 {TASDEV_REG_SDW(0, 0, 0x15), 0x00}, 106 {TASDEV_REG_SDW(0, 0, 0x16), 0x12}, 107 {TASDEV_REG_SDW(0, 0, 0x17), 0x80}, 108 {TAS2783_DVC_LVL, 0x00}, 109 {TASDEV_REG_SDW(0, 0, 0x1b), 0x61}, 110 {TASDEV_REG_SDW(0, 0, 0x1c), 0x36}, 111 {TASDEV_REG_SDW(0, 0, 0x1d), 0x00}, 112 {TASDEV_REG_SDW(0, 0, 0x1f), 0x01}, 113 {TASDEV_REG_SDW(0, 0, 0x20), 0x2e}, 114 {TASDEV_REG_SDW(0, 0, 0x21), 0x00}, 115 {TASDEV_REG_SDW(0, 0, 0x34), 0x06}, 116 {TASDEV_REG_SDW(0, 0, 0x35), 0xbd}, 117 {TASDEV_REG_SDW(0, 0, 0x36), 0xad}, 118 {TASDEV_REG_SDW(0, 0, 0x37), 0xa8}, 119 {TASDEV_REG_SDW(0, 0, 0x38), 0x00}, 120 {TASDEV_REG_SDW(0, 0, 0x3b), 0xfc}, 121 {TASDEV_REG_SDW(0, 0, 0x3d), 0xdd}, 122 {TASDEV_REG_SDW(0, 0, 0x40), 0xf6}, 123 {TASDEV_REG_SDW(0, 0, 0x41), 0x14}, 124 {TASDEV_REG_SDW(0, 0, 0x5c), 0x19}, 125 {TASDEV_REG_SDW(0, 0, 0x5d), 0x80}, 126 {TASDEV_REG_SDW(0, 0, 0x63), 0x48}, 127 {TASDEV_REG_SDW(0, 0, 0x65), 0x08}, 128 {TASDEV_REG_SDW(0, 0, 0x66), 0xb2}, 129 {TASDEV_REG_SDW(0, 0, 0x67), 0x00}, 130 {TASDEV_REG_SDW(0, 0, 0x6a), 0x12}, 131 {TASDEV_REG_SDW(0, 0, 0x6b), 0xfb}, 132 {TASDEV_REG_SDW(0, 0, 0x6c), 0x00}, 133 {TASDEV_REG_SDW(0, 0, 0x6d), 0x00}, 134 {TASDEV_REG_SDW(0, 0, 0x6e), 0x1a}, 135 {TASDEV_REG_SDW(0, 0, 0x6f), 0x00}, 136 {TASDEV_REG_SDW(0, 0, 0x70), 0x96}, 137 {TASDEV_REG_SDW(0, 0, 0x71), 0x02}, 138 {TASDEV_REG_SDW(0, 0, 0x73), 0x08}, 139 {TASDEV_REG_SDW(0, 0, 0x75), 0xe0}, 140 {TASDEV_REG_SDW(0, 0, 0x7a), 0x60}, 141 {TASDEV_REG_SDW(0, 0, 0x60), 0x21}, 142 {TASDEV_REG_SDW(0, 1, 0x02), 0x00}, 143 {TASDEV_REG_SDW(0, 1, 0x17), 0xc0}, 144 {TASDEV_REG_SDW(0, 1, 0x19), 0x60}, 145 {TASDEV_REG_SDW(0, 1, 0x35), 0x75}, 146 {TASDEV_REG_SDW(0, 1, 0x3d), 0x00}, 147 {TASDEV_REG_SDW(0, 1, 0x3e), 0x00}, 148 {TASDEV_REG_SDW(0, 1, 0x3f), 0x00}, 149 {TASDEV_REG_SDW(0, 1, 0x40), 0x00}, 150 {TASDEV_REG_SDW(0, 1, 0x41), 0x00}, 151 {TASDEV_REG_SDW(0, 1, 0x42), 0x00}, 152 {TASDEV_REG_SDW(0, 1, 0x43), 0x00}, 153 {TASDEV_REG_SDW(0, 1, 0x44), 0x00}, 154 {TASDEV_REG_SDW(0, 1, 0x45), 0x00}, 155 {TASDEV_REG_SDW(0, 1, 0x47), 0xab}, 156 {TASDEV_REG_SDW(0, 0xfd, 0x0d), 0x0d}, 157 {TASDEV_REG_SDW(0, 0xfd, 0x39), 0x00}, 158 {TASDEV_REG_SDW(0, 0xfd, 0x3e), 0x00}, 159 {TASDEV_REG_SDW(0, 0xfd, 0x45), 0x00}, 160 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS21, 0x02, 0), 0x0}, 161 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS21, 0x10, 0), 0x0}, 162 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS24, 0x02, 0), 0x0}, 163 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS24, 0x10, 0), 0x0}, 164 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS26, 0x02, 0), 0x0}, 165 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS26, 0x10, 0), 0x0}, 166 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS28, 0x02, 0), 0x0}, 167 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS28, 0x10, 0), 0x0}, 168 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS127, 0x02, 0), 0x0}, 169 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS127, 0x10, 0), 0x0}, 170 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, 0x01, 1), 0x1}, 171 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, 0x02, 1), 0x9c00}, 172 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x01, 0), 0x1}, 173 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x01, 1), 0x1}, 174 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x0b, 1), 0x0}, 175 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x10, 0), 0x0}, 176 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x01, 1), 0x1}, 177 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x01, 0), 0x1}, 178 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x0b, 1), 0x0}, 179 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x10, 0), 0x0}, 180 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 0), 0x1}, 181 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 1), 0x1}, 182 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 2), 0x1}, 183 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 0), 0x0}, 184 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 1), 0x0}, 185 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 2), 0x0}, 186 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x10, 0), 0x0}, 187 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x04, 0), 0x0}, 188 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x08, 0), 0x0}, 189 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x10, 0), 0x0}, 190 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x11, 0), 0x0}, 191 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x04, 0), 0x0}, 192 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x08, 0), 0x0}, 193 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x10, 0), 0x0}, 194 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x11, 0), 0x0}, 195 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x04, 0), 0x0}, 196 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x08, 0), 0x0}, 197 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x10, 0), 0x0}, 198 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x11, 0), 0x0}, 199 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x04, 0), 0x0}, 200 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x08, 0), 0x0}, 201 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x10, 0), 0x0}, 202 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x11, 0), 0x0}, 203 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x01, 0), 0x0}, 204 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x04, 0), 0x0}, 205 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x05, 0), 0x1}, 206 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x08, 0), 0x0}, 207 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x10, 0), 0x0}, 208 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x11, 0), 0x0}, 209 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x12, 0), 0x0}, 210 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x01, 0), 0x0}, 211 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x04, 0), 0x0}, 212 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x05, 0), 0x1}, 213 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x08, 0), 0x0}, 214 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x10, 0), 0x0}, 215 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x11, 0), 0x0}, 216 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x12, 0), 0x0}, 217 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 0), 0x0}, 218 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 1), 0x0}, 219 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 2), 0x0}, 220 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 3), 0x0}, 221 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 4), 0x0}, 222 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 5), 0x0}, 223 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 6), 0x0}, 224 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 7), 0x0}, 225 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x06, 0), 0x0}, 226 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT23, 0x04, 0), 0x0}, 227 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT23, 0x08, 0), 0x0}, 228 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x04, 0), 0x0}, 229 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x08, 0), 0x0}, 230 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x11, 0), 0x0}, 231 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x04, 0), 0x0}, 232 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x08, 0), 0x0}, 233 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x11, 0), 0x0}, 234 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x04, 0), 0x0}, 235 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x08, 0), 0x0}, 236 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x11, 0), 0x0}, 237 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x04, 0), 0x0}, 238 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x08, 0), 0x0}, 239 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x11, 0), 0x0}, 240 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0), 0x0}, 241 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 1), 0x0}, 242 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 2), 0x0}, 243 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 3), 0x0}, 244 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 4), 0x0}, 245 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 5), 0x0}, 246 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 6), 0x0}, 247 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 7), 0x0}, 248 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 8), 0x0}, 249 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 9), 0x0}, 250 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xa), 0x0}, 251 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xb), 0x0}, 252 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xc), 0x0}, 253 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xd), 0x0}, 254 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xe), 0x0}, 255 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xf), 0x0}, 256 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 0x1, 0), 0x3}, 257 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 0x10, 0), 0x3}, 258 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x06, 0), 0x0}, 259 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x10, 0), 0x0}, 260 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x11, 0), 0x0}, 261 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x12, 0), 0x0}, 262 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x13, 0), 0x0}, 263 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x06, 0), 0x0}, 264 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x10, 0), 0x0}, 265 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x11, 0), 0x0}, 266 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x12, 0), 0x0}, 267 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x13, 0), 0x0}, 268 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x05, 0), 0x0}, 269 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x10, 0), 0x1}, 270 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x11, 0), 0x0}, 271 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x12, 0), 0x0}, 272 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_TG23, 0x10, 0), 0x0}, 273 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x01, 0), 0x1}, 274 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x06, 0), 0x0}, 275 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x07, 0), 0x0}, 276 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x08, 0), 0x0}, 277 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x09, 0), 0x0}, 278 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x0a, 0), 0x0}, 279 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x10, 0), 0x1}, 280 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x12, 0), 0x0}, 281 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x13, 0), 0x0}, 282 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x14, 0), 0x0}, 283 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x15, 0), 0x0}, 284 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x16, 0), 0x0}, 285 {SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_UDMPU23, 0x10, 0), 0x0}, 286 }; 287 288 static const struct reg_sequence tas2783_init_seq[] = { 289 REG_SEQ0(SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x10, 0x00), 0x04), 290 REG_SEQ0(0x00800418, 0x00), 291 REG_SEQ0(0x00800419, 0x00), 292 REG_SEQ0(0x0080041a, 0x00), 293 REG_SEQ0(0x0080041b, 0x00), 294 REG_SEQ0(0x00800428, 0x40), 295 REG_SEQ0(0x00800429, 0x00), 296 REG_SEQ0(0x0080042a, 0x00), 297 REG_SEQ0(0x0080042b, 0x00), 298 REG_SEQ0(SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x1, 0x00), 0x00), 299 REG_SEQ0(0x0080005c, 0xD9), 300 REG_SEQ0(0x00800082, 0x20), 301 REG_SEQ0(0x008000a1, 0x00), 302 REG_SEQ0(0x00800097, 0xc8), 303 REG_SEQ0(0x00800099, 0x20), 304 REG_SEQ0(0x008000c7, 0xaa), 305 REG_SEQ0(0x008000b5, 0x74), 306 REG_SEQ0(0x00800082, 0x20), 307 REG_SEQ0(0x00807e8d, 0x0d), 308 REG_SEQ0(0x00807eb9, 0x53), 309 REG_SEQ0(0x00807ebe, 0x42), 310 REG_SEQ0(0x00807ec5, 0x37), 311 REG_SEQ0(0x00800066, 0x92), 312 REG_SEQ0(0x00800003, 0x28), 313 REG_SEQ0(0x00800004, 0x21), 314 REG_SEQ0(0x00800005, 0x41), 315 REG_SEQ0(0x00800006, 0x00), 316 REG_SEQ0(0x00800007, 0x20), 317 REG_SEQ0(0x0080000c, 0x10), 318 REG_SEQ0(0x00800013, 0x08), 319 REG_SEQ0(0x00800015, 0x00), 320 REG_SEQ0(0x00800017, 0x80), 321 REG_SEQ0(0x0080001a, 0x00), 322 REG_SEQ0(0x0080001b, 0x22), 323 REG_SEQ0(0x0080001c, 0x36), 324 REG_SEQ0(0x0080001d, 0x01), 325 REG_SEQ0(0x0080001f, 0x00), 326 REG_SEQ0(0x00800020, 0x2e), 327 REG_SEQ0(0x00800034, 0x06), 328 REG_SEQ0(0x00800035, 0xb9), 329 REG_SEQ0(0x00800036, 0xad), 330 REG_SEQ0(0x00800037, 0xa8), 331 REG_SEQ0(0x00800038, 0x00), 332 REG_SEQ0(0x0080003b, 0xfc), 333 REG_SEQ0(0x0080003d, 0xdd), 334 REG_SEQ0(0x00800040, 0xf6), 335 REG_SEQ0(0x00800041, 0x14), 336 REG_SEQ0(0x0080005c, 0x19), 337 REG_SEQ0(0x0080005d, 0x80), 338 REG_SEQ0(0x00800063, 0x48), 339 REG_SEQ0(0x00800065, 0x08), 340 REG_SEQ0(0x00800067, 0x00), 341 REG_SEQ0(0x0080006a, 0x12), 342 REG_SEQ0(0x0080006b, 0x7b), 343 REG_SEQ0(0x0080006c, 0x00), 344 REG_SEQ0(0x0080006d, 0x00), 345 REG_SEQ0(0x0080006e, 0x1a), 346 REG_SEQ0(0x0080006f, 0x00), 347 REG_SEQ0(0x00800070, 0x96), 348 REG_SEQ0(0x00800071, 0x02), 349 REG_SEQ0(0x00800073, 0x08), 350 REG_SEQ0(0x00800075, 0xe0), 351 REG_SEQ0(0x0080007a, 0x60), 352 REG_SEQ0(0x008000bd, 0x00), 353 REG_SEQ0(0x008000be, 0x00), 354 REG_SEQ0(0x008000bf, 0x00), 355 REG_SEQ0(0x008000c0, 0x00), 356 REG_SEQ0(0x008000c1, 0x00), 357 REG_SEQ0(0x008000c2, 0x00), 358 REG_SEQ0(0x008000c3, 0x00), 359 REG_SEQ0(0x008000c4, 0x00), 360 REG_SEQ0(0x008000c5, 0x00), 361 REG_SEQ0(0x00800008, 0x49), 362 REG_SEQ0(0x00800009, 0x02), 363 REG_SEQ0(0x0080000a, 0x1a), 364 REG_SEQ0(0x0080000d, 0x93), 365 REG_SEQ0(0x0080000e, 0x82), 366 REG_SEQ0(0x0080000f, 0x42), 367 REG_SEQ0(0x00800010, 0x84), 368 REG_SEQ0(0x00800014, 0x0a), 369 REG_SEQ0(0x00800016, 0x00), 370 REG_SEQ0(0x00800060, 0x21), 371 }; 372 373 static int tas2783_sdca_mbq_size(struct device *dev, u32 reg) 374 { 375 switch (reg) { 376 case 0x000 ... 0x080: /* Data port 0. */ 377 case 0x100 ... 0x140: /* Data port 1. */ 378 case 0x200 ... 0x240: /* Data port 2. */ 379 case 0x300 ... 0x340: /* Data port 3. */ 380 case 0x400 ... 0x440: /* Data port 4. */ 381 case 0x500 ... 0x540: /* Data port 5. */ 382 case 0x800000 ... 0x803fff: /* Page 0 ~ 127. */ 383 case 0x807e80 ... 0x807eff: /* Page 253. */ 384 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_UDMPU23, 385 TAS2783_SDCA_CTL_UDMPU_CLUSTER, 0): 386 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, TAS2783_SDCA_CTL_FU_MUTE, 387 TAS2783_DEVICE_CHANNEL_LEFT): 388 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 0x1, 0): 389 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 0x10, 0): 390 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x04, 0): 391 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x10, 0): 392 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x11, 0): 393 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x12, 0): 394 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x10, 0): 395 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x11, 0): 396 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x10, 0): 397 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x11, 0): 398 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_TG23, 0x10, 0): 399 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x01, 0): 400 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x08, 0): 401 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x0a, 0): 402 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x10, 0): 403 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x14, 0): 404 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x15, 0): 405 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x16, 0): 406 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x04, 0): 407 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x04, 0): 408 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x04, 0): 409 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT23, 0x04, 0): 410 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x04, 0): 411 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x04, 0): 412 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x04, 0): 413 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0): 414 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 1): 415 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 2): 416 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 3): 417 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 4): 418 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 5): 419 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 6): 420 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 7): 421 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 8): 422 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 9): 423 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xa): 424 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xb): 425 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xc): 426 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xd): 427 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xe): 428 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x12, 0xf): 429 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS21, 0x02, 0): 430 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS21, 0x10, 0): 431 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS24, 0x02, 0): 432 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS24, 0x10, 0): 433 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS25, 0x02, 0): 434 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS25, 0x10, 0): 435 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS127, 0x02, 0): 436 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS127, 0x10, 0): 437 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS26, 0x02, 0): 438 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS26, 0x10, 0): 439 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS28, 0x02, 0): 440 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_CS28, 0x10, 0): 441 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x01, 0): 442 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x04, 0): 443 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x05, 0): 444 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x10, 0): 445 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x11, 0): 446 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 1): 447 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 2): 448 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x01, 0): 449 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x01, 1): 450 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x01, 0): 451 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x01, 0): 452 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x04, 0): 453 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x05, 0): 454 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x10, 0): 455 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x11, 0): 456 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x01, 0): 457 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x01, 1): 458 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x04, 0): 459 return 1; 460 461 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x10, 0): 462 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x11, 0): 463 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x10, 0): 464 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x11, 0): 465 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x10, 0): 466 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x11, 0): 467 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x11, 0): 468 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x11, 0): 469 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x11, 0): 470 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x11, 0): 471 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 0): 472 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 1): 473 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 2): 474 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 3): 475 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 4): 476 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 5): 477 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 6): 478 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x01, 7): 479 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, 0x02, 1): 480 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x0b, 1): 481 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 1): 482 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 2): 483 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x0b, 0): 484 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x0b, 0): 485 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x0b, 1): 486 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x07, 0): 487 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x09, 0): 488 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x12, 0): 489 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x12, 0): 490 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x12, 0): 491 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x13, 0): 492 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x12, 0): 493 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x13, 0): 494 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x10, 0): 495 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x11, 0): 496 return 2; 497 498 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 0x10, 0): 499 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT21, 0x08, 0): 500 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT26, 0x08, 0): 501 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT28, 0x08, 0): 502 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_IT29, 0x08, 0): 503 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT23, 0x08, 0): 504 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT24, 0x08, 0): 505 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT25, 0x08, 0): 506 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT28, 0x08, 0): 507 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_OT127, 0x08, 0): 508 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MU26, 0x06, 0): 509 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU127, 0x10, 0): 510 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU26, 0x10, 0): 511 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x06, 0): 512 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x12, 0): 513 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_XU22, 0x13, 0): 514 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU21, 0x08, 0): 515 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_MFPU26, 0x08, 0): 516 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_SAPU29, 0x05, 0): 517 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU21, 0x06, 0): 518 case SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PPU26, 0x06, 0): 519 return 4; 520 521 default: 522 return 0; 523 } 524 } 525 526 static bool tas2783_readable_register(struct device *dev, unsigned int reg) 527 { 528 return tas2783_sdca_mbq_size(dev, reg) > 0; 529 } 530 531 static bool tas2783_volatile_register(struct device *dev, u32 reg) 532 { 533 switch (reg) { 534 case 0x000 ... 0x080: /* Data port 0. */ 535 case 0x100 ... 0x140: /* Data port 1. */ 536 case 0x200 ... 0x240: /* Data port 2. */ 537 case 0x300 ... 0x340: /* Data port 3. */ 538 case 0x400 ... 0x440: /* Data port 4. */ 539 case 0x500 ... 0x540: /* Data port 5. */ 540 case 0x800001: 541 return true; 542 543 default: 544 return false; 545 } 546 } 547 548 static const struct regmap_config tas_regmap = { 549 .reg_bits = 32, 550 .val_bits = 8, 551 .readable_reg = tas2783_readable_register, 552 .volatile_reg = tas2783_volatile_register, 553 .reg_defaults = tas2783_reg_default, 554 .num_reg_defaults = ARRAY_SIZE(tas2783_reg_default), 555 .max_register = 0x41008000 + TASDEV_REG_SDW(0xa1, 0x60, 0x7f), 556 .cache_type = REGCACHE_MAPLE, 557 .use_single_read = true, 558 .use_single_write = true, 559 }; 560 561 static const struct regmap_sdw_mbq_cfg tas2783_mbq_cfg = { 562 .mbq_size = tas2783_sdca_mbq_size, 563 }; 564 565 static s32 tas2783_digital_getvol(struct snd_kcontrol *kcontrol, 566 struct snd_ctl_elem_value *ucontrol) 567 { 568 return snd_soc_get_volsw(kcontrol, ucontrol); 569 } 570 571 static s32 tas2783_digital_putvol(struct snd_kcontrol *kcontrol, 572 struct snd_ctl_elem_value *ucontrol) 573 { 574 return snd_soc_put_volsw(kcontrol, ucontrol); 575 } 576 577 static s32 tas2783_amp_getvol(struct snd_kcontrol *kcontrol, 578 struct snd_ctl_elem_value *ucontrol) 579 { 580 return snd_soc_get_volsw(kcontrol, ucontrol); 581 } 582 583 static s32 tas2783_amp_putvol(struct snd_kcontrol *kcontrol, 584 struct snd_ctl_elem_value *ucontrol) 585 { 586 return snd_soc_put_volsw(kcontrol, ucontrol); 587 } 588 589 static const struct snd_kcontrol_new tas2783_snd_controls[] = { 590 SOC_SINGLE_RANGE_EXT_TLV("Amp Volume", TAS2783_AMP_LEVEL, 591 1, 0, 20, 0, tas2783_amp_getvol, 592 tas2783_amp_putvol, tas2781_amp_tlv), 593 SOC_SINGLE_RANGE_EXT_TLV("Speaker Volume", TAS2783_DVC_LVL, 594 0, 0, 200, 1, tas2783_digital_getvol, 595 tas2783_digital_putvol, tas2781_dvc_tlv), 596 }; 597 598 static s32 tas2783_validate_calibdata(struct tas2783_prv *tas_dev, 599 u8 *data, u32 size) 600 { 601 u32 ts, spk_count, size_calculated; 602 u32 crc_calculated, crc_read, i; 603 u32 *tmp_val; 604 struct tm tm; 605 606 i = 0; 607 tmp_val = (u32 *)data; 608 if (tmp_val[i++] != 2783) { 609 dev_err(tas_dev->dev, "cal data magic number mismatch"); 610 return -EINVAL; 611 } 612 613 spk_count = tmp_val[i++]; 614 if (spk_count > TAS2783_CALIB_MAX_SPK_COUNT) { 615 dev_err(tas_dev->dev, "cal data spk_count too large"); 616 return -EINVAL; 617 } 618 619 ts = tmp_val[i++]; 620 time64_to_tm(ts, 0, &tm); 621 dev_dbg(tas_dev->dev, "cal data timestamp: %ld-%d-%d %d:%d:%d", 622 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, 623 tm.tm_hour, tm.tm_min, tm.tm_sec); 624 625 size_calculated = 626 (spk_count * TAS2783_CALIB_PARAMS * sizeof(u32)) + 627 TAS2783_CALIB_HDR_SZ + TAS2783_CALIB_CRC_SZ; 628 if (size_calculated > TAS2783_CALIB_DATA_SZ) { 629 dev_err(tas_dev->dev, "cali data sz too large"); 630 return -EINVAL; 631 } else if (size < size_calculated) { 632 dev_err(tas_dev->dev, "cali data size mismatch calc=%u vs %d\n", 633 size, size_calculated); 634 return -EINVAL; 635 } 636 637 crc_calculated = crc32(~0, data, 638 size_calculated - TAS2783_CALIB_CRC_SZ) ^ ~0; 639 crc_read = tmp_val[(size_calculated - TAS2783_CALIB_CRC_SZ) / sizeof(u32)]; 640 if (crc_calculated != crc_read) { 641 dev_err(tas_dev->dev, 642 "calib data integrity check fail, 0x%08x vs 0x%08x\n", 643 crc_calculated, crc_read); 644 return -EINVAL; 645 } 646 647 return 0; 648 } 649 650 static void tas2783_set_calib_params_to_device(struct tas2783_prv *tas_dev, u32 *cali_data) 651 { 652 u32 dev_count, offset, i, device_num; 653 u32 reg_value; 654 u8 buf[4]; 655 656 dev_count = cali_data[1]; 657 offset = 3; 658 659 for (device_num = 0; device_num < dev_count; device_num++) { 660 if (cali_data[offset] != tas_dev->sdw_peripheral->id.unique_id) { 661 offset += TAS2783_CALIB_PARAMS; 662 continue; 663 } 664 offset++; 665 666 for (i = 0; i < ARRAY_SIZE(tas2783_cali_reg); i++) { 667 reg_value = cali_data[offset + i]; 668 buf[0] = reg_value >> 24; 669 buf[1] = reg_value >> 16; 670 buf[2] = reg_value >> 8; 671 buf[3] = reg_value & 0xff; 672 regmap_bulk_write(tas_dev->regmap, tas2783_cali_reg[i], 673 buf, sizeof(u32)); 674 } 675 break; 676 } 677 678 if (device_num == dev_count) 679 dev_err(tas_dev->dev, "device not found\n"); 680 else 681 dev_dbg(tas_dev->dev, "calib data update done\n"); 682 } 683 684 static s32 tas2783_update_calibdata(struct tas2783_prv *tas_dev) 685 { 686 efi_guid_t efi_guid = TAS2783_CALI_GUID; 687 u32 attr, i, *tmp_val; 688 unsigned long size; 689 s32 ret; 690 efi_status_t status; 691 static efi_char16_t efi_names[][32] = { 692 L"SmartAmpCalibrationData", L"CALI_DATA"}; 693 694 tmp_val = (u32 *)tas_dev->cali_data.data; 695 attr = 0; 696 i = 0; 697 698 /* 699 * In some cases, the calibration is performed in Windows, 700 * and data was saved in UEFI. Linux can access it. 701 */ 702 for (i = 0; i < ARRAY_SIZE(efi_names); i++) { 703 size = 0; 704 status = efi.get_variable(efi_names[i], &efi_guid, &attr, 705 &size, NULL); 706 if (size > TAS2783_CALIB_DATA_SZ) { 707 dev_err(tas_dev->dev, "cali data too large\n"); 708 break; 709 } 710 711 tas_dev->cali_data.read_sz = size; 712 if (status == EFI_BUFFER_TOO_SMALL) { 713 status = efi.get_variable(efi_names[i], &efi_guid, &attr, 714 &tas_dev->cali_data.read_sz, 715 tas_dev->cali_data.data); 716 dev_dbg(tas_dev->dev, "cali get %lu bytes result:%ld\n", 717 tas_dev->cali_data.read_sz, status); 718 } 719 if (status == EFI_SUCCESS) 720 break; 721 } 722 723 if (status != EFI_SUCCESS) { 724 /* Failed got calibration data from EFI. */ 725 dev_dbg(tas_dev->dev, "No calibration data in UEFI."); 726 return 0; 727 } 728 729 mutex_lock(&tas_dev->calib_lock); 730 ret = tas2783_validate_calibdata(tas_dev, tas_dev->cali_data.data, 731 tas_dev->cali_data.read_sz); 732 if (!ret) 733 tas2783_set_calib_params_to_device(tas_dev, tmp_val); 734 mutex_unlock(&tas_dev->calib_lock); 735 736 return ret; 737 } 738 739 static s32 read_header(const u8 *data, struct bin_header_t *hdr) 740 { 741 hdr->vendor_id = get_unaligned_le16(&data[0]); 742 hdr->file_id = get_unaligned_le32(&data[2]); 743 hdr->version = get_unaligned_le16(&data[6]); 744 hdr->length = get_unaligned_le32(&data[8]); 745 return 12; 746 } 747 748 static void tas2783_fw_ready(const struct firmware *fmw, void *context) 749 { 750 struct tas2783_prv *tas_dev = 751 (struct tas2783_prv *)context; 752 const u8 *buf = NULL; 753 s32 offset = 0, img_sz, file_blk_size, ret; 754 struct bin_header_t hdr; 755 756 if (!fmw || !fmw->data) { 757 /* No firmware binary, devices will work in ROM mode. */ 758 dev_err(tas_dev->dev, 759 "Failed to read %s, no side-effect on driver running\n", 760 tas_dev->rca_binaryname); 761 ret = -EINVAL; 762 goto out; 763 } 764 765 img_sz = fmw->size; 766 buf = fmw->data; 767 offset += FW_DL_OFFSET; 768 if (offset >= (img_sz - FW_FL_HDR)) { 769 dev_err(tas_dev->dev, 770 "firmware is too small"); 771 ret = -EINVAL; 772 goto out; 773 } 774 775 mutex_lock(&tas_dev->pde_lock); 776 while (offset < (img_sz - FW_FL_HDR)) { 777 memset(&hdr, 0, sizeof(hdr)); 778 offset += read_header(&buf[offset], &hdr); 779 dev_dbg(tas_dev->dev, 780 "vndr=%d, file=%d, version=%d, len=%d, off=%d\n", 781 hdr.vendor_id, hdr.file_id, hdr.version, 782 hdr.length, offset); 783 /* size also includes the header */ 784 file_blk_size = hdr.length - FW_FL_HDR; 785 786 /* make sure that enough data is there */ 787 if (offset + file_blk_size > img_sz) { 788 ret = -EINVAL; 789 dev_err(tas_dev->dev, 790 "corrupt firmware file"); 791 break; 792 } 793 794 switch (hdr.file_id) { 795 case 0: 796 ret = sdw_nwrite_no_pm(tas_dev->sdw_peripheral, 797 PRAM_ADDR_START, file_blk_size, 798 &buf[offset]); 799 if (ret < 0) 800 dev_err(tas_dev->dev, 801 "PRAM update failed: %d", ret); 802 break; 803 804 case 1: 805 ret = sdw_nwrite_no_pm(tas_dev->sdw_peripheral, 806 YRAM_ADDR_START, file_blk_size, 807 &buf[offset]); 808 if (ret < 0) 809 dev_err(tas_dev->dev, 810 "YRAM update failed: %d", ret); 811 812 break; 813 814 default: 815 ret = -EINVAL; 816 dev_err(tas_dev->dev, "Unsupported file"); 817 break; 818 } 819 820 if (ret == 0) 821 offset += file_blk_size; 822 else 823 break; 824 } 825 mutex_unlock(&tas_dev->pde_lock); 826 if (!ret) 827 tas2783_update_calibdata(tas_dev); 828 829 out: 830 if (!ret) 831 tas_dev->fw_dl_success = true; 832 tas_dev->fw_dl_task_done = true; 833 wake_up(&tas_dev->fw_wait); 834 if (fmw) 835 release_firmware(fmw); 836 } 837 838 static inline s32 tas_clear_latch(struct tas2783_prv *priv) 839 { 840 return regmap_update_bits(priv->regmap, 841 TASDEV_REG_SDW(0, 0, 0x5c), 842 0x04, 0x04); 843 } 844 845 static s32 tas_fu21_event(struct snd_soc_dapm_widget *w, 846 struct snd_kcontrol *k, s32 event) 847 { 848 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); 849 struct tas2783_prv *tas_dev = snd_soc_component_get_drvdata(component); 850 s32 mute; 851 852 switch (event) { 853 case SND_SOC_DAPM_POST_PMU: 854 mute = 0; 855 break; 856 857 case SND_SOC_DAPM_PRE_PMD: 858 mute = 1; 859 break; 860 } 861 862 return sdw_write_no_pm(tas_dev->sdw_peripheral, 863 SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU21, 864 TAS2783_SDCA_CTL_FU_MUTE, 1), mute); 865 } 866 867 static s32 tas_fu23_event(struct snd_soc_dapm_widget *w, 868 struct snd_kcontrol *k, s32 event) 869 { 870 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); 871 struct tas2783_prv *tas_dev = snd_soc_component_get_drvdata(component); 872 s32 mute; 873 874 switch (event) { 875 case SND_SOC_DAPM_POST_PMU: 876 mute = 0; 877 break; 878 879 case SND_SOC_DAPM_PRE_PMD: 880 mute = 1; 881 break; 882 } 883 884 return sdw_write_no_pm(tas_dev->sdw_peripheral, 885 SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_FU23, 886 TAS2783_SDCA_CTL_FU_MUTE, 1), mute); 887 } 888 889 static const struct snd_soc_dapm_widget tas_dapm_widgets[] = { 890 SND_SOC_DAPM_AIF_IN("ASI", "ASI Playback", 0, SND_SOC_NOPM, 0, 0), 891 SND_SOC_DAPM_AIF_OUT("ASI OUT", "ASI Capture", 0, SND_SOC_NOPM, 892 0, 0), 893 SND_SOC_DAPM_DAC_E("FU21", NULL, SND_SOC_NOPM, 0, 0, tas_fu21_event, 894 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 895 SND_SOC_DAPM_DAC_E("FU23", NULL, SND_SOC_NOPM, 0, 0, tas_fu23_event, 896 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 897 SND_SOC_DAPM_OUTPUT("SPK"), 898 SND_SOC_DAPM_INPUT("DMIC"), 899 }; 900 901 static const struct snd_soc_dapm_route tas_audio_map[] = { 902 {"FU21", NULL, "ASI"}, 903 {"SPK", NULL, "FU21"}, 904 {"FU23", NULL, "ASI"}, 905 {"SPK", NULL, "FU23"}, 906 {"ASI OUT", NULL, "DMIC"}, 907 }; 908 909 static s32 tas_set_sdw_stream(struct snd_soc_dai *dai, 910 void *sdw_stream, s32 direction) 911 { 912 if (!sdw_stream) 913 return 0; 914 915 snd_soc_dai_dma_data_set(dai, direction, sdw_stream); 916 917 return 0; 918 } 919 920 static void tas_sdw_shutdown(struct snd_pcm_substream *substream, 921 struct snd_soc_dai *dai) 922 { 923 snd_soc_dai_set_dma_data(dai, substream, NULL); 924 } 925 926 static s32 tas_sdw_hw_params(struct snd_pcm_substream *substream, 927 struct snd_pcm_hw_params *params, 928 struct snd_soc_dai *dai) 929 { 930 struct snd_soc_component *component = dai->component; 931 struct tas2783_prv *tas_dev = 932 snd_soc_component_get_drvdata(component); 933 struct sdw_stream_config stream_config = {0}; 934 struct sdw_port_config port_config = {0}; 935 struct sdw_stream_runtime *sdw_stream; 936 struct sdw_slave *sdw_peripheral = tas_dev->sdw_peripheral; 937 s32 ret, retry = 3; 938 939 if (!tas_dev->fw_dl_success) { 940 dev_err(tas_dev->dev, "error playback without fw download"); 941 return -EINVAL; 942 } 943 944 sdw_stream = snd_soc_dai_get_dma_data(dai, substream); 945 if (!sdw_stream) 946 return -EINVAL; 947 948 ret = tas_clear_latch(tas_dev); 949 if (ret) 950 dev_err(tas_dev->dev, 951 "clear latch failed, err=%d", ret); 952 953 mutex_lock(&tas_dev->pde_lock); 954 /* 955 * Sometimes, there is error returned during power on. 956 * So added retry logic to ensure power on so that 957 * port prepare succeeds 958 */ 959 do { 960 ret = regmap_write(tas_dev->regmap, 961 SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 962 TAS2783_SDCA_CTL_REQ_POW_STATE, 0), 963 TAS2783_SDCA_POW_STATE_ON); 964 if (!ret) 965 break; 966 usleep_range(2000, 2200); 967 } while (retry--); 968 mutex_unlock(&tas_dev->pde_lock); 969 if (ret) 970 return ret; 971 972 /* SoundWire specific configuration */ 973 snd_sdw_params_to_config(substream, params, 974 &stream_config, &port_config); 975 /* port 1 for playback */ 976 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 977 port_config.num = 1; 978 else 979 port_config.num = 2; 980 981 ret = sdw_stream_add_slave(sdw_peripheral, 982 &stream_config, &port_config, 1, sdw_stream); 983 if (ret) 984 dev_err(dai->dev, "Unable to configure port\n"); 985 986 return ret; 987 } 988 989 static s32 tas_sdw_pcm_hw_free(struct snd_pcm_substream *substream, 990 struct snd_soc_dai *dai) 991 { 992 s32 ret; 993 struct snd_soc_component *component = dai->component; 994 struct tas2783_prv *tas_dev = 995 snd_soc_component_get_drvdata(component); 996 struct sdw_stream_runtime *sdw_stream = 997 snd_soc_dai_get_dma_data(dai, substream); 998 999 sdw_stream_remove_slave(tas_dev->sdw_peripheral, sdw_stream); 1000 1001 mutex_lock(&tas_dev->pde_lock); 1002 ret = regmap_write(tas_dev->regmap, 1003 SDW_SDCA_CTL(1, TAS2783_SDCA_ENT_PDE23, 1004 TAS2783_SDCA_CTL_REQ_POW_STATE, 0), 1005 TAS2783_SDCA_POW_STATE_OFF); 1006 mutex_unlock(&tas_dev->pde_lock); 1007 1008 return ret; 1009 } 1010 1011 static const struct snd_soc_dai_ops tas_dai_ops = { 1012 .hw_params = tas_sdw_hw_params, 1013 .hw_free = tas_sdw_pcm_hw_free, 1014 .set_stream = tas_set_sdw_stream, 1015 .shutdown = tas_sdw_shutdown, 1016 }; 1017 1018 static struct snd_soc_dai_driver tas_dai_driver[] = { 1019 { 1020 .name = "tas2783-codec", 1021 .id = 0, 1022 .playback = { 1023 .stream_name = "Playback", 1024 .channels_min = 1, 1025 .channels_max = 4, 1026 .rates = TAS2783_DEVICE_RATES, 1027 .formats = TAS2783_DEVICE_FORMATS, 1028 }, 1029 .capture = { 1030 .stream_name = "Capture", 1031 .channels_min = 1, 1032 .channels_max = 4, 1033 .rates = TAS2783_DEVICE_RATES, 1034 .formats = TAS2783_DEVICE_FORMATS, 1035 }, 1036 .ops = &tas_dai_ops, 1037 .symmetric_rate = 1, 1038 }, 1039 }; 1040 1041 static s32 tas_component_probe(struct snd_soc_component *component) 1042 { 1043 struct tas2783_prv *tas_dev = 1044 snd_soc_component_get_drvdata(component); 1045 1046 tas_dev->component = component; 1047 tas25xx_register_misc(tas_dev->sdw_peripheral); 1048 1049 return 0; 1050 } 1051 1052 static void tas_component_remove(struct snd_soc_component *codec) 1053 { 1054 struct tas2783_prv *tas_dev = 1055 snd_soc_component_get_drvdata(codec); 1056 tas25xx_deregister_misc(); 1057 tas_dev->component = NULL; 1058 } 1059 1060 static const struct snd_soc_component_driver soc_codec_driver_tasdevice = { 1061 .probe = tas_component_probe, 1062 .remove = tas_component_remove, 1063 .controls = tas2783_snd_controls, 1064 .num_controls = ARRAY_SIZE(tas2783_snd_controls), 1065 .dapm_widgets = tas_dapm_widgets, 1066 .num_dapm_widgets = ARRAY_SIZE(tas_dapm_widgets), 1067 .dapm_routes = tas_audio_map, 1068 .num_dapm_routes = ARRAY_SIZE(tas_audio_map), 1069 .idle_bias_on = 1, 1070 .endianness = 1, 1071 }; 1072 1073 static s32 tas_init(struct tas2783_prv *tas_dev) 1074 { 1075 s32 ret; 1076 1077 dev_set_drvdata(tas_dev->dev, tas_dev); 1078 ret = devm_snd_soc_register_component(tas_dev->dev, 1079 &soc_codec_driver_tasdevice, 1080 tas_dai_driver, 1081 ARRAY_SIZE(tas_dai_driver)); 1082 if (ret) { 1083 dev_err(tas_dev->dev, "%s: codec register error:%d.\n", 1084 __func__, ret); 1085 return ret; 1086 } 1087 1088 /* set autosuspend parameters */ 1089 pm_runtime_set_autosuspend_delay(tas_dev->dev, 3000); 1090 pm_runtime_use_autosuspend(tas_dev->dev); 1091 /* make sure the device does not suspend immediately */ 1092 pm_runtime_mark_last_busy(tas_dev->dev); 1093 pm_runtime_enable(tas_dev->dev); 1094 1095 return ret; 1096 } 1097 1098 static s32 tas_read_prop(struct sdw_slave *slave) 1099 { 1100 struct sdw_slave_prop *prop = &slave->prop; 1101 s32 nval; 1102 s32 i, j; 1103 u32 bit; 1104 unsigned long addr; 1105 struct sdw_dpn_prop *dpn; 1106 1107 prop->scp_int1_mask = 1108 SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY; 1109 prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY; 1110 1111 prop->paging_support = true; 1112 1113 /* first we need to allocate memory for set bits in port lists */ 1114 prop->source_ports = 0x04; /* BITMAP: 00000100 */ 1115 prop->sink_ports = 0x2; /* BITMAP: 00000010 */ 1116 1117 nval = hweight32(prop->source_ports); 1118 prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval, 1119 sizeof(*prop->src_dpn_prop), GFP_KERNEL); 1120 if (!prop->src_dpn_prop) 1121 return -ENOMEM; 1122 1123 i = 0; 1124 dpn = prop->src_dpn_prop; 1125 addr = prop->source_ports; 1126 for_each_set_bit(bit, &addr, 32) { 1127 dpn[i].num = bit; 1128 dpn[i].type = SDW_DPN_FULL; 1129 dpn[i].simple_ch_prep_sm = false; 1130 dpn[i].ch_prep_timeout = 10; 1131 i++; 1132 } 1133 1134 /* do this again for sink now */ 1135 nval = hweight32(prop->sink_ports); 1136 prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval, 1137 sizeof(*prop->sink_dpn_prop), GFP_KERNEL); 1138 if (!prop->sink_dpn_prop) 1139 return -ENOMEM; 1140 1141 j = 0; 1142 dpn = prop->sink_dpn_prop; 1143 addr = prop->sink_ports; 1144 for_each_set_bit(bit, &addr, 32) { 1145 dpn[j].num = bit; 1146 dpn[j].type = SDW_DPN_FULL; 1147 dpn[j].simple_ch_prep_sm = false; 1148 dpn[j].ch_prep_timeout = 10; 1149 j++; 1150 } 1151 1152 /* set the timeout values */ 1153 prop->clk_stop_timeout = 200; 1154 1155 return 0; 1156 } 1157 1158 static s32 tas2783_sdca_dev_suspend(struct device *dev) 1159 { 1160 struct tas2783_prv *tas_dev = dev_get_drvdata(dev); 1161 1162 if (!tas_dev->hw_init) 1163 return 0; 1164 1165 regcache_cache_only(tas_dev->regmap, true); 1166 return 0; 1167 } 1168 1169 static s32 tas2783_sdca_dev_system_suspend(struct device *dev) 1170 { 1171 return tas2783_sdca_dev_suspend(dev); 1172 } 1173 1174 static s32 tas2783_sdca_dev_resume(struct device *dev) 1175 { 1176 struct sdw_slave *slave = dev_to_sdw_dev(dev); 1177 struct tas2783_prv *tas_dev = dev_get_drvdata(dev); 1178 unsigned long t; 1179 1180 if (!slave->unattach_request) 1181 goto regmap_sync; 1182 1183 t = wait_for_completion_timeout(&slave->initialization_complete, 1184 msecs_to_jiffies(TAS2783_PROBE_TIMEOUT)); 1185 if (!t) { 1186 dev_err(&slave->dev, "resume: initialization timed out\n"); 1187 sdw_show_ping_status(slave->bus, true); 1188 return -ETIMEDOUT; 1189 } 1190 1191 slave->unattach_request = 0; 1192 1193 regmap_sync: 1194 regcache_cache_only(tas_dev->regmap, false); 1195 regcache_sync(tas_dev->regmap); 1196 return 0; 1197 } 1198 1199 static const struct dev_pm_ops tas2783_sdca_pm = { 1200 SYSTEM_SLEEP_PM_OPS(tas2783_sdca_dev_system_suspend, tas2783_sdca_dev_resume) 1201 RUNTIME_PM_OPS(tas2783_sdca_dev_suspend, tas2783_sdca_dev_resume, NULL) 1202 }; 1203 1204 static s32 tas_io_init(struct device *dev, struct sdw_slave *slave) 1205 { 1206 struct tas2783_prv *tas_dev = dev_get_drvdata(dev); 1207 s32 ret; 1208 u8 unique_id = tas_dev->sdw_peripheral->id.unique_id; 1209 1210 if (tas_dev->hw_init) 1211 return 0; 1212 1213 tas_dev->fw_dl_task_done = false; 1214 tas_dev->fw_dl_success = false; 1215 scnprintf(tas_dev->rca_binaryname, sizeof(tas_dev->rca_binaryname), 1216 "tas2783-%01x.bin", unique_id); 1217 1218 ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_UEVENT, 1219 tas_dev->rca_binaryname, tas_dev->dev, 1220 GFP_KERNEL, tas_dev, tas2783_fw_ready); 1221 if (ret) { 1222 dev_err(tas_dev->dev, 1223 "firmware request failed for uid=%d, ret=%d\n", 1224 unique_id, ret); 1225 return ret; 1226 } 1227 1228 ret = wait_event_timeout(tas_dev->fw_wait, tas_dev->fw_dl_task_done, 1229 msecs_to_jiffies(TIMEOUT_FW_DL_MS)); 1230 if (!ret) { 1231 dev_err(tas_dev->dev, "fw request, wait_event timeout\n"); 1232 ret = -EAGAIN; 1233 } else { 1234 ret = regmap_multi_reg_write(tas_dev->regmap, tas2783_init_seq, 1235 ARRAY_SIZE(tas2783_init_seq)); 1236 tas_dev->hw_init = true; 1237 } 1238 1239 return ret; 1240 } 1241 1242 static s32 tas_update_status(struct sdw_slave *slave, 1243 enum sdw_slave_status status) 1244 { 1245 struct tas2783_prv *tas_dev = dev_get_drvdata(&slave->dev); 1246 struct device *dev = &slave->dev; 1247 1248 dev_dbg(dev, "Peripheral status = %s", 1249 status == SDW_SLAVE_UNATTACHED ? "unattached" : 1250 status == SDW_SLAVE_ATTACHED ? "attached" : "alert"); 1251 1252 tas_dev->status = status; 1253 if (status == SDW_SLAVE_UNATTACHED) 1254 tas_dev->hw_init = false; 1255 1256 /* Perform initialization only if slave status 1257 * is present and hw_init flag is false 1258 */ 1259 if (tas_dev->hw_init || tas_dev->status != SDW_SLAVE_ATTACHED) 1260 return 0; 1261 1262 /* updated the cache data to device */ 1263 regcache_cache_only(tas_dev->regmap, false); 1264 regcache_sync(tas_dev->regmap); 1265 1266 /* perform I/O transfers required for Slave initialization */ 1267 return tas_io_init(&slave->dev, slave); 1268 } 1269 1270 static const struct sdw_slave_ops tas_sdw_ops = { 1271 .read_prop = tas_read_prop, 1272 .update_status = tas_update_status, 1273 }; 1274 1275 static void tas_remove(struct tas2783_prv *tas_dev) 1276 { 1277 snd_soc_unregister_component(tas_dev->dev); 1278 } 1279 1280 static s32 tas_sdw_probe(struct sdw_slave *peripheral, 1281 const struct sdw_device_id *id) 1282 { 1283 struct regmap *regmap; 1284 struct device *dev = &peripheral->dev; 1285 struct tas2783_prv *tas_dev; 1286 1287 tas_dev = devm_kzalloc(dev, sizeof(*tas_dev), GFP_KERNEL); 1288 if (!tas_dev) 1289 return dev_err_probe(dev, -ENOMEM, 1290 "Failed devm_kzalloc"); 1291 1292 tas_dev->dev = dev; 1293 tas_dev->sdw_peripheral = peripheral; 1294 tas_dev->hw_init = false; 1295 mutex_init(&tas_dev->calib_lock); 1296 mutex_init(&tas_dev->pde_lock); 1297 1298 init_waitqueue_head(&tas_dev->fw_wait); 1299 dev_set_drvdata(dev, tas_dev); 1300 regmap = devm_regmap_init_sdw_mbq_cfg(peripheral, 1301 &tas_regmap, 1302 &tas2783_mbq_cfg); 1303 if (IS_ERR(regmap)) 1304 return dev_err_probe(dev, PTR_ERR(regmap), 1305 "Failed devm_regmap_init_sdw."); 1306 1307 /* keep in cache until the device is fully initialized */ 1308 regcache_cache_only(regmap, true); 1309 tas_dev->regmap = regmap; 1310 return tas_init(tas_dev); 1311 } 1312 1313 static s32 tas_sdw_remove(struct sdw_slave *peripheral) 1314 { 1315 struct tas2783_prv *tas_dev = dev_get_drvdata(&peripheral->dev); 1316 1317 pm_runtime_disable(tas_dev->dev); 1318 tas_remove(tas_dev); 1319 mutex_destroy(&tas_dev->calib_lock); 1320 mutex_destroy(&tas_dev->pde_lock); 1321 dev_set_drvdata(&peripheral->dev, NULL); 1322 1323 return 0; 1324 } 1325 1326 static const struct sdw_device_id tas_sdw_id[] = { 1327 /* chipid for the TAS2783 is 0x0000 */ 1328 SDW_SLAVE_ENTRY(0x0102, 0x0000, 0), 1329 {}, 1330 }; 1331 MODULE_DEVICE_TABLE(sdw, tas_sdw_id); 1332 1333 static struct sdw_driver tas_sdw_driver = { 1334 .driver = { 1335 .name = "slave-tas2783", 1336 .pm = pm_ptr(&tas2783_sdca_pm), 1337 }, 1338 .probe = tas_sdw_probe, 1339 .remove = tas_sdw_remove, 1340 .ops = &tas_sdw_ops, 1341 .id_table = tas_sdw_id, 1342 }; 1343 module_sdw_driver(tas_sdw_driver); 1344 1345 MODULE_AUTHOR("Texas Instruments Inc."); 1346 MODULE_DESCRIPTION("ASoC TAS2783 SoundWire Driver"); 1347 MODULE_LICENSE("GPL"); 1348