1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * adv7511_cec.c - Analog Devices ADV7511/33 cec driver 4 * 5 * Copyright 2017 Cisco Systems, Inc. and/or its affiliates. All rights reserved. 6 */ 7 8 #include <linux/device.h> 9 #include <linux/module.h> 10 #include <linux/of_device.h> 11 #include <linux/slab.h> 12 #include <linux/clk.h> 13 14 #include <media/cec.h> 15 16 #include "adv7511.h" 17 18 #define ADV7511_INT1_CEC_MASK \ 19 (ADV7511_INT1_CEC_TX_READY | ADV7511_INT1_CEC_TX_ARBIT_LOST | \ 20 ADV7511_INT1_CEC_TX_RETRY_TIMEOUT | ADV7511_INT1_CEC_RX_READY1 | \ 21 ADV7511_INT1_CEC_RX_READY2 | ADV7511_INT1_CEC_RX_READY3) 22 23 static void adv_cec_tx_raw_status(struct adv7511 *adv7511, u8 tx_raw_status) 24 { 25 unsigned int offset = adv7511->reg_cec_offset; 26 unsigned int val; 27 28 if (regmap_read(adv7511->regmap_cec, 29 ADV7511_REG_CEC_TX_ENABLE + offset, &val)) 30 return; 31 32 if ((val & 0x01) == 0) 33 return; 34 35 if (tx_raw_status & ADV7511_INT1_CEC_TX_ARBIT_LOST) { 36 cec_transmit_attempt_done(adv7511->cec_adap, 37 CEC_TX_STATUS_ARB_LOST); 38 return; 39 } 40 if (tx_raw_status & ADV7511_INT1_CEC_TX_RETRY_TIMEOUT) { 41 u8 status; 42 u8 err_cnt = 0; 43 u8 nack_cnt = 0; 44 u8 low_drive_cnt = 0; 45 unsigned int cnt; 46 47 /* 48 * We set this status bit since this hardware performs 49 * retransmissions. 50 */ 51 status = CEC_TX_STATUS_MAX_RETRIES; 52 if (regmap_read(adv7511->regmap_cec, 53 ADV7511_REG_CEC_TX_LOW_DRV_CNT + offset, &cnt)) { 54 err_cnt = 1; 55 status |= CEC_TX_STATUS_ERROR; 56 } else { 57 nack_cnt = cnt & 0xf; 58 if (nack_cnt) 59 status |= CEC_TX_STATUS_NACK; 60 low_drive_cnt = cnt >> 4; 61 if (low_drive_cnt) 62 status |= CEC_TX_STATUS_LOW_DRIVE; 63 } 64 cec_transmit_done(adv7511->cec_adap, status, 65 0, nack_cnt, low_drive_cnt, err_cnt); 66 return; 67 } 68 if (tx_raw_status & ADV7511_INT1_CEC_TX_READY) { 69 cec_transmit_attempt_done(adv7511->cec_adap, CEC_TX_STATUS_OK); 70 return; 71 } 72 } 73 74 static void adv7511_cec_rx(struct adv7511 *adv7511, int rx_buf) 75 { 76 unsigned int offset = adv7511->reg_cec_offset; 77 struct cec_msg msg = {}; 78 unsigned int len; 79 unsigned int val; 80 u8 i; 81 82 if (regmap_read(adv7511->regmap_cec, 83 ADV7511_REG_CEC_RX_FRAME_LEN[rx_buf] + offset, &len)) 84 return; 85 86 msg.len = len & 0x1f; 87 88 if (msg.len > 16) 89 msg.len = 16; 90 91 if (!msg.len) 92 return; 93 94 for (i = 0; i < msg.len; i++) { 95 regmap_read(adv7511->regmap_cec, 96 i + ADV7511_REG_CEC_RX_FRAME_HDR[rx_buf] + offset, 97 &val); 98 msg.msg[i] = val; 99 } 100 101 /* Toggle RX Ready Clear bit to re-enable this RX buffer */ 102 regmap_update_bits(adv7511->regmap_cec, 103 ADV7511_REG_CEC_RX_BUFFERS + offset, BIT(rx_buf), 104 BIT(rx_buf)); 105 regmap_update_bits(adv7511->regmap_cec, 106 ADV7511_REG_CEC_RX_BUFFERS + offset, BIT(rx_buf), 0); 107 108 cec_received_msg(adv7511->cec_adap, &msg); 109 } 110 111 void adv7511_cec_irq_process(struct adv7511 *adv7511, unsigned int irq1) 112 { 113 unsigned int offset = adv7511->reg_cec_offset; 114 const u32 irq_tx_mask = ADV7511_INT1_CEC_TX_READY | 115 ADV7511_INT1_CEC_TX_ARBIT_LOST | 116 ADV7511_INT1_CEC_TX_RETRY_TIMEOUT; 117 const u32 irq_rx_mask = ADV7511_INT1_CEC_RX_READY1 | 118 ADV7511_INT1_CEC_RX_READY2 | 119 ADV7511_INT1_CEC_RX_READY3; 120 unsigned int rx_status; 121 int rx_order[3] = { -1, -1, -1 }; 122 int i; 123 124 if (irq1 & irq_tx_mask) 125 adv_cec_tx_raw_status(adv7511, irq1); 126 127 if (!(irq1 & irq_rx_mask)) 128 return; 129 130 if (regmap_read(adv7511->regmap_cec, 131 ADV7511_REG_CEC_RX_STATUS + offset, &rx_status)) 132 return; 133 134 /* 135 * ADV7511_REG_CEC_RX_STATUS[5:0] contains the reception order of RX 136 * buffers 0, 1, and 2 in bits [1:0], [3:2], and [5:4] respectively. 137 * The values are to be interpreted as follows: 138 * 139 * 0 = buffer unused 140 * 1 = buffer contains oldest received frame (if applicable) 141 * 2 = buffer contains second oldest received frame (if applicable) 142 * 3 = buffer contains third oldest received frame (if applicable) 143 * 144 * Fill rx_order with the sequence of RX buffer indices to 145 * read from in order, where -1 indicates that there are no 146 * more buffers to process. 147 */ 148 for (i = 0; i < 3; i++) { 149 unsigned int timestamp = (rx_status >> (2 * i)) & 0x3; 150 151 if (timestamp) 152 rx_order[timestamp - 1] = i; 153 } 154 155 /* Read CEC RX buffers in the appropriate order as prescribed above */ 156 for (i = 0; i < 3; i++) { 157 int rx_buf = rx_order[i]; 158 159 if (rx_buf < 0) 160 break; 161 162 adv7511_cec_rx(adv7511, rx_buf); 163 } 164 } 165 166 static int adv7511_cec_adap_enable(struct cec_adapter *adap, bool enable) 167 { 168 struct adv7511 *adv7511 = cec_get_drvdata(adap); 169 unsigned int offset = adv7511->reg_cec_offset; 170 171 if (adv7511->i2c_cec == NULL) 172 return -EIO; 173 174 if (!adv7511->cec_enabled_adap && enable) { 175 /* power up cec section */ 176 regmap_update_bits(adv7511->regmap_cec, 177 ADV7511_REG_CEC_CLK_DIV + offset, 178 0x03, 0x01); 179 /* non-legacy mode and clear all rx buffers */ 180 regmap_write(adv7511->regmap_cec, 181 ADV7511_REG_CEC_RX_BUFFERS + offset, 0x0f); 182 regmap_write(adv7511->regmap_cec, 183 ADV7511_REG_CEC_RX_BUFFERS + offset, 0x08); 184 /* initially disable tx */ 185 regmap_update_bits(adv7511->regmap_cec, 186 ADV7511_REG_CEC_TX_ENABLE + offset, 1, 0); 187 /* enabled irqs: */ 188 /* tx: ready */ 189 /* tx: arbitration lost */ 190 /* tx: retry timeout */ 191 /* rx: ready 1-3 */ 192 regmap_update_bits(adv7511->regmap, 193 ADV7511_REG_INT_ENABLE(1), 0x3f, 194 ADV7511_INT1_CEC_MASK); 195 } else if (adv7511->cec_enabled_adap && !enable) { 196 regmap_update_bits(adv7511->regmap, 197 ADV7511_REG_INT_ENABLE(1), 0x3f, 0); 198 /* disable address mask 1-3 */ 199 regmap_update_bits(adv7511->regmap_cec, 200 ADV7511_REG_CEC_LOG_ADDR_MASK + offset, 201 0x70, 0x00); 202 /* power down cec section */ 203 regmap_update_bits(adv7511->regmap_cec, 204 ADV7511_REG_CEC_CLK_DIV + offset, 205 0x03, 0x00); 206 adv7511->cec_valid_addrs = 0; 207 } 208 adv7511->cec_enabled_adap = enable; 209 return 0; 210 } 211 212 static int adv7511_cec_adap_log_addr(struct cec_adapter *adap, u8 addr) 213 { 214 struct adv7511 *adv7511 = cec_get_drvdata(adap); 215 unsigned int offset = adv7511->reg_cec_offset; 216 unsigned int i, free_idx = ADV7511_MAX_ADDRS; 217 218 if (!adv7511->cec_enabled_adap) 219 return addr == CEC_LOG_ADDR_INVALID ? 0 : -EIO; 220 221 if (addr == CEC_LOG_ADDR_INVALID) { 222 regmap_update_bits(adv7511->regmap_cec, 223 ADV7511_REG_CEC_LOG_ADDR_MASK + offset, 224 0x70, 0); 225 adv7511->cec_valid_addrs = 0; 226 return 0; 227 } 228 229 for (i = 0; i < ADV7511_MAX_ADDRS; i++) { 230 bool is_valid = adv7511->cec_valid_addrs & (1 << i); 231 232 if (free_idx == ADV7511_MAX_ADDRS && !is_valid) 233 free_idx = i; 234 if (is_valid && adv7511->cec_addr[i] == addr) 235 return 0; 236 } 237 if (i == ADV7511_MAX_ADDRS) { 238 i = free_idx; 239 if (i == ADV7511_MAX_ADDRS) 240 return -ENXIO; 241 } 242 adv7511->cec_addr[i] = addr; 243 adv7511->cec_valid_addrs |= 1 << i; 244 245 switch (i) { 246 case 0: 247 /* enable address mask 0 */ 248 regmap_update_bits(adv7511->regmap_cec, 249 ADV7511_REG_CEC_LOG_ADDR_MASK + offset, 250 0x10, 0x10); 251 /* set address for mask 0 */ 252 regmap_update_bits(adv7511->regmap_cec, 253 ADV7511_REG_CEC_LOG_ADDR_0_1 + offset, 254 0x0f, addr); 255 break; 256 case 1: 257 /* enable address mask 1 */ 258 regmap_update_bits(adv7511->regmap_cec, 259 ADV7511_REG_CEC_LOG_ADDR_MASK + offset, 260 0x20, 0x20); 261 /* set address for mask 1 */ 262 regmap_update_bits(adv7511->regmap_cec, 263 ADV7511_REG_CEC_LOG_ADDR_0_1 + offset, 264 0xf0, addr << 4); 265 break; 266 case 2: 267 /* enable address mask 2 */ 268 regmap_update_bits(adv7511->regmap_cec, 269 ADV7511_REG_CEC_LOG_ADDR_MASK + offset, 270 0x40, 0x40); 271 /* set address for mask 1 */ 272 regmap_update_bits(adv7511->regmap_cec, 273 ADV7511_REG_CEC_LOG_ADDR_2 + offset, 274 0x0f, addr); 275 break; 276 } 277 return 0; 278 } 279 280 static int adv7511_cec_adap_transmit(struct cec_adapter *adap, u8 attempts, 281 u32 signal_free_time, struct cec_msg *msg) 282 { 283 struct adv7511 *adv7511 = cec_get_drvdata(adap); 284 unsigned int offset = adv7511->reg_cec_offset; 285 u8 len = msg->len; 286 unsigned int i; 287 288 /* 289 * The number of retries is the number of attempts - 1, but retry 290 * at least once. It's not clear if a value of 0 is allowed, so 291 * let's do at least one retry. 292 */ 293 regmap_update_bits(adv7511->regmap_cec, 294 ADV7511_REG_CEC_TX_RETRY + offset, 295 0x70, max(1, attempts - 1) << 4); 296 297 /* blocking, clear cec tx irq status */ 298 regmap_update_bits(adv7511->regmap, ADV7511_REG_INT(1), 0x38, 0x38); 299 300 /* write data */ 301 for (i = 0; i < len; i++) 302 regmap_write(adv7511->regmap_cec, 303 i + ADV7511_REG_CEC_TX_FRAME_HDR + offset, 304 msg->msg[i]); 305 306 /* set length (data + header) */ 307 regmap_write(adv7511->regmap_cec, 308 ADV7511_REG_CEC_TX_FRAME_LEN + offset, len); 309 /* start transmit, enable tx */ 310 regmap_write(adv7511->regmap_cec, 311 ADV7511_REG_CEC_TX_ENABLE + offset, 0x01); 312 return 0; 313 } 314 315 static const struct cec_adap_ops adv7511_cec_adap_ops = { 316 .adap_enable = adv7511_cec_adap_enable, 317 .adap_log_addr = adv7511_cec_adap_log_addr, 318 .adap_transmit = adv7511_cec_adap_transmit, 319 }; 320 321 static int adv7511_cec_parse_dt(struct device *dev, struct adv7511 *adv7511) 322 { 323 adv7511->cec_clk = devm_clk_get(dev, "cec"); 324 if (IS_ERR(adv7511->cec_clk)) { 325 int ret = PTR_ERR(adv7511->cec_clk); 326 327 adv7511->cec_clk = NULL; 328 return ret; 329 } 330 clk_prepare_enable(adv7511->cec_clk); 331 adv7511->cec_clk_freq = clk_get_rate(adv7511->cec_clk); 332 return 0; 333 } 334 335 int adv7511_cec_init(struct device *dev, struct adv7511 *adv7511) 336 { 337 unsigned int offset = adv7511->reg_cec_offset; 338 int ret = adv7511_cec_parse_dt(dev, adv7511); 339 340 if (ret) 341 goto err_cec_parse_dt; 342 343 adv7511->cec_adap = cec_allocate_adapter(&adv7511_cec_adap_ops, 344 adv7511, dev_name(dev), CEC_CAP_DEFAULTS, ADV7511_MAX_ADDRS); 345 if (IS_ERR(adv7511->cec_adap)) { 346 ret = PTR_ERR(adv7511->cec_adap); 347 goto err_cec_alloc; 348 } 349 350 regmap_write(adv7511->regmap, ADV7511_REG_CEC_CTRL + offset, 0); 351 /* cec soft reset */ 352 regmap_write(adv7511->regmap_cec, 353 ADV7511_REG_CEC_SOFT_RESET + offset, 0x01); 354 regmap_write(adv7511->regmap_cec, 355 ADV7511_REG_CEC_SOFT_RESET + offset, 0x00); 356 357 /* non-legacy mode - use all three RX buffers */ 358 regmap_write(adv7511->regmap_cec, 359 ADV7511_REG_CEC_RX_BUFFERS + offset, 0x08); 360 361 regmap_write(adv7511->regmap_cec, 362 ADV7511_REG_CEC_CLK_DIV + offset, 363 ((adv7511->cec_clk_freq / 750000) - 1) << 2); 364 365 ret = cec_register_adapter(adv7511->cec_adap, dev); 366 if (ret) 367 goto err_cec_register; 368 return 0; 369 370 err_cec_register: 371 cec_delete_adapter(adv7511->cec_adap); 372 adv7511->cec_adap = NULL; 373 err_cec_alloc: 374 dev_info(dev, "Initializing CEC failed with error %d, disabling CEC\n", 375 ret); 376 err_cec_parse_dt: 377 regmap_write(adv7511->regmap, ADV7511_REG_CEC_CTRL + offset, 378 ADV7511_CEC_CTRL_POWER_DOWN); 379 return ret == -EPROBE_DEFER ? ret : 0; 380 } 381