[qemu.git] / hw / misc / cbus.c

/*
 * CBUS three-pin bus and the Retu / Betty / Tahvo / Vilma / Avilma /
 * Hinku / Vinku / Ahne / Pihi chips used in various Nokia platforms.
 * Based on reverse-engineering of a linux driver.
 *
 * Copyright (C) 2008 Nokia Corporation
 * Written by Andrzej Zaborowski <[email protected]>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 or
 * (at your option) version 3 of the License.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include "qemu/osdep.h"
#include "qemu-common.h"
#include "hw/irq.h"
#include "hw/devices.h"
#include "sysemu/sysemu.h"

//#define DEBUG

typedef struct {
    void *opaque;
    void (*io)(void *opaque, int rw, int reg, uint16_t *val);
    int addr;
} CBusSlave;

typedef struct {
    CBus cbus;

    int sel;
    int dat;
    int clk;
    int bit;
    int dir;
    uint16_t val;
    qemu_irq dat_out;

    int addr;
    int reg;
    int rw;
    enum {
        cbus_address,
        cbus_value,
    } cycle;

    CBusSlave *slave[8];
} CBusPriv;

static void cbus_io(CBusPriv *s)
{
    if (s->slave[s->addr])
        s->slave[s->addr]->io(s->slave[s->addr]->opaque,
                        s->rw, s->reg, &s->val);
    else
        hw_error("%s: bad slave address %i\n", __FUNCTION__, s->addr);
}

static void cbus_cycle(CBusPriv *s)
{
    switch (s->cycle) {
    case cbus_address:
        s->addr = (s->val >> 6) & 7;
        s->rw =   (s->val >> 5) & 1;
        s->reg =  (s->val >> 0) & 0x1f;

        s->cycle = cbus_value;
        s->bit = 15;
        s->dir = !s->rw;
        s->val = 0;

        if (s->rw)
            cbus_io(s);
        break;

    case cbus_value:
        if (!s->rw)
            cbus_io(s);

        s->cycle = cbus_address;
        s->bit = 8;
        s->dir = 1;
        s->val = 0;
        break;
    }
}

static void cbus_clk(void *opaque, int line, int level)
{
    CBusPriv *s = (CBusPriv *) opaque;

    if (!s->sel && level && !s->clk) {
        if (s->dir)
            s->val |= s->dat << (s->bit --);
        else
            qemu_set_irq(s->dat_out, (s->val >> (s->bit --)) & 1);

        if (s->bit < 0)
            cbus_cycle(s);
    }

    s->clk = level;
}

static void cbus_dat(void *opaque, int line, int level)
{
    CBusPriv *s = (CBusPriv *) opaque;

    s->dat = level;
}

static void cbus_sel(void *opaque, int line, int level)
{
    CBusPriv *s = (CBusPriv *) opaque;

    if (!level) {
        s->dir = 1;
        s->bit = 8;
        s->val = 0;
    }

    s->sel = level;
}

CBus *cbus_init(qemu_irq dat)
{
    CBusPriv *s = (CBusPriv *) g_malloc0(sizeof(*s));

    s->dat_out = dat;
    s->cbus.clk = qemu_allocate_irq(cbus_clk, s, 0);
    s->cbus.dat = qemu_allocate_irq(cbus_dat, s, 0);
    s->cbus.sel = qemu_allocate_irq(cbus_sel, s, 0);

    s->sel = 1;
    s->clk = 0;
    s->dat = 0;

    return &s->cbus;
}

void cbus_attach(CBus *bus, void *slave_opaque)
{
    CBusSlave *slave = (CBusSlave *) slave_opaque;
    CBusPriv *s = (CBusPriv *) bus;

    s->slave[slave->addr] = slave;
}

/* Retu/Vilma */
typedef struct {
    uint16_t irqst;
    uint16_t irqen;
    uint16_t cc[2];
    int channel;
    uint16_t result[16];
    uint16_t sample;
    uint16_t status;

    struct {
        uint16_t cal;
    } rtc;

    int is_vilma;
    qemu_irq irq;
    CBusSlave cbus;
} CBusRetu;

static void retu_interrupt_update(CBusRetu *s)
{
    qemu_set_irq(s->irq, s->irqst & ~s->irqen);
}

#define RETU_REG_ASICR		0x00	/* (RO) ASIC ID & revision */
#define RETU_REG_IDR		0x01	/* (T)  Interrupt ID */
#define RETU_REG_IMR		0x02	/* (RW) Interrupt mask */
#define RETU_REG_RTCDSR		0x03	/* (RW) RTC seconds register */
#define RETU_REG_RTCHMR		0x04	/* (RO) RTC hours and minutes reg */
#define RETU_REG_RTCHMAR	0x05	/* (RW) RTC hours and minutes set reg */
#define RETU_REG_RTCCALR	0x06	/* (RW) RTC calibration register */
#define RETU_REG_ADCR		0x08	/* (RW) ADC result register */
#define RETU_REG_ADCSCR		0x09	/* (RW) ADC sample control register */
#define RETU_REG_AFCR		0x0a	/* (RW) AFC register */
#define RETU_REG_ANTIFR		0x0b	/* (RW) AntiF register */
#define RETU_REG_CALIBR		0x0c	/* (RW) CalibR register*/
#define RETU_REG_CCR1		0x0d	/* (RW) Common control register 1 */
#define RETU_REG_CCR2		0x0e	/* (RW) Common control register 2 */
#define RETU_REG_RCTRL_CLR	0x0f	/* (T)  Regulator clear register */
#define RETU_REG_RCTRL_SET	0x10	/* (T)  Regulator set register */
#define RETU_REG_TXCR		0x11	/* (RW) TxC register */
#define RETU_REG_STATUS		0x16	/* (RO) Status register */
#define RETU_REG_WATCHDOG	0x17	/* (RW) Watchdog register */
#define RETU_REG_AUDTXR		0x18	/* (RW) Audio Codec Tx register */
#define RETU_REG_AUDPAR		0x19	/* (RW) AudioPA register */
#define RETU_REG_AUDRXR1	0x1a	/* (RW) Audio receive register 1 */
#define RETU_REG_AUDRXR2	0x1b	/* (RW) Audio receive register 2 */
#define RETU_REG_SGR1		0x1c	/* (RW) */
#define RETU_REG_SCR1		0x1d	/* (RW) */
#define RETU_REG_SGR2		0x1e	/* (RW) */
#define RETU_REG_SCR2		0x1f	/* (RW) */

