PPC: e500: msync is 440 only, e500 has real sync
[qemu.git] / hw / smbus_eeprom.c
1 /*
2 * QEMU SMBus EEPROM device
3 *
4 * Copyright (c) 2007 Arastra, Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "hw.h"
26 #include "i2c.h"
27 #include "smbus.h"
28
29 //#define DEBUG
30
31 typedef struct SMBusEEPROMDevice {
32 SMBusDevice smbusdev;
33 void *data;
34 uint8_t offset;
35 } SMBusEEPROMDevice;
36
37 static void eeprom_quick_cmd(SMBusDevice *dev, uint8_t read)
38 {
39 #ifdef DEBUG
40 printf("eeprom_quick_cmd: addr=0x%02x read=%d\n", dev->i2c.address, read);
41 #endif
42 }
43
44 static void eeprom_send_byte(SMBusDevice *dev, uint8_t val)
45 {
46 SMBusEEPROMDevice *eeprom = (SMBusEEPROMDevice *) dev;
47 #ifdef DEBUG
48 printf("eeprom_send_byte: addr=0x%02x val=0x%02x\n",
49 dev->i2c.address, val);
50 #endif
51 eeprom->offset = val;
52 }
53
54 static uint8_t eeprom_receive_byte(SMBusDevice *dev)
55 {
56 SMBusEEPROMDevice *eeprom = (SMBusEEPROMDevice *) dev;
57 uint8_t *data = eeprom->data;
58 uint8_t val = data[eeprom->offset++];
59 #ifdef DEBUG
60 printf("eeprom_receive_byte: addr=0x%02x val=0x%02x\n",
61 dev->i2c.address, val);
62 #endif
63 return val;
64 }
65
66 static void eeprom_write_data(SMBusDevice *dev, uint8_t cmd, uint8_t *buf, int len)
67 {
68 SMBusEEPROMDevice *eeprom = (SMBusEEPROMDevice *) dev;
69 int n;
70 #ifdef DEBUG
71 printf("eeprom_write_byte: addr=0x%02x cmd=0x%02x val=0x%02x\n",
72 dev->i2c.address, cmd, buf[0]);
73 #endif
74 /* An page write operation is not a valid SMBus command.
75 It is a block write without a length byte. Fortunately we
76 get the full block anyway. */
77 /* TODO: Should this set the current location? */
78 if (cmd + len > 256)
79 n = 256 - cmd;
80 else
81 n = len;
82 memcpy(eeprom->data + cmd, buf, n);
83 len -= n;
84 if (len)
85 memcpy(eeprom->data, buf + n, len);
86 }
87
88 static uint8_t eeprom_read_data(SMBusDevice *dev, uint8_t cmd, int n)
89 {
90 SMBusEEPROMDevice *eeprom = (SMBusEEPROMDevice *) dev;
91 /* If this is the first byte then set the current position. */
92 if (n == 0)
93 eeprom->offset = cmd;
94 /* As with writes, we implement block reads without the
95 SMBus length byte. */
96 return eeprom_receive_byte(dev);
97 }
98
99 static int smbus_eeprom_initfn(SMBusDevice *dev)
100 {
101 SMBusEEPROMDevice *eeprom = (SMBusEEPROMDevice *)dev;
102
103 eeprom->offset = 0;
104 return 0;
105 }
106
107 static void smbus_eeprom_class_initfn(ObjectClass *klass, void *data)
108 {
109 SMBusDeviceClass *sc = SMBUS_DEVICE_CLASS(klass);
110
111 sc->init = smbus_eeprom_initfn;
112 sc->quick_cmd = eeprom_quick_cmd;
113 sc->send_byte = eeprom_send_byte;
114 sc->receive_byte = eeprom_receive_byte;
115 sc->write_data = eeprom_write_data;
116 sc->read_data = eeprom_read_data;
117 }
118
119 static DeviceInfo smbus_eeprom_info = {
120 .name = "smbus-eeprom",
121 .size = sizeof(SMBusEEPROMDevice),
122 .class_init = smbus_eeprom_class_initfn,
123 .props = (Property[]) {
124 DEFINE_PROP_PTR("data", SMBusEEPROMDevice, data),
125 DEFINE_PROP_END_OF_LIST(),
126 },
127 };
128
129 static void smbus_eeprom_register_devices(void)
130 {
131 smbus_register_device(&smbus_eeprom_info);
132 }
133
134 device_init(smbus_eeprom_register_devices)
135
136 void smbus_eeprom_init(i2c_bus *smbus, int nb_eeprom,
137 const uint8_t *eeprom_spd, int eeprom_spd_size)
138 {
139 int i;
140 uint8_t *eeprom_buf = g_malloc0(8 * 256); /* XXX: make this persistent */
141 if (eeprom_spd_size > 0) {
142 memcpy(eeprom_buf, eeprom_spd, eeprom_spd_size);
143 }
144
145 for (i = 0; i < nb_eeprom; i++) {
146 DeviceState *eeprom;
147 eeprom = qdev_create((BusState *)smbus, "smbus-eeprom");
148 qdev_prop_set_uint8(eeprom, "address", 0x50 + i);
149 qdev_prop_set_ptr(eeprom, "data", eeprom_buf + (i * 256));
150 qdev_init_nofail(eeprom);
151 }
152 }