soc/codecs/rt5514-spi.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * rt5514-spi.c  --  RT5514 SPI driver
0004  *
0005  * Copyright 2015 Realtek Semiconductor Corp.
0006  * Author: Oder Chiou <oder_chiou@realtek.com>
0007  */
0008
0009 #include <linux/module.h>
0010 #include <linux/input.h>
0011 #include <linux/spi/spi.h>
0012 #include <linux/device.h>
0013 #include <linux/init.h>
0014 #include <linux/delay.h>
0015 #include <linux/interrupt.h>
0016 #include <linux/irq.h>
0017 #include <linux/slab.h>
0018 #include <linux/gpio.h>
0019 #include <linux/sched.h>
0020 #include <linux/uaccess.h>
0021 #include <linux/regulator/consumer.h>
0022 #include <linux/pm_qos.h>
0023 #include <linux/sysfs.h>
0024 #include <linux/clk.h>
0025 #include <sound/core.h>
0026 #include <sound/pcm.h>
0027 #include <sound/pcm_params.h>
0028 #include <sound/soc.h>
0029 #include <sound/soc-dapm.h>
0030 #include <sound/initval.h>
0031 #include <sound/tlv.h>
0032
0033 #include "rt5514-spi.h"
0034
0035 #define DRV_NAME "rt5514-spi"
0036
0037 static struct spi_device *rt5514_spi;
0038
0039 struct rt5514_dsp {
0040     struct device *dev;
0041     struct delayed_work copy_work;
0042     struct mutex dma_lock;
0043     struct snd_pcm_substream *substream;
0044     unsigned int buf_base, buf_limit, buf_rp;
0045     size_t buf_size, get_size, dma_offset;
0046 };
0047
0048 static const struct snd_pcm_hardware rt5514_spi_pcm_hardware = {
0049     .info           = SNDRV_PCM_INFO_MMAP |
0050                   SNDRV_PCM_INFO_MMAP_VALID |
0051                   SNDRV_PCM_INFO_INTERLEAVED,
0052     .formats        = SNDRV_PCM_FMTBIT_S16_LE,
0053     .period_bytes_min   = PAGE_SIZE,
0054     .period_bytes_max   = 0x20000 / 8,
0055     .periods_min        = 8,
0056     .periods_max        = 8,
0057     .channels_min       = 1,
0058     .channels_max       = 1,
0059     .buffer_bytes_max   = 0x20000,
0060 };
0061
0062 static struct snd_soc_dai_driver rt5514_spi_dai = {
0063     .name = "rt5514-dsp-cpu-dai",
0064     .id = 0,
0065     .capture = {
0066         .stream_name = "DSP Capture",
0067         .channels_min = 1,
0068         .channels_max = 1,
0069         .rates = SNDRV_PCM_RATE_16000,
0070         .formats = SNDRV_PCM_FMTBIT_S16_LE,
0071     },
0072 };
0073
0074 static void rt5514_spi_copy_work(struct work_struct *work)
0075 {
0076     struct rt5514_dsp *rt5514_dsp =
0077         container_of(work, struct rt5514_dsp, copy_work.work);
0078     struct snd_pcm_runtime *runtime;
0079     size_t period_bytes, truncated_bytes = 0;
0080     unsigned int cur_wp, remain_data;
0081     u8 buf[8];
0082
0083     mutex_lock(&rt5514_dsp->dma_lock);
0084     if (!rt5514_dsp->substream) {
0085         dev_err(rt5514_dsp->dev, "No pcm substream\n");
0086         goto done;
0087     }
0088
0089     runtime = rt5514_dsp->substream->runtime;
0090     period_bytes = snd_pcm_lib_period_bytes(rt5514_dsp->substream);
0091     if (!period_bytes) {
0092         schedule_delayed_work(&rt5514_dsp->copy_work, 5);
0093         goto done;
0094     }
0095
0096     if (rt5514_dsp->buf_size % period_bytes)
0097         rt5514_dsp->buf_size = (rt5514_dsp->buf_size / period_bytes) *
0098             period_bytes;
0099
0100     if (rt5514_dsp->get_size >= rt5514_dsp->buf_size) {
0101         rt5514_spi_burst_read(RT5514_BUFFER_VOICE_WP, (u8 *)&buf,
0102             sizeof(buf));
0103         cur_wp = buf[0] | buf[1] << 8 | buf[2] << 16 |
0104                     buf[3] << 24;
0105
0106         if (cur_wp >= rt5514_dsp->buf_rp)
0107             remain_data = (cur_wp - rt5514_dsp->buf_rp);
0108         else
0109             remain_data =
0110                 (rt5514_dsp->buf_limit - rt5514_dsp->buf_rp) +
0111                 (cur_wp - rt5514_dsp->buf_base);
0112
0113         if (remain_data < period_bytes) {
0114             schedule_delayed_work(&rt5514_dsp->copy_work, 5);
0115             goto done;
0116         }
0117     }
0118
0119     if (rt5514_dsp->buf_rp + period_bytes <= rt5514_dsp->buf_limit) {
0120         rt5514_spi_burst_read(rt5514_dsp->buf_rp,
0121             runtime->dma_area + rt5514_dsp->dma_offset,
0122             period_bytes);
0123
0124         if (rt5514_dsp->buf_rp + period_bytes == rt5514_dsp->buf_limit)
0125             rt5514_dsp->buf_rp = rt5514_dsp->buf_base;
0126         else
0127             rt5514_dsp->buf_rp += period_bytes;
0128     } else {
0129         truncated_bytes = rt5514_dsp->buf_limit - rt5514_dsp->buf_rp;
0130         rt5514_spi_burst_read(rt5514_dsp->buf_rp,
0131             runtime->dma_area + rt5514_dsp->dma_offset,
0132             truncated_bytes);
0133
0134         rt5514_spi_burst_read(rt5514_dsp->buf_base,
0135             runtime->dma_area + rt5514_dsp->dma_offset +
0136             truncated_bytes, period_bytes - truncated_bytes);
0137
0138         rt5514_dsp->buf_rp = rt5514_dsp->buf_base + period_bytes -
0139             truncated_bytes;
0140     }
0141
0142     rt5514_dsp->get_size += period_bytes;
0143     rt5514_dsp->dma_offset += period_bytes;
0144     if (rt5514_dsp->dma_offset >= runtime->dma_bytes)
0145         rt5514_dsp->dma_offset = 0;
0146
0147     snd_pcm_period_elapsed(rt5514_dsp->substream);
0148
0149     schedule_delayed_work(&rt5514_dsp->copy_work, 5);
0150
0151 done:
0152     mutex_unlock(&rt5514_dsp->dma_lock);
0153 }
0154
0155 static void rt5514_schedule_copy(struct rt5514_dsp *rt5514_dsp)
0156 {
0157     u8 buf[8];
0158
0159     if (!rt5514_dsp->substream)
0160         return;
0161
0162     rt5514_dsp->get_size = 0;
0163
0164     /**
0165      * The address area x1800XXXX is the register address, and it cannot
0166      * support spi burst read perfectly. So we use the spi burst read
0167      * individually to make sure the data correctly.
0168      */
0169     rt5514_spi_burst_read(RT5514_BUFFER_VOICE_BASE, (u8 *)&buf,
0170         sizeof(buf));
0171     rt5514_dsp->buf_base = buf[0] | buf[1] << 8 | buf[2] << 16 |
0172                 buf[3] << 24;
0173
0174     rt5514_spi_burst_read(RT5514_BUFFER_VOICE_LIMIT, (u8 *)&buf,
0175         sizeof(buf));
0176     rt5514_dsp->buf_limit = buf[0] | buf[1] << 8 | buf[2] << 16 |
0177                 buf[3] << 24;
0178
0179     rt5514_spi_burst_read(RT5514_BUFFER_VOICE_WP, (u8 *)&buf,
0180         sizeof(buf));
0181     rt5514_dsp->buf_rp = buf[0] | buf[1] << 8 | buf[2] << 16 |
0182                 buf[3] << 24;
0183
0184     if (rt5514_dsp->buf_rp % 8)
0185         rt5514_dsp->buf_rp = (rt5514_dsp->buf_rp / 8) * 8;
0186
0187     rt5514_dsp->buf_size = rt5514_dsp->buf_limit - rt5514_dsp->buf_base;
0188
0189     if (rt5514_dsp->buf_base && rt5514_dsp->buf_limit &&
0190         rt5514_dsp->buf_rp && rt5514_dsp->buf_size)
0191         schedule_delayed_work(&rt5514_dsp->copy_work, 0);
0192 }
0193
0194 static irqreturn_t rt5514_spi_irq(int irq, void *data)
0195 {
0196     struct rt5514_dsp *rt5514_dsp = data;
0197
0198     rt5514_schedule_copy(rt5514_dsp);
0199
0200     return IRQ_HANDLED;
0201 }
0202
0203 /* PCM for streaming audio from the DSP buffer */
0204 static int rt5514_spi_pcm_open(struct snd_soc_component *component,
0205                    struct snd_pcm_substream *substream)
0206 {
0207     snd_soc_set_runtime_hwparams(substream, &rt5514_spi_pcm_hardware);
0208
0209     return 0;
0210 }
0211
0212 static int rt5514_spi_hw_params(struct snd_soc_component *component,
0213                 struct snd_pcm_substream *substream,
0214                 struct snd_pcm_hw_params *hw_params)
0215 {
0216     struct rt5514_dsp *rt5514_dsp =
0217         snd_soc_component_get_drvdata(component);
0218     u8 buf[8];
0219
0220     mutex_lock(&rt5514_dsp->dma_lock);
0221     rt5514_dsp->substream = substream;
0222     rt5514_dsp->dma_offset = 0;
0223
0224     /* Read IRQ status and schedule copy accordingly. */
0225     rt5514_spi_burst_read(RT5514_IRQ_CTRL, (u8 *)&buf, sizeof(buf));
0226     if (buf[0] & RT5514_IRQ_STATUS_BIT)
0227         rt5514_schedule_copy(rt5514_dsp);
0228
0229     mutex_unlock(&rt5514_dsp->dma_lock);
0230
0231     return 0;
0232 }
0233
0234 static int rt5514_spi_hw_free(struct snd_soc_component *component,
0235                   struct snd_pcm_substream *substream)
0236 {
0237     struct rt5514_dsp *rt5514_dsp =
0238         snd_soc_component_get_drvdata(component);
0239
0240     mutex_lock(&rt5514_dsp->dma_lock);
0241     rt5514_dsp->substream = NULL;
0242     mutex_unlock(&rt5514_dsp->dma_lock);
0243
0244     cancel_delayed_work_sync(&rt5514_dsp->copy_work);
0245
0246     return 0;
0247 }
0248
0249 static snd_pcm_uframes_t rt5514_spi_pcm_pointer(
0250         struct snd_soc_component *component,
0251         struct snd_pcm_substream *substream)
0252 {
0253     struct snd_pcm_runtime *runtime = substream->runtime;
0254     struct rt5514_dsp *rt5514_dsp =
0255         snd_soc_component_get_drvdata(component);
0256
0257     return bytes_to_frames(runtime, rt5514_dsp->dma_offset);
0258 }
0259
0260
0261 static int rt5514_spi_pcm_probe(struct snd_soc_component *component)
0262 {
0263     struct rt5514_dsp *rt5514_dsp;
0264     int ret;
0265
0266     rt5514_dsp = devm_kzalloc(component->dev, sizeof(*rt5514_dsp),
0267             GFP_KERNEL);
0268     if (!rt5514_dsp)
0269         return -ENOMEM;
0270
0271     rt5514_dsp->dev = &rt5514_spi->dev;
0272     mutex_init(&rt5514_dsp->dma_lock);
0273     INIT_DELAYED_WORK(&rt5514_dsp->copy_work, rt5514_spi_copy_work);
0274     snd_soc_component_set_drvdata(component, rt5514_dsp);
0275
0276     if (rt5514_spi->irq) {
0277         ret = devm_request_threaded_irq(&rt5514_spi->dev,
0278             rt5514_spi->irq, NULL, rt5514_spi_irq,
0279             IRQF_TRIGGER_RISING | IRQF_ONESHOT, "rt5514-spi",
0280             rt5514_dsp);
0281         if (ret)
0282             dev_err(&rt5514_spi->dev,
0283                 "%s Failed to reguest IRQ: %d\n", __func__,
0284                 ret);
0285         else
0286             device_init_wakeup(rt5514_dsp->dev, true);
0287     }
0288
0289     return 0;
0290 }
0291
0292 static int rt5514_spi_pcm_new(struct snd_soc_component *component,
0293                   struct snd_soc_pcm_runtime *rtd)
0294 {
0295     snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_VMALLOC,
0296                        NULL, 0, 0);
0297     return 0;
0298 }
0299
0300 static const struct snd_soc_component_driver rt5514_spi_component = {
0301     .name       = DRV_NAME,
0302     .probe      = rt5514_spi_pcm_probe,
0303     .open       = rt5514_spi_pcm_open,
0304     .hw_params  = rt5514_spi_hw_params,
0305     .hw_free    = rt5514_spi_hw_free,
0306     .pointer    = rt5514_spi_pcm_pointer,
0307     .pcm_construct  = rt5514_spi_pcm_new,
0308 };
0309
0310 /**
0311  * rt5514_spi_burst_read - Read data from SPI by rt5514 address.
0312  * @addr: Start address.
0313  * @rxbuf: Data Buffer for reading.
0314  * @len: Data length, it must be a multiple of 8.
0315  *
0316  *
0317  * Returns true for success.
0318  */
0319 int rt5514_spi_burst_read(unsigned int addr, u8 *rxbuf, size_t len)
0320 {
0321     u8 spi_cmd = RT5514_SPI_CMD_BURST_READ;
0322     int status;
0323     u8 write_buf[8];
0324     unsigned int i, end, offset = 0;
0325
0326     struct spi_message message;
0327     struct spi_transfer x[3];
0328
0329     while (offset < len) {
0330         if (offset + RT5514_SPI_BUF_LEN <= len)
0331             end = RT5514_SPI_BUF_LEN;
0332         else
0333             end = len % RT5514_SPI_BUF_LEN;
0334
0335         write_buf[0] = spi_cmd;
0336         write_buf[1] = ((addr + offset) & 0xff000000) >> 24;
0337         write_buf[2] = ((addr + offset) & 0x00ff0000) >> 16;
0338         write_buf[3] = ((addr + offset) & 0x0000ff00) >> 8;
0339         write_buf[4] = ((addr + offset) & 0x000000ff) >> 0;
0340
0341         spi_message_init(&message);
0342         memset(x, 0, sizeof(x));
0343
0344         x[0].len = 5;
0345         x[0].tx_buf = write_buf;
0346         spi_message_add_tail(&x[0], &message);
0347
0348         x[1].len = 4;
0349         x[1].tx_buf = write_buf;
0350         spi_message_add_tail(&x[1], &message);
0351
0352         x[2].len = end;
0353         x[2].rx_buf = rxbuf + offset;
0354         spi_message_add_tail(&x[2], &message);
0355
0356         status = spi_sync(rt5514_spi, &message);
0357
0358         if (status)
0359             return false;
0360
0361         offset += RT5514_SPI_BUF_LEN;
0362     }
0363
0364     for (i = 0; i < len; i += 8) {
0365         write_buf[0] = rxbuf[i + 0];
0366         write_buf[1] = rxbuf[i + 1];
0367         write_buf[2] = rxbuf[i + 2];
0368         write_buf[3] = rxbuf[i + 3];
0369         write_buf[4] = rxbuf[i + 4];
0370         write_buf[5] = rxbuf[i + 5];
0371         write_buf[6] = rxbuf[i + 6];
0372         write_buf[7] = rxbuf[i + 7];
0373
0374         rxbuf[i + 0] = write_buf[7];
0375         rxbuf[i + 1] = write_buf[6];
0376         rxbuf[i + 2] = write_buf[5];
0377         rxbuf[i + 3] = write_buf[4];
0378         rxbuf[i + 4] = write_buf[3];
0379         rxbuf[i + 5] = write_buf[2];
0380         rxbuf[i + 6] = write_buf[1];
0381         rxbuf[i + 7] = write_buf[0];
0382     }
0383
0384     return true;
0385 }
0386 EXPORT_SYMBOL_GPL(rt5514_spi_burst_read);
0387
0388 /**
0389  * rt5514_spi_burst_write - Write data to SPI by rt5514 address.
0390  * @addr: Start address.
0391  * @txbuf: Data Buffer for writng.
0392  * @len: Data length, it must be a multiple of 8.
0393  *
0394  *
0395  * Returns true for success.
0396  */
0397 int rt5514_spi_burst_write(u32 addr, const u8 *txbuf, size_t len)
0398 {
0399     u8 spi_cmd = RT5514_SPI_CMD_BURST_WRITE;
0400     u8 *write_buf;
0401     unsigned int i, end, offset = 0;
0402
0403     write_buf = kmalloc(RT5514_SPI_BUF_LEN + 6, GFP_KERNEL);
0404
0405     if (write_buf == NULL)
0406         return -ENOMEM;
0407
0408     while (offset < len) {
0409         if (offset + RT5514_SPI_BUF_LEN <= len)
0410             end = RT5514_SPI_BUF_LEN;
0411         else
0412             end = len % RT5514_SPI_BUF_LEN;
0413
0414         write_buf[0] = spi_cmd;
0415         write_buf[1] = ((addr + offset) & 0xff000000) >> 24;
0416         write_buf[2] = ((addr + offset) & 0x00ff0000) >> 16;
0417         write_buf[3] = ((addr + offset) & 0x0000ff00) >> 8;
0418         write_buf[4] = ((addr + offset) & 0x000000ff) >> 0;
0419
0420         for (i = 0; i < end; i += 8) {
0421             write_buf[i + 12] = txbuf[offset + i + 0];
0422             write_buf[i + 11] = txbuf[offset + i + 1];
0423             write_buf[i + 10] = txbuf[offset + i + 2];
0424             write_buf[i +  9] = txbuf[offset + i + 3];
0425             write_buf[i +  8] = txbuf[offset + i + 4];
0426             write_buf[i +  7] = txbuf[offset + i + 5];
0427             write_buf[i +  6] = txbuf[offset + i + 6];
0428             write_buf[i +  5] = txbuf[offset + i + 7];
0429         }
0430
0431         write_buf[end + 5] = spi_cmd;
0432
0433         spi_write(rt5514_spi, write_buf, end + 6);
0434
0435         offset += RT5514_SPI_BUF_LEN;
0436     }
0437
0438     kfree(write_buf);
0439
0440     return 0;
0441 }
0442 EXPORT_SYMBOL_GPL(rt5514_spi_burst_write);
0443
0444 static int rt5514_spi_probe(struct spi_device *spi)
0445 {
0446     int ret;
0447
0448     rt5514_spi = spi;
0449
0450     ret = devm_snd_soc_register_component(&spi->dev,
0451                           &rt5514_spi_component,
0452                           &rt5514_spi_dai, 1);
0453     if (ret < 0) {
0454         dev_err(&spi->dev, "Failed to register component.\n");
0455         return ret;
0456     }
0457
0458     return 0;
0459 }
0460
0461 static int __maybe_unused rt5514_suspend(struct device *dev)
0462 {
0463     int irq = to_spi_device(dev)->irq;
0464
0465     if (device_may_wakeup(dev))
0466         enable_irq_wake(irq);
0467
0468     return 0;
0469 }
0470
0471 static int __maybe_unused rt5514_resume(struct device *dev)
0472 {
0473     struct rt5514_dsp *rt5514_dsp = dev_get_drvdata(dev);
0474     int irq = to_spi_device(dev)->irq;
0475     u8 buf[8];
0476
0477     if (device_may_wakeup(dev))
0478         disable_irq_wake(irq);
0479
0480     if (rt5514_dsp) {
0481         if (rt5514_dsp->substream) {
0482             rt5514_spi_burst_read(RT5514_IRQ_CTRL, (u8 *)&buf,
0483                 sizeof(buf));
0484             if (buf[0] & RT5514_IRQ_STATUS_BIT)
0485                 rt5514_schedule_copy(rt5514_dsp);
0486         }
0487     }
0488
0489     return 0;
0490 }
0491
0492 static const struct dev_pm_ops rt5514_pm_ops = {
0493     SET_SYSTEM_SLEEP_PM_OPS(rt5514_suspend, rt5514_resume)
0494 };
0495
0496 static const struct of_device_id rt5514_of_match[] = {
0497     { .compatible = "realtek,rt5514", },
0498     {},
0499 };
0500 MODULE_DEVICE_TABLE(of, rt5514_of_match);
0501
0502 static struct spi_driver rt5514_spi_driver = {
0503     .driver = {
0504         .name = "rt5514",
0505         .pm = &rt5514_pm_ops,
0506         .of_match_table = of_match_ptr(rt5514_of_match),
0507     },
0508     .probe = rt5514_spi_probe,
0509 };
0510 module_spi_driver(rt5514_spi_driver);
0511
0512 MODULE_DESCRIPTION("RT5514 SPI driver");
0513 MODULE_AUTHOR("Oder Chiou <oder_chiou@realtek.com>");
0514 MODULE_LICENSE("GPL v2");