/* Retu Interrupt sources */
enum {
    retu_int_pwr	= 0,	/* Power button */
    retu_int_char	= 1,	/* Charger */
    retu_int_rtcs	= 2,	/* Seconds */
    retu_int_rtcm	= 3,	/* Minutes */
    retu_int_rtcd	= 4,	/* Days */
    retu_int_rtca	= 5,	/* Alarm */
    retu_int_hook	= 6,	/* Hook */
    retu_int_head	= 7,	/* Headset */
    retu_int_adcs	= 8,	/* ADC sample */
};

/* Retu ADC channel wiring */
enum {
    retu_adc_bsi	= 1,	/* BSI */
    retu_adc_batt_temp	= 2,	/* Battery temperature */
    retu_adc_chg_volt	= 3,	/* Charger voltage */
    retu_adc_head_det	= 4,	/* Headset detection */
    retu_adc_hook_det	= 5,	/* Hook detection */
    retu_adc_rf_gp	= 6,	/* RF GP */
    retu_adc_tx_det	= 7,	/* Wideband Tx detection */
    retu_adc_batt_volt	= 8,	/* Battery voltage */
    retu_adc_sens	= 10,	/* Light sensor */
    retu_adc_sens_temp	= 11,	/* Light sensor temperature */
    retu_adc_bbatt_volt	= 12,	/* Backup battery voltage */
    retu_adc_self_temp	= 13,	/* RETU temperature */
};

static inline uint16_t retu_read(CBusRetu *s, int reg)
{
#ifdef DEBUG
    printf("RETU read at %02x\n", reg);
#endif

    switch (reg) {
    case RETU_REG_ASICR:
        return 0x0215 | (s->is_vilma << 7);

    case RETU_REG_IDR:	/* TODO: Or is this ffs(s->irqst)?  */
        return s->irqst;

    case RETU_REG_IMR:
        return s->irqen;

    case RETU_REG_RTCDSR:
    case RETU_REG_RTCHMR:
    case RETU_REG_RTCHMAR:
        /* TODO */
        return 0x0000;

    case RETU_REG_RTCCALR:
        return s->rtc.cal;

    case RETU_REG_ADCR:
        return (s->channel << 10) | s->result[s->channel];
    case RETU_REG_ADCSCR:
        return s->sample;

    case RETU_REG_AFCR:
    case RETU_REG_ANTIFR:
    case RETU_REG_CALIBR:
        /* TODO */
        return 0x0000;

    case RETU_REG_CCR1:
        return s->cc[0];
    case RETU_REG_CCR2:
        return s->cc[1];

    case RETU_REG_RCTRL_CLR:
    case RETU_REG_RCTRL_SET:
    case RETU_REG_TXCR:
        /* TODO */
        return 0x0000;

    case RETU_REG_STATUS:
        return s->status;

    case RETU_REG_WATCHDOG:
    case RETU_REG_AUDTXR:
    case RETU_REG_AUDPAR:
    case RETU_REG_AUDRXR1:
    case RETU_REG_AUDRXR2:
    case RETU_REG_SGR1:
    case RETU_REG_SCR1:
    case RETU_REG_SGR2:
    case RETU_REG_SCR2:
        /* TODO */
        return 0x0000;

    default:
        hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
    }
}

static inline void retu_write(CBusRetu *s, int reg, uint16_t val)
{
#ifdef DEBUG
    printf("RETU write of %04x at %02x\n", val, reg);
#endif

    switch (reg) {
    case RETU_REG_IDR:
        s->irqst ^= val;
        retu_interrupt_update(s);
        break;

    case RETU_REG_IMR:
        s->irqen = val;
        retu_interrupt_update(s);
        break;

    case RETU_REG_RTCDSR:
    case RETU_REG_RTCHMAR:
        /* TODO */
        break;

    case RETU_REG_RTCCALR:
        s->rtc.cal = val;
        break;

    case RETU_REG_ADCR:
        s->channel = (val >> 10) & 0xf;
        s->irqst |= 1 << retu_int_adcs;
        retu_interrupt_update(s);
        break;
    case RETU_REG_ADCSCR:
        s->sample &= ~val;
        break;

    case RETU_REG_AFCR:
    case RETU_REG_ANTIFR:
    case RETU_REG_CALIBR:

    case RETU_REG_CCR1:
        s->cc[0] = val;
        break;
    case RETU_REG_CCR2:
        s->cc[1] = val;
        break;

    case RETU_REG_RCTRL_CLR:
    case RETU_REG_RCTRL_SET:
        /* TODO */
        break;

    case RETU_REG_WATCHDOG:
        if (val == 0 && (s->cc[0] & 2))
            qemu_system_shutdown_request();
        break;

    case RETU_REG_TXCR:
    case RETU_REG_AUDTXR:
    case RETU_REG_AUDPAR:
    case RETU_REG_AUDRXR1:
    case RETU_REG_AUDRXR2:
    case RETU_REG_SGR1:
    case RETU_REG_SCR1:
    case RETU_REG_SGR2:
    case RETU_REG_SCR2:
        /* TODO */
        break;

    default:
        hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
    }
}

