OpenWrt – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 From 5f3557a2e88b324e026d44f8fb7eb3ea37bba16b Mon Sep 17 00:00:00 2001
2 From: Giedrius Trainavicius <giedrius@blokas.io>
3 Date: Tue, 25 Oct 2016 01:47:20 +0300
4 Subject: [PATCH 138/454] Updates for Pisound module code:
5  
6 * Merged 'Fix a warning in DEBUG builds' (1c8b82b).
7 * Updating some strings and copyright information.
8 * Fix for handling high load of MIDI input and output.
9 * Use dual rate oversampling ratio for 96kHz instead of single
10 rate one.
11  
12 Signed-off-by: Giedrius Trainavicius <giedrius@blokas.io>
13 ---
14 .../arm/boot/dts/overlays/pisound-overlay.dts | 4 +-
15 sound/soc/bcm/pisound.c | 209 ++++++++++++------
16 2 files changed, 146 insertions(+), 67 deletions(-)
17  
18 --- a/arch/arm/boot/dts/overlays/pisound-overlay.dts
19 +++ b/arch/arm/boot/dts/overlays/pisound-overlay.dts
20 @@ -1,6 +1,6 @@
21 /*
22 - * pisound Linux kernel module.
23 - * Copyright (C) 2016 Vilniaus Blokas UAB, http://blokas.io/pisound
24 + * Pisound Linux kernel module.
25 + * Copyright (C) 2016-2017 Vilniaus Blokas UAB, https://blokas.io/pisound
26 *
27 * This program is free software; you can redistribute it and/or
28 * modify it under the terms of the GNU General Public License
29 --- a/sound/soc/bcm/pisound.c
30 +++ b/sound/soc/bcm/pisound.c
31 @@ -1,6 +1,6 @@
32 /*
33 - * pisound Linux kernel module.
34 - * Copyright (C) 2016 Vilniaus Blokas UAB, http://blokas.io/pisound
35 + * Pisound Linux kernel module.
36 + * Copyright (C) 2016-2017 Vilniaus Blokas UAB, https://blokas.io/pisound
37 *
38 * This program is free software; you can redistribute it and/or
39 * modify it under the terms of the GNU General Public License
40 @@ -28,6 +28,7 @@
41 #include <linux/spi/spi.h>
42 #include <linux/interrupt.h>
43 #include <linux/kfifo.h>
44 +#include <linux/jiffies.h>
45  
46 #include <sound/core.h>
47 #include <sound/pcm.h>
48 @@ -41,7 +42,8 @@
49 static int pisnd_spi_init(struct device *dev);
50 static void pisnd_spi_uninit(void);
51  
52 -static void pisnd_spi_send(uint8_t val);
53 +static void pisnd_spi_flush(void);
54 +static void pisnd_spi_start(void);
55 static uint8_t pisnd_spi_recv(uint8_t *buffer, uint8_t length);
56  
57 typedef void (*pisnd_spi_recv_cb)(void *data);
58 @@ -56,7 +58,7 @@ static void pisnd_midi_uninit(void);
59  
60 #define PISOUND_LOG_PREFIX "pisound: "
61  
62 -#ifdef DEBUG
63 +#ifdef PISOUND_DEBUG
64 # define printd(...) pr_alert(PISOUND_LOG_PREFIX __VA_ARGS__)
65 #else
66 # define printd(...) do {} while (0)
67 @@ -65,13 +67,18 @@ static void pisnd_midi_uninit(void);
68 #define printe(...) pr_err(PISOUND_LOG_PREFIX __VA_ARGS__)
69 #define printi(...) pr_info(PISOUND_LOG_PREFIX __VA_ARGS__)
70  
71 +static struct snd_rawmidi *g_rmidi;
72 +static struct snd_rawmidi_substream *g_midi_output_substream;
73 +
74 static int pisnd_output_open(struct snd_rawmidi_substream *substream)
75 {
76 + g_midi_output_substream = substream;
77 return 0;
78 }
79  
80 static int pisnd_output_close(struct snd_rawmidi_substream *substream)
81 {
82 + g_midi_output_substream = NULL;
83 return 0;
84 }
85  
86 @@ -80,26 +87,20 @@ static void pisnd_output_trigger(
87 int up
88 )
89 {
90 - uint8_t data;
91 + if (substream != g_midi_output_substream) {
92 + printe("MIDI output trigger called for an unexpected stream!");
93 + return;
94 + }
95  
96 if (!up)
97 return;
98  
99 - while (snd_rawmidi_transmit_peek(substream, &data, 1)) {
100 - pisnd_spi_send(data);
101 - snd_rawmidi_transmit_ack(substream, 1);
102 - }
103 + pisnd_spi_start();
104 }
105  
106 static void pisnd_output_drain(struct snd_rawmidi_substream *substream)
107 {
108 - uint8_t data;
109 -
110 - while (snd_rawmidi_transmit_peek(substream, &data, 1)) {
111 - pisnd_spi_send(data);
112 -
113 - snd_rawmidi_transmit_ack(substream, 1);
114 - }
115 + pisnd_spi_flush();
116 }
117  
118 static int pisnd_input_open(struct snd_rawmidi_substream *substream)
119 @@ -120,7 +121,7 @@ static void pisnd_midi_recv_callback(voi
120 while ((n = pisnd_spi_recv(data, sizeof(data)))) {
121 int res = snd_rawmidi_receive(substream, data, n);
122 (void)res;
123 - printd("midi recv 0x%02x, res = %d\n", data, res);
124 + printd("midi recv %u bytes, res = %d\n", n, res);
125 }
126 }
127  
128 @@ -134,8 +135,6 @@ static void pisnd_input_trigger(struct s
129 }
130 }
131  
132 -static struct snd_rawmidi *g_rmidi;
133 -
134 static struct snd_rawmidi_ops pisnd_output_ops = {
135 .open = pisnd_output_open,
136 .close = pisnd_output_close,
137 @@ -168,7 +167,11 @@ static struct snd_rawmidi_global_ops pis
138  
139 static int pisnd_midi_init(struct snd_card *card)
140 {
141 - int err = snd_rawmidi_new(card, "pisound MIDI", 0, 1, 1, &g_rmidi);
142 + int err;
143 +
144 + g_midi_output_substream = NULL;
145 +
146 + err = snd_rawmidi_new(card, "pisound MIDI", 0, 1, 1, &g_rmidi);
147  
148 if (err < 0) {
149 printe("snd_rawmidi_new failed: %d\n", err);
150 @@ -209,7 +212,7 @@ static void pisnd_midi_uninit(void)
151 static void *g_recvData;
152 static pisnd_spi_recv_cb g_recvCallback;
153  
154 -#define FIFO_SIZE 512
155 +#define FIFO_SIZE 4096
156  
157 static char g_serial_num[11];
158 static char g_id[25];
159 @@ -231,6 +234,7 @@ static struct work_struct pisnd_work_pro
160  
161 static void pisnd_work_handler(struct work_struct *work);
162  
163 +static void spi_transfer(const uint8_t *txbuf, uint8_t *rxbuf, int len);
164 static uint16_t spi_transfer16(uint16_t val);
165  
166 static int pisnd_init_workqueues(void)
167 @@ -285,9 +289,6 @@ static unsigned long spilockflags;
168  
169 static uint16_t spi_transfer16(uint16_t val)
170 {
171 - int err;
172 - struct spi_transfer transfer;
173 - struct spi_message msg;
174 uint8_t txbuf[2];
175 uint8_t rxbuf[2];
176  
177 @@ -296,19 +297,38 @@ static uint16_t spi_transfer16(uint16_t
178 return 0;
179 }
180  
181 + txbuf[0] = val >> 8;
182 + txbuf[1] = val & 0xff;
183 +
184 + spi_transfer(txbuf, rxbuf, sizeof(txbuf));
185 +
186 + printd("received: %02x%02x\n", rxbuf[0], rxbuf[1]);
187 +
188 + return (rxbuf[0] << 8) | rxbuf[1];
189 +}
190 +
191 +static void spi_transfer(const uint8_t *txbuf, uint8_t *rxbuf, int len)
192 +{
193 + int err;
194 + struct spi_transfer transfer;
195 + struct spi_message msg;
196 +
197 + memset(rxbuf, 0, sizeof(txbuf));
198 +
199 + if (!pisnd_spi_device) {
200 + printe("pisnd_spi_device null, returning\n");
201 + return;
202 + }
203 +
204 spi_message_init(&msg);
205  
206 memset(&transfer, 0, sizeof(transfer));
207 - memset(&rxbuf, 0, sizeof(rxbuf));
208  
209 - txbuf[0] = val >> 8;
210 - txbuf[1] = val & 0xff;
211 -
212 - transfer.tx_buf = &txbuf;
213 - transfer.rx_buf = &rxbuf;
214 - transfer.len = sizeof(txbuf);
215 - transfer.speed_hz = 125000;
216 - transfer.delay_usecs = 100;
217 + transfer.tx_buf = txbuf;
218 + transfer.rx_buf = rxbuf;
219 + transfer.len = len;
220 + transfer.speed_hz = 100000;
221 + transfer.delay_usecs = 10;
222 spi_message_add_tail(&transfer, &msg);
223  
224 spin_lock_irqsave(&spilock, spilockflags);
225 @@ -317,13 +337,10 @@ static uint16_t spi_transfer16(uint16_t
226  
227 if (err < 0) {
228 printe("spi_sync error %d\n", err);
229 - return 0;
230 + return;
231 }
232  
233 - printd("received: %02x%02x\n", rxbuf[0], rxbuf[1]);
234 printd("hasMore %d\n", pisnd_spi_has_more());
235 -
236 - return (rxbuf[0] << 8) | rxbuf[1];
237 }
238  
239 static int spi_read_bytes(char *dst, size_t length, uint8_t *bytesRead)
240 @@ -335,7 +352,7 @@ static int spi_read_bytes(char *dst, siz
241 memset(dst, 0, length);
242 *bytesRead = 0;
243  
244 - rx = spi_transfer16(0);
245 + rx = spi_transfer16(0);
246 if (!(rx >> 8))
247 return -EINVAL;
248  
249 @@ -388,35 +405,90 @@ static struct spi_device *pisnd_spi_find
250  
251 static void pisnd_work_handler(struct work_struct *work)
252 {
253 - uint16_t rx;
254 - uint16_t tx;
255 + enum { TRANSFER_SIZE = 4 };
256 + enum { PISOUND_OUTPUT_BUFFER_SIZE = 128 };
257 + enum { MIDI_BYTES_PER_SECOND = 3125 };
258 + int out_buffer_used = 0;
259 + unsigned long now;
260 uint8_t val;
261 + uint8_t txbuf[TRANSFER_SIZE];
262 + uint8_t rxbuf[TRANSFER_SIZE];
263 + uint8_t midibuf[TRANSFER_SIZE];
264 + int i, n;
265 + bool had_data;
266 +
267 + unsigned long last_transfer_at = jiffies;
268  
269 if (work == &pisnd_work_process) {
270 if (pisnd_spi_device == NULL)
271 return;
272  
273 do {
274 - val = 0;
275 - tx = 0;
276 + if (g_midi_output_substream &&
277 + kfifo_avail(&spi_fifo_out) >= sizeof(midibuf)) {
278  
279 - if (g_ledFlashDurationChanged) {
280 - tx = 0xf000 | g_ledFlashDuration;
281 - g_ledFlashDuration = 0;
282 - g_ledFlashDurationChanged = false;
283 - } else if (kfifo_get(&spi_fifo_out, &val)) {
284 - tx = 0x0f00 | val;
285 + n = snd_rawmidi_transmit_peek(
286 + g_midi_output_substream,
287 + midibuf, sizeof(midibuf)
288 + );
289 +
290 + if (n > 0) {
291 + for (i = 0; i < n; ++i)
292 + kfifo_put(
293 + &spi_fifo_out,
294 + midibuf[i]
295 + );
296 + snd_rawmidi_transmit_ack(
297 + g_midi_output_substream,
298 + i
299 + );
300 + }
301 }
302  
303 - rx = spi_transfer16(tx);
304 + had_data = false;
305 + memset(txbuf, 0, sizeof(txbuf));
306 + for (i = 0; i < sizeof(txbuf) &&
307 + out_buffer_used < PISOUND_OUTPUT_BUFFER_SIZE;
308 + i += 2) {
309 +
310 + val = 0;
311 +
312 + if (g_ledFlashDurationChanged) {
313 + txbuf[i+0] = 0xf0;
314 + txbuf[i+1] = g_ledFlashDuration;
315 + g_ledFlashDuration = 0;
316 + g_ledFlashDurationChanged = false;
317 + } else if (kfifo_get(&spi_fifo_out, &val)) {
318 + txbuf[i+0] = 0x0f;
319 + txbuf[i+1] = val;
320 + ++out_buffer_used;
321 + }
322 + }
323  
324 - if (rx & 0xff00) {
325 - kfifo_put(&spi_fifo_in, rx & 0xff);
326 - if (kfifo_len(&spi_fifo_in) > 16
327 - && g_recvCallback)
328 - g_recvCallback(g_recvData);
329 + spi_transfer(txbuf, rxbuf, sizeof(txbuf));
330 + /* Estimate the Pisound's MIDI output buffer usage, so
331 + * that we don't overflow it. Space in the buffer should
332 + * be becoming available at the UART MIDI byte transfer
333 + * rate.
334 + */
335 + now = jiffies;
336 + out_buffer_used -=
337 + (MIDI_BYTES_PER_SECOND / HZ) /
338 + (now - last_transfer_at);
339 + if (out_buffer_used < 0)
340 + out_buffer_used = 0;
341 + last_transfer_at = now;
342 +
343 + for (i = 0; i < sizeof(rxbuf); i += 2) {
344 + if (rxbuf[i]) {
345 + kfifo_put(&spi_fifo_in, rxbuf[i+1]);
346 + if (kfifo_len(&spi_fifo_in) > 16 &&
347 + g_recvCallback)
348 + g_recvCallback(g_recvData);
349 + had_data = true;
350 + }
351 }
352 - } while (rx != 0
353 + } while (had_data
354 || !kfifo_is_empty(&spi_fifo_out)
355 || pisnd_spi_has_more()
356 || g_ledFlashDurationChanged
357 @@ -492,7 +564,7 @@ static int spi_read_info(void)
358 if (!(tmp >> 8))
359 return -EINVAL;
360  
361 - count = tmp & 0xff;
362 + count = tmp & 0xff;
363  
364 for (i = 0; i < count; ++i) {
365 memset(buffer, 0, sizeof(buffer));
366 @@ -628,10 +700,17 @@ static void pisnd_spi_flash_leds(uint8_t
367 pisnd_schedule_process(TASK_PROCESS);
368 }
369  
370 -static void pisnd_spi_send(uint8_t val)
371 +static void pisnd_spi_flush(void)
372 +{
373 + while (!kfifo_is_empty(&spi_fifo_out)) {
374 + pisnd_spi_start();
375 + flush_workqueue(pisnd_workqueue);
376 + }
377 +}
378 +
379 +static void pisnd_spi_start(void)
380 {
381 - kfifo_put(&spi_fifo_out, val);
382 - printd("schedule from spi_send\n");
383 + printd("schedule from spi_start\n");
384 pisnd_schedule_process(TASK_PROCESS);
385 }
386  
387 @@ -765,7 +844,7 @@ static int pisnd_hw_params(
388 struct snd_soc_pcm_runtime *rtd = substream->private_data;
389 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
390  
391 - /* pisound runs on fixed 32 clock counts per channel,
392 + /* Pisound runs on fixed 32 clock counts per channel,
393 * as generated by the master ADC.
394 */
395 snd_soc_dai_set_bclk_ratio(cpu_dai, 32*2);
396 @@ -786,8 +865,8 @@ static int pisnd_hw_params(
397 break;
398 case 96000:
399 gpiod_set_value(osr0, true);
400 - gpiod_set_value(osr1, true);
401 - gpiod_set_value(osr2, false);
402 + gpiod_set_value(osr1, false);
403 + gpiod_set_value(osr2, true);
404 break;
405 case 192000:
406 gpiod_set_value(osr0, true);
407 @@ -1030,7 +1109,7 @@ static int pisnd_probe(struct platform_d
408 return ret;
409 }
410  
411 - printi("Detected pisound card:\n");
412 + printi("Detected Pisound card:\n");
413 printi("\tSerial: %s\n", pisnd_spi_get_serial());
414 printi("\tVersion: %s\n", pisnd_spi_get_version());
415 printi("\tId: %s\n", pisnd_spi_get_id());
416 @@ -1119,5 +1198,5 @@ static struct platform_driver pisnd_driv
417 module_platform_driver(pisnd_driver);
418  
419 MODULE_AUTHOR("Giedrius Trainavicius <giedrius@blokas.io>");
420 -MODULE_DESCRIPTION("ASoC Driver for pisound, http://blokas.io/pisound");
421 +MODULE_DESCRIPTION("ASoC Driver for Pisound, https://blokas.io/pisound");
422 MODULE_LICENSE("GPL v2");