2 * rt5514-spi.c -- RT5514 SPI driver
4 * Copyright 2015 Realtek Semiconductor Corp.
5 * Author: Oder Chiou <oder_chiou@realtek.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/module.h>
13 #include <linux/input.h>
14 #include <linux/spi/spi.h>
15 #include <linux/device.h>
16 #include <linux/init.h>
17 #include <linux/delay.h>
18 #include <linux/interrupt.h>
19 #include <linux/irq.h>
20 #include <linux/slab.h>
21 #include <linux/gpio.h>
22 #include <linux/sched.h>
23 #include <linux/uaccess.h>
24 #include <linux/regulator/consumer.h>
25 #include <linux/pm_qos.h>
26 #include <linux/sysfs.h>
27 #include <linux/clk.h>
28 #include <sound/core.h>
29 #include <sound/pcm.h>
30 #include <sound/pcm_params.h>
31 #include <sound/soc.h>
32 #include <sound/soc-dapm.h>
33 #include <sound/initval.h>
34 #include <sound/tlv.h>
36 #include "rt5514-spi.h"
38 static struct spi_device
*rt5514_spi
;
42 struct delayed_work copy_work
;
43 struct mutex dma_lock
;
44 struct snd_pcm_substream
*substream
;
45 unsigned int buf_base
, buf_limit
, buf_rp
;
51 static const struct snd_pcm_hardware rt5514_spi_pcm_hardware
= {
52 .info
= SNDRV_PCM_INFO_MMAP
|
53 SNDRV_PCM_INFO_MMAP_VALID
|
54 SNDRV_PCM_INFO_INTERLEAVED
,
55 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
56 .period_bytes_min
= PAGE_SIZE
,
57 .period_bytes_max
= 0x20000 / 8,
62 .buffer_bytes_max
= 0x20000,
65 static struct snd_soc_dai_driver rt5514_spi_dai
= {
66 .name
= "rt5514-dsp-cpu-dai",
69 .stream_name
= "DSP Capture",
72 .rates
= SNDRV_PCM_RATE_16000
,
73 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
77 static void rt5514_spi_copy_work(struct work_struct
*work
)
79 struct rt5514_dsp
*rt5514_dsp
=
80 container_of(work
, struct rt5514_dsp
, copy_work
.work
);
81 struct snd_pcm_runtime
*runtime
;
82 size_t period_bytes
, truncated_bytes
= 0;
84 mutex_lock(&rt5514_dsp
->dma_lock
);
85 if (!rt5514_dsp
->substream
) {
86 dev_err(rt5514_dsp
->dev
, "No pcm substream\n");
90 runtime
= rt5514_dsp
->substream
->runtime
;
91 period_bytes
= snd_pcm_lib_period_bytes(rt5514_dsp
->substream
);
93 if (rt5514_dsp
->buf_size
- rt5514_dsp
->dsp_offset
< period_bytes
)
94 period_bytes
= rt5514_dsp
->buf_size
- rt5514_dsp
->dsp_offset
;
96 if (rt5514_dsp
->buf_rp
+ period_bytes
<= rt5514_dsp
->buf_limit
) {
97 rt5514_spi_burst_read(rt5514_dsp
->buf_rp
,
98 runtime
->dma_area
+ rt5514_dsp
->dma_offset
,
101 if (rt5514_dsp
->buf_rp
+ period_bytes
== rt5514_dsp
->buf_limit
)
102 rt5514_dsp
->buf_rp
= rt5514_dsp
->buf_base
;
104 rt5514_dsp
->buf_rp
+= period_bytes
;
106 truncated_bytes
= rt5514_dsp
->buf_limit
- rt5514_dsp
->buf_rp
;
107 rt5514_spi_burst_read(rt5514_dsp
->buf_rp
,
108 runtime
->dma_area
+ rt5514_dsp
->dma_offset
,
111 rt5514_spi_burst_read(rt5514_dsp
->buf_base
,
112 runtime
->dma_area
+ rt5514_dsp
->dma_offset
+
113 truncated_bytes
, period_bytes
- truncated_bytes
);
115 rt5514_dsp
->buf_rp
= rt5514_dsp
->buf_base
+
116 period_bytes
- truncated_bytes
;
119 rt5514_dsp
->dma_offset
+= period_bytes
;
120 if (rt5514_dsp
->dma_offset
>= runtime
->dma_bytes
)
121 rt5514_dsp
->dma_offset
= 0;
123 rt5514_dsp
->dsp_offset
+= period_bytes
;
125 snd_pcm_period_elapsed(rt5514_dsp
->substream
);
127 if (rt5514_dsp
->dsp_offset
< rt5514_dsp
->buf_size
)
128 schedule_delayed_work(&rt5514_dsp
->copy_work
, 5);
130 mutex_unlock(&rt5514_dsp
->dma_lock
);
133 /* PCM for streaming audio from the DSP buffer */
134 static int rt5514_spi_pcm_open(struct snd_pcm_substream
*substream
)
136 snd_soc_set_runtime_hwparams(substream
, &rt5514_spi_pcm_hardware
);
141 static int rt5514_spi_hw_params(struct snd_pcm_substream
*substream
,
142 struct snd_pcm_hw_params
*hw_params
)
144 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
145 struct rt5514_dsp
*rt5514_dsp
=
146 snd_soc_platform_get_drvdata(rtd
->platform
);
149 mutex_lock(&rt5514_dsp
->dma_lock
);
150 ret
= snd_pcm_lib_alloc_vmalloc_buffer(substream
,
151 params_buffer_bytes(hw_params
));
152 rt5514_dsp
->substream
= substream
;
153 mutex_unlock(&rt5514_dsp
->dma_lock
);
158 static int rt5514_spi_hw_free(struct snd_pcm_substream
*substream
)
160 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
161 struct rt5514_dsp
*rt5514_dsp
=
162 snd_soc_platform_get_drvdata(rtd
->platform
);
164 mutex_lock(&rt5514_dsp
->dma_lock
);
165 rt5514_dsp
->substream
= NULL
;
166 mutex_unlock(&rt5514_dsp
->dma_lock
);
168 cancel_delayed_work_sync(&rt5514_dsp
->copy_work
);
170 return snd_pcm_lib_free_vmalloc_buffer(substream
);
173 static int rt5514_spi_prepare(struct snd_pcm_substream
*substream
)
175 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
176 struct rt5514_dsp
*rt5514_dsp
=
177 snd_soc_platform_get_drvdata(rtd
->platform
);
180 rt5514_dsp
->dma_offset
= 0;
181 rt5514_dsp
->dsp_offset
= 0;
184 * The address area x1800XXXX is the register address, and it cannot
185 * support spi burst read perfectly. So we use the spi burst read
186 * individually to make sure the data correctly.
188 rt5514_spi_burst_read(RT5514_BUFFER_VOICE_BASE
, (u8
*)&buf
,
190 rt5514_dsp
->buf_base
= buf
[0] | buf
[1] << 8 | buf
[2] << 16 |
193 rt5514_spi_burst_read(RT5514_BUFFER_VOICE_LIMIT
, (u8
*)&buf
,
195 rt5514_dsp
->buf_limit
= buf
[0] | buf
[1] << 8 | buf
[2] << 16 |
198 rt5514_spi_burst_read(RT5514_BUFFER_VOICE_RP
, (u8
*)&buf
,
200 rt5514_dsp
->buf_rp
= buf
[0] | buf
[1] << 8 | buf
[2] << 16 |
203 rt5514_spi_burst_read(RT5514_BUFFER_VOICE_SIZE
, (u8
*)&buf
,
205 rt5514_dsp
->buf_size
= buf
[0] | buf
[1] << 8 | buf
[2] << 16 |
211 static int rt5514_spi_trigger(struct snd_pcm_substream
*substream
, int cmd
)
213 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
214 struct rt5514_dsp
*rt5514_dsp
=
215 snd_soc_platform_get_drvdata(rtd
->platform
);
217 if (cmd
== SNDRV_PCM_TRIGGER_START
) {
218 if (rt5514_dsp
->buf_base
&& rt5514_dsp
->buf_limit
&&
219 rt5514_dsp
->buf_rp
&& rt5514_dsp
->buf_size
)
220 schedule_delayed_work(&rt5514_dsp
->copy_work
, 0);
226 static snd_pcm_uframes_t
rt5514_spi_pcm_pointer(
227 struct snd_pcm_substream
*substream
)
229 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
230 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
231 struct rt5514_dsp
*rt5514_dsp
=
232 snd_soc_platform_get_drvdata(rtd
->platform
);
234 return bytes_to_frames(runtime
, rt5514_dsp
->dma_offset
);
237 static const struct snd_pcm_ops rt5514_spi_pcm_ops
= {
238 .open
= rt5514_spi_pcm_open
,
239 .hw_params
= rt5514_spi_hw_params
,
240 .hw_free
= rt5514_spi_hw_free
,
241 .trigger
= rt5514_spi_trigger
,
242 .prepare
= rt5514_spi_prepare
,
243 .pointer
= rt5514_spi_pcm_pointer
,
244 .mmap
= snd_pcm_lib_mmap_vmalloc
,
245 .page
= snd_pcm_lib_get_vmalloc_page
,
248 static int rt5514_spi_pcm_probe(struct snd_soc_platform
*platform
)
250 struct rt5514_dsp
*rt5514_dsp
;
252 rt5514_dsp
= devm_kzalloc(platform
->dev
, sizeof(*rt5514_dsp
),
255 rt5514_dsp
->dev
= &rt5514_spi
->dev
;
256 mutex_init(&rt5514_dsp
->dma_lock
);
257 INIT_DELAYED_WORK(&rt5514_dsp
->copy_work
, rt5514_spi_copy_work
);
258 snd_soc_platform_set_drvdata(platform
, rt5514_dsp
);
263 static struct snd_soc_platform_driver rt5514_spi_platform
= {
264 .probe
= rt5514_spi_pcm_probe
,
265 .ops
= &rt5514_spi_pcm_ops
,
268 static const struct snd_soc_component_driver rt5514_spi_dai_component
= {
269 .name
= "rt5514-spi-dai",
273 * rt5514_spi_burst_read - Read data from SPI by rt5514 address.
274 * @addr: Start address.
275 * @rxbuf: Data Buffer for reading.
276 * @len: Data length, it must be a multiple of 8.
279 * Returns true for success.
281 int rt5514_spi_burst_read(unsigned int addr
, u8
*rxbuf
, size_t len
)
283 u8 spi_cmd
= RT5514_SPI_CMD_BURST_READ
;
286 unsigned int i
, end
, offset
= 0;
288 struct spi_message message
;
289 struct spi_transfer x
[3];
291 while (offset
< len
) {
292 if (offset
+ RT5514_SPI_BUF_LEN
<= len
)
293 end
= RT5514_SPI_BUF_LEN
;
295 end
= len
% RT5514_SPI_BUF_LEN
;
297 write_buf
[0] = spi_cmd
;
298 write_buf
[1] = ((addr
+ offset
) & 0xff000000) >> 24;
299 write_buf
[2] = ((addr
+ offset
) & 0x00ff0000) >> 16;
300 write_buf
[3] = ((addr
+ offset
) & 0x0000ff00) >> 8;
301 write_buf
[4] = ((addr
+ offset
) & 0x000000ff) >> 0;
303 spi_message_init(&message
);
304 memset(x
, 0, sizeof(x
));
307 x
[0].tx_buf
= write_buf
;
308 spi_message_add_tail(&x
[0], &message
);
311 x
[1].tx_buf
= write_buf
;
312 spi_message_add_tail(&x
[1], &message
);
315 x
[2].rx_buf
= rxbuf
+ offset
;
316 spi_message_add_tail(&x
[2], &message
);
318 status
= spi_sync(rt5514_spi
, &message
);
323 offset
+= RT5514_SPI_BUF_LEN
;
326 for (i
= 0; i
< len
; i
+= 8) {
327 write_buf
[0] = rxbuf
[i
+ 0];
328 write_buf
[1] = rxbuf
[i
+ 1];
329 write_buf
[2] = rxbuf
[i
+ 2];
330 write_buf
[3] = rxbuf
[i
+ 3];
331 write_buf
[4] = rxbuf
[i
+ 4];
332 write_buf
[5] = rxbuf
[i
+ 5];
333 write_buf
[6] = rxbuf
[i
+ 6];
334 write_buf
[7] = rxbuf
[i
+ 7];
336 rxbuf
[i
+ 0] = write_buf
[7];
337 rxbuf
[i
+ 1] = write_buf
[6];
338 rxbuf
[i
+ 2] = write_buf
[5];
339 rxbuf
[i
+ 3] = write_buf
[4];
340 rxbuf
[i
+ 4] = write_buf
[3];
341 rxbuf
[i
+ 5] = write_buf
[2];
342 rxbuf
[i
+ 6] = write_buf
[1];
343 rxbuf
[i
+ 7] = write_buf
[0];
350 * rt5514_spi_burst_write - Write data to SPI by rt5514 address.
351 * @addr: Start address.
352 * @txbuf: Data Buffer for writng.
353 * @len: Data length, it must be a multiple of 8.
356 * Returns true for success.
358 int rt5514_spi_burst_write(u32 addr
, const u8
*txbuf
, size_t len
)
360 u8 spi_cmd
= RT5514_SPI_CMD_BURST_WRITE
;
362 unsigned int i
, end
, offset
= 0;
364 write_buf
= kmalloc(RT5514_SPI_BUF_LEN
+ 6, GFP_KERNEL
);
366 if (write_buf
== NULL
)
369 while (offset
< len
) {
370 if (offset
+ RT5514_SPI_BUF_LEN
<= len
)
371 end
= RT5514_SPI_BUF_LEN
;
373 end
= len
% RT5514_SPI_BUF_LEN
;
375 write_buf
[0] = spi_cmd
;
376 write_buf
[1] = ((addr
+ offset
) & 0xff000000) >> 24;
377 write_buf
[2] = ((addr
+ offset
) & 0x00ff0000) >> 16;
378 write_buf
[3] = ((addr
+ offset
) & 0x0000ff00) >> 8;
379 write_buf
[4] = ((addr
+ offset
) & 0x000000ff) >> 0;
381 for (i
= 0; i
< end
; i
+= 8) {
382 write_buf
[i
+ 12] = txbuf
[offset
+ i
+ 0];
383 write_buf
[i
+ 11] = txbuf
[offset
+ i
+ 1];
384 write_buf
[i
+ 10] = txbuf
[offset
+ i
+ 2];
385 write_buf
[i
+ 9] = txbuf
[offset
+ i
+ 3];
386 write_buf
[i
+ 8] = txbuf
[offset
+ i
+ 4];
387 write_buf
[i
+ 7] = txbuf
[offset
+ i
+ 5];
388 write_buf
[i
+ 6] = txbuf
[offset
+ i
+ 6];
389 write_buf
[i
+ 5] = txbuf
[offset
+ i
+ 7];
392 write_buf
[end
+ 5] = spi_cmd
;
394 spi_write(rt5514_spi
, write_buf
, end
+ 6);
396 offset
+= RT5514_SPI_BUF_LEN
;
403 EXPORT_SYMBOL_GPL(rt5514_spi_burst_write
);
405 static int rt5514_spi_probe(struct spi_device
*spi
)
411 ret
= devm_snd_soc_register_platform(&spi
->dev
, &rt5514_spi_platform
);
413 dev_err(&spi
->dev
, "Failed to register platform.\n");
417 ret
= devm_snd_soc_register_component(&spi
->dev
,
418 &rt5514_spi_dai_component
,
421 dev_err(&spi
->dev
, "Failed to register component.\n");
428 static const struct of_device_id rt5514_of_match
[] = {
429 { .compatible
= "realtek,rt5514", },
432 MODULE_DEVICE_TABLE(of
, rt5514_of_match
);
434 static struct spi_driver rt5514_spi_driver
= {
437 .of_match_table
= of_match_ptr(rt5514_of_match
),
439 .probe
= rt5514_spi_probe
,
441 module_spi_driver(rt5514_spi_driver
);
443 MODULE_DESCRIPTION("RT5514 SPI driver");
444 MODULE_AUTHOR("Oder Chiou <oder_chiou@realtek.com>");
445 MODULE_LICENSE("GPL v2");