static void retu_io(void *opaque, int rw, int reg, uint16_t *val)
{
    CBusRetu *s = (CBusRetu *) opaque;

    if (rw)
        *val = retu_read(s, reg);
    else
        retu_write(s, reg, *val);
}

void *retu_init(qemu_irq irq, int vilma)
{
    CBusRetu *s = (CBusRetu *) g_malloc0(sizeof(*s));

    s->irq = irq;
    s->irqen = 0xffff;
    s->irqst = 0x0000;
    s->status = 0x0020;
    s->is_vilma = !!vilma;
    s->rtc.cal = 0x01;
    s->result[retu_adc_bsi] = 0x3c2;
    s->result[retu_adc_batt_temp] = 0x0fc;
    s->result[retu_adc_chg_volt] = 0x165;
    s->result[retu_adc_head_det] = 123;
    s->result[retu_adc_hook_det] = 1023;
    s->result[retu_adc_rf_gp] = 0x11;
    s->result[retu_adc_tx_det] = 0x11;
    s->result[retu_adc_batt_volt] = 0x250;
    s->result[retu_adc_sens] = 2;
    s->result[retu_adc_sens_temp] = 0x11;
    s->result[retu_adc_bbatt_volt] = 0x3d0;
    s->result[retu_adc_self_temp] = 0x330;

    s->cbus.opaque = s;
    s->cbus.io = retu_io;
    s->cbus.addr = 1;

    return &s->cbus;
}

void retu_key_event(void *retu, int state)
{
    CBusSlave *slave = (CBusSlave *) retu;
    CBusRetu *s = (CBusRetu *) slave->opaque;

    s->irqst |= 1 << retu_int_pwr;
    retu_interrupt_update(s);

    if (state)
        s->status &= ~(1 << 5);
    else
        s->status |= 1 << 5;
}

#if 0
static void retu_head_event(void *retu, int state)
{
    CBusSlave *slave = (CBusSlave *) retu;
    CBusRetu *s = (CBusRetu *) slave->opaque;

    if ((s->cc[0] & 0x500) == 0x500) {	/* TODO: Which bits? */
        /* TODO: reissue the interrupt every 100ms or so.  */
        s->irqst |= 1 << retu_int_head;
        retu_interrupt_update(s);
    }

    if (state)
        s->result[retu_adc_head_det] = 50;
    else
        s->result[retu_adc_head_det] = 123;
}

static void retu_hook_event(void *retu, int state)
{
    CBusSlave *slave = (CBusSlave *) retu;
    CBusRetu *s = (CBusRetu *) slave->opaque;

    if ((s->cc[0] & 0x500) == 0x500) {
        /* TODO: reissue the interrupt every 100ms or so.  */
        s->irqst |= 1 << retu_int_hook;
        retu_interrupt_update(s);
    }

    if (state)
        s->result[retu_adc_hook_det] = 50;
    else
        s->result[retu_adc_hook_det] = 123;
}
#endif

/* Tahvo/Betty */
typedef struct {
    uint16_t irqst;
    uint16_t irqen;
    uint8_t charger;
    uint8_t backlight;
    uint16_t usbr;
    uint16_t power;

    int is_betty;
    qemu_irq irq;
    CBusSlave cbus;
} CBusTahvo;

static void tahvo_interrupt_update(CBusTahvo *s)
{
    qemu_set_irq(s->irq, s->irqst & ~s->irqen);
}

#define TAHVO_REG_ASICR		0x00	/* (RO) ASIC ID & revision */
#define TAHVO_REG_IDR		0x01	/* (T)  Interrupt ID */
#define TAHVO_REG_IDSR		0x02	/* (RO) Interrupt status */
#define TAHVO_REG_IMR		0x03	/* (RW) Interrupt mask */
#define TAHVO_REG_CHAPWMR	0x04	/* (RW) Charger PWM */
#define TAHVO_REG_LEDPWMR	0x05	/* (RW) LED PWM */
#define TAHVO_REG_USBR		0x06	/* (RW) USB control */
#define TAHVO_REG_RCR		0x07	/* (RW) Some kind of power management */
#define TAHVO_REG_CCR1		0x08	/* (RW) Common control register 1 */
#define TAHVO_REG_CCR2		0x09	/* (RW) Common control register 2 */
#define TAHVO_REG_TESTR1	0x0a	/* (RW) Test register 1 */
#define TAHVO_REG_TESTR2	0x0b	/* (RW) Test register 2 */
#define TAHVO_REG_NOPR		0x0c	/* (RW) Number of periods */
#define TAHVO_REG_FRR		0x0d	/* (RO) FR */

