* 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, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
- * MA 02111-1307 USA
+ * 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 "hw.h"
#define VERBOSE 1
-struct menelaus_s {
+typedef struct {
i2c_slave i2c;
- qemu_irq irq;
int firstbyte;
uint8_t reg;
struct {
uint8_t ctrl;
uint16_t comp;
- QEMUTimer *hz;
+ QEMUTimer *hz_tm;
int64_t next;
struct tm tm;
struct tm new;
int sec_offset;
int alm_sec;
int next_comp;
- struct tm *(*gettime)(const time_t *timep, struct tm *result);
} rtc;
- qemu_irq handler[3];
+ qemu_irq out[4];
qemu_irq *in;
int pwrbtn_state;
qemu_irq pwrbtn;
-};
+} MenelausState;
-static inline void menelaus_update(struct menelaus_s *s)
+static inline void menelaus_update(MenelausState *s)
{
- qemu_set_irq(s->irq, s->status & ~s->mask);
+ qemu_set_irq(s->out[3], s->status & ~s->mask);
}
-static inline void menelaus_rtc_start(struct menelaus_s *s)
+static inline void menelaus_rtc_start(MenelausState *s)
{
s->rtc.next =+ qemu_get_clock(rt_clock);
- qemu_mod_timer(s->rtc.hz, s->rtc.next);
+ qemu_mod_timer(s->rtc.hz_tm, s->rtc.next);
}
-static inline void menelaus_rtc_stop(struct menelaus_s *s)
+static inline void menelaus_rtc_stop(MenelausState *s)
{
- qemu_del_timer(s->rtc.hz);
+ qemu_del_timer(s->rtc.hz_tm);
s->rtc.next =- qemu_get_clock(rt_clock);
if (s->rtc.next < 1)
s->rtc.next = 1;
}
-static void menelaus_rtc_update(struct menelaus_s *s)
+static void menelaus_rtc_update(MenelausState *s)
{
qemu_get_timedate(&s->rtc.tm, s->rtc.sec_offset);
}
-static void menelaus_alm_update(struct menelaus_s *s)
+static void menelaus_alm_update(MenelausState *s)
{
if ((s->rtc.ctrl & 3) == 3)
s->rtc.alm_sec = qemu_timedate_diff(&s->rtc.alm) - s->rtc.sec_offset;
static void menelaus_rtc_hz(void *opaque)
{
- struct menelaus_s *s = (struct menelaus_s *) opaque;
+ MenelausState *s = (MenelausState *) opaque;
s->rtc.next_comp --;
s->rtc.alm_sec --;
s->rtc.next += 1000;
- qemu_mod_timer(s->rtc.hz, s->rtc.next);
+ qemu_mod_timer(s->rtc.hz_tm, s->rtc.next);
if ((s->rtc.ctrl >> 3) & 3) { /* EVERY */
menelaus_rtc_update(s);
if (((s->rtc.ctrl >> 3) & 3) == 1 && !s->rtc.tm.tm_sec)
menelaus_update(s);
}
-void menelaus_reset(i2c_slave *i2c)
+static void menelaus_reset(i2c_slave *i2c)
{
- struct menelaus_s *s = (struct menelaus_s *) i2c;
+ MenelausState *s = (MenelausState *) i2c;
s->reg = 0x00;
s->vcore[0] = 0x0c; /* XXX: X-loader needs 0x8c? check! */
static void menelaus_gpio_set(void *opaque, int line, int level)
{
- struct menelaus_s *s = (struct menelaus_s *) opaque;
+ MenelausState *s = (MenelausState *) opaque;
/* No interrupt generated */
s->inputs &= ~(1 << line);
static void menelaus_pwrbtn_set(void *opaque, int line, int level)
{
- struct menelaus_s *s = (struct menelaus_s *) opaque;
+ MenelausState *s = (MenelausState *) opaque;
if (!s->pwrbtn_state && level) {
s->status |= 1 << 11; /* PSHBTN */
static uint8_t menelaus_read(void *opaque, uint8_t addr)
{
- struct menelaus_s *s = (struct menelaus_s *) opaque;
+ MenelausState *s = (MenelausState *) opaque;
int reg = 0;
switch (addr) {
static void menelaus_write(void *opaque, uint8_t addr, uint8_t value)
{
- struct menelaus_s *s = (struct menelaus_s *) opaque;
+ MenelausState *s = (MenelausState *) opaque;
int line;
int reg = 0;
struct tm tm;
break;
case MENELAUS_GPIO_CTRL:
- for (line = 0; line < 3; line ++)
- if (((s->dir ^ value) >> line) & 1)
- if (s->handler[line])
- qemu_set_irq(s->handler[line],
- ((s->outputs & ~s->dir) >> line) & 1);
+ for (line = 0; line < 3; line ++) {
+ if (((s->dir ^ value) >> line) & 1) {
+ qemu_set_irq(s->out[line],
+ ((s->outputs & ~s->dir) >> line) & 1);
+ }
+ }
s->dir = value & 0x67;
break;
case MENELAUS_GPIO_OUT:
- for (line = 0; line < 3; line ++)
- if ((((s->outputs ^ value) & ~s->dir) >> line) & 1)
- if (s->handler[line])
- qemu_set_irq(s->handler[line], (s->outputs >> line) & 1);
+ for (line = 0; line < 3; line ++) {
+ if ((((s->outputs ^ value) & ~s->dir) >> line) & 1) {
+ qemu_set_irq(s->out[line], (s->outputs >> line) & 1);
+ }
+ }
s->outputs = value & 0x07;
break;
static void menelaus_event(i2c_slave *i2c, enum i2c_event event)
{
- struct menelaus_s *s = (struct menelaus_s *) i2c;
+ MenelausState *s = (MenelausState *) i2c;
if (event == I2C_START_SEND)
s->firstbyte = 1;
static int menelaus_tx(i2c_slave *i2c, uint8_t data)
{
- struct menelaus_s *s = (struct menelaus_s *) i2c;
+ MenelausState *s = (MenelausState *) i2c;
/* Interpret register address byte */
if (s->firstbyte) {
s->reg = data;
static int menelaus_rx(i2c_slave *i2c)
{
- struct menelaus_s *s = (struct menelaus_s *) i2c;
+ MenelausState *s = (MenelausState *) i2c;
return menelaus_read(s, s->reg ++);
}
static void menelaus_save(QEMUFile *f, void *opaque)
{
- struct menelaus_s *s = (struct menelaus_s *) opaque;
+ MenelausState *s = (MenelausState *) opaque;
qemu_put_be32(f, s->firstbyte);
qemu_put_8s(f, &s->reg);
qemu_put_8s(f, &s->vcore[2]);
qemu_put_8s(f, &s->vcore[3]);
qemu_put_8s(f, &s->vcore[4]);
- qemu_put_8s(f, &s->dcdc[3]);
- qemu_put_8s(f, &s->dcdc[3]);
- qemu_put_8s(f, &s->dcdc[3]);
+ qemu_put_8s(f, &s->dcdc[0]);
+ qemu_put_8s(f, &s->dcdc[1]);
+ qemu_put_8s(f, &s->dcdc[2]);
qemu_put_8s(f, &s->ldo[0]);
qemu_put_8s(f, &s->ldo[1]);
qemu_put_8s(f, &s->ldo[2]);
static int menelaus_load(QEMUFile *f, void *opaque, int version_id)
{
- struct menelaus_s *s = (struct menelaus_s *) opaque;
+ MenelausState *s = (MenelausState *) opaque;
s->firstbyte = qemu_get_be32(f);
qemu_get_8s(f, &s->reg);
qemu_get_8s(f, &s->vcore[2]);
qemu_get_8s(f, &s->vcore[3]);
qemu_get_8s(f, &s->vcore[4]);
- qemu_get_8s(f, &s->dcdc[3]);
- qemu_get_8s(f, &s->dcdc[3]);
- qemu_get_8s(f, &s->dcdc[3]);
+ qemu_get_8s(f, &s->dcdc[0]);
+ qemu_get_8s(f, &s->dcdc[1]);
+ qemu_get_8s(f, &s->dcdc[2]);
qemu_get_8s(f, &s->ldo[0]);
qemu_get_8s(f, &s->ldo[1]);
qemu_get_8s(f, &s->ldo[2]);
return 0;
}
-static int menelaus_iid = 0;
-
-i2c_slave *twl92230_init(i2c_bus *bus, qemu_irq irq)
+static int twl92230_init(i2c_slave *i2c)
{
- struct menelaus_s *s = (struct menelaus_s *)
- i2c_slave_init(bus, 0, sizeof(struct menelaus_s));
+ MenelausState *s = FROM_I2C_SLAVE(MenelausState, i2c);
- s->i2c.event = menelaus_event;
- s->i2c.recv = menelaus_rx;
- s->i2c.send = menelaus_tx;
-
- s->irq = irq;
- s->rtc.hz = qemu_new_timer(rt_clock, menelaus_rtc_hz, s);
- s->in = qemu_allocate_irqs(menelaus_gpio_set, s, 3);
+ s->rtc.hz_tm = qemu_new_timer(rt_clock, menelaus_rtc_hz, s);
+ /* Three output pins plus one interrupt pin. */
+ qdev_init_gpio_out(&i2c->qdev, s->out, 4);
+ qdev_init_gpio_in(&i2c->qdev, menelaus_gpio_set, 3);
s->pwrbtn = qemu_allocate_irqs(menelaus_pwrbtn_set, s, 1)[0];
menelaus_reset(&s->i2c);
- register_savevm("menelaus", menelaus_iid ++,
- 0, menelaus_save, menelaus_load, s);
-
- return &s->i2c;
+ register_savevm("menelaus", -1, 0, menelaus_save, menelaus_load, s);
+ return 0;
}
-qemu_irq *twl92230_gpio_in_get(i2c_slave *i2c)
-{
- struct menelaus_s *s = (struct menelaus_s *) i2c;
-
- return s->in;
-}
+static I2CSlaveInfo twl92230_info = {
+ .qdev.name ="twl92230",
+ .qdev.size = sizeof(MenelausState),
+ .init = twl92230_init,
+ .event = menelaus_event,
+ .recv = menelaus_rx,
+ .send = menelaus_tx
+};
-void twl92230_gpio_out_set(i2c_slave *i2c, int line, qemu_irq handler)
+static void twl92230_register_devices(void)
{
- struct menelaus_s *s = (struct menelaus_s *) i2c;
-
- if (line >= 3 || line < 0) {
- fprintf(stderr, "%s: No GPO line %i\n", __FUNCTION__, line);
- exit(-1);
- }
- s->handler[line] = handler;
+ i2c_register_slave(&twl92230_info);
}
+
+device_init(twl92230_register_devices)