1// SPDX-License-Identifier: GPL-2.0-only
  2//
  3// rt722-sdca-sdw.c -- rt722 SDCA ALSA SoC audio driver
  4//
  5// Copyright(c) 2023 Realtek Semiconductor Corp.
  6//
  7//
  8
  9#include <linux/delay.h>
 10#include <linux/device.h>
 11#include <linux/module.h>
 12#include <linux/mod_devicetable.h>
 13#include <linux/pm_runtime.h>
 14#include <linux/soundwire/sdw_registers.h>
 15
 16#include "rt722-sdca.h"
 17#include "rt722-sdca-sdw.h"
 18
 19static bool rt722_sdca_readable_register(struct device *dev, unsigned int reg)
 20{
 21	switch (reg) {
 22	case 0x2f01 ... 0x2f0a:
 23	case 0x2f35 ... 0x2f36:
 24	case 0x2f50:
 25	case 0x2f54:
 26	case 0x2f58 ... 0x2f5d:
 27	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_GE49, RT722_SDCA_CTL_SELECTED_MODE,
 28			0):
 29	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_GE49, RT722_SDCA_CTL_DETECTED_MODE,
 30			0):
 31	case SDW_SDCA_CTL(FUNC_NUM_HID, RT722_SDCA_ENT_HID01, RT722_SDCA_CTL_HIDTX_CURRENT_OWNER,
 32			0) ... SDW_SDCA_CTL(FUNC_NUM_HID, RT722_SDCA_ENT_HID01,
 33			RT722_SDCA_CTL_HIDTX_MESSAGE_LENGTH, 0):
 34	case RT722_BUF_ADDR_HID1 ... RT722_BUF_ADDR_HID2:
 35		return true;
 36	default:
 37		return false;
 38	}
 39}
 40
 41static bool rt722_sdca_volatile_register(struct device *dev, unsigned int reg)
 42{
 43	switch (reg) {
 44	case 0x2f01:
 45	case 0x2f54:
 46	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_GE49, RT722_SDCA_CTL_DETECTED_MODE,
 47			0):
 48	case SDW_SDCA_CTL(FUNC_NUM_HID, RT722_SDCA_ENT_HID01, RT722_SDCA_CTL_HIDTX_CURRENT_OWNER,
 49			0) ... SDW_SDCA_CTL(FUNC_NUM_HID, RT722_SDCA_ENT_HID01,
 50			RT722_SDCA_CTL_HIDTX_MESSAGE_LENGTH, 0):
 51	case RT722_BUF_ADDR_HID1 ... RT722_BUF_ADDR_HID2:
 52		return true;
 53	default:
 54		return false;
 55	}
 56}
 57
 58static bool rt722_sdca_mbq_readable_register(struct device *dev, unsigned int reg)
 59{
 60	switch (reg) {
 61	case 0x2000000 ... 0x2000024:
 62	case 0x2000029 ... 0x200004a:
 63	case 0x2000051 ... 0x2000052:
 64	case 0x200005a ... 0x200005b:
 65	case 0x2000061 ... 0x2000069:
 66	case 0x200006b:
 67	case 0x2000070:
 68	case 0x200007f:
 69	case 0x2000082 ... 0x200008e:
 70	case 0x2000090 ... 0x2000094:
 71	case 0x3110000:
 72	case 0x5300000 ... 0x5300002:
 73	case 0x5400002:
 74	case 0x5600000 ... 0x5600007:
 75	case 0x5700000 ... 0x5700004:
 76	case 0x5800000 ... 0x5800004:
 77	case 0x5b00003:
 78	case 0x5c00011:
 79	case 0x5d00006:
 80	case 0x5f00000 ... 0x5f0000d:
 81	case 0x5f00030:
 82	case 0x6100000 ... 0x6100051:
 83	case 0x6100055 ... 0x6100057:
 84	case 0x6100062:
 85	case 0x6100064 ... 0x6100065:
 86	case 0x6100067:
 87	case 0x6100070 ... 0x610007c:
 88	case 0x6100080:
 89	case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT722_SDCA_ENT_USER_FU1E, RT722_SDCA_CTL_FU_VOLUME,
 90			CH_01):
 91	case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT722_SDCA_ENT_USER_FU1E, RT722_SDCA_CTL_FU_VOLUME,
 92			CH_02):
 93	case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT722_SDCA_ENT_USER_FU1E, RT722_SDCA_CTL_FU_VOLUME,
 94			CH_03):
 95	case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT722_SDCA_ENT_USER_FU1E, RT722_SDCA_CTL_FU_VOLUME,
 96			CH_04):
 97	case SDW_SDCA_CTL(FUNC_NUM_AMP, RT722_SDCA_ENT_USER_FU06, RT722_SDCA_CTL_FU_VOLUME, CH_L):
 98	case SDW_SDCA_CTL(FUNC_NUM_AMP, RT722_SDCA_ENT_USER_FU06, RT722_SDCA_CTL_FU_VOLUME, CH_R):
 99	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_USER_FU05, RT722_SDCA_CTL_FU_VOLUME,