static inline uint16_t tahvo_read(CBusTahvo *s, int reg)
{
#ifdef DEBUG
    printf("TAHVO read at %02x\n", reg);
#endif

    switch (reg) {
    case TAHVO_REG_ASICR:
        return 0x0021 | (s->is_betty ? 0x0b00 : 0x0300);	/* 22 in N810 */

    case TAHVO_REG_IDR:
    case TAHVO_REG_IDSR:	/* XXX: what does this do?  */
        return s->irqst;

    case TAHVO_REG_IMR:
        return s->irqen;

    case TAHVO_REG_CHAPWMR:
        return s->charger;

    case TAHVO_REG_LEDPWMR:
        return s->backlight;

    case TAHVO_REG_USBR:
        return s->usbr;

    case TAHVO_REG_RCR:
        return s->power;

    case TAHVO_REG_CCR1:
    case TAHVO_REG_CCR2:
    case TAHVO_REG_TESTR1:
    case TAHVO_REG_TESTR2:
    case TAHVO_REG_NOPR:
    case TAHVO_REG_FRR:
        return 0x0000;

    default:
        hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
    }
}

static inline void tahvo_write(CBusTahvo *s, int reg, uint16_t val)
{
#ifdef DEBUG
    printf("TAHVO write of %04x at %02x\n", val, reg);
#endif

    switch (reg) {
    case TAHVO_REG_IDR:
        s->irqst ^= val;
        tahvo_interrupt_update(s);
        break;

    case TAHVO_REG_IMR:
        s->irqen = val;
        tahvo_interrupt_update(s);
        break;

    case TAHVO_REG_CHAPWMR:
        s->charger = val;
        break;

    case TAHVO_REG_LEDPWMR:
        if (s->backlight != (val & 0x7f)) {
            s->backlight = val & 0x7f;
            printf("%s: LCD backlight now at %i / 127\n",
                            __FUNCTION__, s->backlight);
        }
        break;

    case TAHVO_REG_USBR:
        s->usbr = val;
        break;

    case TAHVO_REG_RCR:
        s->power = val;
        break;

    case TAHVO_REG_CCR1:
    case TAHVO_REG_CCR2:
    case TAHVO_REG_TESTR1:
    case TAHVO_REG_TESTR2:
    case TAHVO_REG_NOPR:
    case TAHVO_REG_FRR:
        break;

    default:
        hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
    }
}

static void tahvo_io(void *opaque, int rw, int reg, uint16_t *val)
{
    CBusTahvo *s = (CBusTahvo *) opaque;

    if (rw)
        *val = tahvo_read(s, reg);
    else
        tahvo_write(s, reg, *val);
}

void *tahvo_init(qemu_irq irq, int betty)
{
    CBusTahvo *s = (CBusTahvo *) g_malloc0(sizeof(*s));

    s->irq = irq;
    s->irqen = 0xffff;
    s->irqst = 0x0000;
    s->is_betty = !!betty;

    s->cbus.opaque = s;
    s->cbus.io = tahvo_io;
    s->cbus.addr = 2;

    return &s->cbus;
}
Commit	Line	Data
7e7c5e4c AZ	1	/*
	2	* CBUS three-pin bus and the Retu / Betty / Tahvo / Vilma / Avilma /
	3	* Hinku / Vinku / Ahne / Pihi chips used in various Nokia platforms.
	4	* Based on reverse-engineering of a linux driver.
	5	*
	6	* Copyright (C) 2008 Nokia Corporation
	7	* Written by Andrzej Zaborowski <[email protected]>
	8	*
	9	* This program is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU General Public License as
	11	* published by the Free Software Foundation; either version 2 or
	12	* (at your option) version 3 of the License.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
fad6cb1a	19	* You should have received a copy of the GNU General Public License along
8167ee88	20	* with this program; if not, see <http://www.gnu.org/licenses/>.
7e7c5e4c AZ	21	*/
7e7c5e4c AZ	22
0d1c9782	23	#include "qemu/osdep.h"
7e7c5e4c	24	#include "qemu-common.h"
83c9f4ca	25	#include "hw/irq.h"
bd2be150	26	#include "hw/devices.h"
9c17d615	27	#include "sysemu/sysemu.h"
7e7c5e4c AZ	28
	29	//#define DEBUG
	30
bc24a225 PB	31	typedef struct {
	32	void *opaque;
	33	void (io)(void opaque, int rw, int reg, uint16_t *val);
	34	int addr;
	35	} CBusSlave;
	36
	37	typedef struct {
	38	CBus cbus;
7e7c5e4c AZ	39
	40	int sel;
	41	int dat;
	42	int clk;
	43	int bit;
	44	int dir;
	45	uint16_t val;
	46	qemu_irq dat_out;
	47
	48	int addr;
	49	int reg;
	50	int rw;
	51	enum {
	52	cbus_address,
	53	cbus_value,
	54	} cycle;
	55
bc24a225 PB	56	CBusSlave *slave[8];
bc24a225 PB	57	} CBusPriv;
7e7c5e4c	58
bc24a225	59	static void cbus_io(CBusPriv *s)
7e7c5e4c AZ	60	{
	61	if (s->slave[s->addr])
	62	s->slave[s->addr]->io(s->slave[s->addr]->opaque,
	63	s->rw, s->reg, &s->val);
	64	else
2ac71179	65	hw_error("%s: bad slave address %i\n", __FUNCTION__, s->addr);
7e7c5e4c AZ	66	}
7e7c5e4c AZ	67
bc24a225	68	static void cbus_cycle(CBusPriv *s)
7e7c5e4c AZ	69	{
	70	switch (s->cycle) {
	71	case cbus_address:
	72	s->addr = (s->val >> 6) & 7;
	73	s->rw = (s->val >> 5) & 1;
	74	s->reg = (s->val >> 0) & 0x1f;
	75
	76	s->cycle = cbus_value;
	77	s->bit = 15;
	78	s->dir = !s->rw;
	79	s->val = 0;
	80
	81	if (s->rw)
	82	cbus_io(s);
	83	break;
	84
	85	case cbus_value:
	86	if (!s->rw)
	87	cbus_io(s);
	88
	89	s->cycle = cbus_address;
	90	s->bit = 8;
	91	s->dir = 1;
	92	s->val = 0;
	93	break;
	94	}
	95	}
	96
	97	static void cbus_clk(void *opaque, int line, int level)
	98	{
bc24a225	99	CBusPriv s = (CBusPriv ) opaque;
7e7c5e4c AZ	100
	101	if (!s->sel && level && !s->clk) {
	102	if (s->dir)
	103	s->val \|= s->dat << (s->bit --);
	104	else
	105	qemu_set_irq(s->dat_out, (s->val >> (s->bit --)) & 1);
	106
	107	if (s->bit < 0)
	108	cbus_cycle(s);
	109	}
	110
	111	s->clk = level;
	112	}
	113
	114	static void cbus_dat(void *opaque, int line, int level)
	115	{
bc24a225	116	CBusPriv s = (CBusPriv ) opaque;
7e7c5e4c AZ	117
	118	s->dat = level;
	119	}
	120
	121	static void cbus_sel(void *opaque, int line, int level)
	122	{
bc24a225	123	CBusPriv s = (CBusPriv ) opaque;
7e7c5e4c AZ	124
	125	if (!level) {
	126	s->dir = 1;
	127	s->bit = 8;
	128	s->val = 0;
	129	}
	130
	131	s->sel = level;
	132	}
	133
