Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'soundwire-6.3-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/soundwire
Pull soundwire updates from Vinod Koul:
"This is a small update which features a bit of core changes and driver
updates in Intel and cadence driver.
Core:
- sdw_transfer_defer() API change to drop an argument
- Reset page address rework
- Export sdw_nwrite_no_pm and sdw_nread_no_pm APIs
Drivers:
- Cadence and related intel driver updates for FIFO handling and low
level msg transfers"
* tag 'soundwire-6.3-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/soundwire:
soundwire: cadence: further simplify low-level xfer_msg_defer() callback
soundwire: cadence: use directly bus sdw_defer structure
soundwire: bus: remove sdw_defer argument in sdw_transfer_defer()
soundwire: stream: use consistent pattern for freeing buffers
soundwire: bus: Remove unused reset_page_addr() callback
soundwire: bus: Don't zero page registers after every transaction
soundwire: bus_type: Avoid lockdep assert in sdw_drv_probe()
soundwire: stream: Move remaining register accesses over to no_pm
soundwire: debugfs: Switch to sdw_read_no_pm
soundwire: Provide build stubs for common functions
soundwire: bus: export sdw_nwrite_no_pm and sdw_nread_no_pm functions
soundwire: cadence: remove unused sdw_cdns_master_ops declaration
soundwire: enable optional clock registers for SoundWire 1.2 devices
ASoC/soundwire: remove is_sdca boolean property
soundwire: cadence: Drain the RX FIFO after an IO timeout
soundwire: cadence: Remove wasted space in response_buf
soundwire: cadence: Don't overflow the command FIFOs
soundwire: intel: remove DAI startup/shutdown
+207
-167
+16
-40
drivers/soundwire/bus.c
+16
-40
drivers/soundwire/bus.c
···
225
225
}
226
226
227
227
static inline int do_transfer_defer(struct sdw_bus *bus,
228
-
struct sdw_msg *msg,
229
-
struct sdw_defer *defer)
228
+
struct sdw_msg *msg)
230
229
{
230
+
struct sdw_defer *defer = &bus->defer_msg;
231
231
int retry = bus->prop.err_threshold;
232
232
enum sdw_command_response resp;
233
233
int ret = 0, i;
···
237
237
init_completion(&defer->complete);
238
238
239
239
for (i = 0; i <= retry; i++) {
240
-
resp = bus->ops->xfer_msg_defer(bus, msg, defer);
241
-
ret = find_response_code(resp);
242
-
/* if cmd is ok or ignored return */
243
-
if (ret == 0 || ret == -ENODATA)
244
-
return ret;
245
-
}
246
-
247
-
return ret;
248
-
}
249
-
250
-
static int sdw_reset_page(struct sdw_bus *bus, u16 dev_num)
251
-
{
252
-
int retry = bus->prop.err_threshold;
253
-
enum sdw_command_response resp;
254
-
int ret = 0, i;
255
-
256
-
for (i = 0; i <= retry; i++) {
257
-
resp = bus->ops->reset_page_addr(bus, dev_num);
240
+
resp = bus->ops->xfer_msg_defer(bus);
258
241
ret = find_response_code(resp);
259
242
/* if cmd is ok or ignored return */
260
243
if (ret == 0 || ret == -ENODATA)
···
257
274
msg->dev_num, ret,
258
275
(msg->flags & SDW_MSG_FLAG_WRITE) ? "write" : "read",
259
276
msg->addr, msg->len);
260
-
261
-
if (msg->page)
262
-
sdw_reset_page(bus, msg->dev_num);
263
277
264
278
return ret;
265
279
}
···
315
335
* sdw_transfer_defer() - Asynchronously transfer message to a SDW Slave device
316
336
* @bus: SDW bus
317
337
* @msg: SDW message to be xfered
318
-
* @defer: Defer block for signal completion
319
338
*
320
339
* Caller needs to hold the msg_lock lock while calling this
321
340
*/
322
-
int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg,
323
-
struct sdw_defer *defer)
341
+
int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg)
324
342
{
325
343
int ret;
326
344
327
345
if (!bus->ops->xfer_msg_defer)
328
346
return -ENOTSUPP;
329
347
330
-
ret = do_transfer_defer(bus, msg, defer);
348
+
ret = do_transfer_defer(bus, msg);
331
349
if (ret != 0 && ret != -ENODATA)
332
350
dev_err(bus->dev, "Defer trf on Slave %d failed:%d\n",
333
351
msg->dev_num, ret);
334
-
335
-
if (msg->page)
336
-
sdw_reset_page(bus, msg->dev_num);
337
352
338
353
return ret;
339
354
}
···
389
414
* all clients need to use the pm versions
390
415
*/
391
416
392
-
static int
393
-
sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
417
+
int sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
394
418
{
395
419
struct sdw_msg msg;
396
420
int ret;
···
404
430
ret = 0;
405
431
return ret;
406
432
}
433
+
EXPORT_SYMBOL(sdw_nread_no_pm);
407
434
408
-
static int
409
-
sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
435
+
int sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
410
436
{
411
437
struct sdw_msg msg;
412
438
int ret;
···
421
447
ret = 0;
422
448
return ret;
423
449
}
450
+
EXPORT_SYMBOL(sdw_nwrite_no_pm);
424
451
425
452
int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value)
426
453
{
···
1189
1214
val &= ~SDW_DPN_INT_PORT_READY;
1190
1215
}
1191
1216
1192
-
ret = sdw_update(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val);
1217
+
ret = sdw_update_no_pm(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val);
1193
1218
if (ret < 0)
1194
1219
dev_err(&slave->dev,
1195
1220
"SDW_DPN_INTMASK write failed:%d\n", val);
···
1208
1233
1209
1234
/*
1210
1235
* frequency base and scale registers are required for SDCA
1211
-
* devices. They may also be used for 1.2+/non-SDCA devices,
1212
-
* but we will need a DisCo property to cover this case
1236
+
* devices. They may also be used for 1.2+/non-SDCA devices.
1237
+
* Driver can set the property, we will need a DisCo property
1238
+
* to discover this case from platform firmware.
1213
1239
*/
1214
-
if (!slave->id.class_id)
1240
+
if (!slave->id.class_id && !slave->prop.clock_reg_supported)
1215
1241
return 0;
1216
1242
1217
1243
if (!mclk_freq) {
···
1563
1587
goto io_err;
1564
1588
}
1565
1589
1566
-
if (slave->prop.is_sdca) {
1590
+
if (slave->id.class_id) {
1567
1591
ret = sdw_read_no_pm(slave, SDW_DP0_INT);
1568
1592
if (ret < 0) {
1569
1593
dev_err(&slave->dev,
···
1700
1724
goto io_err;
1701
1725
}
1702
1726
1703
-
if (slave->prop.is_sdca) {
1727
+
if (slave->id.class_id) {
1704
1728
ret = sdw_read_no_pm(slave, SDW_DP0_INT);
1705
1729
if (ret < 0) {
1706
1730
dev_err(&slave->dev,
+1
-2
drivers/soundwire/bus.h
+1
-2
drivers/soundwire/bus.h
···
151
151
bool enable, int mask);
152
152
153
153
int sdw_transfer(struct sdw_bus *bus, struct sdw_msg *msg);
154
-
int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg,
155
-
struct sdw_defer *defer);
154
+
int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg);
156
155
157
156
#define SDW_READ_INTR_CLEAR_RETRY 10
158
157
+3
-6
drivers/soundwire/bus_type.c
+3
-6
drivers/soundwire/bus_type.c
···
105
105
if (ret)
106
106
return ret;
107
107
108
-
mutex_lock(&slave->sdw_dev_lock);
109
-
110
108
ret = drv->probe(slave, id);
111
109
if (ret) {
112
110
name = drv->name;
113
111
if (!name)
114
112
name = drv->driver.name;
115
-
mutex_unlock(&slave->sdw_dev_lock);
116
113
117
114
dev_err(dev, "Probe of %s failed: %d\n", name, ret);
118
115
dev_pm_domain_detach(dev, false);
119
116
return ret;
120
117
}
118
+
119
+
mutex_lock(&slave->sdw_dev_lock);
121
120
122
121
/* device is probed so let's read the properties now */
123
122
if (drv->ops && drv->ops->read_prop)
···
166
167
int ret = 0;
167
168
168
169
mutex_lock(&slave->sdw_dev_lock);
169
-
170
170
slave->probed = false;
171
+
mutex_unlock(&slave->sdw_dev_lock);
171
172
172
173
if (drv->remove)
173
174
ret = drv->remove(slave);
174
-
175
-
mutex_unlock(&slave->sdw_dev_lock);
176
175
177
176
dev_pm_domain_detach(dev, false);
178
177
+39
-41
drivers/soundwire/cadence_master.c
+39
-41
drivers/soundwire/cadence_master.c
···
127
127
128
128
#define CDNS_MCP_CMD_BASE 0x80
129
129
#define CDNS_MCP_RESP_BASE 0x80
130
-
#define CDNS_MCP_CMD_LEN 0x20
130
+
/* FIFO can hold 8 commands */
131
+
#define CDNS_MCP_CMD_LEN 8
131
132
#define CDNS_MCP_CMD_WORD_LEN 0x4
132
133
133
134
#define CDNS_MCP_CMD_SSP_TAG BIT(31)
···
555
554
return SDW_CMD_OK;
556
555
}
557
556
557
+
static void cdns_read_response(struct sdw_cdns *cdns)
558
+
{
559
+
u32 num_resp, cmd_base;
560
+
int i;
561
+
562
+
/* RX_FIFO_AVAIL can be 2 entries more than the FIFO size */
563
+
BUILD_BUG_ON(ARRAY_SIZE(cdns->response_buf) < CDNS_MCP_CMD_LEN + 2);
564
+
565
+
num_resp = cdns_readl(cdns, CDNS_MCP_FIFOSTAT);
566
+
num_resp &= CDNS_MCP_RX_FIFO_AVAIL;
567
+
if (num_resp > ARRAY_SIZE(cdns->response_buf)) {
568
+
dev_warn(cdns->dev, "RX AVAIL %d too long\n", num_resp);
569
+
num_resp = ARRAY_SIZE(cdns->response_buf);
570
+
}
571
+
572
+
cmd_base = CDNS_MCP_CMD_BASE;
573
+
574
+
for (i = 0; i < num_resp; i++) {
575
+
cdns->response_buf[i] = cdns_readl(cdns, cmd_base);
576
+
cmd_base += CDNS_MCP_CMD_WORD_LEN;
577
+
}
578
+
}
579
+
558
580
static enum sdw_command_response
559
581
_cdns_xfer_msg(struct sdw_cdns *cdns, struct sdw_msg *msg, int cmd,
560
582
int offset, int count, bool defer)
···
619
595
dev_err(cdns->dev, "IO transfer timed out, cmd %d device %d addr %x len %d\n",
620
596
cmd, msg->dev_num, msg->addr, msg->len);
621
597
msg->len = 0;
598
+
599
+
/* Drain anything in the RX_FIFO */
600
+
cdns_read_response(cdns);
601
+
622
602
return SDW_CMD_TIMEOUT;
623
603
}
624
604
···
749
721
EXPORT_SYMBOL(cdns_xfer_msg);
750
722
751
723
enum sdw_command_response
752
-
cdns_xfer_msg_defer(struct sdw_bus *bus,
753
-
struct sdw_msg *msg, struct sdw_defer *defer)
724
+
cdns_xfer_msg_defer(struct sdw_bus *bus)
754
725
{
755
726
struct sdw_cdns *cdns = bus_to_cdns(bus);
727
+
struct sdw_defer *defer = &bus->defer_msg;
728
+
struct sdw_msg *msg = defer->msg;
756
729
int cmd = 0, ret;
757
730
758
731
/* for defer only 1 message is supported */
···
764
735
if (ret)
765
736
return SDW_CMD_FAIL_OTHER;
766
737
767
-
cdns->defer = defer;
768
-
cdns->defer->length = msg->len;
769
-
770
738
return _cdns_xfer_msg(cdns, msg, cmd, 0, msg->len, true);
771
739
}
772
740
EXPORT_SYMBOL(cdns_xfer_msg_defer);
773
-
774
-
enum sdw_command_response
775
-
cdns_reset_page_addr(struct sdw_bus *bus, unsigned int dev_num)
776
-
{
777
-
struct sdw_cdns *cdns = bus_to_cdns(bus);
778
-
struct sdw_msg msg;
779
-
780
-
/* Create dummy message with valid device number */
781
-
memset(&msg, 0, sizeof(msg));
782
-
msg.dev_num = dev_num;
783
-
784
-
return cdns_program_scp_addr(cdns, &msg);
785
-
}
786
-
EXPORT_SYMBOL(cdns_reset_page_addr);
787
741
788
742
u32 cdns_read_ping_status(struct sdw_bus *bus)
789
743
{
···
779
767
/*
780
768
* IRQ handling
781
769
*/
782
-
783
-
static void cdns_read_response(struct sdw_cdns *cdns)
784
-
{
785
-
u32 num_resp, cmd_base;
786
-
int i;
787
-
788
-
num_resp = cdns_readl(cdns, CDNS_MCP_FIFOSTAT);
789
-
num_resp &= CDNS_MCP_RX_FIFO_AVAIL;
790
-
791
-
cmd_base = CDNS_MCP_CMD_BASE;
792
-
793
-
for (i = 0; i < num_resp; i++) {
794
-
cdns->response_buf[i] = cdns_readl(cdns, cmd_base);
795
-
cmd_base += CDNS_MCP_CMD_WORD_LEN;
796
-
}
797
-
}
798
770
799
771
static int cdns_update_slave_status(struct sdw_cdns *cdns,
800
772
u64 slave_intstat)
···
877
881
return IRQ_NONE;
878
882
879
883
if (int_status & CDNS_MCP_INT_RX_WL) {
884
+
struct sdw_bus *bus = &cdns->bus;
885
+
struct sdw_defer *defer = &bus->defer_msg;
886
+
880
887
cdns_read_response(cdns);
881
888
882
-
if (cdns->defer) {
883
-
cdns_fill_msg_resp(cdns, cdns->defer->msg,
884
-
cdns->defer->length, 0);
885
-
complete(&cdns->defer->complete);
886
-
cdns->defer = NULL;
889
+
if (defer && defer->msg) {
890
+
cdns_fill_msg_resp(cdns, defer->msg,
891
+
defer->length, 0);
892
+
complete(&defer->complete);
887
893
} else {
888
894
complete(&cdns->tx_complete);
889
895
}
+13
-9
drivers/soundwire/cadence_master.h
+13
-9
drivers/soundwire/cadence_master.h
···
8
8
#define SDW_CADENCE_GSYNC_KHZ 4 /* 4 kHz */
9
9
#define SDW_CADENCE_GSYNC_HZ (SDW_CADENCE_GSYNC_KHZ * 1000)
10
10
11
+
/*
12
+
* The Cadence IP supports up to 32 entries in the FIFO, though implementations
13
+
* can configure the IP to have a smaller FIFO.
14
+
*/
15
+
#define CDNS_MCP_IP_MAX_CMD_LEN 32
16
+
11
17
/**
12
18
* struct sdw_cdns_pdi: PDI (Physical Data Interface) instance
13
19
*
···
109
103
* @instance: instance number
110
104
* @response_buf: SoundWire response buffer
111
105
* @tx_complete: Tx completion
112
-
* @defer: Defer pointer
113
106
* @ports: Data ports
114
107
* @num_ports: Total number of data ports
115
108
* @pcm: PCM streams
···
122
117
struct sdw_bus bus;
123
118
unsigned int instance;
124
119
125
-
u32 response_buf[0x80];
120
+
/*
121
+
* The datasheet says the RX FIFO AVAIL can be 2 entries more
122
+
* than the FIFO capacity, so allow for this.
123
+
*/
124
+
u32 response_buf[CDNS_MCP_IP_MAX_CMD_LEN + 2];
125
+
126
126
struct completion tx_complete;
127
-
struct sdw_defer *defer;
128
127
129
128
struct sdw_cdns_port *ports;
130
129
int num_ports;
···
156
147
/* Exported symbols */
157
148
158
149
int sdw_cdns_probe(struct sdw_cdns *cdns);
159
-
extern struct sdw_master_ops sdw_cdns_master_ops;
160
150
161
151
irqreturn_t sdw_cdns_irq(int irq, void *dev_id);
162
152
irqreturn_t sdw_cdns_thread(int irq, void *dev_id);
···
181
173
u32 ch, u32 dir, struct sdw_cdns_pdi *pdi);
182
174
183
175
enum sdw_command_response
184
-
cdns_reset_page_addr(struct sdw_bus *bus, unsigned int dev_num);
185
-
186
-
enum sdw_command_response
187
176
cdns_xfer_msg(struct sdw_bus *bus, struct sdw_msg *msg);
188
177
189
178
enum sdw_command_response
190
-
cdns_xfer_msg_defer(struct sdw_bus *bus,
191
-
struct sdw_msg *msg, struct sdw_defer *defer);
179
+
cdns_xfer_msg_defer(struct sdw_bus *bus);
192
180
193
181
u32 cdns_read_ping_status(struct sdw_bus *bus);
194
182
+12
-1
drivers/soundwire/debugfs.c
+12
-1
drivers/soundwire/debugfs.c
···
4
4
#include <linux/device.h>
5
5
#include <linux/debugfs.h>
6
6
#include <linux/mod_devicetable.h>
7
+
#include <linux/pm_runtime.h>
7
8
#include <linux/slab.h>
8
9
#include <linux/soundwire/sdw.h>
9
10
#include <linux/soundwire/sdw_registers.h>
···
36
35
{
37
36
int value;
38
37
39
-
value = sdw_read(slave, reg);
38
+
value = sdw_read_no_pm(slave, reg);
40
39
41
40
if (value < 0)
42
41
return scnprintf(buf + pos, RD_BUF - pos, "%3x\tXX\n", reg);
···
55
54
buf = kzalloc(RD_BUF, GFP_KERNEL);
56
55
if (!buf)
57
56
return -ENOMEM;
57
+
58
+
ret = pm_runtime_resume_and_get(&slave->dev);
59
+
if (ret < 0 && ret != -EACCES) {
60
+
kfree(buf);
61
+
return ret;
62
+
}
58
63
59
64
ret = scnprintf(buf, RD_BUF, "Register Value\n");
60
65
···
119
112
}
120
113
121
114
seq_printf(s_file, "%s", buf);
115
+
116
+
pm_runtime_mark_last_busy(&slave->dev);
117
+
pm_runtime_put(&slave->dev);
118
+
122
119
kfree(buf);
123
120
124
121
return 0;
-27
drivers/soundwire/intel.c
-27
drivers/soundwire/intel.c
···
778
778
* DAI routines
779
779
*/
780
780
781
-
static int intel_startup(struct snd_pcm_substream *substream,
782
-
struct snd_soc_dai *dai)
783
-
{
784
-
struct sdw_cdns *cdns = snd_soc_dai_get_drvdata(dai);
785
-
int ret;
786
-
787
-
ret = pm_runtime_resume_and_get(cdns->dev);
788
-
if (ret < 0 && ret != -EACCES) {
789
-
dev_err_ratelimited(cdns->dev,
790
-
"pm_runtime_resume_and_get failed in %s, ret %d\n",
791
-
__func__, ret);
792
-
return ret;
793
-
}
794
-
return 0;
795
-
}
796
-
797
781
static int intel_hw_params(struct snd_pcm_substream *substream,
798
782
struct snd_pcm_hw_params *params,
799
783
struct snd_soc_dai *dai)
···
938
954
return 0;
939
955
}
940
956
941
-
static void intel_shutdown(struct snd_pcm_substream *substream,
942
-
struct snd_soc_dai *dai)
943
-
{
944
-
struct sdw_cdns *cdns = snd_soc_dai_get_drvdata(dai);
945
-
946
-
pm_runtime_mark_last_busy(cdns->dev);
947
-
pm_runtime_put_autosuspend(cdns->dev);
948
-
}
949
-
950
957
static int intel_pcm_set_sdw_stream(struct snd_soc_dai *dai,
951
958
void *stream, int direction)
952
959
{
···
1063
1088
}
1064
1089
1065
1090
static const struct snd_soc_dai_ops intel_pcm_dai_ops = {
1066
-
.startup = intel_startup,
1067
1091
.hw_params = intel_hw_params,
1068
1092
.prepare = intel_prepare,
1069
1093
.hw_free = intel_hw_free,
1070
1094
.trigger = intel_trigger,
1071
-
.shutdown = intel_shutdown,
1072
1095
.set_stream = intel_pcm_set_sdw_stream,
1073
1096
.get_stream = intel_get_sdw_stream,
1074
1097
};
-1
drivers/soundwire/intel_auxdevice.c
-1
drivers/soundwire/intel_auxdevice.c
···
113
113
.override_adr = sdw_dmi_override_adr,
114
114
.xfer_msg = cdns_xfer_msg,
115
115
.xfer_msg_defer = cdns_xfer_msg_defer,
116
-
.reset_page_addr = cdns_reset_page_addr,
117
116
.set_bus_conf = cdns_bus_conf,
118
117
.pre_bank_switch = generic_pre_bank_switch,
119
118
.post_bank_switch = generic_post_bank_switch,
+19
-19
drivers/soundwire/stream.c
+19
-19
drivers/soundwire/stream.c
···
81
81
}
82
82
83
83
/* Program DPN_OffsetCtrl2 registers */
84
-
ret = sdw_write(slave, addr1, t_params->offset2);
84
+
ret = sdw_write_no_pm(slave, addr1, t_params->offset2);
85
85
if (ret < 0) {
86
86
dev_err(bus->dev, "DPN_OffsetCtrl2 register write failed\n");
87
87
return ret;
88
88
}
89
89
90
90
/* Program DPN_BlockCtrl3 register */
91
-
ret = sdw_write(slave, addr2, t_params->blk_pkg_mode);
91
+
ret = sdw_write_no_pm(slave, addr2, t_params->blk_pkg_mode);
92
92
if (ret < 0) {
93
93
dev_err(bus->dev, "DPN_BlockCtrl3 register write failed\n");
94
94
return ret;
···
105
105
/* Program DPN_SampleCtrl2 register */
106
106
wbuf = FIELD_GET(SDW_DPN_SAMPLECTRL_HIGH, t_params->sample_interval - 1);
107
107
108
-
ret = sdw_write(slave, addr3, wbuf);
108
+
ret = sdw_write_no_pm(slave, addr3, wbuf);
109
109
if (ret < 0) {
110
110
dev_err(bus->dev, "DPN_SampleCtrl2 register write failed\n");
111
111
return ret;
···
115
115
wbuf = FIELD_PREP(SDW_DPN_HCTRL_HSTART, t_params->hstart);
116
116
wbuf |= FIELD_PREP(SDW_DPN_HCTRL_HSTOP, t_params->hstop);
117
117
118
-
ret = sdw_write(slave, addr4, wbuf);
118
+
ret = sdw_write_no_pm(slave, addr4, wbuf);
119
119
if (ret < 0)
120
120
dev_err(bus->dev, "DPN_HCtrl register write failed\n");
121
121
···
163
163
wbuf = FIELD_PREP(SDW_DPN_PORTCTRL_DATAMODE, p_params->data_mode);
164
164
wbuf |= FIELD_PREP(SDW_DPN_PORTCTRL_FLOWMODE, p_params->flow_mode);
165
165
166
-
ret = sdw_update(s_rt->slave, addr1, 0xF, wbuf);
166
+
ret = sdw_update_no_pm(s_rt->slave, addr1, 0xF, wbuf);
167
167
if (ret < 0) {
168
168
dev_err(&s_rt->slave->dev,
169
169
"DPN_PortCtrl register write failed for port %d\n",
···
173
173
174
174
if (!dpn_prop->read_only_wordlength) {
175
175
/* Program DPN_BlockCtrl1 register */
176
-
ret = sdw_write(s_rt->slave, addr2, (p_params->bps - 1));
176
+
ret = sdw_write_no_pm(s_rt->slave, addr2, (p_params->bps - 1));
177
177
if (ret < 0) {
178
178
dev_err(&s_rt->slave->dev,
179
179
"DPN_BlockCtrl1 register write failed for port %d\n",
···
184
184
185
185
/* Program DPN_SampleCtrl1 register */
186
186
wbuf = (t_params->sample_interval - 1) & SDW_DPN_SAMPLECTRL_LOW;
187
-
ret = sdw_write(s_rt->slave, addr3, wbuf);
187
+
ret = sdw_write_no_pm(s_rt->slave, addr3, wbuf);
188
188
if (ret < 0) {
189
189
dev_err(&s_rt->slave->dev,
190
190
"DPN_SampleCtrl1 register write failed for port %d\n",
···
193
193
}
194
194
195
195
/* Program DPN_OffsetCtrl1 registers */
196
-
ret = sdw_write(s_rt->slave, addr4, t_params->offset1);
196
+
ret = sdw_write_no_pm(s_rt->slave, addr4, t_params->offset1);
197
197
if (ret < 0) {
198
198
dev_err(&s_rt->slave->dev,
199
199
"DPN_OffsetCtrl1 register write failed for port %d\n",
···
203
203
204
204
/* Program DPN_BlockCtrl2 register*/
205
205
if (t_params->blk_grp_ctrl_valid) {
206
-
ret = sdw_write(s_rt->slave, addr5, t_params->blk_grp_ctrl);
206
+
ret = sdw_write_no_pm(s_rt->slave, addr5, t_params->blk_grp_ctrl);
207
207
if (ret < 0) {
208
208
dev_err(&s_rt->slave->dev,
209
209
"DPN_BlockCtrl2 reg write failed for port %d\n",
···
214
214
215
215
/* program DPN_LaneCtrl register */
216
216
if (slave_prop->lane_control_support) {
217
-
ret = sdw_write(s_rt->slave, addr6, t_params->lane_ctrl);
217
+
ret = sdw_write_no_pm(s_rt->slave, addr6, t_params->lane_ctrl);
218
218
if (ret < 0) {
219
219
dev_err(&s_rt->slave->dev,
220
220
"DPN_LaneCtrl register write failed for port %d\n",
···
319
319
* it is safe to reset this register
320
320
*/
321
321
if (en)
322
-
ret = sdw_write(s_rt->slave, addr, p_rt->ch_mask);
322
+
ret = sdw_write_no_pm(s_rt->slave, addr, p_rt->ch_mask);
323
323
else
324
-
ret = sdw_write(s_rt->slave, addr, 0x0);
324
+
ret = sdw_write_no_pm(s_rt->slave, addr, 0x0);
325
325
326
326
if (ret < 0)
327
327
dev_err(&s_rt->slave->dev,
···
476
476
addr = SDW_DPN_PREPARECTRL(p_rt->num);
477
477
478
478
if (prep)
479
-
ret = sdw_write(s_rt->slave, addr, p_rt->ch_mask);
479
+
ret = sdw_write_no_pm(s_rt->slave, addr, p_rt->ch_mask);
480
480
else
481
-
ret = sdw_write(s_rt->slave, addr, 0x0);
481
+
ret = sdw_write_no_pm(s_rt->slave, addr, 0x0);
482
482
483
483
if (ret < 0) {
484
484
dev_err(&s_rt->slave->dev,
···
491
491
wait_for_completion_timeout(port_ready,
492
492
msecs_to_jiffies(dpn_prop->ch_prep_timeout));
493
493
494
-
val = sdw_read(s_rt->slave, SDW_DPN_PREPARESTATUS(p_rt->num));
494
+
val = sdw_read_no_pm(s_rt->slave, SDW_DPN_PREPARESTATUS(p_rt->num));
495
495
if ((val < 0) || (val & p_rt->ch_mask)) {
496
496
ret = (val < 0) ? val : -ETIMEDOUT;
497
497
dev_err(&s_rt->slave->dev,
···
684
684
if (!wr_msg)
685
685
return -ENOMEM;
686
686
687
-
bus->defer_msg.msg = wr_msg;
688
-
689
687
wbuf = kzalloc(sizeof(*wbuf), GFP_KERNEL);
690
688
if (!wbuf) {
691
689
ret = -ENOMEM;
···
711
713
multi_link = bus->multi_link && (m_rt_count >= bus->hw_sync_min_links);
712
714
713
715
if (multi_link)
714
-
ret = sdw_transfer_defer(bus, wr_msg, &bus->defer_msg);
716
+
ret = sdw_transfer_defer(bus, wr_msg);
715
717
else
716
718
ret = sdw_transfer(bus, wr_msg);
717
719
···
721
723
}
722
724
723
725
if (!multi_link) {
724
-
kfree(wr_msg);
725
726
kfree(wbuf);
727
+
kfree(wr_msg);
726
728
bus->defer_msg.msg = NULL;
727
729
bus->params.curr_bank = !bus->params.curr_bank;
728
730
bus->params.next_bank = !bus->params.next_bank;
···
767
769
if (bus->defer_msg.msg) {
768
770
kfree(bus->defer_msg.msg->buf);
769
771
kfree(bus->defer_msg.msg);
772
+
bus->defer_msg.msg = NULL;
770
773
}
771
774
772
775
return 0;
···
866
867
if (bus->defer_msg.msg) {
867
868
kfree(bus->defer_msg.msg->buf);
868
869
kfree(bus->defer_msg.msg);
870
+
bus->defer_msg.msg = NULL;
869
871
}
870
872
}
871
873
+104
-18
include/linux/soundwire/sdw.h
+104
-18
include/linux/soundwire/sdw.h
···
4
4
#ifndef __SOUNDWIRE_H
5
5
#define __SOUNDWIRE_H
6
6
7
+
#include <linux/bug.h>
7
8
#include <linux/mod_devicetable.h>
8
9
#include <linux/bitfield.h>
9
10
···
366
365
* @sink_dpn_prop: Sink Data Port N properties
367
366
* @scp_int1_mask: SCP_INT1_MASK desired settings
368
367
* @quirks: bitmask identifying deltas from the MIPI specification
369
-
* @is_sdca: the Slave supports the SDCA specification
368
+
* @clock_reg_supported: the Peripheral implements the clock base and scale
369
+
* registers introduced with the SoundWire 1.2 specification. SDCA devices
370
+
* do not need to set this boolean property as the registers are required.
370
371
*/
371
372
struct sdw_slave_prop {
372
373
u32 mipi_revision;
···
392
389
struct sdw_dpn_prop *sink_dpn_prop;
393
390
u8 scp_int1_mask;
394
391
u32 quirks;
395
-
bool is_sdca;
392
+
bool clock_reg_supported;
396
393
};
397
394
398
395
#define SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY BIT(0)
···
839
836
* @read_prop: Read Master properties
840
837
* @override_adr: Override value read from firmware (quirk for buggy firmware)
841
838
* @xfer_msg: Transfer message callback
842
-
* @xfer_msg_defer: Defer version of transfer message callback
843
-
* @reset_page_addr: Reset the SCP page address registers
839
+
* @xfer_msg_defer: Defer version of transfer message callback. The message is handled with the
840
+
* bus struct @sdw_defer
844
841
* @set_bus_conf: Set the bus configuration
845
842
* @pre_bank_switch: Callback for pre bank switch
846
843
* @post_bank_switch: Callback for post bank switch
···
854
851
enum sdw_command_response (*xfer_msg)
855
852
(struct sdw_bus *bus, struct sdw_msg *msg);
856
853
enum sdw_command_response (*xfer_msg_defer)
857
-
(struct sdw_bus *bus, struct sdw_msg *msg,
858
-
struct sdw_defer *defer);
859
-
enum sdw_command_response (*reset_page_addr)
860
-
(struct sdw_bus *bus, unsigned int dev_num);
854
+
(struct sdw_bus *bus);
861
855
int (*set_bus_conf)(struct sdw_bus *bus,
862
856
struct sdw_bus_params *params);
863
857
int (*pre_bank_switch)(struct sdw_bus *bus);
···
1023
1023
struct sdw_port_config *port_config,
1024
1024
unsigned int num_ports,
1025
1025
struct sdw_stream_runtime *stream);
1026
-
int sdw_stream_add_slave(struct sdw_slave *slave,
1027
-
struct sdw_stream_config *stream_config,
1028
-
struct sdw_port_config *port_config,
1029
-
unsigned int num_ports,
1030
-
struct sdw_stream_runtime *stream);
1031
1026
int sdw_stream_remove_master(struct sdw_bus *bus,
1032
-
struct sdw_stream_runtime *stream);
1033
-
int sdw_stream_remove_slave(struct sdw_slave *slave,
1034
1027
struct sdw_stream_runtime *stream);
1035
1028
int sdw_startup_stream(void *sdw_substream);
1036
1029
int sdw_prepare_stream(struct sdw_stream_runtime *stream);
···
1035
1042
int sdw_bus_clk_stop(struct sdw_bus *bus);
1036
1043
int sdw_bus_exit_clk_stop(struct sdw_bus *bus);
1037
1044
1038
-
/* messaging and data APIs */
1045
+
int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id);
1046
+
void sdw_extract_slave_id(struct sdw_bus *bus, u64 addr, struct sdw_slave_id *id);
1039
1047
1048
+
#if IS_ENABLED(CONFIG_SOUNDWIRE)
1049
+
1050
+
int sdw_stream_add_slave(struct sdw_slave *slave,
1051
+
struct sdw_stream_config *stream_config,
1052
+
struct sdw_port_config *port_config,
1053
+
unsigned int num_ports,
1054
+
struct sdw_stream_runtime *stream);
1055
+
int sdw_stream_remove_slave(struct sdw_slave *slave,
1056
+
struct sdw_stream_runtime *stream);
1057
+
1058
+
/* messaging and data APIs */
1040
1059
int sdw_read(struct sdw_slave *slave, u32 addr);
1041
1060
int sdw_write(struct sdw_slave *slave, u32 addr, u8 value);
1042
1061
int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value);
1043
1062
int sdw_read_no_pm(struct sdw_slave *slave, u32 addr);
1044
1063
int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val);
1064
+
int sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val);
1045
1065
int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val);
1066
+
int sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val);
1046
1067
int sdw_update(struct sdw_slave *slave, u32 addr, u8 mask, u8 val);
1047
1068
int sdw_update_no_pm(struct sdw_slave *slave, u32 addr, u8 mask, u8 val);
1048
1069
1049
-
int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id);
1050
-
void sdw_extract_slave_id(struct sdw_bus *bus, u64 addr, struct sdw_slave_id *id);
1070
+
#else
1071
+
1072
+
static inline int sdw_stream_add_slave(struct sdw_slave *slave,
1073
+
struct sdw_stream_config *stream_config,
1074
+
struct sdw_port_config *port_config,
1075
+
unsigned int num_ports,
1076
+
struct sdw_stream_runtime *stream)
1077
+
{
1078
+
WARN_ONCE(1, "SoundWire API is disabled");
1079
+
return -EINVAL;
1080
+
}
1081
+
1082
+
static inline int sdw_stream_remove_slave(struct sdw_slave *slave,
1083
+
struct sdw_stream_runtime *stream)
1084
+
{
1085
+
WARN_ONCE(1, "SoundWire API is disabled");
1086
+
return -EINVAL;
1087
+
}
1088
+
1089
+
/* messaging and data APIs */
1090
+
static inline int sdw_read(struct sdw_slave *slave, u32 addr)
1091
+
{
1092
+
WARN_ONCE(1, "SoundWire API is disabled");
1093
+
return -EINVAL;
1094
+
}
1095
+
1096
+
static inline int sdw_write(struct sdw_slave *slave, u32 addr, u8 value)
1097
+
{
1098
+
WARN_ONCE(1, "SoundWire API is disabled");
1099
+
return -EINVAL;
1100
+
}
1101
+
1102
+
static inline int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value)
1103
+
{
1104
+
WARN_ONCE(1, "SoundWire API is disabled");
1105
+
return -EINVAL;
1106
+
}
1107
+
1108
+
static inline int sdw_read_no_pm(struct sdw_slave *slave, u32 addr)
1109
+
{
1110
+
WARN_ONCE(1, "SoundWire API is disabled");
1111
+
return -EINVAL;
1112
+
}
1113
+
1114
+
static inline int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
1115
+
{
1116
+
WARN_ONCE(1, "SoundWire API is disabled");
1117
+
return -EINVAL;
1118
+
}
1119
+
1120
+
static inline int sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
1121
+
{
1122
+
WARN_ONCE(1, "SoundWire API is disabled");
1123
+
return -EINVAL;
1124
+
}
1125
+
1126
+
static inline int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
1127
+
{
1128
+
WARN_ONCE(1, "SoundWire API is disabled");
1129
+
return -EINVAL;
1130
+
}
1131
+
1132
+
static inline int sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
1133
+
{
1134
+
WARN_ONCE(1, "SoundWire API is disabled");
1135
+
return -EINVAL;
1136
+
}
1137
+
1138
+
static inline int sdw_update(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
1139
+
{
1140
+
WARN_ONCE(1, "SoundWire API is disabled");
1141
+
return -EINVAL;
1142
+
}
1143
+
1144
+
static inline int sdw_update_no_pm(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
1145
+
{
1146
+
WARN_ONCE(1, "SoundWire API is disabled");
1147
+
return -EINVAL;
1148
+
}
1149
+
1150
+
#endif /* CONFIG_SOUNDWIRE */
1051
1151
1052
1152
#endif /* __SOUNDWIRE_H */
-1
sound/soc/codecs/rt1316-sdw.c
-1
sound/soc/codecs/rt1316-sdw.c
-1
sound/soc/codecs/rt1318-sdw.c
-1
sound/soc/codecs/rt1318-sdw.c