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 
45 struct 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 
53 static 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 
76 void 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 
100 static 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 
118 static 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 
142 oom:
143 	kfree(solo_pcm);
144 	return -ENOMEM;
145 }
146 
147 static 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 
159 static 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 
193 static int snd_solo_pcm_prepare(struct snd_pcm_substream *ss)
194 {
195 	return 0;
196 }
197 
198 static 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 
207 static 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 
234 static 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 
260 static 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 
270 static 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 
282 static 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 
293 static 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 
309 static 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 
317 static 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 
352 int 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 
405 snd_error:
406 	snd_card_free(card);
407 	return ret;
408 }
409 
410 void 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 }
421