bc24a225	134	CBus *cbus_init(qemu_irq dat)
7e7c5e4c	135	{
7267c094	136	CBusPriv s = (CBusPriv ) g_malloc0(sizeof(*s));
7e7c5e4c AZ	137
7e7c5e4c AZ	138	s->dat_out = dat;
f3c7d038 AF	139	s->cbus.clk = qemu_allocate_irq(cbus_clk, s, 0);
	140	s->cbus.dat = qemu_allocate_irq(cbus_dat, s, 0);
	141	s->cbus.sel = qemu_allocate_irq(cbus_sel, s, 0);
7e7c5e4c AZ	142
	143	s->sel = 1;
	144	s->clk = 0;
	145	s->dat = 0;
	146
	147	return &s->cbus;
	148	}
	149
bc24a225	150	void cbus_attach(CBus bus, void slave_opaque)
7e7c5e4c	151	{
bc24a225 PB	152	CBusSlave slave = (CBusSlave ) slave_opaque;
bc24a225 PB	153	CBusPriv s = (CBusPriv ) bus;
7e7c5e4c AZ	154
	155	s->slave[slave->addr] = slave;
	156	}
	157
	158	/* Retu/Vilma */
bc24a225	159	typedef struct {
7e7c5e4c AZ	160	uint16_t irqst;
	161	uint16_t irqen;
	162	uint16_t cc[2];
	163	int channel;
	164	uint16_t result[16];
	165	uint16_t sample;
	166	uint16_t status;
	167
	168	struct {
	169	uint16_t cal;
	170	} rtc;
	171
	172	int is_vilma;
	173	qemu_irq irq;
bc24a225 PB	174	CBusSlave cbus;
bc24a225 PB	175	} CBusRetu;
7e7c5e4c	176
bc24a225	177	static void retu_interrupt_update(CBusRetu *s)
7e7c5e4c AZ	178	{
	179	qemu_set_irq(s->irq, s->irqst & ~s->irqen);
	180	}
	181
	182	#define RETU_REG_ASICR 0x00 /* (RO) ASIC ID & revision */
	183	#define RETU_REG_IDR 0x01 /* (T) Interrupt ID */
	184	#define RETU_REG_IMR 0x02 /* (RW) Interrupt mask */
	185	#define RETU_REG_RTCDSR 0x03 /* (RW) RTC seconds register */
	186	#define RETU_REG_RTCHMR 0x04 /* (RO) RTC hours and minutes reg */
	187	#define RETU_REG_RTCHMAR 0x05 /* (RW) RTC hours and minutes set reg */
	188	#define RETU_REG_RTCCALR 0x06 /* (RW) RTC calibration register */
	189	#define RETU_REG_ADCR 0x08 /* (RW) ADC result register */
	190	#define RETU_REG_ADCSCR 0x09 /* (RW) ADC sample control register */
	191	#define RETU_REG_AFCR 0x0a /* (RW) AFC register */
	192	#define RETU_REG_ANTIFR 0x0b /* (RW) AntiF register */
	193	#define RETU_REG_CALIBR 0x0c /* (RW) CalibR register*/
	194	#define RETU_REG_CCR1 0x0d /* (RW) Common control register 1 */
	195	#define RETU_REG_CCR2 0x0e /* (RW) Common control register 2 */
	196	#define RETU_REG_RCTRL_CLR 0x0f /* (T) Regulator clear register */
	197	#define RETU_REG_RCTRL_SET 0x10 /* (T) Regulator set register */
	198	#define RETU_REG_TXCR 0x11 /* (RW) TxC register */
	199	#define RETU_REG_STATUS 0x16 /* (RO) Status register */
	200	#define RETU_REG_WATCHDOG 0x17 /* (RW) Watchdog register */
	201	#define RETU_REG_AUDTXR 0x18 /* (RW) Audio Codec Tx register */
	202	#define RETU_REG_AUDPAR 0x19 /* (RW) AudioPA register */
	203	#define RETU_REG_AUDRXR1 0x1a /* (RW) Audio receive register 1 */
	204	#define RETU_REG_AUDRXR2 0x1b /* (RW) Audio receive register 2 */
	205	#define RETU_REG_SGR1 0x1c /* (RW) */
	206	#define RETU_REG_SCR1 0x1d /* (RW) */
	207	#define RETU_REG_SGR2 0x1e /* (RW) */
	208	#define RETU_REG_SCR2 0x1f /* (RW) */
	209
	210	/* Retu Interrupt sources */
	211	enum {
	212	retu_int_pwr = 0, /* Power button */
	213	retu_int_char = 1, /* Charger */
	214	retu_int_rtcs = 2, /* Seconds */
	215	retu_int_rtcm = 3, /* Minutes */
	216	retu_int_rtcd = 4, /* Days */
	217	retu_int_rtca = 5, /* Alarm */
	218	retu_int_hook = 6, /* Hook */
	219	retu_int_head = 7, /* Headset */
	220	retu_int_adcs = 8, /* ADC sample */
	221	};
	222
	223	/* Retu ADC channel wiring */
	224	enum {
	225	retu_adc_bsi = 1, /* BSI */
	226	retu_adc_batt_temp = 2, /* Battery temperature */
	227	retu_adc_chg_volt = 3, /* Charger voltage */
	228	retu_adc_head_det = 4, /* Headset detection */
	229	retu_adc_hook_det = 5, /* Hook detection */
	230	retu_adc_rf_gp = 6, /* RF GP */
	231	retu_adc_tx_det = 7, /* Wideband Tx detection */
	232	retu_adc_batt_volt = 8, /* Battery voltage */
	233	retu_adc_sens = 10, /* Light sensor */
	234	retu_adc_sens_temp = 11, /* Light sensor temperature */
	235	retu_adc_bbatt_volt = 12, /* Backup battery voltage */
	236	retu_adc_self_temp = 13, /* RETU temperature */
	237	};
	238
