Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/iap/iap-core.c
LiveboxAndy 77f8c9c9f1 Update to allow the Apple Radio Remote to function on iPod Video 5G. 
This was broken when the major update to iap was comitted.
ia-lingo7.c created and various iap related files modified.
On 4G, 6G and Nano 1/2Gen iPods the remote will function
even though the radio won't.
Tested on 4G Greyscale, 4G Color, 4G Photo, 4G Mini 1st Gen,
4G Mini 2Gen, Nano 1G, Nano 2G, Video 5G, Video 5.5G

Change-Id: Ia74e3d07d9ab5edc6da8eafa96801ede722be331
2020-07-09 18:02:07 +00:00

1422 lines
36 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Alan Korr & Nick Robinson
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include "panic.h"
#include "iap-core.h"
#include "iap-lingo.h"
#include "button.h"
#include "config.h"
#include "cpu.h"
#include "system.h"
#include "kernel.h"
#include "thread.h"
#include "serial.h"
#include "appevents.h"
#include "core_alloc.h"
#include "playlist.h"
#include "playback.h"
#include "audio.h"
#include "settings.h"
#include "metadata.h"
#include "sound.h"
#include "action.h"
#include "powermgmt.h"
#include "usb.h"
#include "tuner.h"
#if CONFIG_TUNER
#include "ipod_remote_tuner.h"
#endif
/* MS_TO_TICKS converts a milisecond time period into the
* corresponding amount of ticks. If the time period cannot
* be accurately measured in ticks it will round up.
*/
#if (HZ>1000)
#error "HZ is >1000, please fix MS_TO_TICKS"
#endif
#define MS_PER_HZ (1000/HZ)
#define MS_TO_TICKS(x) (((x)+MS_PER_HZ-1)/MS_PER_HZ)
/* IAP specifies a timeout of 25ms for traffic from a device to the iPod.
* Depending on HZ this cannot be accurately measured. Find out the next
* best thing.
*/
#define IAP_PKT_TIMEOUT (MS_TO_TICKS(25))
/* Events in the iap_queue */
#define IAP_EV_TICK (1) /* The regular task timeout */
#define IAP_EV_MSG_RCVD (2) /* A complete message has been received from the device */
#define IAP_EV_MALLOC (3) /* Allocate memory for the RX/TX buffers */
static bool iap_started = false;
static bool iap_setupflag = false, iap_running = false;
/* This is set to true if a SYS_POWEROFF message is received,
* signalling impending power off
*/
static bool iap_shutdown = false;
static struct timeout iap_task_tmo;
unsigned long iap_remotebtn = 0;
/* Used to make sure a button press is delivered to the processing
* backend. While this is !0, no new incoming messasges are processed.
* Counted down by remote_control_rx()
*/
int iap_repeatbtn = 0;
/* Used to time out button down events in case we miss the button up event
* from the device somehow.
* If a device sends a button down event it's required to repeat that event
* every 30 to 100ms as long as the button is pressed, and send an explicit
* button up event if the button is released.
* In case the button up event is lost any down events will time out after
* ~200ms.
* iap_periodic() will count down this variable and reset all buttons if
* it reaches 0
*/
unsigned int iap_timeoutbtn = 0;
bool iap_btnrepeat = false, iap_btnshuffle = false;
static long thread_stack[(DEFAULT_STACK_SIZE*6)/sizeof(long)];
static struct event_queue iap_queue;
/* These are pointer used to manage a dynamically allocated buffer which
* will hold both the RX and TX side of things.
*
* iap_buffer_handle is the handle returned from core_alloc()
* iap_buffers points to the start of the complete buffer
*
* The buffer is partitioned as follows:
* - TX_BUFLEN+6 bytes for the TX buffer
* The 6 extra bytes are for the sync byte, the SOP byte, the length indicators
* (3 bytes) and the checksum byte.
* iap_txstart points to the beginning of the TX buffer
* iap_txpayload points to the beginning of the payload portion of the TX buffer
* iap_txnext points to the position where the next byte will be placed
*
* - RX_BUFLEN+2 bytes for the RX buffer
* The RX buffer can hold multiple packets at once, up to it's
* maximum capacity. Every packet consists of a two byte length
* indicator followed by the actual payload. The length indicator
* is two bytes for every length, even for packets with a length <256
* bytes.
*
* Once a packet has been processed from the RX buffer the rest
* of the buffer (and the pointers below) are shifted to the front
* so that the next packet again starts at the beginning of the
* buffer. This happens with interrupts disabled, to prevent
* writing into the buffer during the move.
*
* iap_rxstart points to the beginning of the RX buffer
* iap_rxpayload starts to the beginning of the currently recieved
* packet
* iap_rxnext points to the position where the next incoming byte
* will be placed
* iap_rxlen is not a pointer, but an indicator of the free
* space left in the RX buffer.
*
* The RX buffer is placed behind the TX buffer so that an eventual TX
* buffer overflow has some place to spill into where it will not cause
* immediate damage. See the comments for IAP_TX_* and iap_send_tx()
*/
#define IAP_MALLOC_SIZE (TX_BUFLEN+6+RX_BUFLEN+2)
#ifdef IAP_MALLOC_DYNAMIC
static int iap_buffer_handle;
#endif
static unsigned char* iap_buffers;
static unsigned char* iap_rxstart;
static unsigned char* iap_rxpayload;
static unsigned char* iap_rxnext;
static uint32_t iap_rxlen;
static unsigned char* iap_txstart;
unsigned char* iap_txpayload;
unsigned char* iap_txnext;
/* The versions of the various Lingoes we support. A major version
* of 0 means unsupported
*/
unsigned char lingo_versions[32][2] = {
{1, 9}, /* General lingo, 0x00 */
#ifdef HAVE_LINE_REC
{1, 1}, /* Microphone lingo, 0x01 */
#else
{0, 0}, /* Microphone lingo, 0x01, disabled */
#endif
{1, 2}, /* Simple remote lingo, 0x02 */
{1, 5}, /* Display remote lingo, 0x03 */
{1, 12}, /* Extended Interface lingo, 0x04 */
{1, 1}, /* RF/BT Transmitter lingo, 0x05 */
{0, 0}, /* USB Host lingo, 0x06, disabled */
#if CONFIG_TUNER
{1, 0}, /* RF Receiver lingo, 0x07 */
#else
{0, 0}, /* RF Receiver lingo, 0x07 disabled */
#endif
{} /* every other lingo, disabled */
};
/* states of the iap de-framing state machine */
enum fsm_state {
ST_SYNC, /* wait for 0xFF sync byte */
ST_SOF, /* wait for 0x55 start-of-frame byte */
ST_LEN, /* receive length byte (small packet) */
ST_LENH, /* receive length high byte (large packet) */
ST_LENL, /* receive length low byte (large packet) */
ST_DATA, /* receive data */
ST_CHECK /* verify checksum */
};
static struct state_t {
enum fsm_state state; /* current fsm state */
unsigned int len; /* payload data length */
unsigned int check; /* running checksum over [len,payload,check] */
unsigned int count; /* playload bytes counter */
} frame_state = {
.state = ST_SYNC
};
enum interface_state interface_state = IST_STANDARD;
struct device_t device;
#ifdef IAP_MALLOC_DYNAMIC
static int iap_move_callback(int handle, void* current, void* new);
static struct buflib_callbacks iap_buflib_callbacks = {
iap_move_callback,
NULL
};
#endif
static void iap_malloc(void);
void put_u16(unsigned char *buf, const uint16_t data)
{
buf[0] = (data >> 8) & 0xFF;
buf[1] = (data >> 0) & 0xFF;
}
void put_u32(unsigned char *buf, const uint32_t data)
{
buf[0] = (data >> 24) & 0xFF;
buf[1] = (data >> 16) & 0xFF;
buf[2] = (data >> 8) & 0xFF;
buf[3] = (data >> 0) & 0xFF;
}
uint32_t get_u32(const unsigned char *buf)
{
return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
}
uint16_t get_u16(const unsigned char *buf)
{
return (buf[0] << 8) | buf[1];
}
#if defined(LOGF_ENABLE) && defined(ROCKBOX_HAS_LOGF)
/* Convert a buffer into a printable string, perl style
* buf contains the data to be converted, len is the length
* of the buffer.
*
* This will convert at most 1024 bytes from buf
*/
static char* hexstring(const unsigned char *buf, unsigned int len) {
static char hexbuf[4097];
unsigned int l;
const unsigned char* p;
unsigned char* out;
unsigned char h[] = {'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
if (len > 1024) {
l = 1024;
} else {
l = len;
}
p = buf;
out = hexbuf;
do {
*out++ = h[(*p)>>4];
*out++ = h[*p & 0x0F];
} while(--l && p++);
*out = 0x00;
return hexbuf;
}
#endif
void iap_tx_strlcpy(const unsigned char *str)
{
ptrdiff_t txfree;
int r;
txfree = TX_BUFLEN - (iap_txnext - iap_txstart);
r = strlcpy(iap_txnext, str, txfree);
if (r < txfree)
{
/* No truncation occured
* Account for the terminating \0
*/
iap_txnext += (r+1);
} else {
/* Truncation occured, the TX buffer is now full. */
iap_txnext = iap_txstart + TX_BUFLEN;
}
}
void iap_reset_auth(struct auth_t* auth)
{
auth->state = AUST_NONE;
auth->max_section = 0;
auth->next_section = 0;
}
void iap_reset_device(struct device_t* device)
{
iap_reset_auth(&(device->auth));
device->lingoes = 0;
device->notifications = 0;
device->changed_notifications = 0;
device->do_notify = false;
device->do_power_notify = false;
device->accinfo = ACCST_NONE;
device->capabilities = 0;
device->capabilities_queried = 0;
}
static int iap_task(struct timeout *tmo)
{
(void) tmo;
queue_post(&iap_queue, IAP_EV_TICK, 0);
return MS_TO_TICKS(100);
}
void iap_set_remote_volume(void)
{
IAP_TX_INIT(0x03, 0x0D);
IAP_TX_PUT(0x04);
IAP_TX_PUT(0x00);
IAP_TX_PUT(0xFF & (int)((global_settings.volume + 90) * 2.65625));
iap_send_tx();
}
/* This thread is waiting for events posted to iap_queue and calls
* the appropriate subroutines in response
*/
static void iap_thread(void)
{
struct queue_event ev;
while(1) {
queue_wait(&iap_queue, &ev);
switch (ev.id)
{
/* Handle the regular 100ms tick used for driving the
* authentication state machine and notifications
*/
case IAP_EV_TICK:
{
iap_periodic();
break;
}
/* Handle a newly received message from the device */
case IAP_EV_MSG_RCVD:
{
iap_handlepkt();
break;
}
/* Handle memory allocation. This is used only once, during
* startup
*/
case IAP_EV_MALLOC:
{
iap_malloc();
break;
}
/* Handle poweroff message */
case SYS_POWEROFF:
{
iap_shutdown = true;
break;
}
/* Ack USB thread */
case SYS_USB_CONNECTED:
{
usb_acknowledge(SYS_USB_CONNECTED_ACK);
break;
}
}
}
}
/* called by playback when the next track starts */
static void iap_track_changed(unsigned short id, void *ignored)
{
(void)id;
(void)ignored;
if ((interface_state == IST_EXTENDED) && device.do_notify) {
long playlist_pos = playlist_next(0);
playlist_pos -= playlist_get_first_index(NULL);
if(playlist_pos < 0)
playlist_pos += playlist_amount();
IAP_TX_INIT4(0x04, 0x0027);
IAP_TX_PUT(0x01);
IAP_TX_PUT_U32(playlist_pos);
iap_send_tx();
return;
}
}
/* Do general setup of the needed infrastructure.
*
* Please note that a lot of additional work is done by iap_start()
*/
void iap_setup(const int ratenum)
{
iap_bitrate_set(ratenum);
iap_remotebtn = BUTTON_NONE;
iap_setupflag = true;
iap_started = false;
iap_running = false;
}
/* Actually bring up the message queue, message handler thread and
* notification timer
*
* NOTE: This is running in interrupt context
*/
static void iap_start(void)
{
unsigned int tid;
if (iap_started)
return;
iap_reset_device(&device);
queue_init(&iap_queue, true);
tid = create_thread(iap_thread, thread_stack, sizeof(thread_stack),
0, "iap"
IF_PRIO(, PRIORITY_SYSTEM)
IF_COP(, CPU));
if (!tid)
panicf("Could not create iap thread");
timeout_register(&iap_task_tmo, iap_task, MS_TO_TICKS(100), (intptr_t)NULL);
add_event(PLAYBACK_EVENT_TRACK_CHANGE, iap_track_changed);
/* Since we cannot allocate memory while in interrupt context
* post a message to our own queue to get that done
*/
queue_post(&iap_queue, IAP_EV_MALLOC, 0);
iap_started = true;
}
static void iap_malloc(void)
{
#ifndef IAP_MALLOC_DYNAMIC
static unsigned char serbuf[IAP_MALLOC_SIZE];
#endif
if (iap_running)
return;
#ifdef IAP_MALLOC_DYNAMIC
iap_buffer_handle = core_alloc_ex("iap", IAP_MALLOC_SIZE, &iap_buflib_callbacks);
if (iap_buffer_handle < 0)
panicf("Could not allocate buffer memory");
iap_buffers = core_get_data(iap_buffer_handle);
#else
iap_buffers = serbuf;
#endif
iap_txstart = iap_buffers;
iap_txpayload = iap_txstart+5;
iap_txnext = iap_txpayload;
iap_rxstart = iap_buffers+(TX_BUFLEN+6);
iap_rxpayload = iap_rxstart;
iap_rxnext = iap_rxpayload;
iap_rxlen = RX_BUFLEN+2;
iap_running = true;
}
void iap_bitrate_set(const int ratenum)
{
switch(ratenum)
{
case 0:
serial_bitrate(0);
break;
case 1:
serial_bitrate(9600);
break;
case 2:
serial_bitrate(19200);
break;
case 3:
serial_bitrate(38400);
break;
case 4:
serial_bitrate(57600);
break;
}
}
/* Message format:
0xff
0x55
length
mode
command (2 bytes)
parameters (0-n bytes)
checksum (length+mode+parameters+checksum == 0)
*/
/* Send the current content of the TX buffer.
* This will check for TX buffer overflow and panic, but it might
* be too late by then (although one would have to overflow the complete
* RX buffer as well)
*/
void iap_send_tx(void)
{
int i, chksum;
ptrdiff_t txlen;
unsigned char* txstart;
txlen = iap_txnext - iap_txpayload;
if (txlen <= 0)
return;
if (txlen > TX_BUFLEN)
panicf("IAP: TX buffer overflow");
if (txlen < 256)
{
/* Short packet */
txstart = iap_txstart+2;
*(txstart+2) = txlen;
chksum = txlen;
} else {
/* Long packet */
txstart = iap_txstart;
*(txstart+2) = 0x00;
*(txstart+3) = (txlen >> 8) & 0xFF;
*(txstart+4) = (txlen) & 0xFF;
chksum = *(txstart+3) + *(txstart+4);
}
*(txstart) = 0xFF;
*(txstart+1) = 0x55;
for (i=0; i<txlen; i++)
{
chksum += iap_txpayload[i];
}
*(iap_txnext) = 0x100 - (chksum & 0xFF);
#if defined(LOGF_ENABLE) && defined(ROCKBOX_HAS_LOGF)
logf("T: %s", hexstring(txstart+3, (iap_txnext - txstart)-3));
#endif
for (i=0; i <= (iap_txnext - txstart); i++)
{
while(!tx_rdy()) ;
tx_writec(txstart[i]);
}
}
/* This is just a compatibility wrapper around the new TX buffer
* infrastructure
*/
void iap_send_pkt(const unsigned char * data, const int len)
{
if (!iap_running)
return;
iap_txnext = iap_txpayload;
IAP_TX_PUT_DATA(data, len);
iap_send_tx();
}
bool iap_getc(const unsigned char x)
{
struct state_t *s = &frame_state;
static long pkt_timeout;
if (!iap_setupflag)
return false;
/* Check the time since the last packet arrived. */
if ((s->state != ST_SYNC) && TIME_AFTER(current_tick, pkt_timeout)) {
/* Packet timeouts only make sense while not waiting for the
* sync byte */
s->state = ST_SYNC;
return iap_getc(x);
}
/* run state machine to detect and extract a valid frame */
switch (s->state) {
case ST_SYNC:
if (x == 0xFF) {
/* The IAP infrastructure is started by the first received sync
* byte. It takes a while to spin up, so do not advance the state
* machine until it has started.
*/
if (!iap_running)
{
iap_start();
break;
}
iap_rxnext = iap_rxpayload;
s->state = ST_SOF;
}
break;
case ST_SOF:
if (x == 0x55) {
/* received a valid sync/SOF pair */
s->state = ST_LEN;
} else {
s->state = ST_SYNC;
return iap_getc(x);
}
break;
case ST_LEN:
s->check = x;
s->count = 0;
if (x == 0) {
/* large packet */
s->state = ST_LENH;
} else {
/* small packet */
if (x > (iap_rxlen-2))
{
/* Packet too long for buffer */
s->state = ST_SYNC;
break;
}
s->len = x;
s->state = ST_DATA;
put_u16(iap_rxnext, s->len);
iap_rxnext += 2;
}
break;
case ST_LENH:
s->check += x;
s->len = x << 8;
s->state = ST_LENL;
break;
case ST_LENL:
s->check += x;
s->len += x;
if ((s->len == 0) || (s->len > (iap_rxlen-2))) {
/* invalid length */
s->state = ST_SYNC;
break;
} else {
s->state = ST_DATA;
put_u16(iap_rxnext, s->len);
iap_rxnext += 2;
}
break;
case ST_DATA:
s->check += x;
*(iap_rxnext++) = x;
s->count += 1;
if (s->count == s->len) {
s->state = ST_CHECK;
}
break;
case ST_CHECK:
s->check += x;
if ((s->check & 0xFF) == 0) {
/* done, received a valid frame */
iap_rxpayload = iap_rxnext;
queue_post(&iap_queue, IAP_EV_MSG_RCVD, 0);
} else {
/* Invalid frame */
}
s->state = ST_SYNC;
break;
default:
#ifdef LOGF_ENABLE
logf("Unhandled iap state %d", (int) s->state);
#else
panicf("Unhandled iap state %d", (int) s->state);
#endif
break;
}
pkt_timeout = current_tick + IAP_PKT_TIMEOUT;
/* return true while still hunting for the sync and start-of-frame byte */
return (s->state == ST_SYNC) || (s->state == ST_SOF);
}
void iap_get_trackinfo(const unsigned int track, struct mp3entry* id3)
{
int tracknum;
int fd;
struct playlist_track_info info;
tracknum = track;
tracknum += playlist_get_first_index(NULL);
if(tracknum >= playlist_amount())
tracknum -= playlist_amount();
/* If the tracknumber is not the current one,
read id3 from disk */
if(playlist_next(0) != tracknum)
{
playlist_get_track_info(NULL, tracknum, &info);
fd = open(info.filename, O_RDONLY);
memset(id3, 0, sizeof(*id3));
get_metadata(id3, fd, info.filename);
close(fd);
} else {
memcpy(id3, audio_current_track(), sizeof(*id3));
}
}
uint32_t iap_get_trackpos(void)
{
struct mp3entry *id3 = audio_current_track();
return id3->elapsed;
}
uint32_t iap_get_trackindex(void)
{
struct playlist_info* playlist = playlist_get_current();
return (playlist->index - playlist->first_index);
}
void iap_periodic(void)
{
static int count;
if(!iap_setupflag) return;
/* Handle pending authentication tasks */
switch (device.auth.state)
{
case AUST_INIT:
{
/* Send out GetDevAuthenticationInfo */
IAP_TX_INIT(0x00, 0x14);
iap_send_tx();
device.auth.state = AUST_CERTREQ;
break;
}
case AUST_CERTDONE:
{
/* Send out GetDevAuthenticationSignature, with
* 20 bytes of challenge and a retry counter of 1.
* Since we do not really care about the content of the
* challenge we just use the first 20 bytes of whatever
* is in the RX buffer right now.
*/
IAP_TX_INIT(0x00, 0x17);
IAP_TX_PUT_DATA(iap_rxstart,
(device.auth.version == 0x100) ? 16 : 20);
IAP_TX_PUT(0x01);
iap_send_tx();
device.auth.state = AUST_CHASENT;
break;
}
default:
{
break;
}
}
/* Time out button down events */
if (iap_timeoutbtn)
iap_timeoutbtn -= 1;
if (!iap_timeoutbtn)
{
iap_remotebtn = BUTTON_NONE;
iap_repeatbtn = 0;
iap_btnshuffle = false;
iap_btnrepeat = false;
}
/* Handle power down messages. */
if (iap_shutdown && device.do_power_notify)
{
/* NotifyiPodStateChange */
IAP_TX_INIT(0x00, 0x23);
IAP_TX_PUT(0x01);
iap_send_tx();
/* No further actions, we're going down */
iap_reset_device(&device);
return;
}
/* Handle GetAccessoryInfo messages */
if (device.accinfo == ACCST_INIT)
{
/* GetAccessoryInfo */
IAP_TX_INIT(0x00, 0x27);
IAP_TX_PUT(0x00);
iap_send_tx();
device.accinfo = ACCST_SENT;
}
/* Do not send requests for device information while
* an authentication is still running, this seems to
* confuse some devices
*/
if (!DEVICE_AUTH_RUNNING && (device.accinfo == ACCST_DATA))
{
int first_set;
/* Find the first bit set in the capabilities field,
* ignoring those we already asked for
*/
first_set = find_first_set_bit(device.capabilities & (~device.capabilities_queried));
if (first_set != 32)
{
/* Add bit to queried cababilities */
device.capabilities_queried |= BIT_N(first_set);
switch (first_set)
{
/* Name */
case 0x01:
/* Firmware version */
case 0x04:
/* Hardware version */
case 0x05:
/* Manufacturer */
case 0x06:
/* Model number */
case 0x07:
/* Serial number */
case 0x08:
/* Maximum payload size */
case 0x09:
{
IAP_TX_INIT(0x00, 0x27);
IAP_TX_PUT(first_set);
iap_send_tx();
break;
}
/* Minimum supported iPod firmware version */
case 0x02:
{
IAP_TX_INIT(0x00, 0x27);
IAP_TX_PUT(2);
IAP_TX_PUT_U32(IAP_IPOD_MODEL);
IAP_TX_PUT(IAP_IPOD_FIRMWARE_MAJOR);
IAP_TX_PUT(IAP_IPOD_FIRMWARE_MINOR);
IAP_TX_PUT(IAP_IPOD_FIRMWARE_REV);
iap_send_tx();
break;
}
/* Minimum supported lingo version. Queries Lingo 0 */
case 0x03:
{
IAP_TX_INIT(0x00, 0x27);
IAP_TX_PUT(3);
IAP_TX_PUT(0);
iap_send_tx();
break;
}
}
device.accinfo = ACCST_SENT;
}
}
if (!device.do_notify) return;
if ((device.notifications == 0) && (interface_state != IST_EXTENDED)) return;
/* Volume change notifications are sent every 100ms */
if (device.notifications & (BIT_N(4) | BIT_N(16))) {
/* Currently we do not track volume changes for BIT_N(16),
*
*/
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x04);
IAP_TX_PUT(0x00);
IAP_TX_PUT(0xFF &(int)((global_settings.volume + 90) * 2.65625));
device.changed_notifications |= BIT_N(4);
iap_send_tx();
}
/* All other events are sent every 500ms */
count += 1;
if (count < 5) return;
count = 0;
/* RemoteEventNotification */
/* Mode 04 PlayStatusChangeNotification */
/* Are we in Extended Mode */
if (interface_state == IST_EXTENDED) {
/* Return Track Position */
struct mp3entry *id3 = audio_current_track();
unsigned long time_elapsed = id3->elapsed;
IAP_TX_INIT4(0x04, 0x0027);
IAP_TX_PUT(0x04);
IAP_TX_PUT_U32(time_elapsed);
iap_send_tx();
}
/* Track position (ms) or Track position (s) */
if (device.notifications & (BIT_N(0) | BIT_N(15)))
{
uint32_t t;
uint16_t ts;
bool changed;
t = iap_get_trackpos();
ts = (t / 1000) & 0xFFFF;
if ((device.notifications & BIT_N(0)) && (device.trackpos_ms != t))
{
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x00);
IAP_TX_PUT_U32(t);
device.changed_notifications |= BIT_N(0);
changed = true;
iap_send_tx();
}
if ((device.notifications & BIT_N(15)) && (device.trackpos_s != ts)) {
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x0F);
IAP_TX_PUT_U16(ts);
device.changed_notifications |= BIT_N(15);
changed = true;
iap_send_tx();
}
if (changed)
{
device.trackpos_ms = t;
device.trackpos_s = ts;
}
}
/* Track index */
if (device.notifications & BIT_N(1))
{
uint32_t index;
index = iap_get_trackindex();
if (device.track_index != index) {
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x01);
IAP_TX_PUT_U32(index);
device.changed_notifications |= BIT_N(1);
iap_send_tx();
device.track_index = index;
}
}
/* Chapter index */
if (device.notifications & BIT_N(2))
{
uint32_t index;
index = iap_get_trackindex();
if (device.track_index != index)
{
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x02);
IAP_TX_PUT_U32(index);
IAP_TX_PUT_U16(0);
IAP_TX_PUT_U16(0xFFFF);
device.changed_notifications |= BIT_N(2);
iap_send_tx();
device.track_index = index;
}
}
/* Play status */
if (device.notifications & BIT_N(3))
{
unsigned char play_status;
play_status = audio_status();
if (device.play_status != play_status)
{
/* If play_status = PAUSE/STOP we should mute else
* we should unmute
* 0 = Stopped
* 1 = Playing
* 2 = Pause
* 3 = Play/Pause
*/
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x03);
if (play_status & AUDIO_STATUS_PLAY) {
/* Playing or paused */
if (play_status & AUDIO_STATUS_PAUSE) {
/* Paused */
IAP_TX_PUT(0x02);
} else {
/* Playing */
IAP_TX_PUT(0x01);
}
} else {
IAP_TX_PUT(0x00);
}
device.changed_notifications |= BIT_N(3);
iap_send_tx();
device.play_status = play_status;
if (play_status != 1) {
/* Not Playing */
audio_pause();
#if CONFIG_TUNER
if (radio_present==1) {
tuner_set(RADIO_MUTE,1);
}
#endif
} else {
/* Playing */
audio_resume();
#if CONFIG_TUNER
if (radio_present==1) {
tuner_set(RADIO_MUTE,0);
}
#endif
}
}
}
/* Power/Battery */
if (device.notifications & BIT_N(5))
{
unsigned char power_state;
unsigned char battery_l;
power_state = charger_input_state;
battery_l = battery_level();
if ((device.power_state != power_state) || (device.battery_level != battery_l))
{
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x05);
iap_fill_power_state();
device.changed_notifications |= BIT_N(5);
iap_send_tx();
device.power_state = power_state;
device.battery_level = battery_l;
}
}
/* Equalizer state
* This is not handled yet.
*
* TODO: Fix equalizer handling
*/
/* Shuffle */
if (device.notifications & BIT_N(7))
{
unsigned char shuffle;
shuffle = global_settings.playlist_shuffle;
if (device.shuffle != shuffle)
{
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x07);
IAP_TX_PUT(shuffle?0x01:0x00);
device.changed_notifications |= BIT_N(7);
iap_send_tx();
device.shuffle = shuffle;
}
}
/* Repeat */
if (device.notifications & BIT_N(8))
{
unsigned char repeat;
repeat = global_settings.repeat_mode;
if (device.repeat != repeat)
{
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x08);
switch (repeat)
{
case REPEAT_OFF:
{
IAP_TX_PUT(0x00);
break;
}
case REPEAT_ONE:
{
IAP_TX_PUT(0x01);
break;
}
case REPEAT_ALL:
{
IAP_TX_PUT(0x02);
break;
}
}
device.changed_notifications |= BIT_N(8);
iap_send_tx();
device.repeat = repeat;
}
}
/* Date/Time */
if (device.notifications & BIT_N(9))
{
struct tm* tm;
tm = get_time();
if (memcmp(tm, &(device.datetime), sizeof(struct tm)))
{
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x09);
IAP_TX_PUT_U16(tm->tm_year);
/* Month */
IAP_TX_PUT(tm->tm_mon+1);
/* Day */
IAP_TX_PUT(tm->tm_mday);
/* Hour */
IAP_TX_PUT(tm->tm_hour);
/* Minute */
IAP_TX_PUT(tm->tm_min);
device.changed_notifications |= BIT_N(9);
iap_send_tx();
memcpy(&(device.datetime), tm, sizeof(struct tm));
}
}
/* Alarm
* This is not supported yet.
*
* TODO: Fix alarm handling
*/
/* Backlight
* This is not supported yet.
*
* TODO: Fix backlight handling
*/
/* Hold switch */
if (device.notifications & BIT_N(0x0C))
{
unsigned char hold;
hold = button_hold();
if (device.hold != hold) {
IAP_TX_INIT(0x03, 0x09);
IAP_TX_PUT(0x0C);
IAP_TX_PUT(hold?0x01:0x00);
device.changed_notifications |= BIT_N(0x0C);
iap_send_tx();
device.hold = hold;
}
}
/* Sound check
* This is not supported yet.
*
* TODO: Fix sound check handling
*/
/* Audiobook check
* This is not supported yet.
*
* TODO: Fix audiobook handling
*/
}
/* Change the current interface state.
* On a change from IST_EXTENDED to IST_STANDARD, or from IST_STANDARD
* to IST_EXTENDED, pause playback, if playing
*/
void iap_interface_state_change(const enum interface_state new)
{
if (((interface_state == IST_EXTENDED) && (new == IST_STANDARD)) ||
((interface_state == IST_STANDARD) && (new == IST_EXTENDED))) {
if (audio_status() == AUDIO_STATUS_PLAY)
{
REMOTE_BUTTON(BUTTON_RC_PLAY);
}
}
interface_state = new;
}
static void iap_handlepkt_mode5(const unsigned int len, const unsigned char *buf)
{
(void) len;
unsigned int cmd = buf[1];
switch (cmd)
{
/* Sent from iPod Begin Transmission */
case 0x02:
{
/* RF Transmitter: Begin High Power transmission */
unsigned char data0[] = {0x05, 0x02};
iap_send_pkt(data0, sizeof(data0));
break;
}
/* Sent from iPod End High Power Transmission */
case 0x03:
{
/* RF Transmitter: End High Power transmission */
unsigned char data1[] = {0x05, 0x03};
iap_send_pkt(data1, sizeof(data1));
break;
}
/* Return Version Number ?*/
case 0x04:
{
/* do nothing */
break;
}
}
}
void iap_handlepkt(void)
{
int level;
int length;
if(!iap_setupflag) return;
/* if we are waiting for a remote button to go out,
delay the handling of the new packet */
if(iap_repeatbtn)
{
queue_post(&iap_queue, IAP_EV_MSG_RCVD, 0);
sleep(1);
return;
}
/* handle command by mode */
length = get_u16(iap_rxstart);
#if defined(LOGF_ENABLE) && defined(ROCKBOX_HAS_LOGF)
logf("R: %s", hexstring(iap_rxstart+2, (length)));
#endif
if (length != 0) {
unsigned char mode = *(iap_rxstart+2);
switch (mode) {
case 0: iap_handlepkt_mode0(length, iap_rxstart+2); break;
#ifdef HAVE_LINE_REC
case 1: iap_handlepkt_mode1(length, iap_rxstart+2); break;
#endif
case 2: iap_handlepkt_mode2(length, iap_rxstart+2); break;
case 3: iap_handlepkt_mode3(length, iap_rxstart+2); break;
case 4: iap_handlepkt_mode4(length, iap_rxstart+2); break;
case 5: iap_handlepkt_mode5(length, iap_rxstart+2); break;
#if CONFIG_TUNER
case 7: iap_handlepkt_mode7(length, iap_rxstart+2); break;
#endif
}
}
/* Remove the handled packet from the RX buffer
* This needs to be done with interrupts disabled, to make
* sure the buffer and the pointers into it are handled
* cleanly
*/
level = disable_irq_save();
memmove(iap_rxstart, iap_rxstart+(length+2), (RX_BUFLEN+2)-(length+2));
iap_rxnext -= (length+2);
iap_rxpayload -= (length+2);
iap_rxlen += (length+2);
restore_irq(level);
/* poke the poweroff timer */
reset_poweroff_timer();
}
int remote_control_rx(void)
{
int btn = iap_remotebtn;
if(iap_repeatbtn)
iap_repeatbtn--;
return btn;
}
const unsigned char *iap_get_serbuf(void)
{
return iap_rxstart;
}
#ifdef IAP_MALLOC_DYNAMIC
static int iap_move_callback(int handle, void* current, void* new)
{
(void) handle;
(void) current;
iap_txstart = new;
iap_txpayload = iap_txstart+5;
iap_txnext = iap_txpayload;
iap_rxstart = iap_buffers+(TX_BUFLEN+6);
return BUFLIB_CB_OK;
}
#endif
/* Change the shuffle state */
void iap_shuffle_state(const bool state)
{
/* Set shuffle to enabled */
if(state && !global_settings.playlist_shuffle)
{
global_settings.playlist_shuffle = 1;
settings_save();
if (audio_status() & AUDIO_STATUS_PLAY)
playlist_randomise(NULL, current_tick, true);
}
/* Set shuffle to disabled */
else if(!state && global_settings.playlist_shuffle)
{
global_settings.playlist_shuffle = 0;
settings_save();
if (audio_status() & AUDIO_STATUS_PLAY)
playlist_sort(NULL, true);
}
}
/* Change the repeat state */
void iap_repeat_state(const unsigned char state)
{
if (state != global_settings.repeat_mode)
{
global_settings.repeat_mode = state;
settings_save();
if (audio_status() & AUDIO_STATUS_PLAY)
audio_flush_and_reload_tracks();
}
}
void iap_repeat_next(void)
{
switch (global_settings.repeat_mode)
{
case REPEAT_OFF:
{
iap_repeat_state(REPEAT_ALL);
break;
}
case REPEAT_ALL:
{
iap_repeat_state(REPEAT_ONE);
break;
}
case REPEAT_ONE:
{
iap_repeat_state(REPEAT_OFF);
break;
}
}
}
/* This function puts the current power/battery state
* into the TX buffer. The buffer is assumed to be initialized
*/
void iap_fill_power_state(void)
{
unsigned char power_state;
unsigned char battery_l;
power_state = charger_input_state;
battery_l = battery_level();
if (power_state == NO_CHARGER) {
if (battery_l < 30) {
IAP_TX_PUT(0x00);
} else {
IAP_TX_PUT(0x01);
}
IAP_TX_PUT((char)((battery_l * 255)/100));
} else {
IAP_TX_PUT(0x04);
IAP_TX_PUT(0x00);
}
}
Reference in a new issue View git blame Copy permalink