hw/i2c/mpc_i2c.c

   1 /*
   2  * Copyright (C) 2014 Freescale Semiconductor, Inc. All rights reserved.
   3  *
   4  * Author: Amit Tomar, <Amit.Tomar@freescale.com>
   5  *
   6  * Description:
   7  * This file is derived from IMX I2C controller,
   8  * by Jean-Christophe DUBOIS .
   9  *
  10  * Thanks to Scott Wood and Alexander Graf for their kind help on this.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License, version 2 or later,
  14  * as published by the Free Software Foundation.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "hw/i2c/i2c.h"
  22 #include "hw/irq.h"
  23 #include "qemu/log.h"
  24 #include "qemu/module.h"
  25 #include "hw/sysbus.h"
  26 #include "migration/vmstate.h"
  27 #include "qom/object.h"
  28
  29 /* #define DEBUG_I2C */
  30
  31 #ifdef DEBUG_I2C
  32 #define DPRINTF(fmt, ...)              \
  33     do { fprintf(stderr, "mpc_i2c[%s]: " fmt, __func__, ## __VA_ARGS__); \
  34     } while (0)
  35 #else
  36 #define DPRINTF(fmt, ...) do {} while (0)
  37 #endif
  38
  39 #define TYPE_MPC_I2C "mpc-i2c"
  40 OBJECT_DECLARE_SIMPLE_TYPE(MPCI2CState, MPC_I2C)
  41
  42 #define MPC_I2C_ADR   0x00
  43 #define MPC_I2C_FDR   0x04
  44 #define MPC_I2C_CR    0x08
  45 #define MPC_I2C_SR    0x0c
  46 #define MPC_I2C_DR    0x10
  47 #define MPC_I2C_DFSRR 0x14
  48
  49 #define CCR_MEN  (1 << 7)
  50 #define CCR_MIEN (1 << 6)
  51 #define CCR_MSTA (1 << 5)
  52 #define CCR_MTX  (1 << 4)
  53 #define CCR_TXAK (1 << 3)
  54 #define CCR_RSTA (1 << 2)
  55 #define CCR_BCST (1 << 0)
  56
  57 #define CSR_MCF  (1 << 7)
  58 #define CSR_MAAS (1 << 6)
  59 #define CSR_MBB  (1 << 5)
  60 #define CSR_MAL  (1 << 4)
  61 #define CSR_SRW  (1 << 2)
  62 #define CSR_MIF  (1 << 1)
  63 #define CSR_RXAK (1 << 0)
  64
  65 #define CADR_MASK 0xFE
  66 #define CFDR_MASK 0x3F
  67 #define CCR_MASK  0xFC
  68 #define CSR_MASK  0xED
  69 #define CDR_MASK  0xFF
  70
  71 #define CYCLE_RESET 0xFF
  72
  73 struct MPCI2CState {
  74     SysBusDevice parent_obj;
  75
  76     I2CBus *bus;
  77     qemu_irq irq;
  78     MemoryRegion iomem;
  79
  80     uint8_t address;
  81     uint8_t adr;
  82     uint8_t fdr;
  83     uint8_t cr;
  84     uint8_t sr;
  85     uint8_t dr;
  86     uint8_t dfssr;
  87 };
  88
  89 static bool mpc_i2c_is_enabled(MPCI2CState *s)
  90 {
  91     return s->cr & CCR_MEN;
  92 }
  93
  94 static bool mpc_i2c_is_master(MPCI2CState *s)
  95 {
  96     return s->cr & CCR_MSTA;
  97 }
  98
  99 static bool mpc_i2c_direction_is_tx(MPCI2CState *s)
 100 {
 101     return s->cr & CCR_MTX;
 102 }
 103
 104 static bool mpc_i2c_irq_pending(MPCI2CState *s)
 105 {
 106     return s->sr & CSR_MIF;
 107 }
 108
 109 static bool mpc_i2c_irq_is_enabled(MPCI2CState *s)
 110 {
 111     return s->cr & CCR_MIEN;
 112 }
 113
 114 static void mpc_i2c_reset(DeviceState *dev)
 115 {
 116     MPCI2CState *i2c = MPC_I2C(dev);
 117
 118     i2c->address = 0xFF;
 119     i2c->adr = 0x00;
 120     i2c->fdr = 0x00;
 121     i2c->cr =  0x00;
 122     i2c->sr =  0x81;
 123     i2c->dr =  0x00;
 124 }
 125
 126 static void mpc_i2c_irq(MPCI2CState *s)
 127 {
 128     bool irq_active = false;
 129
 130     if (mpc_i2c_is_enabled(s) && mpc_i2c_irq_is_enabled(s)
 131                               && mpc_i2c_irq_pending(s)) {
 132         irq_active = true;
 133     }
 134
 135     if (irq_active) {
 136         qemu_irq_raise(s->irq);
 137     } else {
 138         qemu_irq_lower(s->irq);
 139     }
 140 }
 141
 142 static void mpc_i2c_soft_reset(MPCI2CState *s)
 143 {
 144     /* This is a soft reset. ADR is preserved during soft resets */
 145     uint8_t adr = s->adr;
 146     mpc_i2c_reset(DEVICE(s));
 147     s->adr = adr;
 148 }
 149
 150 static void  mpc_i2c_address_send(MPCI2CState *s)
 151 {
 152     /* if returns non zero slave address is not right */
 153     if (i2c_start_transfer(s->bus, s->dr >> 1, s->dr & (0x01))) {
 154         s->sr |= CSR_RXAK;
 155     } else {
 156         s->address = s->dr;
 157         s->sr &= ~CSR_RXAK;
 158         s->sr |=  CSR_MCF; /* Set after Byte Transfer is completed */
 159         s->sr |=  CSR_MIF; /* Set after Byte Transfer is completed */
 160         mpc_i2c_irq(s);
 161     }
 162 }
 163
 164 static void  mpc_i2c_data_send(MPCI2CState *s)
 165 {
 166     if (i2c_send(s->bus, s->dr)) {
 167         /* End of transfer */
 168         s->sr |= CSR_RXAK;
 169         i2c_end_transfer(s->bus);
 170     } else {
 171         s->sr &= ~CSR_RXAK;
 172         s->sr |=  CSR_MCF; /* Set after Byte Transfer is completed */
 173         s->sr |=  CSR_MIF; /* Set after Byte Transfer is completed */
 174         mpc_i2c_irq(s);
 175     }
 176 }
 177
 178 static void  mpc_i2c_data_recive(MPCI2CState *s)
 179 {
 180     int ret;
 181     /* get the next byte */
 182     ret = i2c_recv(s->bus);
 183     if (ret >= 0) {
 184         s->sr |= CSR_MCF; /* Set after Byte Transfer is completed */
 185         s->sr |= CSR_MIF; /* Set after Byte Transfer is completed */
 186         mpc_i2c_irq(s);
 187     } else {
 188         DPRINTF("read failed for device");
 189         ret = 0xff;
 190     }
 191     s->dr = ret;
 192 }
 193
 194 static uint64_t mpc_i2c_read(void *opaque, hwaddr addr, unsigned size)
 195 {
 196     MPCI2CState *s = opaque;
 197     uint8_t value;
 198
 199     switch (addr) {
 200     case MPC_I2C_ADR:
 201         value = s->adr;
 202         break;
 203     case MPC_I2C_FDR:
 204         value = s->fdr;
 205         break;
 206     case MPC_I2C_CR:
 207         value = s->cr;
 208         break;
 209     case MPC_I2C_SR:
 210         value = s->sr;
 211         break;
 212     case MPC_I2C_DR:
 213         value = s->dr;
 214         if (mpc_i2c_is_master(s)) { /* master mode */
 215             if (mpc_i2c_direction_is_tx(s)) {
 216                 DPRINTF("MTX is set not in recv mode\n");
 217             } else {
 218                 mpc_i2c_data_recive(s);
 219             }
 220         }
 221         break;
 222     default:
 223         value = 0;
 224         DPRINTF("ERROR: Bad read addr 0x%x\n", (unsigned int)addr);
 225         break;
 226     }
 227
 228     DPRINTF("%s: addr " TARGET_FMT_plx " %02" PRIx32 "\n", __func__,
 229                                          addr, value);
 230     return (uint64_t)value;
 231 }
 232
 233 static void mpc_i2c_write(void *opaque, hwaddr addr,
 234                             uint64_t value, unsigned size)
 235 {
 236     MPCI2CState *s = opaque;
 237
 238     DPRINTF("%s: addr " TARGET_FMT_plx " val %08" PRIx64 "\n", __func__,
 239                                              addr, value);
 240     switch (addr) {
 241     case MPC_I2C_ADR:
 242         s->adr = value & CADR_MASK;
 243         break;
 244     case MPC_I2C_FDR:
 245         s->fdr = value & CFDR_MASK;
 246         break;
 247     case MPC_I2C_CR:
 248         if (mpc_i2c_is_enabled(s) && ((value & CCR_MEN) == 0)) {
 249             mpc_i2c_soft_reset(s);
 250             break;
 251         }
 252         /* normal write */
 253         s->cr = value & CCR_MASK;
 254         if (mpc_i2c_is_master(s)) { /* master mode */
 255             /* set the bus to busy after master is set as per RM */
 256             s->sr |= CSR_MBB;
 257         } else {
 258             /* bus is not busy anymore */
 259             s->sr &= ~CSR_MBB;
 260             /* Reset the address for fresh write/read cycle */
 261         if (s->address != CYCLE_RESET) {
 262             i2c_end_transfer(s->bus);
 263             s->address = CYCLE_RESET;
 264             }
 265         }
 266         /* For restart end the onging transfer */
 267         if (s->cr & CCR_RSTA) {
 268             if (s->address != CYCLE_RESET) {
 269                 s->address = CYCLE_RESET;
 270                 i2c_end_transfer(s->bus);
 271                 s->cr &= ~CCR_RSTA;
 272             }
 273         }
 274         break;
 275     case MPC_I2C_SR:
 276         s->sr = value & CSR_MASK;
 277         /* Lower the interrupt */
 278         if (!(s->sr & CSR_MIF) || !(s->sr & CSR_MAL)) {
 279             mpc_i2c_irq(s);
 280         }
 281         break;
 282     case MPC_I2C_DR:
 283         /* if the device is not enabled, nothing to do */
 284         if (!mpc_i2c_is_enabled(s)) {
 285             break;
 286         }
 287         s->dr = value & CDR_MASK;
 288         if (mpc_i2c_is_master(s)) { /* master mode */
 289             if (s->address == CYCLE_RESET) {
 290                 mpc_i2c_address_send(s);
 291             } else {
 292                 mpc_i2c_data_send(s);
 293             }
 294         }
 295         break;
 296     case MPC_I2C_DFSRR:
 297         s->dfssr = value;
 298         break;
 299     default:
 300         DPRINTF("ERROR: Bad write addr 0x%x\n", (unsigned int)addr);
 301         break;
 302     }
 303 }
 304
 305 static const MemoryRegionOps i2c_ops = {
 306     .read =  mpc_i2c_read,
 307     .write =  mpc_i2c_write,
 308     .valid.max_access_size = 1,
 309     .endianness = DEVICE_NATIVE_ENDIAN,
 310 };
 311
 312 static const VMStateDescription mpc_i2c_vmstate = {
 313     .name = TYPE_MPC_I2C,
 314     .version_id = 1,
 315     .minimum_version_id = 1,
 316     .fields = (VMStateField[]) {
 317         VMSTATE_UINT8(address, MPCI2CState),
 318         VMSTATE_UINT8(adr, MPCI2CState),
 319         VMSTATE_UINT8(fdr, MPCI2CState),
 320         VMSTATE_UINT8(cr, MPCI2CState),
 321         VMSTATE_UINT8(sr, MPCI2CState),
 322         VMSTATE_UINT8(dr, MPCI2CState),
 323         VMSTATE_UINT8(dfssr, MPCI2CState),
 324         VMSTATE_END_OF_LIST()
 325     }
 326 };
 327
 328 static void mpc_i2c_realize(DeviceState *dev, Error **errp)
 329 {
 330     MPCI2CState  *i2c = MPC_I2C(dev);
 331     sysbus_init_irq(SYS_BUS_DEVICE(dev), &i2c->irq);
 332     memory_region_init_io(&i2c->iomem, OBJECT(i2c), &i2c_ops, i2c,
 333                           "mpc-i2c", 0x14);
 334     sysbus_init_mmio(SYS_BUS_DEVICE(dev), &i2c->iomem);
 335     i2c->bus = i2c_init_bus(dev, "i2c");
 336 }
 337
 338 static void mpc_i2c_class_init(ObjectClass *klass, void *data)
 339 {
 340     DeviceClass *dc = DEVICE_CLASS(klass);
 341
 342     dc->vmsd  = &mpc_i2c_vmstate ;
 343     dc->reset = mpc_i2c_reset;
 344     dc->realize = mpc_i2c_realize;
 345     dc->desc = "MPC I2C Controller";
 346 }
 347
 348 static const TypeInfo mpc_i2c_type_info = {
 349     .name          = TYPE_MPC_I2C,
 350     .parent        = TYPE_SYS_BUS_DEVICE,
 351     .instance_size = sizeof(MPCI2CState),
 352     .class_init    = mpc_i2c_class_init,
 353 };
 354
 355 static void mpc_i2c_register_types(void)
 356 {
 357     type_register_static(&mpc_i2c_type_info);
 358 }
 359
 360 type_init(mpc_i2c_register_types)