bc24a225	239	static inline uint16_t retu_read(CBusRetu *s, int reg)
7e7c5e4c AZ	240	{
	241	#ifdef DEBUG
	242	printf("RETU read at %02x\n", reg);
	243	#endif
	244
	245	switch (reg) {
	246	case RETU_REG_ASICR:
	247	return 0x0215 \| (s->is_vilma << 7);
	248
	249	case RETU_REG_IDR: /* TODO: Or is this ffs(s->irqst)? */
	250	return s->irqst;
	251
	252	case RETU_REG_IMR:
	253	return s->irqen;
	254
	255	case RETU_REG_RTCDSR:
	256	case RETU_REG_RTCHMR:
	257	case RETU_REG_RTCHMAR:
	258	/* TODO */
	259	return 0x0000;
	260
	261	case RETU_REG_RTCCALR:
	262	return s->rtc.cal;
	263
	264	case RETU_REG_ADCR:
	265	return (s->channel << 10) \| s->result[s->channel];
	266	case RETU_REG_ADCSCR:
	267	return s->sample;
	268
	269	case RETU_REG_AFCR:
	270	case RETU_REG_ANTIFR:
	271	case RETU_REG_CALIBR:
	272	/* TODO */
	273	return 0x0000;
	274
	275	case RETU_REG_CCR1:
	276	return s->cc[0];
	277	case RETU_REG_CCR2:
	278	return s->cc[1];
	279
	280	case RETU_REG_RCTRL_CLR:
	281	case RETU_REG_RCTRL_SET:
	282	case RETU_REG_TXCR:
	283	/* TODO */
	284	return 0x0000;
	285
	286	case RETU_REG_STATUS:
	287	return s->status;
	288
	289	case RETU_REG_WATCHDOG:
	290	case RETU_REG_AUDTXR:
	291	case RETU_REG_AUDPAR:
	292	case RETU_REG_AUDRXR1:
	293	case RETU_REG_AUDRXR2:
	294	case RETU_REG_SGR1:
	295	case RETU_REG_SCR1:
	296	case RETU_REG_SGR2:
	297	case RETU_REG_SCR2:
	298	/* TODO */
	299	return 0x0000;
	300
	301	default:
2ac71179	302	hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
7e7c5e4c AZ	303	}
	304	}
	305
