1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2025 Cirrus Logic, Inc. and
3 // Cirrus Logic International Semiconductor Ltd.
4
5 /*
6 * The MIPI SDCA specification is available for public downloads at
7 * https://www.mipi.org/mipi-sdca-v1-0-download
8 */
9
10 #include <linux/bitmap.h>
11 #include <linux/bits.h>
12 #include <linux/cleanup.h>
13 #include <linux/device.h>
14 #include <linux/interrupt.h>
15 #include <linux/regmap.h>
16 #include <linux/soundwire/sdw.h>
17 #include <linux/soundwire/sdw_registers.h>
18 #include <sound/sdca.h>
19 #include <sound/sdca_function.h>
20 #include <sound/sdca_interrupts.h>
21 #include <sound/soc-component.h>
22 #include <sound/soc.h>
23
24 #define IRQ_SDCA(number) REGMAP_IRQ_REG(number, ((number) / BITS_PER_BYTE), \
25 SDW_SCP_SDCA_INTMASK_SDCA_##number)
26
27 static const struct regmap_irq regmap_irqs[SDCA_MAX_INTERRUPTS] = {
28 IRQ_SDCA(0),
29 IRQ_SDCA(1),
30 IRQ_SDCA(2),
31 IRQ_SDCA(3),
32 IRQ_SDCA(4),
33 IRQ_SDCA(5),
34 IRQ_SDCA(6),
35 IRQ_SDCA(7),
36 IRQ_SDCA(8),
37 IRQ_SDCA(9),
38 IRQ_SDCA(10),
39 IRQ_SDCA(11),
40 IRQ_SDCA(12),
41 IRQ_SDCA(13),
42 IRQ_SDCA(14),
43 IRQ_SDCA(15),
44 IRQ_SDCA(16),
45 IRQ_SDCA(17),
46 IRQ_SDCA(18),
47 IRQ_SDCA(19),
48 IRQ_SDCA(20),
49 IRQ_SDCA(21),
50 IRQ_SDCA(22),
51 IRQ_SDCA(23),
52 IRQ_SDCA(24),
53 IRQ_SDCA(25),
54 IRQ_SDCA(26),
55 IRQ_SDCA(27),
56 IRQ_SDCA(28),
57 IRQ_SDCA(29),
58 IRQ_SDCA(30),
59 };
60
61 static const struct regmap_irq_chip sdca_irq_chip = {
62 .name = "sdca_irq",
63
64 .status_base = SDW_SCP_SDCA_INT1,
65 .unmask_base = SDW_SCP_SDCA_INTMASK1,
66 .ack_base = SDW_SCP_SDCA_INT1,
67 .num_regs = 4,
68
69 .irqs = regmap_irqs,
70 .num_irqs = SDCA_MAX_INTERRUPTS,
71
72 .runtime_pm = true,
73 };
74
base_handler(int irq,void * data)75 static irqreturn_t base_handler(int irq, void *data)
76 {
77 struct sdca_interrupt *interrupt = data;
78 struct device *dev = interrupt->component->dev;
79
80 dev_info(dev, "%s irq without full handling\n", interrupt->name);
81
82 return IRQ_HANDLED;
83 }
84
function_status_handler(int irq,void * data)85 static irqreturn_t function_status_handler(int irq, void *data)
86 {
87 struct sdca_interrupt *interrupt = data;
88 struct device *dev = interrupt->component->dev;
89 unsigned int reg, val;
90 unsigned long status;
91 unsigned int mask;
92 int ret;
93
94 reg = SDW_SDCA_CTL(interrupt->function->desc->adr, interrupt->entity->id,
95 interrupt->control->sel, 0);
96
97 ret = regmap_read(interrupt->component->regmap, reg, &val);
98 if (ret < 0) {
99 dev_err(dev, "failed to read function status: %d\n", ret);
100 return IRQ_NONE;
101 }
102
103 dev_dbg(dev, "function status: %#x\n", val);
104
105 status = val;
106 for_each_set_bit(mask, &status, BITS_PER_BYTE) {
107 mask = 1 << mask;
108
109 switch (mask) {
110 case SDCA_CTL_ENTITY_0_FUNCTION_NEEDS_INITIALIZATION:
111 //FIXME: Add init writes
112 break;
113 case SDCA_CTL_ENTITY_0_FUNCTION_FAULT:
114 dev_err(dev, "function fault\n");
115 break;
116 case SDCA_CTL_ENTITY_0_UMP_SEQUENCE_FAULT:
117 dev_err(dev, "ump sequence fault\n");
118 break;
119 case SDCA_CTL_ENTITY_0_FUNCTION_BUSY:
120 dev_info(dev, "unexpected function busy\n");
121 break;
122 case SDCA_CTL_ENTITY_0_DEVICE_NEWLY_ATTACHED:
123 case SDCA_CTL_ENTITY_0_INTS_DISABLED_ABNORMALLY:
124 case SDCA_CTL_ENTITY_0_STREAMING_STOPPED_ABNORMALLY:
125 case SDCA_CTL_ENTITY_0_FUNCTION_HAS_BEEN_RESET:
126 break;
127 }
128 }
129
130 ret = regmap_write(interrupt->component->regmap, reg, val);
131 if (ret < 0) {
132 dev_err(dev, "failed to clear function status: %d\n", ret);
133 return IRQ_NONE;
134 }
135
136 return IRQ_HANDLED;
137 }
138
detected_mode_handler(int irq,void * data)139 static irqreturn_t detected_mode_handler(int irq, void *data)
140 {
141 struct sdca_interrupt *interrupt = data;
142 struct snd_soc_component *component = interrupt->component;
143 struct device *dev = component->dev;
144 struct snd_soc_card *card = component->card;
145 struct rw_semaphore *rwsem = &card->snd_card->controls_rwsem;
146 struct snd_kcontrol *kctl = interrupt->priv;
147 struct snd_ctl_elem_value *ucontrol __free(kfree) = NULL;
148 struct soc_enum *soc_enum;
149 unsigned int reg, val;
150 int ret;
151
152 if (!kctl) {
153 const char *name __free(kfree) = kasprintf(GFP_KERNEL, "%s %s",
154 interrupt->entity->label,
155 SDCA_CTL_SELECTED_MODE_NAME);
156
157 if (!name)
158 return IRQ_NONE;
159
160 kctl = snd_soc_component_get_kcontrol(component, name);
161 if (!kctl) {
162 dev_dbg(dev, "control not found: %s\n", name);
163 return IRQ_NONE;
164 }
165
166 interrupt->priv = kctl;
167 }
168
169 soc_enum = (struct soc_enum *)kctl->private_value;
170
171 reg = SDW_SDCA_CTL(interrupt->function->desc->adr, interrupt->entity->id,
172 interrupt->control->sel, 0);
173
174 ret = regmap_read(component->regmap, reg, &val);
175 if (ret < 0) {
176 dev_err(dev, "failed to read detected mode: %d\n", ret);
177 return IRQ_NONE;
178 }
179
180 switch (val) {
181 case SDCA_DETECTED_MODE_DETECTION_IN_PROGRESS:
182 case SDCA_DETECTED_MODE_JACK_UNKNOWN:
183 reg = SDW_SDCA_CTL(interrupt->function->desc->adr,
184 interrupt->entity->id,
185 SDCA_CTL_GE_SELECTED_MODE, 0);
186
187 /*
188 * Selected mode is not normally marked as volatile register
189 * (RW), but here force a read from the hardware. If the
190 * detected mode is unknown we need to see what the device
191 * selected as a "safe" option.
192 */
193 regcache_drop_region(component->regmap, reg, reg);
194
195 ret = regmap_read(component->regmap, reg, &val);
196 if (ret) {
197 dev_err(dev, "failed to re-check selected mode: %d\n", ret);
198 return IRQ_NONE;
199 }
200 break;
201 default:
202 break;
203 }
204
205 dev_dbg(dev, "%s: %#x\n", interrupt->name, val);
206
207 ucontrol = kzalloc(sizeof(*ucontrol), GFP_KERNEL);
208 if (!ucontrol)
209 return IRQ_NONE;
210
211 ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(soc_enum, val);
212
213 down_write(rwsem);
214 ret = kctl->put(kctl, ucontrol);
215 up_write(rwsem);
216 if (ret < 0) {
217 dev_err(dev, "failed to update selected mode: %d\n", ret);
218 return IRQ_NONE;
219 }
220
221 snd_ctl_notify(card->snd_card, SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
222
223 return IRQ_HANDLED;
224 }
225
sdca_irq_request_locked(struct device * dev,struct sdca_interrupt_info * info,int sdca_irq,const char * name,irq_handler_t handler,void * data)226 static int sdca_irq_request_locked(struct device *dev,
227 struct sdca_interrupt_info *info,
228 int sdca_irq, const char *name,
229 irq_handler_t handler, void *data)
230 {
231 int irq;
232 int ret;
233
234 irq = regmap_irq_get_virq(info->irq_data, sdca_irq);
235 if (irq < 0)
236 return irq;
237
238 ret = devm_request_threaded_irq(dev, irq, NULL, handler,
239 IRQF_ONESHOT, name, data);
240 if (ret)
241 return ret;
242
243 dev_dbg(dev, "requested irq %d for %s\n", irq, name);
244
245 return 0;
246 }
247
248 /**
249 * sdca_request_irq - request an individual SDCA interrupt
250 * @dev: Pointer to the struct device against which things should be allocated.
251 * @interrupt_info: Pointer to the interrupt information structure.
252 * @sdca_irq: SDCA interrupt position.
253 * @name: Name to be given to the IRQ.
254 * @handler: A callback thread function to be called for the IRQ.
255 * @data: Private data pointer that will be passed to the handler.
256 *
257 * Typically this is handled internally by sdca_irq_populate, however if
258 * a device requires custom IRQ handling this can be called manually before
259 * calling sdca_irq_populate, which will then skip that IRQ whilst processing.
260 *
261 * Return: Zero on success, and a negative error code on failure.
262 */
sdca_irq_request(struct device * dev,struct sdca_interrupt_info * info,int sdca_irq,const char * name,irq_handler_t handler,void * data)263 int sdca_irq_request(struct device *dev, struct sdca_interrupt_info *info,
264 int sdca_irq, const char *name, irq_handler_t handler,
265 void *data)
266 {
267 int ret;
268
269 if (sdca_irq < 0 || sdca_irq >= SDCA_MAX_INTERRUPTS) {
270 dev_err(dev, "bad irq request: %d\n", sdca_irq);
271 return -EINVAL;
272 }
273
274 guard(mutex)(&info->irq_lock);
275
276 ret = sdca_irq_request_locked(dev, info, sdca_irq, name, handler, data);
277 if (ret) {
278 dev_err(dev, "failed to request irq %s: %d\n", name, ret);
279 return ret;
280 }
281
282 info->irqs[sdca_irq].externally_requested = true;
283
284 return 0;
285 }
286 EXPORT_SYMBOL_NS_GPL(sdca_irq_request, "SND_SOC_SDCA");
287
288 /**
289 * sdca_irq_data_populate - Populate common interrupt data
290 * @component: Pointer to the ASoC component for the Function.
291 * @function: Pointer to the SDCA Function.
292 * @entity: Pointer to the SDCA Entity.
293 * @control: Pointer to the SDCA Control.
294 * @interrupt: Pointer to the SDCA interrupt for this IRQ.
295 *
296 * Return: Zero on success, and a negative error code on failure.
297 */
sdca_irq_data_populate(struct snd_soc_component * component,struct sdca_function_data * function,struct sdca_entity * entity,struct sdca_control * control,struct sdca_interrupt * interrupt)298 int sdca_irq_data_populate(struct snd_soc_component *component,
299 struct sdca_function_data *function,
300 struct sdca_entity *entity,
301 struct sdca_control *control,
302 struct sdca_interrupt *interrupt)
303 {
304 struct device *dev = component->dev;
305 const char *name;
306
307 name = devm_kasprintf(dev, GFP_KERNEL, "%s %s %s", function->desc->name,
308 entity->label, control->label);
309 if (!name)
310 return -ENOMEM;
311
312 interrupt->name = name;
313 interrupt->component = component;
314 interrupt->function = function;
315 interrupt->entity = entity;
316 interrupt->control = control;
317
318 return 0;
319 }
320 EXPORT_SYMBOL_NS_GPL(sdca_irq_data_populate, "SND_SOC_SDCA");
321
322 /**
323 * sdca_irq_populate - Request all the individual IRQs for an SDCA Function
324 * @function: Pointer to the SDCA Function.
325 * @component: Pointer to the ASoC component for the Function.
326 * @info: Pointer to the SDCA interrupt info for this device.
327 *
328 * Typically this would be called from the driver for a single SDCA Function.
329 *
330 * Return: Zero on success, and a negative error code on failure.
331 */
sdca_irq_populate(struct sdca_function_data * function,struct snd_soc_component * component,struct sdca_interrupt_info * info)332 int sdca_irq_populate(struct sdca_function_data *function,
333 struct snd_soc_component *component,
334 struct sdca_interrupt_info *info)
335 {
336 struct device *dev = component->dev;
337 int i, j;
338
339 guard(mutex)(&info->irq_lock);
340
341 for (i = 0; i < function->num_entities; i++) {
342 struct sdca_entity *entity = &function->entities[i];
343
344 for (j = 0; j < entity->num_controls; j++) {
345 struct sdca_control *control = &entity->controls[j];
346 int irq = control->interrupt_position;
347 struct sdca_interrupt *interrupt;
348 irq_handler_t handler;
349 int ret;
350
351 if (irq == SDCA_NO_INTERRUPT) {
352 continue;
353 } else if (irq < 0 || irq >= SDCA_MAX_INTERRUPTS) {
354 dev_err(dev, "bad irq position: %d\n", irq);
355 return -EINVAL;
356 }
357
358 interrupt = &info->irqs[irq];
359
360 if (interrupt->externally_requested) {
361 dev_dbg(dev,
362 "skipping irq %d, externally requested\n",
363 irq);
364 continue;
365 }
366
367 ret = sdca_irq_data_populate(component, function, entity,
368 control, interrupt);
369 if (ret)
370 return ret;
371
372 handler = base_handler;
373
374 switch (entity->type) {
375 case SDCA_ENTITY_TYPE_ENTITY_0:
376 if (control->sel == SDCA_CTL_ENTITY_0_FUNCTION_STATUS)
377 handler = function_status_handler;
378 break;
379 case SDCA_ENTITY_TYPE_GE:
380 if (control->sel == SDCA_CTL_GE_DETECTED_MODE)
381 handler = detected_mode_handler;
382 break;
383 default:
384 break;
385 }
386
387 ret = sdca_irq_request_locked(dev, info, irq, interrupt->name,
388 handler, interrupt);
389 if (ret) {
390 dev_err(dev, "failed to request irq %s: %d\n",
391 interrupt->name, ret);
392 return ret;
393 }
394 }
395 }
396
397 return 0;
398 }
399 EXPORT_SYMBOL_NS_GPL(sdca_irq_populate, "SND_SOC_SDCA");
400
401 /**
402 * sdca_irq_allocate - allocate an SDCA interrupt structure for a device
403 * @dev: Device pointer against which things should be allocated.
404 * @regmap: regmap to be used for accessing the SDCA IRQ registers.
405 * @irq: The interrupt number.
406 *
407 * Typically this would be called from the top level driver for the whole
408 * SDCA device, as only a single instance is required across all Functions
409 * on the device.
410 *
411 * Return: A pointer to the allocated sdca_interrupt_info struct, or an
412 * error code.
413 */
sdca_irq_allocate(struct device * dev,struct regmap * regmap,int irq)414 struct sdca_interrupt_info *sdca_irq_allocate(struct device *dev,
415 struct regmap *regmap, int irq)
416 {
417 struct sdca_interrupt_info *info;
418 int ret;
419
420 info = devm_kzalloc(dev, sizeof(*info), GFP_KERNEL);
421 if (!info)
422 return ERR_PTR(-ENOMEM);
423
424 info->irq_chip = sdca_irq_chip;
425
426 ret = devm_mutex_init(dev, &info->irq_lock);
427 if (ret)
428 return ERR_PTR(ret);
429
430 ret = devm_regmap_add_irq_chip(dev, regmap, irq, IRQF_ONESHOT, 0,
431 &info->irq_chip, &info->irq_data);
432 if (ret) {
433 dev_err(dev, "failed to register irq chip: %d\n", ret);
434 return ERR_PTR(ret);
435 }
436
437 dev_dbg(dev, "registered on irq %d\n", irq);
438
439 return info;
440 }
441 EXPORT_SYMBOL_NS_GPL(sdca_irq_allocate, "SND_SOC_SDCA");
442
443 MODULE_LICENSE("GPL");
444 MODULE_DESCRIPTION("SDCA IRQ library");
445