?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add platform file for Iaudio M5.
[Rockbox.git] / apps / plugins / alpine_cdc.c
blob9cc1f9cde4e4b8be41d76d1a0c91c6475711bb7f
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 *
11 * Copyright (C) 2003-2005 Jörg Hohensohn
12 *
13 * Alpine CD changer Project
14 * This is a feasibility study for Archos emulating an Alpine M-Bus CD changer.
15 *
16 * Currently it will do seeks and change tracks, but nothing like disks.
17 * The debug version shows a dump of the M-Bus communication on screen.
18 *
19 * Usage: Start plugin, it will stay in the background and do the emulation.
20 * You need to make an adapter with an 8-pin DIN plug for the radio at one end
21 * and a 4-ring 3.5 mm plug for the Archos headphone jack at the other.
22 * The Archos remote pin connects to the M-Bus, audio as usual.
23 *
24 * All files in this archive are subject to the GNU General Public License.
25 * See the file COPYING in the source tree root for full license agreement.
26 *
27 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
28 * KIND, either express or implied.
29 *
30 ****************************************************************************/
31
32 #include "plugin.h"
33
34 /* Only build for (correct) target */
35 #if !defined(SIMULATOR) && CONFIG_CPU==SH7034 && !defined(HAVE_MMC)
36
37 PLUGIN_HEADER
38
39 #ifdef HAVE_LCD_CHARCELLS /* player model */
40 #define LINES 2
41 #define COLUMNS 11
42 #else /* recorder models */
43 #define LINES 8
44 #define COLUMNS 32 /* can't really tell for proportional font */
45 #endif
46
47 /****************** imports ******************/
48
49 #include "sh7034.h"
50 #include "system.h"
51
52 /****************** constants ******************/
53
54 /* measured bit time on the M-Bus is 3.075 ms = 325.2 Hz */
55 #define MBUS_BAUDRATE 3252 /* make it 10 * bittime */
56 #define MBUS_STEP_FREQ (MBUS_BAUDRATE/2) /* 5 steps per bit */
57 #define MBUS_BIT_FREQ (MBUS_BAUDRATE/10) /* the true bit frequency again */
58
59 #define MBUS_MAX_SIZE 16 /* maximum length of an M-Bus packet, incl. checksum */
60 #define MBUS_RCV_QUEUESIZE 4 /* how many packets can be queued by receiver */
61
62 #define ERI1 (*((volatile unsigned long*)0x090001A0)) /* RX error */
63 #define RXI1 (*((volatile unsigned long*)0x090001A4)) /* RX */
64
65 #define PB10 0x0400
66
67 /* receive status */
68 #define RX_BUSY 0 /* reception in progress */
69 #define RX_RECEIVED 1 /* valid data available */
70 #define RX_FRAMING 2 /* frame error */
71 #define RX_OVERRUN 3 /* receiver overrun */
72 #define RX_PARITY 4 /* parity error */
73 #define RX_SYMBOL 5 /* invalid bit timing */
74 #define RX_OVERFLOW 6 /* buffer full */
75 #define RX_OVERLAP 7 /* receive interrupt while transmitting */
76
77 /* timer operation mode */
78 #define TM_OFF 0 /* not in use */
79 #define TM_TRANSMIT 1 /* periodic timer to transmit */
80 #define TM_RX_TIMEOUT 2 /* single shot for receive timeout */
81
82 /* emulation play state */
83 #define EMU_IDLE 0
84 #define EMU_PREPARING 1
85 #define EMU_STOPPED 2
86 #define EMU_PAUSED 3
87 #define EMU_PLAYING 4
88 #define EMU_SPINUP 5
89 #define EMU_FF 6
90 #define EMU_FR 7
91
92
93 /****************** prototypes ******************/
94
95 void timer_init(unsigned hz, unsigned to); /* setup static timer registers and values */
96 void timer_set_mode(int mode); /* define for what the timer should be used right now */
97 void timer4_isr(void); /* IMIA4 ISR */
98
99 void transmit_isr(void); /* 2nd level ISR for M-Bus transmission */
100
101 void uart_init(unsigned baudrate); /* UART setup */
102 void uart_rx_isr(void) __attribute__((interrupt_handler)); /* RXI1 ISR */
103 void uart_err_isr(void) __attribute__((interrupt_handler)); /* ERI1 ISR */
104 void receive_timeout_isr(void); /* 2nd level ISR for receiver timeout */
105
106 void mbus_init(void); /* prepare the M-Bus layer */
107 int mbus_send(unsigned char* p_msg, int digits); /* packet send */
108 int mbus_receive(unsigned char* p_msg, unsigned bufsize, int timeout); /* packet receive */
109
110 unsigned char calc_checksum(unsigned char* p_msg, int digits); /* make M-Bus checksum */
111 bool bit_test(unsigned char* buf, unsigned bit); /* test one bit of M-Bus packet */
112 void bit_set(unsigned char* buf, unsigned bit, bool val); /* set/clear one bit of M-Bus packet */
113
114 void print_scroll(char* string); /* implements a scrolling screen */
115 void dump_packet(char* dest, int dst_size, char* src, int n); /* convert packet to ASCII */
116
117 void emu_init(void); /* init changer emulation */
118 void emu_process_packet(unsigned char* mbus_msg, int msg_size); /* feed a received radio packet */
119 void emu_tick(void); /* for regular actions of the emulator */
120
121 int get_playtime(void); /* return the current track time in seconds */
122 int get_tracklength(void); /* return the total length of the current track */
123 void set_track(int selected);
124 int get_track(void); /* return the track number */
125 void set_play(void); /* start or resume playback */
126 void set_pause(void); /* pause playback */
127 void set_stop(void); /* stop playback */
128 void set_position(int seconds); /* seek */
129 void get_playmsg(void); /* update the play message with Rockbox info */
130 void get_diskmsg(void); /* update the disk status message with Rockbox info */
131
132 void sound_neutral(void); /* set to everything flat and 0 dB volume */
133 void sound_normal(void); /* return to user settings */
134
135 void thread(void); /* the thread running it all */
136 int main(void* parameter); /* main loop */
137 enum plugin_status plugin_start(struct plugin_api* api, void* parameter); /* entry */
138
139
140 /****************** data types ******************/
141
142 /* one entry in the receive queue */
143 typedef struct
144 {
145 unsigned char buf[MBUS_MAX_SIZE]; /* message buffer */
146 unsigned size; /* length of data in the buffer */
147 unsigned error; /* error code from reception */
148 } t_rcv_queue_entry;
149
150
151 /****************** globals ******************/
152
153
154 /* information owned by the timer transmit ISR */
155 struct
156 {
157 unsigned char send_buf[MBUS_MAX_SIZE]; /* M-Bus message */
158 unsigned send_size; /* current length of data in the buffer */
159 unsigned index; /* index for which byte to send */
160 unsigned byte; /* which byte to send */
161 unsigned bitmask; /* which bit to send */
162 unsigned step; /* where in the pulse are we */
163 bool bit; /* currently sent bit */
164 bool collision; /* set if a collision happened */
165 bool busy; /* flag if in transmission */
166 } gSendIRQ;
167
168
169 /* information owned by the UART receive ISR */
170 struct
171 {
172 t_rcv_queue_entry queue[MBUS_RCV_QUEUESIZE]; /* M-Bus message queue */
173 unsigned buf_read; /* readout maintained by the user application */
174 unsigned buf_write; /* writing maintained by ISR */
175 bool overflow; /* indicate queue overflow */
176 unsigned byte; /* currently assembled byte */
177 unsigned bit; /* which bit to receive */
178 } gRcvIRQ;
179
180
181 /* information owned by the timer */
182 struct
183 {
184 unsigned mode; /* off, transmit, receive timout */
185 unsigned transmit; /* value for transmit */
186 unsigned timeout; /* value for receive timeout */
187 } gTimer;
188
189
190 /* information owned by the changer emulation */
191 struct
192 {
193 unsigned char playmsg[15]; /* current play state msg */
194 unsigned char changemsg[11]; /* changing message */
195 unsigned char diskmsg[12]; /* disk status message */
196 long poll_interval; /* call the emu each n ticks */
197 int time; /* seconds within the song */
198 int set_state; /* the desired state to change into */
199 } gEmu;
200
201
202 /* communication to the worker thread */
203 struct
204 {
205 bool foreground; /* set as long as we're owning the UI */
206 bool exiting; /* signal to the thread that we want to exit */
207 bool ended; /* response from the thread, that is has exited */
208 } gTread;
209
210 static struct plugin_api* rb; /* here is the global API struct pointer */
211
212
213 /****************** implementation ******************/
214
215
216 /* setup static timer registers and values */
217 void timer_init(unsigned hz, unsigned to)
218 {
219 rb->memset(&gTimer, 0, sizeof(gTimer));
220
221 gTimer.transmit = TIMER_FREQ / hz; /* time for bit transitions */
222 gTimer.timeout = TIMER_FREQ / to; /* time for receive timeout */
223 }
224
225
226 /* define for what the timer should be used right now */
227 void timer_set_mode(int mode)
228 {
229 TCNT4 = 0; /* start counting at 0 */
230 gTimer.mode = mode; /* store the mode */
231
232 if (mode == TM_RX_TIMEOUT)
233 {
234 rb->timer_register(1, NULL, gTimer.timeout, 11, timer4_isr);
235 }
236 else if (mode == TM_TRANSMIT)
237 {
238 rb->timer_register(1, NULL, gTimer.transmit, 14, timer4_isr);
239 }
240 else
241 {
242 rb->timer_unregister();
243 }
244 }
245
246
247 void timer4_isr(void) /* IMIA4 */
248 {
249 switch (gTimer.mode)
250 { /* distribute the interrupt */
251 case TM_TRANSMIT:
252 transmit_isr();
253 break;
254 case TM_RX_TIMEOUT:
255 receive_timeout_isr();
256 rb->timer_unregister(); /* single shot */
257 break;
258 default:
259 timer_set_mode(TM_OFF); /* spurious interrupt */
260 } /* switch */
261 }
262
263
264 /* About Alpine M-Bus
265 * ------------------
266 *
267 * The protocol uses a single wire in half duplex mode.
268 * A bit like I2C, this wire is either pulled low or left floating high.
269 * Bit time is ~3 ms, a "zero" is coded as ~0.6 ms low, a "one" as ~1.8 ms low.
270 * Nice to view in a 0.6 ms grid:
271 *
272 * 0 0.6 1.2 1.8 2.4 3.0
273 * | | | | | |
274 * __ ___________________
275 * \____/ \ "zero" bit
276 * __ _________
277 * \______________/ \ "one" bit
278 *
279 * So I send out the data in a timer interrupt spawned to 0.6 ms.
280 * In phases where the line is floating high, I can check for collisions.
281 * (happens if the other side driving it low, too.)
282 *
283 * Data is transmitted in multiples of 4 bit, to ease BCD representation.
284 */
285
286
287 /* 2nd level ISR for M-Bus transmission */
288 void transmit_isr(void)
289 {
290 bool exit = false;
291
292 TSR4 &= ~0x01; /* clear the interrupt */
293
294 switch(gSendIRQ.step++)
295 {
296 case 0:
297 and_b(~0x04, &PBDRH); /* low (read-modify-write access may have changed it while it was input) */
298 or_b(0x04, &PBIORH); /* drive low (output) */
299 break;
300 case 1: /* 0.6 ms */
301 if (!gSendIRQ.bit) /* sending "zero"? */
302 and_b(~0x04, &PBIORH); /* float (input) */
303 break;
304 case 2: /* 1.2 ms */
305 if (!gSendIRQ.bit && ((PBDR & PB10) == 0))
306 gSendIRQ.collision = true;
307 break;
308 case 3: /* 1.8 ms */
309 if (gSendIRQ.bit) /* sending "one"? */
310 and_b(~0x04, &PBIORH); /* float (input) */
311 else if ((PBDR & PB10) == 0)
312 gSendIRQ.collision = true;
313 break;
314 case 4: /* 2.4 ms */
315 if ((PBDR & PB10) == 0)
316 gSendIRQ.collision = true;
317
318 /* prepare next round */
319 gSendIRQ.step = 0;
320 gSendIRQ.bitmask >>= 1;
321 if (gSendIRQ.bitmask)
322 { /* new bit */
323 gSendIRQ.bit = (gSendIRQ.byte & gSendIRQ.bitmask) != 0;
324 }
325 else
326 { /* new byte */
327 if (++gSendIRQ.index < gSendIRQ.send_size)
328 {
329 gSendIRQ.bitmask = 0x08;
330 gSendIRQ.byte = gSendIRQ.send_buf[gSendIRQ.index];
331 gSendIRQ.bit = (gSendIRQ.byte & gSendIRQ.bitmask) != 0;
332 }
333 else
334 exit = true; /* done */
335 }
336 break;
337 }
338
339 if (exit || gSendIRQ.collision)
340 { /* stop transmission */
341 or_b(0x20, PBCR1_ADDR+1); /* RxD1 again for PB10 */
342 timer_set_mode(TM_OFF); /* stop the timer */
343 gSendIRQ.busy = false; /* do this last, to avoid race conditions */
344 }
345 }
346
347
348 /* For receiving, I use the "normal" serial RX feature of the CPU,
349 * so we can receive within an interrupt, no line polling necessary.
350 * Luckily, the M-Bus bit always starts with a falling edge and ends with a high,
351 * this matches with the start bit and the stop bit of a serial transmission.
352 * The baudrate is set such that the M-Bus bit time (ca. 3ms) matches
353 * the serial reception time of one byte, so we receive one byte per
354 * M-Bus bit.
355 * Start bit, 8 data bits and stop bit (total=10) nicely fall into the 5
356 * phases like above:
357 *
358 * 0 0.6 1.2 1.8 2.4 3.0 ms
359 * | | | | | | time
360 * __ _______________________________
361 * \_______/ \ "zero" bit
362 * __ _______________
363 * \_______________________/ \ "one" bit
364 *
365 * | | | | | | | | | | | serial sampling interval
366 * Start 0 1 2 3 4 5 6 7 Stop bit (LSB first!)
367 *
368 * By looking at the bit pattern in the serial byte we can distinguish
369 * the short low from the longer low, tell "zero" and "one" apart.
370 * So we receive 0xFE for a "zero", 0xE0 for a "one".
371 * It may be necessary to treat the bits next to transitions as don't care,
372 * in case the timing is not so accurate.
373 * Bits are always sent "back-to-back", so I detect the packet end by timeout.
374 */
375
376
377 void uart_init(unsigned baudrate)
378 {
379 RXI1 = (unsigned long)uart_rx_isr; /* install ISR */
380 ERI1 = (unsigned long)uart_err_isr; /* install ISR */
381
382 SCR1 = 0x00; /* disable everything; select async mode with SCK pin as I/O */
383 SMR1 = 0x00; /* async, 8N1, NoMultiProc, sysclock/1 */
384 BRR1 = ((FREQ/(32*baudrate))-1);
385
386 IPRE = (IPRE & ~0xf000) | 0xc000; /* interrupt on level 12 */
387
388 rb->sleep(1); /* hardware needs to settle for at least one bit interval */
389
390 and_b(~(SCI_RDRF | SCI_ORER | SCI_FER | SCI_PER), &SSR1); /* clear any receiver flag */
391 or_b(SCI_RE | SCI_RIE , &SCR1); /* enable the receiver with interrupt */
392 }
393
394
395 void uart_rx_isr(void) /* RXI1 */
396 {
397 unsigned char data;
398 t_rcv_queue_entry* p_entry = &gRcvIRQ.queue[gRcvIRQ.buf_write]; /* short cut */
399
400 data = RDR1; /* get data */
401
402 and_b(~SCI_RDRF, &SSR1); /* clear data received flag */
403
404 if (gTimer.mode == TM_TRANSMIT)
405 p_entry->error = RX_OVERLAP; /* oops, we're also transmitting, stop */
406 else
407 timer_set_mode(TM_RX_TIMEOUT); /* (re)spawn timeout */
408
409 if (p_entry->error != RX_BUSY)
410 return;
411
412 if ((data & ~0x00) == 0xFE) /* 01111111 in line order (reverse) */
413 { /* "zero" received */
414 gRcvIRQ.byte <<= 1;
415 }
416 else if ((data & ~0x00) == 0xE0) /* 00000111 in line order (reverse) */
417 { /* "one" received */
418 gRcvIRQ.byte = gRcvIRQ.byte << 1 | 0x01;
419 }
420 else
421 { /* unrecognized pulse */
422 p_entry->error = RX_SYMBOL;
423 }
424
425 if (p_entry->error == RX_BUSY)
426 {
427 if (++gRcvIRQ.bit >= 4)
428 { /* byte completed */
429 if (p_entry->size >= sizeof(p_entry->buf))
430 {
431 p_entry->error = RX_OVERFLOW; /* buffer full */
432 }
433 else
434 {
435 p_entry->buf[p_entry->size] = gRcvIRQ.byte;
436 gRcvIRQ.byte = 0;
437 gRcvIRQ.bit = 0;
438 p_entry->size++;
439 }
440 }
441 }
442 }
443
444
445 void uart_err_isr(void) /* ERI1 */
446 {
447 t_rcv_queue_entry* p_entry = &gRcvIRQ.queue[gRcvIRQ.buf_write]; /* short cut */
448
449 if (p_entry->error == RX_BUSY)
450 { /* terminate reception in case of error */
451 if (SSR1 & SCI_FER)
452 p_entry->error = RX_FRAMING;
453 else if (SSR1 & SCI_ORER)
454 p_entry->error = RX_OVERRUN;
455 else if (SSR1 & SCI_PER)
456 p_entry->error = RX_PARITY;
457 }
458
459 /* clear any receiver flag */
460 and_b(~(SCI_RDRF | SCI_ORER | SCI_FER | SCI_PER), &SSR1);
461 }
462
463
464 /* 2nd level ISR for receiver timeout, this finalizes reception */
465 void receive_timeout_isr(void)
466 {
467 t_rcv_queue_entry* p_entry = &gRcvIRQ.queue[gRcvIRQ.buf_write]; /* short cut */
468
469 timer_set_mode(TM_OFF); /* single shot */
470
471 if (p_entry->error == RX_BUSY) /* everthing OK so far? */
472 p_entry->error = RX_RECEIVED; /* end with valid data */
473
474 /* move to next queue entry */
475 gRcvIRQ.buf_write++;
476 if (gRcvIRQ.buf_write >= MBUS_RCV_QUEUESIZE)
477 gRcvIRQ.buf_write = 0;
478 p_entry = &gRcvIRQ.queue[gRcvIRQ.buf_write];
479
480 if (gRcvIRQ.buf_write == gRcvIRQ.buf_read)
481 { /* queue overflow */
482 gRcvIRQ.overflow = true;
483 /* what can I do? Continueing overwrites the oldest. */
484 }
485
486 gRcvIRQ.byte = 0;
487 gRcvIRQ.bit = 0;
488 p_entry->size = 0;
489 p_entry->error = RX_BUSY; /* enable receive on new entry */
490 }
491
492
493 /* generate the checksum */
494 unsigned char calc_checksum(unsigned char* p_msg, int digits)
495 {
496 int chk = 0;
497 int i;
498
499 for (i=0; i<digits; i++)
500 {
501 chk ^= p_msg[i];
502 }
503 chk = (chk+1) % 16;
504
505 return chk;
506 }
507
508
509 /****************** high-level M-Bus functions ******************/
510
511 void mbus_init(void)
512 {
513 /* init the send object */
514 rb->memset(&gSendIRQ, 0, sizeof(gSendIRQ));
515 timer_init(MBUS_STEP_FREQ, (MBUS_BIT_FREQ*10)/15); /* setup frequency and timeout (1.5 bit) */
516
517 /* init receiver */
518 rb->memset(&gRcvIRQ, 0, sizeof(gRcvIRQ));
519 uart_init(MBUS_BAUDRATE);
520 }
521
522
523 /* send out a number of BCD digits (one per byte) with M-Bus protocol */
524 int mbus_send(unsigned char* p_msg, int digits)
525 {
526 /* wait for previous transmit/receive to end */
527 while(gTimer.mode != TM_OFF) /* wait for "free line" */
528 rb->sleep(1);
529
530 /* fill in our part */
531 rb->memcpy(gSendIRQ.send_buf, p_msg, digits);
532
533 /* add checksum */
534 gSendIRQ.send_buf[digits] = calc_checksum(p_msg, digits);
535 digits++;
536
537 /* debug dump, to be removed */
538 if (gTread.foreground)
539 {
540 char buf[MBUS_MAX_SIZE+1];
541 dump_packet(buf, sizeof(buf), gSendIRQ.send_buf, digits);
542 /*print_scroll(buf); */
543 }
544
545 gSendIRQ.send_size = digits;
546
547 /* prepare everything so the ISR can start right away */
548 gSendIRQ.index = 0;
549 gSendIRQ.byte = gSendIRQ.send_buf[0];
550 gSendIRQ.bitmask = 0x08;
551 gSendIRQ.step = 0;
552 gSendIRQ.bit = (gSendIRQ.byte & gSendIRQ.bitmask) != 0;
553 gSendIRQ.collision = false;
554 gSendIRQ.busy = true;
555
556 /* last chance to wait for a new detected receive to end */
557 while(gTimer.mode != TM_OFF) /* wait for "free line" */
558 rb->sleep(1);
559
560 and_b(~0x30, PBCR1_ADDR+1); /* GPIO for PB10 */
561 timer_set_mode(TM_TRANSMIT); /* run */
562
563 /* make the call blocking until sent out */
564 rb->sleep(digits*4*HZ/MBUS_BIT_FREQ); /* should take this long */
565
566 while(gSendIRQ.busy) /* poll in case it lasts longer */
567 rb->sleep(1); /* (should not happen) */
568
569 /* debug output, to be removed */
570 if (gTread.foreground)
571 {
572 if (gSendIRQ.collision)
573 print_scroll("collision");
574 }
575
576 return gSendIRQ.collision;
577 }
578
579
580 /* returns the size of message copy, 0 if timed out, negative on error */
581 int mbus_receive(unsigned char* p_msg, unsigned bufsize, int timeout)
582 {
583 int retval = 0;
584
585 do
586 {
587 if (gRcvIRQ.buf_read != gRcvIRQ.buf_write)
588 { /* something in the queue */
589 t_rcv_queue_entry* p_entry = &gRcvIRQ.queue[gRcvIRQ.buf_read]; /* short cut */
590
591 if (p_entry->error == RX_RECEIVED)
592 { /* seems valid */
593 rb->memcpy(p_msg, p_entry->buf, MIN(p_entry->size, bufsize));
594 retval = p_entry->size; /* return message size */
595 }
596 else
597 { /* an error occured */
598 retval = - p_entry->error; /* return negative number */
599 }
600
601 /* next queue readout position */
602 gRcvIRQ.buf_read++;
603 if (gRcvIRQ.buf_read >= MBUS_RCV_QUEUESIZE)
604 gRcvIRQ.buf_read = 0;
605
606 return retval; /* exit */
607 }
608
609 if (timeout != 0 || gTimer.mode != TM_OFF) /* also carry on if reception in progress */
610 {
611 if (timeout != -1 && timeout != 0) /* if not infinite or expired */
612 timeout--;
613
614 rb->sleep(1); /* wait a while */
615 }
616
617 } while (timeout != 0 || gTimer.mode != TM_OFF);
618
619 return 0; /* timeout */
620 }
621
622
623 /****************** MMI helper fuctions ******************/
624
625
626 void print_scroll(char* string)
627 {
628 static char screen[LINES][COLUMNS+1]; /* visible strings */
629 static unsigned pos = 0; /* next print position */
630 static unsigned screentop = 0; /* for scrolling */
631
632 if (!gTread.foreground)
633 return; /* just to protect careless callers */
634
635 if (pos >= LINES)
636 { /* need to scroll first */
637 int i;
638 rb->lcd_clear_display();
639 screentop++;
640 for (i=0; i<LINES-1; i++)
641 rb->lcd_puts(0, i, screen[(i+screentop) % LINES]);
642
643 pos = LINES-1;
644 }
645
646 /* no strncpy avail. */
647 rb->snprintf(screen[(pos+screentop) % LINES], sizeof(screen[0]), "%s", string);
648
649 rb->lcd_puts(0, pos, screen[(pos+screentop) % LINES]);
650 #ifndef HAVE_LCD_CHARCELLS
651 rb->lcd_update();
652 #endif
653 pos++;
654 }
655
656
657 void dump_packet(char* dest, int dst_size, char* src, int n)
658 {
659 int i;
660 int len = MIN(dst_size-1, n);
661
662 for (i=0; i<len; i++)
663 { /* convert to hex digits */
664 dest[i] = src[i] < 10 ? '0' + src[i] : 'A' + src[i] - 10;
665 }
666 dest[i] = '\0'; /* zero terminate string */
667 }
668
669
670 /****************** CD changer emulation ******************/
671
672 bool bit_test(unsigned char* buf, unsigned bit)
673 {
674 return (buf[bit/4] & (0x01 << bit%4)) != 0;
675 }
676
677
678 void bit_set(unsigned char* buf, unsigned bit, bool val)
679 {
680 if (val)
681 buf[bit/4] |= (0x01 << bit%4);
682 else
683 buf[bit/4] &= ~(0x01 << bit%4);
684 }
685
686
687 void emu_init(void)
688 {
689 rb->memset(&gEmu, 0, sizeof(gEmu));
690
691 gEmu.poll_interval = HZ;
692
693 /* init the play message to 990000000000000 */
694 gEmu.playmsg[0] = gEmu.playmsg[1] = 0x9;
695
696 /* init the changing message to 9B900000001 */
697 gEmu.changemsg[0] = gEmu.changemsg[2] = 0x9;
698 gEmu.changemsg[1] = 0xB;
699 gEmu.changemsg[10] = 0x1;
700
701 /* init the disk status message to 9C1019999990 */
702 rb->memset(&gEmu.diskmsg, 0x9, sizeof(gEmu.diskmsg));
703 gEmu.diskmsg[1] = 0xC;
704 gEmu.diskmsg[2] = gEmu.diskmsg[4] = 0x1;
705 gEmu.diskmsg[3] = gEmu.diskmsg[11] = 0x0;
706 }
707
708 /* feed a radio command into the emulator */
709 void emu_process_packet(unsigned char* mbus_msg, int msg_size)
710 {
711 bool playmsg_dirty = false;
712 bool diskmsg_dirty = false;
713
714 if (msg_size == 2 && mbus_msg[0] == 1 && mbus_msg[1] == 8)
715 { /* 18: ping */
716 mbus_send("\x09\x08", 2); /* 98: ping OK */
717 }
718 else if (msg_size == 5 && mbus_msg[0] == 1 && mbus_msg[1] == 1 && mbus_msg[2] == 1)
719 { /* set play state */
720 if (bit_test(mbus_msg, 16))
721 {
722 if (gEmu.set_state == EMU_FF || gEmu.set_state == EMU_FR) /* was seeking? */
723 { /* seek to final position */
724 set_position(gEmu.time);
725 }
726 else if (gEmu.set_state != EMU_PLAYING || gEmu.set_state != EMU_PAUSED)
727 { /* was not playing yet, better send disk message */
728 diskmsg_dirty = true;
729 }
730 set_play();
731 gEmu.set_state = EMU_PLAYING;
732 playmsg_dirty = true;
733 }
734
735 if (bit_test(mbus_msg, 17))
736 {
737 gEmu.set_state = EMU_PAUSED;
738 playmsg_dirty = true;
739 set_pause();
740 }
741
742 if (bit_test(mbus_msg, 14))
743 {
744 gEmu.set_state = EMU_STOPPED;
745 playmsg_dirty = true;
746 set_stop();
747 }
748
749 if (bit_test(mbus_msg, 18))
750 {
751 gEmu.set_state = EMU_FF;
752 playmsg_dirty = true;
753 set_pause();
754 }
755
756 if (bit_test(mbus_msg, 19))
757 {
758 gEmu.set_state = EMU_FR;
759 playmsg_dirty = true;
760 set_pause();
761 }
762
763 if (bit_test(mbus_msg, 12)) /* scan stop */
764 {
765 bit_set(gEmu.playmsg, 51, false);
766 playmsg_dirty = true;
767 }
768
769 if (gEmu.set_state == EMU_FF || gEmu.set_state == EMU_FR)
770 gEmu.poll_interval = HZ/4; /* faster refresh */
771 else
772 gEmu.poll_interval = HZ;
773 }
774 else if (msg_size == 8 && mbus_msg[0] == 1 && mbus_msg[1] == 1 && mbus_msg[2] == 4)
775 { /* set program mode */
776 gEmu.playmsg[11] = mbus_msg[3]; /* copy repeat, random, intro */
777 gEmu.playmsg[12] = mbus_msg[4]; /* ToDo */
778 playmsg_dirty = true;
779 }
780 else if (msg_size ==8 && mbus_msg[0] == 1 && mbus_msg[1] == 1 && mbus_msg[2] == 3)
781 { /* changing */
782 gEmu.time = 0; /* reset playtime */
783 playmsg_dirty = true;
784 if (mbus_msg[3] == 0)
785 { /* changing track */
786 if (mbus_msg[4] == 0xA && mbus_msg[5] == 0x3)
787 { /* next random */
788 gEmu.playmsg[3] = rb->rand() % 10; /* ToDo */
789 gEmu.playmsg[4] = rb->rand() % 10;
790 }
791 else if (mbus_msg[4] == 0xB && mbus_msg[5] == 0x3)
792 { /* previous random */
793 gEmu.playmsg[3] = rb->rand() % 10; /* ToDo */
794 gEmu.playmsg[4] = rb->rand() % 10;
795 }
796 else
797 { /* normal track select */
798 set_track(mbus_msg[4]*10 + mbus_msg[5]);
799 }
800 }
801 else
802 { /* changing disk */
803 diskmsg_dirty = true;
804 gEmu.changemsg[3] = mbus_msg[3]; /* copy disk */
805 gEmu.diskmsg[2] = mbus_msg[3];
806 gEmu.changemsg[7] = gEmu.playmsg[11]; /* copy flags from status */
807 gEmu.changemsg[8] = gEmu.playmsg[12];
808 /*gEmu.playmsg[3] = 0; */ /* reset to track 1 */
809 /*gEmu.playmsg[4] = 1; */
810 mbus_send(gEmu.changemsg, sizeof(gEmu.changemsg));
811 }
812 }
813 else
814 { /* if in doubt, send Ack */
815 mbus_send("\x09\x0F\x00\x00\x00\x00\x00", 7);
816 }
817
818 if (playmsg_dirty)
819 {
820 rb->yield(); /* give the audio thread a chance to process */
821 get_playmsg(); /* force update */
822 mbus_send(gEmu.playmsg, sizeof(gEmu.playmsg));
823 }
824
825 if (diskmsg_dirty)
826 {
827 get_diskmsg(); /* force update */
828 mbus_send(gEmu.diskmsg, sizeof(gEmu.diskmsg));
829 }
830 }
831
832
833 /* called each second in case the emulator has something to do */
834 void emu_tick(void)
835 {
836 get_playmsg(); /* force update */
837 if (bit_test(gEmu.playmsg, 56)) /* play bit */
838 {
839 unsigned remain; /* helper as we walk down the digits */
840
841 switch(gEmu.set_state)
842 {
843 case EMU_FF:
844 gEmu.time += 10;
845 case EMU_FR:
846 gEmu.time -= 5;
847
848 if (gEmu.time < 0)
849 gEmu.time = 0;
850 else if (gEmu.time > get_tracklength())
851 gEmu.time = get_tracklength();
852
853 /* convert value to MM:SS */
854 remain = (unsigned)gEmu.time;
855 gEmu.playmsg[7] = remain / (10*60);
856 remain -= gEmu.playmsg[7] * (10*60);
857 gEmu.playmsg[8] = remain / 60;
858 remain -= gEmu.playmsg[8] * 60;
859 gEmu.playmsg[9] = remain / 10;
860 remain -= gEmu.playmsg[9] * 10;
861 gEmu.playmsg[10] = remain;
862 }
863
864 mbus_send(gEmu.playmsg, sizeof(gEmu.playmsg));
865 }
866 }
867
868
869 /****************** communication with Rockbox playback ******************/
870
871
872 /* update the play message with Rockbox info */
873 void get_playmsg(void)
874 {
875 int track, time;
876
877 if (gEmu.set_state != EMU_FF && gEmu.set_state != EMU_FR)
878 {
879 switch(rb->audio_status())
880 {
881 case AUDIO_STATUS_PLAY:
882 print_scroll("AudioStat Play");
883 if (gEmu.set_state == EMU_FF || gEmu.set_state == EMU_FR)
884 gEmu.playmsg[2] = gEmu.set_state; /* set FF/FR */
885 else
886 gEmu.playmsg[2] = EMU_PLAYING; /* set normal play */
887
888 bit_set(gEmu.playmsg, 56, true); /* set play */
889 bit_set(gEmu.playmsg, 57, false); /* clear pause */
890 bit_set(gEmu.playmsg, 59, false); /* clear stop */
891 break;
892
893 case AUDIO_STATUS_PLAY | AUDIO_STATUS_PAUSE:
894 print_scroll("AudioStat Pause");
895 gEmu.playmsg[2] = EMU_PAUSED;
896 bit_set(gEmu.playmsg, 56, false); /* clear play */
897 bit_set(gEmu.playmsg, 57, true); /* set pause */
898 bit_set(gEmu.playmsg, 59, false); /* clear stop */
899 break;
900
901 default:
902 print_scroll("AudioStat 0");
903 gEmu.playmsg[2] = EMU_STOPPED;
904 bit_set(gEmu.playmsg, 56, false); /* clear play */
905 bit_set(gEmu.playmsg, 57, false); /* clear pause */
906 bit_set(gEmu.playmsg, 59, true); /* set stop */
907 break;
908 }
909
910 /* convert value to MM:SS */
911 time = get_playtime();
912 gEmu.time = time; /* copy it */
913 gEmu.playmsg[7] = time / (10*60);
914 time -= gEmu.playmsg[7] * (10*60);
915 gEmu.playmsg[8] = time / 60;
916 time -= gEmu.playmsg[8] * 60;
917 gEmu.playmsg[9] = time / 10;
918 time -= gEmu.playmsg[9] * 10;
919 gEmu.playmsg[10] = time;
920 }
921 else /* FF/FR */
922 {
923 gEmu.playmsg[2] = gEmu.set_state; /* in FF/FR, report that instead */
924 }
925
926 track = get_track();
927 gEmu.playmsg[3] = track / 10;
928 gEmu.playmsg[4] = track % 10;
929 }
930
931 /* update the disk status message with Rockbox info */
932 void get_diskmsg(void)
933 {
934 int tracks = rb->playlist_amount();
935 if (tracks > 99)
936 tracks = 99;
937 gEmu.diskmsg[5] = tracks / 10;
938 gEmu.diskmsg[6] = tracks % 10;
939 }
940
941 /* return the current track time in seconds */
942 int get_playtime(void)
943 {
944 struct mp3entry* p_mp3entry;
945
946 p_mp3entry = rb->audio_current_track();
947 if (p_mp3entry == NULL)
948 return 0;
949
950 return p_mp3entry->elapsed / 1000;
951 }
952
953 /* return the total length of the current track */
954 int get_tracklength(void)
955 {
956 struct mp3entry* p_mp3entry;
957
958 p_mp3entry = rb->audio_current_track();
959 if (p_mp3entry == NULL)
960 return 0;
961
962 return p_mp3entry->length / 1000;
963 }
964
965 /* change to a new track */
966 void set_track(int selected)
967 {
968 if (selected > get_track())
969 {
970 print_scroll("audio_next");
971 rb->audio_next();
972 }
973 else if (selected < get_track())
974 {
975 print_scroll("audio_prev");
976 rb->audio_prev();
977 }
978 }
979
980 /* return the track number */
981 int get_track(void)
982 {
983 struct mp3entry* p_mp3entry;
984
985 p_mp3entry = rb->audio_current_track();
986 if (p_mp3entry == NULL)
987 return 0;
988
989 return p_mp3entry->index + 1; /* track numbers start with 1 */
990 }
991
992 /* start or resume playback */
993 void set_play(void)
994 {
995 if (rb->audio_status() == AUDIO_STATUS_PLAY)
996 return;
997
998 if (rb->audio_status() == (AUDIO_STATUS_PLAY | AUDIO_STATUS_PAUSE))
999 {
1000 print_scroll("audio_resume");
1001 rb->audio_resume();
1002 }
1003 else
1004 {
1005 print_scroll("audio_play(0)");
1006 rb->audio_play(0);
1007 }
1008 }
1009
1010 /* pause playback */
1011 void set_pause(void)
1012 {
1013 if (rb->audio_status() == AUDIO_STATUS_PLAY)
1014 {
1015 print_scroll("audio_pause");
1016 rb->audio_pause();
1017 }
1018 }
1019
1020 /* stop playback */
1021 void set_stop(void)
1022 {
1023 if (rb->audio_status() & AUDIO_STATUS_PLAY)
1024 {
1025 print_scroll("audio_stop");
1026 rb->audio_stop();
1027 }
1028 }
1029
1030 /* seek */
1031 void set_position(int seconds)
1032 {
1033 if (rb->audio_status() & AUDIO_STATUS_PLAY)
1034 {
1035 print_scroll("audio_ff_rewind");
1036 rb->audio_ff_rewind(seconds * 1000);
1037 }
1038 }
1039
1040 /****************** main thread + helper ******************/
1041
1042 /* set to everything flat and 0 dB volume */
1043 void sound_neutral(void)
1044 { /* neutral sound settings */
1045 rb->sound_set(SOUND_BASS, 0);
1046 rb->sound_set(SOUND_TREBLE, 0);
1047 rb->sound_set(SOUND_BALANCE, 0);
1048 rb->sound_set(SOUND_VOLUME, 0);
1049 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
1050 rb->sound_set(SOUND_LOUDNESS, 0);
1051 rb->sound_set(SOUND_SUPERBASS, 0);
1052 rb->sound_set(SOUND_AVC, 0);
1053 #endif
1054 }
1055
1056 /* return to user settings */
1057 void sound_normal(void)
1058 { /* restore sound settings */
1059 rb->sound_set(SOUND_BASS, rb->global_settings->bass);
1060 rb->sound_set(SOUND_TREBLE, rb->global_settings->treble);
1061 rb->sound_set(SOUND_BALANCE, rb->global_settings->balance);
1062 rb->sound_set(SOUND_VOLUME, rb->global_settings->volume);
1063 #if (CONFIG_CODEC == MAS3587F) || (CONFIG_CODEC == MAS3539F)
1064 rb->sound_set(SOUND_LOUDNESS, rb->global_settings->loudness);
1065 rb->sound_set(SOUND_SUPERBASS, rb->global_settings->superbass);
1066 rb->sound_set(SOUND_AVC, rb->global_settings->avc);
1067 #endif
1068 }
1069
1070 /* the thread running it all */
1071 void thread(void)
1072 {
1073 int msg_size;
1074 unsigned char mbus_msg[MBUS_MAX_SIZE];
1075 char buf[32];
1076 bool connected = false;
1077 long last_tick = *rb->current_tick; /* for 1 sec tick */
1078
1079 do
1080 {
1081 msg_size = mbus_receive(mbus_msg, sizeof(mbus_msg), 1);
1082 if (msg_size > 0)
1083 { /* received something */
1084 if(gTread.foreground)
1085 {
1086 dump_packet(buf, sizeof(buf), mbus_msg, msg_size);
1087 /*print_scroll(buf); */
1088 }
1089 if (msg_size > 2 && mbus_msg[0] == 1
1090 && mbus_msg[msg_size-1] == calc_checksum(mbus_msg, msg_size-1))
1091 { /* sanity and checksum OK */
1092 if (!connected)
1093 { /* with the first received packet: */
1094 sound_neutral(); /* set to flat and 0dB volume */
1095 connected = true;
1096 }
1097 emu_process_packet(mbus_msg, msg_size-1); /* pass without chksum */
1098 }
1099 else if(gTread.foreground)
1100 { /* not OK */
1101 print_scroll("bad packet");
1102 }
1103 }
1104 else if (msg_size < 0 && gTread.foreground)
1105 { /* error */
1106 rb->snprintf(buf, sizeof(buf), "rcv error %d", msg_size);
1107 print_scroll(buf);
1108 }
1109
1110 if (*rb->current_tick - last_tick >= gEmu.poll_interval)
1111 { /* call the emulation regulary */
1112 emu_tick();
1113 last_tick += gEmu.poll_interval;
1114 }
1115
1116 } while (!gTread.exiting);
1117
1118 gTread.ended = true; /* acknowledge the exit */
1119 rb->remove_thread(NULL); /* commit suicide */
1120 }
1121
1122 /* callback to end the TSR plugin, called before a new one gets loaded */
1123 bool exit_tsr(bool reenter)
1124 {
1125 if (reenter)
1126 return false; /* dont let it start again */
1127 gTread.exiting = true; /* tell the thread to end */
1128 while (!gTread.ended) /* wait until it did */
1129 rb->yield();
1130
1131 uart_init(BAUDRATE); /* return to standard baudrate */
1132 IPRE = (IPRE & ~0xF000); /* UART interrupt off */
1133 timer_set_mode(TM_OFF); /* timer interrupt off */
1134
1135 sound_normal(); /* restore sound settings */
1136 return true;
1137 }
1138
1139 /****************** main ******************/
1140
1141
1142 int main(void* parameter)
1143 {
1144 (void)parameter;
1145 #ifdef DEBUG
1146 int button;
1147 #endif
1148 int stacksize;
1149 void* stack;
1150
1151 mbus_init(); /* init the M-Bus layer */
1152 emu_init(); /* init emulator */
1153
1154 rb->splash(HZ/5, true, "Alpine CDC"); /* be quick on autostart */
1155
1156 #ifdef DEBUG
1157 print_scroll("Alpine M-Bus Test");
1158 print_scroll("any key to TSR");
1159 #endif
1160
1161 /* init the worker thread */
1162 stack = rb->plugin_get_buffer(&stacksize); /* use the rest as stack */
1163 stack = (void*)(((unsigned int)stack + 100) & ~3); /* a bit away, 32 bit align */
1164 stacksize = (stacksize - 100) & ~3;
1165 if (stacksize < DEFAULT_STACK_SIZE)
1166 {
1167 rb->splash(HZ*2, true, "Out of memory");
1168 return -1;
1169 }
1170
1171 rb->memset(&gTread, 0, sizeof(gTread));
1172 gTread.foreground = true;
1173 rb->create_thread(thread, stack, stacksize, "CDC"
1174 IF_PRIO(, PRIORITY_BACKGROUND)
1175 IF_COP(, CPU, false));
1176
1177 #ifdef DEBUG
1178 do
1179 {
1180 button = rb->button_get(true);
1181 } while (button & BUTTON_REL);
1182 #endif
1183
1184 gTread.foreground = false; /* we're in the background now */
1185 rb->plugin_tsr(exit_tsr); /* stay resident */
1186
1187 #ifdef DEBUG
1188 return rb->default_event_handler(button);
1189 #else
1190 return 0;
1191 #endif
1192 }
1193
1194
1195 /***************** Plugin Entry Point *****************/
1196
1197
1198 enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
1199 {
1200 rb = api; /* copy to global api pointer */
1201
1202 /* now go ahead and have fun! */
1203 return (main(parameter)==0) ? PLUGIN_OK : PLUGIN_ERROR;
1204 }
1205
1206 #endif /* #ifndef SIMULATOR, etc. */
Open Source Jukebox Firmware