cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

solo6x10-g723.c (10586B)


      1// SPDX-License-Identifier: GPL-2.0-or-later
      2/*
      3 * Copyright (C) 2010-2013 Bluecherry, LLC <https://www.bluecherrydvr.com>
      4 *
      5 * Original author:
      6 * Ben Collins <bcollins@ubuntu.com>
      7 *
      8 * Additional work by:
      9 * John Brooks <john.brooks@bluecherry.net>
     10 */
     11
     12#include <linux/kernel.h>
     13#include <linux/mempool.h>
     14#include <linux/poll.h>
     15#include <linux/kthread.h>
     16#include <linux/freezer.h>
     17#include <linux/module.h>
     18#include <linux/slab.h>
     19
     20#include <sound/core.h>
     21#include <sound/initval.h>
     22#include <sound/pcm.h>
     23#include <sound/control.h>
     24
     25#include "solo6x10.h"
     26#include "solo6x10-tw28.h"
     27
     28#define G723_FDMA_PAGES		32
     29#define G723_PERIOD_BYTES	48
     30#define G723_PERIOD_BLOCK	1024
     31#define G723_FRAMES_PER_PAGE	48
     32
     33/* Sets up channels 16-19 for decoding and 0-15 for encoding */
     34#define OUTMODE_MASK		0x300
     35
     36#define SAMPLERATE		8000
     37#define BITRATE			25
     38
     39/* The solo writes to 1k byte pages, 32 pages, in the dma. Each 1k page
     40 * is broken down to 20 * 48 byte regions (one for each channel possible)
     41 * with the rest of the page being dummy data. */
     42#define PERIODS			G723_FDMA_PAGES
     43#define G723_INTR_ORDER		4 /* 0 - 4 */
     44
     45struct solo_snd_pcm {
     46	int				on;
     47	spinlock_t			lock;
     48	struct solo_dev			*solo_dev;
     49	u8				*g723_buf;
     50	dma_addr_t			g723_dma;
     51};
     52
     53static void solo_g723_config(struct solo_dev *solo_dev)
     54{
     55	int clk_div;
     56
     57	clk_div = (solo_dev->clock_mhz * 1000000)
     58		/ (SAMPLERATE * (BITRATE * 2) * 2);
     59
     60	solo_reg_write(solo_dev, SOLO_AUDIO_SAMPLE,
     61		       SOLO_AUDIO_BITRATE(BITRATE)
     62		       | SOLO_AUDIO_CLK_DIV(clk_div));
     63
     64	solo_reg_write(solo_dev, SOLO_AUDIO_FDMA_INTR,
     65		       SOLO_AUDIO_FDMA_INTERVAL(1)
     66		       | SOLO_AUDIO_INTR_ORDER(G723_INTR_ORDER)
     67		       | SOLO_AUDIO_FDMA_BASE(SOLO_G723_EXT_ADDR(solo_dev) >> 16));
     68
     69	solo_reg_write(solo_dev, SOLO_AUDIO_CONTROL,
     70		       SOLO_AUDIO_ENABLE
     71		       | SOLO_AUDIO_I2S_MODE
     72		       | SOLO_AUDIO_I2S_MULTI(3)
     73		       | SOLO_AUDIO_MODE(OUTMODE_MASK));
     74}
     75
     76void solo_g723_isr(struct solo_dev *solo_dev)
     77{
     78	struct snd_pcm_str *pstr =
     79		&solo_dev->snd_pcm->streams[SNDRV_PCM_STREAM_CAPTURE];
     80	struct snd_pcm_substream *ss;
     81	struct solo_snd_pcm *solo_pcm;
     82
     83	for (ss = pstr->substream; ss != NULL; ss = ss->next) {
     84		if (snd_pcm_substream_chip(ss) == NULL)
     85			continue;
     86
     87		/* This means open() hasn't been called on this one */
     88		if (snd_pcm_substream_chip(ss) == solo_dev)
     89			continue;
     90
     91		/* Haven't triggered a start yet */
     92		solo_pcm = snd_pcm_substream_chip(ss);
     93		if (!solo_pcm->on)
     94			continue;
     95
     96		snd_pcm_period_elapsed(ss);
     97	}
     98}
     99
    100static const struct snd_pcm_hardware snd_solo_pcm_hw = {
    101	.info			= (SNDRV_PCM_INFO_MMAP |
    102				   SNDRV_PCM_INFO_INTERLEAVED |
    103				   SNDRV_PCM_INFO_BLOCK_TRANSFER |
    104				   SNDRV_PCM_INFO_MMAP_VALID),
    105	.formats		= SNDRV_PCM_FMTBIT_U8,
    106	.rates			= SNDRV_PCM_RATE_8000,
    107	.rate_min		= SAMPLERATE,
    108	.rate_max		= SAMPLERATE,
    109	.channels_min		= 1,
    110	.channels_max		= 1,
    111	.buffer_bytes_max	= G723_PERIOD_BYTES * PERIODS,
    112	.period_bytes_min	= G723_PERIOD_BYTES,
    113	.period_bytes_max	= G723_PERIOD_BYTES,
    114	.periods_min		= PERIODS,
    115	.periods_max		= PERIODS,
    116};
    117
    118static int snd_solo_pcm_open(struct snd_pcm_substream *ss)
    119{
    120	struct solo_dev *solo_dev = snd_pcm_substream_chip(ss);
    121	struct solo_snd_pcm *solo_pcm;
    122
    123	solo_pcm = kzalloc(sizeof(*solo_pcm), GFP_KERNEL);
    124	if (solo_pcm == NULL)
    125		goto oom;
    126
    127	solo_pcm->g723_buf = dma_alloc_coherent(&solo_dev->pdev->dev,
    128						G723_PERIOD_BYTES,
    129						&solo_pcm->g723_dma,
    130						GFP_KERNEL);
    131	if (solo_pcm->g723_buf == NULL)
    132		goto oom;
    133
    134	spin_lock_init(&solo_pcm->lock);
    135	solo_pcm->solo_dev = solo_dev;
    136	ss->runtime->hw = snd_solo_pcm_hw;
    137
    138	snd_pcm_substream_chip(ss) = solo_pcm;
    139
    140	return 0;
    141
    142oom:
    143	kfree(solo_pcm);
    144	return -ENOMEM;
    145}
    146
    147static int snd_solo_pcm_close(struct snd_pcm_substream *ss)
    148{
    149	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
    150
    151	snd_pcm_substream_chip(ss) = solo_pcm->solo_dev;
    152	dma_free_coherent(&solo_pcm->solo_dev->pdev->dev, G723_PERIOD_BYTES,
    153			  solo_pcm->g723_buf, solo_pcm->g723_dma);
    154	kfree(solo_pcm);
    155
    156	return 0;
    157}
    158
    159static int snd_solo_pcm_trigger(struct snd_pcm_substream *ss, int cmd)
    160{
    161	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
    162	struct solo_dev *solo_dev = solo_pcm->solo_dev;
    163	int ret = 0;
    164
    165	spin_lock(&solo_pcm->lock);
    166
    167	switch (cmd) {
    168	case SNDRV_PCM_TRIGGER_START:
    169		if (solo_pcm->on == 0) {
    170			/* If this is the first user, switch on interrupts */
    171			if (atomic_inc_return(&solo_dev->snd_users) == 1)
    172				solo_irq_on(solo_dev, SOLO_IRQ_G723);
    173			solo_pcm->on = 1;
    174		}
    175		break;
    176	case SNDRV_PCM_TRIGGER_STOP:
    177		if (solo_pcm->on) {
    178			/* If this was our last user, switch them off */
    179			if (atomic_dec_return(&solo_dev->snd_users) == 0)
    180				solo_irq_off(solo_dev, SOLO_IRQ_G723);
    181			solo_pcm->on = 0;
    182		}
    183		break;
    184	default:
    185		ret = -EINVAL;
    186	}
    187
    188	spin_unlock(&solo_pcm->lock);
    189
    190	return ret;
    191}
    192
    193static int snd_solo_pcm_prepare(struct snd_pcm_substream *ss)
    194{
    195	return 0;
    196}
    197
    198static snd_pcm_uframes_t snd_solo_pcm_pointer(struct snd_pcm_substream *ss)
    199{
    200	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
    201	struct solo_dev *solo_dev = solo_pcm->solo_dev;
    202	snd_pcm_uframes_t idx = solo_reg_read(solo_dev, SOLO_AUDIO_STA) & 0x1f;
    203
    204	return idx * G723_FRAMES_PER_PAGE;
    205}
    206
    207static int snd_solo_pcm_copy_user(struct snd_pcm_substream *ss, int channel,
    208				  unsigned long pos, void __user *dst,
    209				  unsigned long count)
    210{
    211	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
    212	struct solo_dev *solo_dev = solo_pcm->solo_dev;
    213	int err, i;
    214
    215	for (i = 0; i < (count / G723_FRAMES_PER_PAGE); i++) {
    216		int page = (pos / G723_FRAMES_PER_PAGE) + i;
    217
    218		err = solo_p2m_dma_t(solo_dev, 0, solo_pcm->g723_dma,
    219				     SOLO_G723_EXT_ADDR(solo_dev) +
    220				     (page * G723_PERIOD_BLOCK) +
    221				     (ss->number * G723_PERIOD_BYTES),
    222				     G723_PERIOD_BYTES, 0, 0);
    223		if (err)
    224			return err;
    225
    226		if (copy_to_user(dst, solo_pcm->g723_buf, G723_PERIOD_BYTES))
    227			return -EFAULT;
    228		dst += G723_PERIOD_BYTES;
    229	}
    230
    231	return 0;
    232}
    233
    234static int snd_solo_pcm_copy_kernel(struct snd_pcm_substream *ss, int channel,
    235				    unsigned long pos, void *dst,
    236				    unsigned long count)
    237{
    238	struct solo_snd_pcm *solo_pcm = snd_pcm_substream_chip(ss);
    239	struct solo_dev *solo_dev = solo_pcm->solo_dev;
    240	int err, i;
    241
    242	for (i = 0; i < (count / G723_FRAMES_PER_PAGE); i++) {
    243		int page = (pos / G723_FRAMES_PER_PAGE) + i;
    244
    245		err = solo_p2m_dma_t(solo_dev, 0, solo_pcm->g723_dma,
    246				     SOLO_G723_EXT_ADDR(solo_dev) +
    247				     (page * G723_PERIOD_BLOCK) +
    248				     (ss->number * G723_PERIOD_BYTES),
    249				     G723_PERIOD_BYTES, 0, 0);
    250		if (err)
    251			return err;
    252
    253		memcpy(dst, solo_pcm->g723_buf, G723_PERIOD_BYTES);
    254		dst += G723_PERIOD_BYTES;
    255	}
    256
    257	return 0;
    258}
    259
    260static const struct snd_pcm_ops snd_solo_pcm_ops = {
    261	.open = snd_solo_pcm_open,
    262	.close = snd_solo_pcm_close,
    263	.prepare = snd_solo_pcm_prepare,
    264	.trigger = snd_solo_pcm_trigger,
    265	.pointer = snd_solo_pcm_pointer,
    266	.copy_user = snd_solo_pcm_copy_user,
    267	.copy_kernel = snd_solo_pcm_copy_kernel,
    268};
    269
    270static int snd_solo_capture_volume_info(struct snd_kcontrol *kcontrol,
    271					struct snd_ctl_elem_info *info)
    272{
    273	info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
    274	info->count = 1;
    275	info->value.integer.min = 0;
    276	info->value.integer.max = 15;
    277	info->value.integer.step = 1;
    278
    279	return 0;
    280}
    281
    282static int snd_solo_capture_volume_get(struct snd_kcontrol *kcontrol,
    283				       struct snd_ctl_elem_value *value)
    284{
    285	struct solo_dev *solo_dev = snd_kcontrol_chip(kcontrol);
    286	u8 ch = value->id.numid - 1;
    287
    288	value->value.integer.value[0] = tw28_get_audio_gain(solo_dev, ch);
    289
    290	return 0;
    291}
    292
    293static int snd_solo_capture_volume_put(struct snd_kcontrol *kcontrol,
    294				       struct snd_ctl_elem_value *value)
    295{
    296	struct solo_dev *solo_dev = snd_kcontrol_chip(kcontrol);
    297	u8 ch = value->id.numid - 1;
    298	u8 old_val;
    299
    300	old_val = tw28_get_audio_gain(solo_dev, ch);
    301	if (old_val == value->value.integer.value[0])
    302		return 0;
    303
    304	tw28_set_audio_gain(solo_dev, ch, value->value.integer.value[0]);
    305
    306	return 1;
    307}
    308
    309static const struct snd_kcontrol_new snd_solo_capture_volume = {
    310	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
    311	.name = "Capture Volume",
    312	.info = snd_solo_capture_volume_info,
    313	.get = snd_solo_capture_volume_get,
    314	.put = snd_solo_capture_volume_put,
    315};
    316
    317static int solo_snd_pcm_init(struct solo_dev *solo_dev)
    318{
    319	struct snd_card *card = solo_dev->snd_card;
    320	struct snd_pcm *pcm;
    321	struct snd_pcm_substream *ss;
    322	int ret;
    323	int i;
    324
    325	ret = snd_pcm_new(card, card->driver, 0, 0, solo_dev->nr_chans,
    326			  &pcm);
    327	if (ret < 0)
    328		return ret;
    329
    330	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
    331			&snd_solo_pcm_ops);
    332
    333	snd_pcm_chip(pcm) = solo_dev;
    334	pcm->info_flags = 0;
    335	strscpy(pcm->name, card->shortname, sizeof(pcm->name));
    336
    337	for (i = 0, ss = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
    338	     ss; ss = ss->next, i++)
    339		sprintf(ss->name, "Camera #%d Audio", i);
    340
    341	snd_pcm_set_managed_buffer_all(pcm,
    342				       SNDRV_DMA_TYPE_CONTINUOUS,
    343				       NULL,
    344				       G723_PERIOD_BYTES * PERIODS,
    345				       G723_PERIOD_BYTES * PERIODS);
    346
    347	solo_dev->snd_pcm = pcm;
    348
    349	return 0;
    350}
    351
    352int solo_g723_init(struct solo_dev *solo_dev)
    353{
    354	static struct snd_device_ops ops = { };
    355	struct snd_card *card;
    356	struct snd_kcontrol_new kctl;
    357	char name[32];
    358	int ret;
    359
    360	atomic_set(&solo_dev->snd_users, 0);
    361
    362	/* Allows for easier mapping between video and audio */
    363	sprintf(name, "Softlogic%d", solo_dev->vfd->num);
    364
    365	ret = snd_card_new(&solo_dev->pdev->dev,
    366			   SNDRV_DEFAULT_IDX1, name, THIS_MODULE, 0,
    367			   &solo_dev->snd_card);
    368	if (ret < 0)
    369		return ret;
    370
    371	card = solo_dev->snd_card;
    372
    373	strscpy(card->driver, SOLO6X10_NAME, sizeof(card->driver));
    374	strscpy(card->shortname, "SOLO-6x10 Audio", sizeof(card->shortname));
    375	sprintf(card->longname, "%s on %s IRQ %d", card->shortname,
    376		pci_name(solo_dev->pdev), solo_dev->pdev->irq);
    377
    378	ret = snd_device_new(card, SNDRV_DEV_LOWLEVEL, solo_dev, &ops);
    379	if (ret < 0)
    380		goto snd_error;
    381
    382	/* Mixer controls */
    383	strscpy(card->mixername, "SOLO-6x10", sizeof(card->mixername));
    384	kctl = snd_solo_capture_volume;
    385	kctl.count = solo_dev->nr_chans;
    386
    387	ret = snd_ctl_add(card, snd_ctl_new1(&kctl, solo_dev));
    388	if (ret < 0)
    389		goto snd_error;
    390
    391	ret = solo_snd_pcm_init(solo_dev);
    392	if (ret < 0)
    393		goto snd_error;
    394
    395	ret = snd_card_register(card);
    396	if (ret < 0)
    397		goto snd_error;
    398
    399	solo_g723_config(solo_dev);
    400
    401	dev_info(&solo_dev->pdev->dev, "Alsa sound card as %s\n", name);
    402
    403	return 0;
    404
    405snd_error:
    406	snd_card_free(card);
    407	return ret;
    408}
    409
    410void solo_g723_exit(struct solo_dev *solo_dev)
    411{
    412	if (!solo_dev->snd_card)
    413		return;
    414
    415	solo_reg_write(solo_dev, SOLO_AUDIO_CONTROL, 0);
    416	solo_irq_off(solo_dev, SOLO_IRQ_G723);
    417
    418	snd_card_free(solo_dev->snd_card);
    419	solo_dev->snd_card = NULL;
    420}