bc24a225	306	static inline void retu_write(CBusRetu *s, int reg, uint16_t val)
7e7c5e4c AZ	307	{
	308	#ifdef DEBUG
	309	printf("RETU write of %04x at %02x\n", val, reg);
	310	#endif
	311
	312	switch (reg) {
	313	case RETU_REG_IDR:
	314	s->irqst ^= val;
	315	retu_interrupt_update(s);
	316	break;
	317
	318	case RETU_REG_IMR:
	319	s->irqen = val;
	320	retu_interrupt_update(s);
	321	break;
	322
	323	case RETU_REG_RTCDSR:
	324	case RETU_REG_RTCHMAR:
	325	/* TODO */
	326	break;
	327
	328	case RETU_REG_RTCCALR:
	329	s->rtc.cal = val;
	330	break;
	331
	332	case RETU_REG_ADCR:
	333	s->channel = (val >> 10) & 0xf;
	334	s->irqst \|= 1 << retu_int_adcs;
	335	retu_interrupt_update(s);
	336	break;
	337	case RETU_REG_ADCSCR:
	338	s->sample &= ~val;
	339	break;
	340
	341	case RETU_REG_AFCR:
	342	case RETU_REG_ANTIFR:
	343	case RETU_REG_CALIBR:
	344
	345	case RETU_REG_CCR1:
	346	s->cc[0] = val;
	347	break;
	348	case RETU_REG_CCR2:
	349	s->cc[1] = val;
	350	break;
	351
	352	case RETU_REG_RCTRL_CLR:
	353	case RETU_REG_RCTRL_SET:
	354	/* TODO */
	355	break;
	356
	357	case RETU_REG_WATCHDOG:
	358	if (val == 0 && (s->cc[0] & 2))
	359	qemu_system_shutdown_request();
	360	break;
	361
	362	case RETU_REG_TXCR:
	363	case RETU_REG_AUDTXR:
	364	case RETU_REG_AUDPAR:
	365	case RETU_REG_AUDRXR1:
	366	case RETU_REG_AUDRXR2:
	367	case RETU_REG_SGR1:
	368	case RETU_REG_SCR1:
	369	case RETU_REG_SGR2:
	370	case RETU_REG_SCR2:
371	/* TODO */
372	break;
373
374	default:
2ac71179	375	hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
7e7c5e4c AZ	376	}
	377	}
	378
	379	static void retu_io(void opaque, int rw, int reg, uint16_t val)
	380	{
bc24a225	381	CBusRetu s = (CBusRetu ) opaque;
7e7c5e4c AZ	382
	383	if (rw)
	384	*val = retu_read(s, reg);
	385	else
	386	retu_write(s, reg, *val);
	387	}
	388
	389	void *retu_init(qemu_irq irq, int vilma)
	390	{
7267c094	391	CBusRetu s = (CBusRetu ) g_malloc0(sizeof(*s));
7e7c5e4c AZ	392
	393	s->irq = irq;
	394	s->irqen = 0xffff;
	395	s->irqst = 0x0000;
	396	s->status = 0x0020;
	397	s->is_vilma = !!vilma;
	398	s->rtc.cal = 0x01;
	399	s->result[retu_adc_bsi] = 0x3c2;
	400	s->result[retu_adc_batt_temp] = 0x0fc;
	401	s->result[retu_adc_chg_volt] = 0x165;
	402	s->result[retu_adc_head_det] = 123;
	403	s->result[retu_adc_hook_det] = 1023;
	404	s->result[retu_adc_rf_gp] = 0x11;
	405	s->result[retu_adc_tx_det] = 0x11;
	406	s->result[retu_adc_batt_volt] = 0x250;
	407	s->result[retu_adc_sens] = 2;
	408	s->result[retu_adc_sens_temp] = 0x11;
	409	s->result[retu_adc_bbatt_volt] = 0x3d0;
	410	s->result[retu_adc_self_temp] = 0x330;
	411
	412	s->cbus.opaque = s;
	413	s->cbus.io = retu_io;
	414	s->cbus.addr = 1;
	415
	416	return &s->cbus;
	417	}
	418
	419	void retu_key_event(void *retu, int state)
	420	{
bc24a225 PB	421	CBusSlave slave = (CBusSlave ) retu;
bc24a225 PB	422	CBusRetu s = (CBusRetu ) slave->opaque;
7e7c5e4c AZ	423
	424	s->irqst \|= 1 << retu_int_pwr;
	425	retu_interrupt_update(s);
	426
	427	if (state)
	428	s->status &= ~(1 << 5);
	429	else
	430	s->status \|= 1 << 5;
	431	}
	432
b1d8e52e BS	433	#if 0
b1d8e52e BS	434	static void retu_head_event(void *retu, int state)
7e7c5e4c	435	{
bc24a225 PB	436	CBusSlave slave = (CBusSlave ) retu;
bc24a225 PB	437	CBusRetu s = (CBusRetu ) slave->opaque;
7e7c5e4c AZ	438
	439	if ((s->cc[0] & 0x500) == 0x500) { /* TODO: Which bits? */
	440	/* TODO: reissue the interrupt every 100ms or so. */
	441	s->irqst \|= 1 << retu_int_head;
	442	retu_interrupt_update(s);
	443	}
	444
	445	if (state)
	446	s->result[retu_adc_head_det] = 50;
	447	else
	448	s->result[retu_adc_head_det] = 123;
	449	}
	450
b1d8e52e	451	static void retu_hook_event(void *retu, int state)
7e7c5e4c	452	{
bc24a225 PB	453	CBusSlave slave = (CBusSlave ) retu;
bc24a225 PB	454	CBusRetu s = (CBusRetu ) slave->opaque;
7e7c5e4c AZ	455
	456	if ((s->cc[0] & 0x500) == 0x500) {
	457	/* TODO: reissue the interrupt every 100ms or so. */
	458	s->irqst \|= 1 << retu_int_hook;
	459	retu_interrupt_update(s);
	460	}
	461
	462	if (state)
	463	s->result[retu_adc_hook_det] = 50;
	464	else
	465	s->result[retu_adc_hook_det] = 123;
	466	}
