ths | 5fafdf2 | 2007-09-16 21:08:06 +0000 | [diff] [blame] | 1 | /* |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 2 | * QEMU SMBus device emulation. |
| 3 | * |
| 4 | * Copyright (c) 2007 CodeSourcery. |
| 5 | * Written by Paul Brook |
| 6 | * |
Matthew Fernandez | 8e31bf3 | 2011-06-26 12:21:35 +1000 | [diff] [blame] | 7 | * This code is licensed under the LGPL. |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 8 | */ |
| 9 | |
| 10 | /* TODO: Implement PEC. */ |
| 11 | |
Peter Maydell | 0430891 | 2016-01-26 18:17:30 +0000 | [diff] [blame] | 12 | #include "qemu/osdep.h" |
Paolo Bonzini | 83c9f4c | 2013-02-04 15:40:22 +0100 | [diff] [blame] | 13 | #include "hw/hw.h" |
Paolo Bonzini | 0d09e41 | 2013-02-05 17:06:20 +0100 | [diff] [blame] | 14 | #include "hw/i2c/i2c.h" |
| 15 | #include "hw/i2c/smbus.h" |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 16 | |
| 17 | //#define DEBUG_SMBUS 1 |
| 18 | |
| 19 | #ifdef DEBUG_SMBUS |
Blue Swirl | 001faf3 | 2009-05-13 17:53:17 +0000 | [diff] [blame] | 20 | #define DPRINTF(fmt, ...) \ |
| 21 | do { printf("smbus(%02x): " fmt , dev->i2c.address, ## __VA_ARGS__); } while (0) |
| 22 | #define BADF(fmt, ...) \ |
| 23 | do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__); exit(1);} while (0) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 24 | #else |
Blue Swirl | 001faf3 | 2009-05-13 17:53:17 +0000 | [diff] [blame] | 25 | #define DPRINTF(fmt, ...) do {} while(0) |
| 26 | #define BADF(fmt, ...) \ |
| 27 | do { fprintf(stderr, "smbus: error: " fmt , ## __VA_ARGS__);} while (0) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 28 | #endif |
| 29 | |
| 30 | enum { |
| 31 | SMBUS_IDLE, |
| 32 | SMBUS_WRITE_DATA, |
| 33 | SMBUS_RECV_BYTE, |
| 34 | SMBUS_READ_DATA, |
| 35 | SMBUS_DONE, |
| 36 | SMBUS_CONFUSED = -1 |
| 37 | }; |
| 38 | |
| 39 | static void smbus_do_quick_cmd(SMBusDevice *dev, int recv) |
| 40 | { |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 41 | SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev); |
Paul Brook | 1ea9667 | 2009-05-14 22:35:08 +0100 | [diff] [blame] | 42 | |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 43 | DPRINTF("Quick Command %d\n", recv); |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 44 | if (sc->quick_cmd) { |
| 45 | sc->quick_cmd(dev, recv); |
| 46 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 47 | } |
| 48 | |
| 49 | static void smbus_do_write(SMBusDevice *dev) |
| 50 | { |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 51 | SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev); |
Paul Brook | 1ea9667 | 2009-05-14 22:35:08 +0100 | [diff] [blame] | 52 | |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 53 | if (dev->data_len == 0) { |
| 54 | smbus_do_quick_cmd(dev, 0); |
| 55 | } else if (dev->data_len == 1) { |
| 56 | DPRINTF("Send Byte\n"); |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 57 | if (sc->send_byte) { |
| 58 | sc->send_byte(dev, dev->data_buf[0]); |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 59 | } |
| 60 | } else { |
| 61 | dev->command = dev->data_buf[0]; |
| 62 | DPRINTF("Command %d len %d\n", dev->command, dev->data_len - 1); |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 63 | if (sc->write_data) { |
| 64 | sc->write_data(dev, dev->command, dev->data_buf + 1, |
| 65 | dev->data_len - 1); |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 66 | } |
| 67 | } |
| 68 | } |
| 69 | |
Corey Minyard | d307c28 | 2017-01-09 11:40:20 +0000 | [diff] [blame^] | 70 | static int smbus_i2c_event(I2CSlave *s, enum i2c_event event) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 71 | { |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 72 | SMBusDevice *dev = SMBUS_DEVICE(s); |
Paul Brook | 1ea9667 | 2009-05-14 22:35:08 +0100 | [diff] [blame] | 73 | |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 74 | switch (event) { |
| 75 | case I2C_START_SEND: |
| 76 | switch (dev->mode) { |
| 77 | case SMBUS_IDLE: |
| 78 | DPRINTF("Incoming data\n"); |
| 79 | dev->mode = SMBUS_WRITE_DATA; |
| 80 | break; |
| 81 | default: |
| 82 | BADF("Unexpected send start condition in state %d\n", dev->mode); |
| 83 | dev->mode = SMBUS_CONFUSED; |
| 84 | break; |
| 85 | } |
| 86 | break; |
| 87 | |
| 88 | case I2C_START_RECV: |
| 89 | switch (dev->mode) { |
| 90 | case SMBUS_IDLE: |
| 91 | DPRINTF("Read mode\n"); |
| 92 | dev->mode = SMBUS_RECV_BYTE; |
| 93 | break; |
| 94 | case SMBUS_WRITE_DATA: |
| 95 | if (dev->data_len == 0) { |
| 96 | BADF("Read after write with no data\n"); |
| 97 | dev->mode = SMBUS_CONFUSED; |
| 98 | } else { |
| 99 | if (dev->data_len > 1) { |
| 100 | smbus_do_write(dev); |
| 101 | } else { |
| 102 | dev->command = dev->data_buf[0]; |
| 103 | DPRINTF("%02x: Command %d\n", dev->i2c.address, |
| 104 | dev->command); |
| 105 | } |
| 106 | DPRINTF("Read mode\n"); |
| 107 | dev->data_len = 0; |
| 108 | dev->mode = SMBUS_READ_DATA; |
| 109 | } |
| 110 | break; |
| 111 | default: |
| 112 | BADF("Unexpected recv start condition in state %d\n", dev->mode); |
| 113 | dev->mode = SMBUS_CONFUSED; |
| 114 | break; |
| 115 | } |
| 116 | break; |
| 117 | |
| 118 | case I2C_FINISH: |
| 119 | switch (dev->mode) { |
| 120 | case SMBUS_WRITE_DATA: |
| 121 | smbus_do_write(dev); |
| 122 | break; |
| 123 | case SMBUS_RECV_BYTE: |
| 124 | smbus_do_quick_cmd(dev, 1); |
| 125 | break; |
| 126 | case SMBUS_READ_DATA: |
| 127 | BADF("Unexpected stop during receive\n"); |
| 128 | break; |
| 129 | default: |
| 130 | /* Nothing to do. */ |
| 131 | break; |
| 132 | } |
| 133 | dev->mode = SMBUS_IDLE; |
| 134 | dev->data_len = 0; |
| 135 | break; |
| 136 | |
| 137 | case I2C_NACK: |
| 138 | switch (dev->mode) { |
| 139 | case SMBUS_DONE: |
| 140 | /* Nothing to do. */ |
| 141 | break; |
| 142 | case SMBUS_READ_DATA: |
| 143 | dev->mode = SMBUS_DONE; |
| 144 | break; |
| 145 | default: |
| 146 | BADF("Unexpected NACK in state %d\n", dev->mode); |
| 147 | dev->mode = SMBUS_CONFUSED; |
| 148 | break; |
| 149 | } |
| 150 | } |
Corey Minyard | d307c28 | 2017-01-09 11:40:20 +0000 | [diff] [blame^] | 151 | |
| 152 | return 0; |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 153 | } |
| 154 | |
Anthony Liguori | 9e07bdf | 2011-12-04 20:28:27 -0600 | [diff] [blame] | 155 | static int smbus_i2c_recv(I2CSlave *s) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 156 | { |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 157 | SMBusDevice *dev = SMBUS_DEVICE(s); |
| 158 | SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev); |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 159 | int ret; |
| 160 | |
| 161 | switch (dev->mode) { |
| 162 | case SMBUS_RECV_BYTE: |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 163 | if (sc->receive_byte) { |
| 164 | ret = sc->receive_byte(dev); |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 165 | } else { |
| 166 | ret = 0; |
| 167 | } |
| 168 | DPRINTF("Receive Byte %02x\n", ret); |
| 169 | dev->mode = SMBUS_DONE; |
| 170 | break; |
| 171 | case SMBUS_READ_DATA: |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 172 | if (sc->read_data) { |
| 173 | ret = sc->read_data(dev, dev->command, dev->data_len); |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 174 | dev->data_len++; |
| 175 | } else { |
| 176 | ret = 0; |
| 177 | } |
| 178 | DPRINTF("Read data %02x\n", ret); |
| 179 | break; |
| 180 | default: |
| 181 | BADF("Unexpected read in state %d\n", dev->mode); |
| 182 | dev->mode = SMBUS_CONFUSED; |
| 183 | ret = 0; |
| 184 | break; |
| 185 | } |
| 186 | return ret; |
| 187 | } |
| 188 | |
Anthony Liguori | 9e07bdf | 2011-12-04 20:28:27 -0600 | [diff] [blame] | 189 | static int smbus_i2c_send(I2CSlave *s, uint8_t data) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 190 | { |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 191 | SMBusDevice *dev = SMBUS_DEVICE(s); |
Paul Brook | 1ea9667 | 2009-05-14 22:35:08 +0100 | [diff] [blame] | 192 | |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 193 | switch (dev->mode) { |
| 194 | case SMBUS_WRITE_DATA: |
| 195 | DPRINTF("Write data %02x\n", data); |
| 196 | dev->data_buf[dev->data_len++] = data; |
| 197 | break; |
| 198 | default: |
| 199 | BADF("Unexpected write in state %d\n", dev->mode); |
| 200 | break; |
| 201 | } |
| 202 | return 0; |
| 203 | } |
| 204 | |
Anthony Liguori | 9e07bdf | 2011-12-04 20:28:27 -0600 | [diff] [blame] | 205 | static int smbus_device_init(I2CSlave *i2c) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 206 | { |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 207 | SMBusDevice *dev = SMBUS_DEVICE(i2c); |
| 208 | SMBusDeviceClass *sc = SMBUS_DEVICE_GET_CLASS(dev); |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 209 | |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 210 | return sc->init(dev); |
Paul Brook | 1ea9667 | 2009-05-14 22:35:08 +0100 | [diff] [blame] | 211 | } |
balrog | 3f58226 | 2007-05-23 21:47:51 +0000 | [diff] [blame] | 212 | |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 213 | /* Master device commands. */ |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 214 | int smbus_quick_command(I2CBus *bus, uint8_t addr, int read) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 215 | { |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 216 | if (i2c_start_transfer(bus, addr, read)) { |
| 217 | return -1; |
| 218 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 219 | i2c_end_transfer(bus); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 220 | return 0; |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 221 | } |
| 222 | |
Paolo Bonzini | 285364e | 2014-03-31 18:26:29 +0200 | [diff] [blame] | 223 | int smbus_receive_byte(I2CBus *bus, uint8_t addr) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 224 | { |
| 225 | uint8_t data; |
| 226 | |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 227 | if (i2c_start_transfer(bus, addr, 1)) { |
| 228 | return -1; |
| 229 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 230 | data = i2c_recv(bus); |
| 231 | i2c_nack(bus); |
| 232 | i2c_end_transfer(bus); |
| 233 | return data; |
| 234 | } |
| 235 | |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 236 | int smbus_send_byte(I2CBus *bus, uint8_t addr, uint8_t data) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 237 | { |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 238 | if (i2c_start_transfer(bus, addr, 0)) { |
| 239 | return -1; |
| 240 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 241 | i2c_send(bus, data); |
| 242 | i2c_end_transfer(bus); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 243 | return 0; |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 244 | } |
| 245 | |
Paolo Bonzini | 285364e | 2014-03-31 18:26:29 +0200 | [diff] [blame] | 246 | int smbus_read_byte(I2CBus *bus, uint8_t addr, uint8_t command) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 247 | { |
| 248 | uint8_t data; |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 249 | if (i2c_start_transfer(bus, addr, 0)) { |
| 250 | return -1; |
| 251 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 252 | i2c_send(bus, command); |
Corey Minyard | cc083d8 | 2016-10-24 10:42:33 -0500 | [diff] [blame] | 253 | if (i2c_start_transfer(bus, addr, 1)) { |
Corey Minyard | d307c28 | 2017-01-09 11:40:20 +0000 | [diff] [blame^] | 254 | i2c_end_transfer(bus); |
| 255 | return -1; |
Corey Minyard | cc083d8 | 2016-10-24 10:42:33 -0500 | [diff] [blame] | 256 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 257 | data = i2c_recv(bus); |
| 258 | i2c_nack(bus); |
| 259 | i2c_end_transfer(bus); |
| 260 | return data; |
| 261 | } |
| 262 | |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 263 | int smbus_write_byte(I2CBus *bus, uint8_t addr, uint8_t command, uint8_t data) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 264 | { |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 265 | if (i2c_start_transfer(bus, addr, 0)) { |
| 266 | return -1; |
| 267 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 268 | i2c_send(bus, command); |
| 269 | i2c_send(bus, data); |
| 270 | i2c_end_transfer(bus); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 271 | return 0; |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 272 | } |
| 273 | |
Paolo Bonzini | 285364e | 2014-03-31 18:26:29 +0200 | [diff] [blame] | 274 | int smbus_read_word(I2CBus *bus, uint8_t addr, uint8_t command) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 275 | { |
| 276 | uint16_t data; |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 277 | if (i2c_start_transfer(bus, addr, 0)) { |
| 278 | return -1; |
| 279 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 280 | i2c_send(bus, command); |
Corey Minyard | cc083d8 | 2016-10-24 10:42:33 -0500 | [diff] [blame] | 281 | if (i2c_start_transfer(bus, addr, 1)) { |
Corey Minyard | d307c28 | 2017-01-09 11:40:20 +0000 | [diff] [blame^] | 282 | i2c_end_transfer(bus); |
| 283 | return -1; |
Corey Minyard | cc083d8 | 2016-10-24 10:42:33 -0500 | [diff] [blame] | 284 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 285 | data = i2c_recv(bus); |
| 286 | data |= i2c_recv(bus) << 8; |
| 287 | i2c_nack(bus); |
| 288 | i2c_end_transfer(bus); |
| 289 | return data; |
| 290 | } |
| 291 | |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 292 | int smbus_write_word(I2CBus *bus, uint8_t addr, uint8_t command, uint16_t data) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 293 | { |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 294 | if (i2c_start_transfer(bus, addr, 0)) { |
| 295 | return -1; |
| 296 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 297 | i2c_send(bus, command); |
| 298 | i2c_send(bus, data & 0xff); |
| 299 | i2c_send(bus, data >> 8); |
| 300 | i2c_end_transfer(bus); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 301 | return 0; |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 302 | } |
| 303 | |
Andreas Färber | a5c8285 | 2013-08-03 00:18:51 +0200 | [diff] [blame] | 304 | int smbus_read_block(I2CBus *bus, uint8_t addr, uint8_t command, uint8_t *data) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 305 | { |
| 306 | int len; |
| 307 | int i; |
| 308 | |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 309 | if (i2c_start_transfer(bus, addr, 0)) { |
| 310 | return -1; |
| 311 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 312 | i2c_send(bus, command); |
Corey Minyard | cc083d8 | 2016-10-24 10:42:33 -0500 | [diff] [blame] | 313 | if (i2c_start_transfer(bus, addr, 1)) { |
Corey Minyard | d307c28 | 2017-01-09 11:40:20 +0000 | [diff] [blame^] | 314 | i2c_end_transfer(bus); |
| 315 | return -1; |
Corey Minyard | cc083d8 | 2016-10-24 10:42:33 -0500 | [diff] [blame] | 316 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 317 | len = i2c_recv(bus); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 318 | if (len > 32) { |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 319 | len = 0; |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 320 | } |
| 321 | for (i = 0; i < len; i++) { |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 322 | data[i] = i2c_recv(bus); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 323 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 324 | i2c_nack(bus); |
| 325 | i2c_end_transfer(bus); |
| 326 | return len; |
| 327 | } |
| 328 | |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 329 | int smbus_write_block(I2CBus *bus, uint8_t addr, uint8_t command, uint8_t *data, |
| 330 | int len) |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 331 | { |
| 332 | int i; |
| 333 | |
| 334 | if (len > 32) |
| 335 | len = 32; |
| 336 | |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 337 | if (i2c_start_transfer(bus, addr, 0)) { |
| 338 | return -1; |
| 339 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 340 | i2c_send(bus, command); |
| 341 | i2c_send(bus, len); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 342 | for (i = 0; i < len; i++) { |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 343 | i2c_send(bus, data[i]); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 344 | } |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 345 | i2c_end_transfer(bus); |
Paolo Bonzini | 046a184 | 2014-03-31 18:26:30 +0200 | [diff] [blame] | 346 | return 0; |
pbrook | 0ff596d | 2007-05-23 00:03:59 +0000 | [diff] [blame] | 347 | } |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 348 | |
| 349 | static void smbus_device_class_init(ObjectClass *klass, void *data) |
| 350 | { |
| 351 | I2CSlaveClass *sc = I2C_SLAVE_CLASS(klass); |
| 352 | |
| 353 | sc->init = smbus_device_init; |
| 354 | sc->event = smbus_i2c_event; |
| 355 | sc->recv = smbus_i2c_recv; |
| 356 | sc->send = smbus_i2c_send; |
| 357 | } |
| 358 | |
Andreas Färber | 8c43a6f | 2013-01-10 16:19:07 +0100 | [diff] [blame] | 359 | static const TypeInfo smbus_device_type_info = { |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 360 | .name = TYPE_SMBUS_DEVICE, |
| 361 | .parent = TYPE_I2C_SLAVE, |
| 362 | .instance_size = sizeof(SMBusDevice), |
| 363 | .abstract = true, |
| 364 | .class_size = sizeof(SMBusDeviceClass), |
| 365 | .class_init = smbus_device_class_init, |
| 366 | }; |
| 367 | |
Andreas Färber | 83f7d43 | 2012-02-09 15:20:55 +0100 | [diff] [blame] | 368 | static void smbus_device_register_types(void) |
Anthony Liguori | b5ea932 | 2011-12-04 20:39:20 -0600 | [diff] [blame] | 369 | { |
| 370 | type_register_static(&smbus_device_type_info); |
| 371 | } |
| 372 | |
Andreas Färber | 83f7d43 | 2012-02-09 15:20:55 +0100 | [diff] [blame] | 373 | type_init(smbus_device_register_types) |