100			CH_L):
101	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_USER_FU05, RT722_SDCA_CTL_FU_VOLUME,
102			CH_R):
103	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_USER_FU0F, RT722_SDCA_CTL_FU_VOLUME,
104			CH_L):
105	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_USER_FU0F, RT722_SDCA_CTL_FU_VOLUME,
106			CH_R):
107	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_PLATFORM_FU44,
108			RT722_SDCA_CTL_FU_CH_GAIN, CH_L):
109	case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT722_SDCA_ENT_PLATFORM_FU44,
110			RT722_SDCA_CTL_FU_CH_GAIN, CH_R):
111		return true;
112	default:
113		return false;
114	}
115}
116
117static bool rt722_sdca_mbq_volatile_register(struct device *dev, unsigned int reg)
118{
119	switch (reg) {
120	case 0x2000000:
121	case 0x200000d:
122	case 0x2000019:
123	case 0x2000020:
124	case 0x2000030:
125	case 0x2000046:
126	case 0x2000067:
127	case 0x2000084:
128	case 0x2000086:
129	case 0x3110000:
130		return true;
131	default:
132		return false;
133	}
134}
135
136static const struct regmap_config rt722_sdca_regmap = {
137	.reg_bits = 32,
138	.val_bits = 8,
139	.readable_reg = rt722_sdca_readable_register,
140	.volatile_reg = rt722_sdca_volatile_register,
141	.max_register = 0x44ffffff,
142	.reg_defaults = rt722_sdca_reg_defaults,
143	.num_reg_defaults = ARRAY_SIZE(rt722_sdca_reg_defaults),
144	.cache_type = REGCACHE_MAPLE,
145	.use_single_read = true,
146	.use_single_write = true,
147};
148
149static const struct regmap_config rt722_sdca_mbq_regmap = {
150	.name = "sdw-mbq",
151	.reg_bits = 32,
152	.val_bits = 16,
153	.readable_reg = rt722_sdca_mbq_readable_register,
154	.volatile_reg = rt722_sdca_mbq_volatile_register,
155	.max_register = 0x41000312,
156	.reg_defaults = rt722_sdca_mbq_defaults,
157	.num_reg_defaults = ARRAY_SIZE(rt722_sdca_mbq_defaults),
158	.cache_type = REGCACHE_MAPLE,
159	.use_single_read = true,
160	.use_single_write = true,
161};
162
163static int rt722_sdca_update_status(struct sdw_slave *slave,
164				enum sdw_slave_status status)
165{
166	struct rt722_sdca_priv *rt722 = dev_get_drvdata(&slave->dev);
167
168	if (status == SDW_SLAVE_UNATTACHED)
169		rt722->hw_init = false;
170
171	if (status == SDW_SLAVE_ATTACHED) {
172		if (rt722->hs_jack) {
173		/*
174		 * Due to the SCP_SDCA_INTMASK will be cleared by any reset, and then
175		 * if the device attached again, we will need to set the setting back.
176		 * It could avoid losing the jack detection interrupt.
177		 * This also could sync with the cache value as the rt722_sdca_jack_init set.
178		 */
179			sdw_write_no_pm(rt722->slave, SDW_SCP_SDCA_INTMASK1,
180				SDW_SCP_SDCA_INTMASK_SDCA_0);
181			sdw_write_no_pm(rt722->slave, SDW_SCP_SDCA_INTMASK2,
182				SDW_SCP_SDCA_INTMASK_SDCA_8);
183		}
184	}
185
186	/*
187	 * Perform initialization only if slave status is present and
188	 * hw_init flag is false
189	 */
190	if (rt722->hw_init || status != SDW_SLAVE_ATTACHED)
191		return 0;
192
193	/* perform I/O transfers required for Slave initialization */
194	return rt722_sdca_io_init(&slave->dev, slave);
195}
196
197static int rt722_sdca_read_prop(struct sdw_slave *slave)
198{
199	struct sdw_slave_prop *prop = &slave->prop;
200	int nval;
201	int i, j;
202	u32 bit;
203	unsigned long addr;
204	struct sdw_dpn_prop *dpn;
205
206	prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY;
207	prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY;
208
209	prop->paging_support = true;
210
211	/*
212	 * port = 1 for headphone playback
213	 * port = 2 for headset-mic capture
214	 * port = 3 for speaker playback
215	 * port = 6 for digital-mic capture
216	 */
217	prop->source_ports = BIT(6) | BIT(2); /* BITMAP: 01000100 */
218	prop->sink_ports = BIT(3) | BIT(1); /* BITMAP:  00001010 */
219
220	nval = hweight32(prop->source_ports);
221	prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,
222		sizeof(*prop->src_dpn_prop), GFP_KERNEL);
223	if (!prop->src_dpn_prop)
224		return -ENOMEM;
225
226	i = 0;
227	dpn = prop->src_dpn_prop;
228	addr = prop->source_ports;
229	for_each_set_bit(bit, &addr, 32) {
230		dpn[i].num = bit;
231		dpn[i].type = SDW_DPN_FULL;
232		dpn[i].simple_ch_prep_sm = true;
233		dpn[i].ch_prep_timeout = 10;
234		i++;
235	}
236
237	/* do this again for sink now */
238	nval = hweight32(prop->sink_ports);
239	prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,
240		sizeof(*prop->sink_dpn_prop), GFP_KERNEL);
241	if (!prop->sink_dpn_prop)
242		return -ENOMEM;
243
244	j = 0;
245	dpn = prop->sink_dpn_prop;
246	addr = prop->sink_ports;
247	for_each_set_bit(bit, &addr, 32) {
248		dpn[j].num = bit;
249		dpn[j].type = SDW_DPN_FULL;
250		dpn[j].simple_ch_prep_sm = true;
251		dpn[j].ch_prep_timeout = 10;
252		j++;
253	}
254
255	/* set the timeout values */
256	prop->clk_stop_timeout = 900;
257
258	/* wake-up event */
259	prop->wake_capable = 1;
260
261	/* Three data lanes are supported by rt722-sdca codec */
262	prop->lane_control_support = true;
263
264	return 0;
265}
266
267static int rt722_sdca_interrupt_callback(struct sdw_slave *slave,
268					struct sdw_slave_intr_status *status)
269{
270	struct rt722_sdca_priv *rt722 = dev_get_drvdata(&slave->dev);
271	int ret, stat;
272	int count = 0, retry = 3;
273	unsigned int sdca_cascade, scp_sdca_stat1, scp_sdca_stat2 = 0;
274
275	if (cancel_delayed_work_sync(&rt722->jack_detect_work)) {
276		dev_warn(&slave->dev, "%s the pending delayed_work was cancelled", __func__);
277		/* avoid the HID owner doesn't change to device */
278		if (rt722->scp_sdca_stat2)
279			scp_sdca_stat2 = rt722->scp_sdca_stat2;
280	}
281
282	/*
283	 * The critical section below intentionally protects a rather large piece of code.
284	 * We don't want to allow the system suspend to disable an interrupt while we are
285	 * processing it, which could be problematic given the quirky SoundWire interrupt
286	 * scheme. We do want however to prevent new workqueues from being scheduled if
287	 * the disable_irq flag was set during system suspend.
288	 */
289	mutex_lock(&rt722->disable_irq_lock);
290
291	ret = sdw_read_no_pm(rt722->slave, SDW_SCP_SDCA_INT1);
292	if (ret < 0)
293		goto io_error;
294	rt722->scp_sdca_stat1 = ret;
295	ret = sdw_read_no_pm(rt722->slave, SDW_SCP_SDCA_INT2);
296	if (ret < 0)
297		goto io_error;
298	rt722->scp_sdca_stat2 = ret;
299	if (scp_sdca_stat2)
300		rt722->scp_sdca_stat2 |= scp_sdca_stat2;
301	do {
302		/* clear flag */
303		ret = sdw_read_no_pm(rt722->slave, SDW_SCP_SDCA_INT1);
304		if (ret < 0)
305			goto io_error;
306		if (ret & SDW_SCP_SDCA_INTMASK_SDCA_0) {
307			ret = sdw_update_no_pm(rt722->slave, SDW_SCP_SDCA_INT1,
308				SDW_SCP_SDCA_INT_SDCA_0, SDW_SCP_SDCA_INT_SDCA_0);
309			if (ret < 0)
310				goto io_error;
311		}
312
313		ret = sdw_read_no_pm(rt722->slave, SDW_SCP_SDCA_INT2);
314		if (ret < 0)
315			goto io_error;
316		if (ret & SDW_SCP_SDCA_INTMASK_SDCA_8) {
317			ret = sdw_write_no_pm(rt722->slave, SDW_SCP_SDCA_INT2,
318						SDW_SCP_SDCA_INTMASK_SDCA_8);
319			if (ret < 0)
320				goto io_error;
321		}
322
323		/* check if flag clear or not */
324		ret = sdw_read_no_pm(rt722->slave, SDW_DP0_INT);
325		if (ret < 0)
326			goto io_error;
327		sdca_cascade = ret & SDW_DP0_SDCA_CASCADE;
328
329		ret = sdw_read_no_pm(rt722->slave, SDW_SCP_SDCA_INT1);
330		if (ret < 0)
331			goto io_error;
332		scp_sdca_stat1 = ret & SDW_SCP_SDCA_INTMASK_SDCA_0;
333
334		ret = sdw_read_no_pm(rt722->slave, SDW_SCP_SDCA_INT2);
335		if (ret < 0)
336			goto io_error;
337		scp_sdca_stat2 = ret & SDW_SCP_SDCA_INTMASK_SDCA_8;
338
339		stat = scp_sdca_stat1 || scp_sdca_stat2 || sdca_cascade;
340
341		count++;
342	} while (stat != 0 && count < retry);
343
344	if (stat)
345		dev_warn(&slave->dev,
346			"%s scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__,
347			rt722->scp_sdca_stat1, rt722->scp_sdca_stat2);
348
349	if (status->sdca_cascade && !rt722->disable_irq)
350		mod_delayed_work(system_power_efficient_wq,
351			&rt722->jack_detect_work, msecs_to_jiffies(280));
352
353	mutex_unlock(&rt722->disable_irq_lock);
354
355	return 0;
356
357io_error:
358	mutex_unlock(&rt722->disable_irq_lock);
359	pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
360	return ret;
361}
362
363static const struct sdw_slave_ops rt722_sdca_slave_ops = {
364	.read_prop = rt722_sdca_read_prop,
365	.interrupt_callback = rt722_sdca_interrupt_callback,
366	.update_status = rt722_sdca_update_status,
367};
368
369static int rt722_sdca_sdw_probe(struct sdw_slave *slave,
370				const struct sdw_device_id *id)
371{
372	struct regmap *regmap, *mbq_regmap;
373
374	/* Regmap Initialization */
375	mbq_regmap = devm_regmap_init_sdw_mbq(slave, &rt722_sdca_mbq_regmap);
376	if (IS_ERR(mbq_regmap))
377		return PTR_ERR(mbq_regmap);
378
379	regmap = devm_regmap_init_sdw(slave, &rt722_sdca_regmap);
380	if (IS_ERR(regmap))
381		return PTR_ERR(regmap);
382
383	return rt722_sdca_init(&slave->dev, regmap, mbq_regmap, slave);
384}
385
386static int rt722_sdca_sdw_remove(struct sdw_slave *slave)
387{
388	struct rt722_sdca_priv *rt722 = dev_get_drvdata(&slave->dev);
389
390	if (rt722->hw_init) {
391		cancel_delayed_work_sync(&rt722->jack_detect_work);
392		cancel_delayed_work_sync(&rt722->jack_btn_check_work);
393	}
394
395	if (rt722->first_hw_init)
396		pm_runtime_disable(&slave->dev);
397
398	mutex_destroy(&rt722->calibrate_mutex);
399	mutex_destroy(&rt722->disable_irq_lock);
400
401	return 0;
402}
403
404static const struct sdw_device_id rt722_sdca_id[] = {
405	SDW_SLAVE_ENTRY_EXT(0x025d, 0x722, 0x3, 0x1, 0),
406	{},
407};
408MODULE_DEVICE_TABLE(sdw, rt722_sdca_id);
409
410static int __maybe_unused rt722_sdca_dev_suspend(struct device *dev)
411{
412	struct rt722_sdca_priv *rt722 = dev_get_drvdata(dev);
413
414	if (!rt722->hw_init)
415		return 0;
416
417	cancel_delayed_work_sync(&rt722->jack_detect_work);
418	cancel_delayed_work_sync(&rt722->jack_btn_check_work);
419
420	regcache_cache_only(rt722->regmap, true);
421	regcache_cache_only(rt722->mbq_regmap, true);
422
423	return 0;
424}
425
426static int __maybe_unused rt722_sdca_dev_system_suspend(struct device *dev)
427{
428	struct rt722_sdca_priv *rt722_sdca = dev_get_drvdata(dev);
429	struct sdw_slave *slave = dev_to_sdw_dev(dev);
430	int ret1, ret2;
431
432	if (!rt722_sdca->hw_init)
433		return 0;
434
435	/*
436	 * prevent new interrupts from being handled after the
437	 * deferred work completes and before the parent disables
438	 * interrupts on the link
439	 */
440	mutex_lock(&rt722_sdca->disable_irq_lock);
441	rt722_sdca->disable_irq = true;
442	ret1 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK1,
443				SDW_SCP_SDCA_INTMASK_SDCA_0, 0);
444	ret2 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK2,
445				SDW_SCP_SDCA_INTMASK_SDCA_8, 0);
446	mutex_unlock(&rt722_sdca->disable_irq_lock);
447
448	if (ret1 < 0 || ret2 < 0) {
449		/* log but don't prevent suspend from happening */
450		dev_dbg(&slave->dev, "%s: could not disable SDCA interrupts\n:", __func__);
451	}
452
453	return rt722_sdca_dev_suspend(dev);
454}
455
456#define RT722_PROBE_TIMEOUT 5000
457
458static int __maybe_unused rt722_sdca_dev_resume(struct device *dev)
459{
460	struct sdw_slave *slave = dev_to_sdw_dev(dev);
461	struct rt722_sdca_priv *rt722 = dev_get_drvdata(dev);
462	unsigned long time;
463
464	if (!rt722->first_hw_init)
465		return 0;
466
467	if (!slave->unattach_request) {
468		mutex_lock(&rt722->disable_irq_lock);
469		if (rt722->disable_irq == true) {
470			sdw_write_no_pm(slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0);
471			sdw_write_no_pm(slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8);
472			rt722->disable_irq = false;
473		}
474		mutex_unlock(&rt722->disable_irq_lock);
475		goto regmap_sync;
476	}
477
478	time = wait_for_completion_timeout(&slave->initialization_complete,
479				msecs_to_jiffies(RT722_PROBE_TIMEOUT));
480	if (!time) {
481		dev_err(&slave->dev, "Initialization not complete, timed out\n");
482		sdw_show_ping_status(slave->bus, true);
483
484		return -ETIMEDOUT;
485	}
486
487regmap_sync:
488	slave->unattach_request = 0;
489	regcache_cache_only(rt722->regmap, false);
490	regcache_sync(rt722->regmap);
491	regcache_cache_only(rt722->mbq_regmap, false);
492	regcache_sync(rt722->mbq_regmap);
493	return 0;
494}
495
496static const struct dev_pm_ops rt722_sdca_pm = {
497	SET_SYSTEM_SLEEP_PM_OPS(rt722_sdca_dev_system_suspend, rt722_sdca_dev_resume)
498	SET_RUNTIME_PM_OPS(rt722_sdca_dev_suspend, rt722_sdca_dev_resume, NULL)
499};
500
501static struct sdw_driver rt722_sdca_sdw_driver = {
502	.driver = {
503		.name = "rt722-sdca",
504		.pm = &rt722_sdca_pm,
505	},
506	.probe = rt722_sdca_sdw_probe,
507	.remove = rt722_sdca_sdw_remove,
508	.ops = &rt722_sdca_slave_ops,
509	.id_table = rt722_sdca_id,
510};
511module_sdw_driver(rt722_sdca_sdw_driver);
512
513MODULE_DESCRIPTION("ASoC RT722 SDCA SDW driver");
514MODULE_AUTHOR("Jack Yu <jack.yu@realtek.com>");
515MODULE_LICENSE("GPL");