b1d8e52e	467	#endif
7e7c5e4c AZ	468
7e7c5e4c AZ	469	/* Tahvo/Betty */
bc24a225	470	typedef struct {
7e7c5e4c AZ	471	uint16_t irqst;
	472	uint16_t irqen;
	473	uint8_t charger;
	474	uint8_t backlight;
	475	uint16_t usbr;
	476	uint16_t power;
	477
	478	int is_betty;
	479	qemu_irq irq;
bc24a225 PB	480	CBusSlave cbus;
bc24a225 PB	481	} CBusTahvo;
7e7c5e4c	482
bc24a225	483	static void tahvo_interrupt_update(CBusTahvo *s)
7e7c5e4c AZ	484	{
	485	qemu_set_irq(s->irq, s->irqst & ~s->irqen);
	486	}
	487
	488	#define TAHVO_REG_ASICR 0x00 /* (RO) ASIC ID & revision */
	489	#define TAHVO_REG_IDR 0x01 /* (T) Interrupt ID */
	490	#define TAHVO_REG_IDSR 0x02 /* (RO) Interrupt status */
	491	#define TAHVO_REG_IMR 0x03 /* (RW) Interrupt mask */
	492	#define TAHVO_REG_CHAPWMR 0x04 /* (RW) Charger PWM */
	493	#define TAHVO_REG_LEDPWMR 0x05 /* (RW) LED PWM */
	494	#define TAHVO_REG_USBR 0x06 /* (RW) USB control */
	495	#define TAHVO_REG_RCR 0x07 /* (RW) Some kind of power management */
	496	#define TAHVO_REG_CCR1 0x08 /* (RW) Common control register 1 */
	497	#define TAHVO_REG_CCR2 0x09 /* (RW) Common control register 2 */
	498	#define TAHVO_REG_TESTR1 0x0a /* (RW) Test register 1 */
	499	#define TAHVO_REG_TESTR2 0x0b /* (RW) Test register 2 */
	500	#define TAHVO_REG_NOPR 0x0c /* (RW) Number of periods */
	501	#define TAHVO_REG_FRR 0x0d /* (RO) FR */
	502
bc24a225	503	static inline uint16_t tahvo_read(CBusTahvo *s, int reg)
7e7c5e4c AZ	504	{
	505	#ifdef DEBUG
	506	printf("TAHVO read at %02x\n", reg);
	507	#endif
	508
	509	switch (reg) {
	510	case TAHVO_REG_ASICR:
	511	return 0x0021 \| (s->is_betty ? 0x0b00 : 0x0300); /* 22 in N810 */
	512
	513	case TAHVO_REG_IDR:
	514	case TAHVO_REG_IDSR: /* XXX: what does this do? */
	515	return s->irqst;
	516
	517	case TAHVO_REG_IMR:
	518	return s->irqen;
	519
	520	case TAHVO_REG_CHAPWMR:
	521	return s->charger;
	522
	523	case TAHVO_REG_LEDPWMR:
	524	return s->backlight;
	525
	526	case TAHVO_REG_USBR:
	527	return s->usbr;
	528
	529	case TAHVO_REG_RCR:
	530	return s->power;
	531
	532	case TAHVO_REG_CCR1:
	533	case TAHVO_REG_CCR2:
	534	case TAHVO_REG_TESTR1:
	535	case TAHVO_REG_TESTR2:
	536	case TAHVO_REG_NOPR:
	537	case TAHVO_REG_FRR:
	538	return 0x0000;
	539
	540	default:
2ac71179	541	hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
7e7c5e4c AZ	542	}
	543	}
	544
bc24a225	545	static inline void tahvo_write(CBusTahvo *s, int reg, uint16_t val)
7e7c5e4c AZ	546	{
	547	#ifdef DEBUG
	548	printf("TAHVO write of %04x at %02x\n", val, reg);
	549	#endif
	550
	551	switch (reg) {
	552	case TAHVO_REG_IDR:
	553	s->irqst ^= val;
	554	tahvo_interrupt_update(s);
	555	break;
	556
	557	case TAHVO_REG_IMR:
	558	s->irqen = val;
	559	tahvo_interrupt_update(s);
	560	break;
	561
	562	case TAHVO_REG_CHAPWMR:
	563	s->charger = val;
	564	break;
	565
	566	case TAHVO_REG_LEDPWMR:
	567	if (s->backlight != (val & 0x7f)) {
	568	s->backlight = val & 0x7f;
	569	printf("%s: LCD backlight now at %i / 127\n",
	570	__FUNCTION__, s->backlight);
	571	}
	572	break;
	573
	574	case TAHVO_REG_USBR:
	575	s->usbr = val;
	576	break;
	577
	578	case TAHVO_REG_RCR:
	579	s->power = val;
	580	break;
	581
	582	case TAHVO_REG_CCR1:
	583	case TAHVO_REG_CCR2:
	584	case TAHVO_REG_TESTR1:
	585	case TAHVO_REG_TESTR2:
	586	case TAHVO_REG_NOPR:
	587	case TAHVO_REG_FRR:
	588	break;
	589
	590	default:
2ac71179	591	hw_error("%s: bad register %02x\n", __FUNCTION__, reg);
7e7c5e4c AZ	592	}
	593	}
	594
	595	static void tahvo_io(void opaque, int rw, int reg, uint16_t val)
	596	{
bc24a225	597	CBusTahvo s = (CBusTahvo ) opaque;
7e7c5e4c AZ	598
	599	if (rw)
	600	*val = tahvo_read(s, reg);
	601	else
	602	tahvo_write(s, reg, *val);
	603	}
	604
	605	void *tahvo_init(qemu_irq irq, int betty)
	606	{
7267c094	607	CBusTahvo s = (CBusTahvo ) g_malloc0(sizeof(*s));
7e7c5e4c AZ	608
	609	s->irq = irq;
	610	s->irqen = 0xffff;
	611	s->irqst = 0x0000;
	612	s->is_betty = !!betty;
	613
	614	s->cbus.opaque = s;
	615	s->cbus.io = tahvo_io;
	616	s->cbus.addr = 2;
	617
	618	return &s->cbus;
	619	}