drivers/i2c/i2c-core-smbus.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Linux I2C core SMBus and SMBus emulation code
   4  *
   5  * This file contains the SMBus functions which are always included in the I2C
   6  * core because they can be emulated via I2C. SMBus specific extensions
   7  * (e.g. smbalert) are handled in a separate i2c-smbus module.
   8  *
   9  * All SMBus-related things are written by Frodo Looijaard <frodol@dds.nl>
  10  * SMBus 2.0 support by Mark Studebaker <mdsxyz123@yahoo.com> and
  11  * Jean Delvare <jdelvare@suse.de>
  12  */
  13 #include <linux/device.h>
  14 #include <linux/err.h>
  15 #include <linux/i2c.h>
  16 #include <linux/i2c-smbus.h>
  17 #include <linux/slab.h>
  18
  19 #include "i2c-core.h"
  20
  21 #define CREATE_TRACE_POINTS
  22 #include <trace/events/smbus.h>
  23
  24
  25 /* The SMBus parts */
  26
  27 #define POLY    (0x1070U << 3)
  28 static u8 crc8(u16 data)
  29 {
  30         int i;
  31
  32         for (i = 0; i < 8; i++) {
  33                 if (data & 0x8000)
  34                         data = data ^ POLY;
  35                 data = data << 1;
  36         }
  37         return (u8)(data >> 8);
  38 }
  39
  40 /* Incremental CRC8 over count bytes in the array pointed to by p */
  41 static u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count)
  42 {
  43         int i;
  44
  45         for (i = 0; i < count; i++)
  46                 crc = crc8((crc ^ p[i]) << 8);
  47         return crc;
  48 }
  49
  50 /* Assume a 7-bit address, which is reasonable for SMBus */
  51 static u8 i2c_smbus_msg_pec(u8 pec, struct i2c_msg *msg)
  52 {
  53         /* The address will be sent first */
  54         u8 addr = i2c_8bit_addr_from_msg(msg);
  55         pec = i2c_smbus_pec(pec, &addr, 1);
  56
  57         /* The data buffer follows */
  58         return i2c_smbus_pec(pec, msg->buf, msg->len);
  59 }
  60
  61 /* Used for write only transactions */
  62 static inline void i2c_smbus_add_pec(struct i2c_msg *msg)
  63 {
  64         msg->buf[msg->len] = i2c_smbus_msg_pec(0, msg);
  65         msg->len++;
  66 }
  67
  68 /* Return <0 on CRC error
  69    If there was a write before this read (most cases) we need to take the
  70    partial CRC from the write part into account.
  71    Note that this function does modify the message (we need to decrease the
  72    message length to hide the CRC byte from the caller). */
  73 static int i2c_smbus_check_pec(u8 cpec, struct i2c_msg *msg)
  74 {
  75         u8 rpec = msg->buf[--msg->len];
  76         cpec = i2c_smbus_msg_pec(cpec, msg);
  77
  78         if (rpec != cpec) {
  79                 pr_debug("Bad PEC 0x%02x vs. 0x%02x\n",
  80                         rpec, cpec);
  81                 return -EBADMSG;
  82         }
  83         return 0;
  84 }
  85
  86 /**
  87  * i2c_smbus_read_byte - SMBus "receive byte" protocol
  88  * @client: Handle to slave device
  89  *
  90  * This executes the SMBus "receive byte" protocol, returning negative errno
  91  * else the byte received from the device.
  92  */
  93 s32 i2c_smbus_read_byte(const struct i2c_client *client)
  94 {
  95         union i2c_smbus_data data;
  96         int status;
  97
  98         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
  99                                 I2C_SMBUS_READ, 0,
 100                                 I2C_SMBUS_BYTE, &data);
 101         return (status < 0) ? status : data.byte;
 102 }
 103 EXPORT_SYMBOL(i2c_smbus_read_byte);
 104
 105 /**
 106  * i2c_smbus_write_byte - SMBus "send byte" protocol
 107  * @client: Handle to slave device
 108  * @value: Byte to be sent
 109  *
 110  * This executes the SMBus "send byte" protocol, returning negative errno
 111  * else zero on success.
 112  */
 113 s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value)
 114 {
 115         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 116                               I2C_SMBUS_WRITE, value, I2C_SMBUS_BYTE, NULL);
 117 }
 118 EXPORT_SYMBOL(i2c_smbus_write_byte);
 119
 120 /**
 121  * i2c_smbus_read_byte_data - SMBus "read byte" protocol
 122  * @client: Handle to slave device
 123  * @command: Byte interpreted by slave
 124  *
 125  * This executes the SMBus "read byte" protocol, returning negative errno
 126  * else a data byte received from the device.
 127  */
 128 s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command)
 129 {
 130         union i2c_smbus_data data;
 131         int status;
 132
 133         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 134                                 I2C_SMBUS_READ, command,
 135                                 I2C_SMBUS_BYTE_DATA, &data);
 136         return (status < 0) ? status : data.byte;
 137 }
 138 EXPORT_SYMBOL(i2c_smbus_read_byte_data);
 139
 140 /**
 141  * i2c_smbus_write_byte_data - SMBus "write byte" protocol
 142  * @client: Handle to slave device
 143  * @command: Byte interpreted by slave
 144  * @value: Byte being written
 145  *
 146  * This executes the SMBus "write byte" protocol, returning negative errno
 147  * else zero on success.
 148  */
 149 s32 i2c_smbus_write_byte_data(const struct i2c_client *client, u8 command,
 150                               u8 value)
 151 {
 152         union i2c_smbus_data data;
 153         data.byte = value;
 154         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 155                               I2C_SMBUS_WRITE, command,
 156                               I2C_SMBUS_BYTE_DATA, &data);
 157 }
 158 EXPORT_SYMBOL(i2c_smbus_write_byte_data);
 159
 160 /**
 161  * i2c_smbus_read_word_data - SMBus "read word" protocol
 162  * @client: Handle to slave device
 163  * @command: Byte interpreted by slave
 164  *
 165  * This executes the SMBus "read word" protocol, returning negative errno
 166  * else a 16-bit unsigned "word" received from the device.
 167  */
 168 s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command)
 169 {
 170         union i2c_smbus_data data;
 171         int status;
 172
 173         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 174                                 I2C_SMBUS_READ, command,
 175                                 I2C_SMBUS_WORD_DATA, &data);
 176         return (status < 0) ? status : data.word;
 177 }
 178 EXPORT_SYMBOL(i2c_smbus_read_word_data);
 179
 180 /**
 181  * i2c_smbus_write_word_data - SMBus "write word" protocol
 182  * @client: Handle to slave device
 183  * @command: Byte interpreted by slave
 184  * @value: 16-bit "word" being written
 185  *
 186  * This executes the SMBus "write word" protocol, returning negative errno
 187  * else zero on success.
 188  */
 189 s32 i2c_smbus_write_word_data(const struct i2c_client *client, u8 command,
 190                               u16 value)
 191 {
 192         union i2c_smbus_data data;
 193         data.word = value;
 194         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 195                               I2C_SMBUS_WRITE, command,
 196                               I2C_SMBUS_WORD_DATA, &data);
 197 }
 198 EXPORT_SYMBOL(i2c_smbus_write_word_data);
 199
 200 /**
 201  * i2c_smbus_read_block_data - SMBus "block read" protocol
 202  * @client: Handle to slave device
 203  * @command: Byte interpreted by slave
 204  * @values: Byte array into which data will be read; big enough to hold
 205  *      the data returned by the slave.  SMBus allows at most 32 bytes.
 206  *
 207  * This executes the SMBus "block read" protocol, returning negative errno
 208  * else the number of data bytes in the slave's response.
 209  *
 210  * Note that using this function requires that the client's adapter support
 211  * the I2C_FUNC_SMBUS_READ_BLOCK_DATA functionality.  Not all adapter drivers
 212  * support this; its emulation through I2C messaging relies on a specific
 213  * mechanism (I2C_M_RECV_LEN) which may not be implemented.
 214  */
 215 s32 i2c_smbus_read_block_data(const struct i2c_client *client, u8 command,
 216                               u8 *values)
 217 {
 218         union i2c_smbus_data data;
 219         int status;
 220
 221         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 222                                 I2C_SMBUS_READ, command,
 223                                 I2C_SMBUS_BLOCK_DATA, &data);
 224         if (status)
 225                 return status;
 226
 227         memcpy(values, &data.block[1], data.block[0]);
 228         return data.block[0];
 229 }
 230 EXPORT_SYMBOL(i2c_smbus_read_block_data);
 231
 232 /**
 233  * i2c_smbus_write_block_data - SMBus "block write" protocol
 234  * @client: Handle to slave device
 235  * @command: Byte interpreted by slave
 236  * @length: Size of data block; SMBus allows at most 32 bytes
 237  * @values: Byte array which will be written.
 238  *
 239  * This executes the SMBus "block write" protocol, returning negative errno
 240  * else zero on success.
 241  */
 242 s32 i2c_smbus_write_block_data(const struct i2c_client *client, u8 command,
 243                                u8 length, const u8 *values)
 244 {
 245         union i2c_smbus_data data;
 246
 247         if (length > I2C_SMBUS_BLOCK_MAX)
 248                 length = I2C_SMBUS_BLOCK_MAX;
 249         data.block[0] = length;
 250         memcpy(&data.block[1], values, length);
 251         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 252                               I2C_SMBUS_WRITE, command,
 253                               I2C_SMBUS_BLOCK_DATA, &data);
 254 }
 255 EXPORT_SYMBOL(i2c_smbus_write_block_data);
 256
 257 /* Returns the number of read bytes */
 258 s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client, u8 command,
 259                                   u8 length, u8 *values)
 260 {
 261         union i2c_smbus_data data;
 262         int status;
 263
 264         if (length > I2C_SMBUS_BLOCK_MAX)
 265                 length = I2C_SMBUS_BLOCK_MAX;
 266         data.block[0] = length;
 267         status = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 268                                 I2C_SMBUS_READ, command,
 269                                 I2C_SMBUS_I2C_BLOCK_DATA, &data);
 270         if (status < 0)
 271                 return status;
 272
 273         memcpy(values, &data.block[1], data.block[0]);
 274         return data.block[0];
 275 }
 276 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
 277
 278 s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client, u8 command,
 279                                    u8 length, const u8 *values)
 280 {
 281         union i2c_smbus_data data;
 282
 283         if (length > I2C_SMBUS_BLOCK_MAX)
 284                 length = I2C_SMBUS_BLOCK_MAX;
 285         data.block[0] = length;
 286         memcpy(data.block + 1, values, length);
 287         return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
 288                               I2C_SMBUS_WRITE, command,
 289                               I2C_SMBUS_I2C_BLOCK_DATA, &data);
 290 }
 291 EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
 292
 293 static void i2c_smbus_try_get_dmabuf(struct i2c_msg *msg, u8 init_val)
 294 {
 295         bool is_read = msg->flags & I2C_M_RD;
 296         unsigned char *dma_buf;
 297
 298         dma_buf = kzalloc(I2C_SMBUS_BLOCK_MAX + (is_read ? 2 : 3), GFP_KERNEL);
 299         if (!dma_buf)
 300                 return;
 301
 302         msg->buf = dma_buf;
 303         msg->flags |= I2C_M_DMA_SAFE;
 304
 305         if (init_val)
 306                 msg->buf[0] = init_val;
 307 }
 308
 309 /*
 310  * Simulate a SMBus command using the I2C protocol.
 311  * No checking of parameters is done!
 312  */
 313 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter *adapter, u16 addr,
 314                                    unsigned short flags,
 315                                    char read_write, u8 command, int size,
 316                                    union i2c_smbus_data *data)
 317 {
 318         /*
 319          * So we need to generate a series of msgs. In the case of writing, we
 320          * need to use only one message; when reading, we need two. We
 321          * initialize most things with sane defaults, to keep the code below
 322          * somewhat simpler.
 323          */
 324         unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
 325         unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
 326         int nmsgs = read_write == I2C_SMBUS_READ ? 2 : 1;
 327         u8 partial_pec = 0;
 328         int status;
 329         struct i2c_msg msg[2] = {
 330                 {
 331                         .addr = addr,
 332                         .flags = flags,
 333                         .len = 1,
 334                         .buf = msgbuf0,
 335                 }, {
 336                         .addr = addr,
 337                         .flags = flags | I2C_M_RD,
 338                         .len = 0,
 339                         .buf = msgbuf1,
 340                 },
 341         };
 342         bool wants_pec = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
 343                           && size != I2C_SMBUS_I2C_BLOCK_DATA);
 344
 345         msgbuf0[0] = command;
 346         switch (size) {
 347         case I2C_SMBUS_QUICK:
 348                 msg[0].len = 0;
 349                 /* Special case: The read/write field is used as data */
 350                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
 351                                         I2C_M_RD : 0);
 352                 nmsgs = 1;
 353                 break;
 354         case I2C_SMBUS_BYTE:
 355                 if (read_write == I2C_SMBUS_READ) {
 356                         /* Special case: only a read! */
 357                         msg[0].flags = I2C_M_RD | flags;
 358                         nmsgs = 1;
 359                 }
 360                 break;
 361         case I2C_SMBUS_BYTE_DATA:
 362                 if (read_write == I2C_SMBUS_READ)
 363                         msg[1].len = 1;
 364                 else {
 365                         msg[0].len = 2;
 366                         msgbuf0[1] = data->byte;
 367                 }
 368                 break;
 369         case I2C_SMBUS_WORD_DATA:
 370                 if (read_write == I2C_SMBUS_READ)
 371                         msg[1].len = 2;
 372                 else {
 373                         msg[0].len = 3;
 374                         msgbuf0[1] = data->word & 0xff;
 375                         msgbuf0[2] = data->word >> 8;
 376                 }
 377                 break;
 378         case I2C_SMBUS_PROC_CALL:
 379                 nmsgs = 2; /* Special case */
 380                 read_write = I2C_SMBUS_READ;
 381                 msg[0].len = 3;
 382                 msg[1].len = 2;
 383                 msgbuf0[1] = data->word & 0xff;
 384                 msgbuf0[2] = data->word >> 8;
 385                 break;
 386         case I2C_SMBUS_BLOCK_DATA:
 387                 if (read_write == I2C_SMBUS_READ) {
 388                         msg[1].flags |= I2C_M_RECV_LEN;
 389                         msg[1].len = 1; /* block length will be added by
 390                                            the underlying bus driver */
 391                         i2c_smbus_try_get_dmabuf(&msg[1], 0);
 392                 } else {
 393                         msg[0].len = data->block[0] + 2;
 394                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
 395                                 dev_err(&adapter->dev,
 396                                         "Invalid block write size %d\n",
 397                                         data->block[0]);
 398                                 return -EINVAL;
 399                         }
 400
 401                         i2c_smbus_try_get_dmabuf(&msg[0], command);
 402                         memcpy(msg[0].buf + 1, data->block, msg[0].len - 1);
 403                 }
 404                 break;
 405         case I2C_SMBUS_BLOCK_PROC_CALL:
 406                 nmsgs = 2; /* Another special case */
 407                 read_write = I2C_SMBUS_READ;
 408                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
 409                         dev_err(&adapter->dev,
 410                                 "Invalid block write size %d\n",
 411                                 data->block[0]);
 412                         return -EINVAL;
 413                 }
 414
 415                 msg[0].len = data->block[0] + 2;
 416                 i2c_smbus_try_get_dmabuf(&msg[0], command);
 417                 memcpy(msg[0].buf + 1, data->block, msg[0].len - 1);
 418
 419                 msg[1].flags |= I2C_M_RECV_LEN;
 420                 msg[1].len = 1; /* block length will be added by
 421                                    the underlying bus driver */
 422                 i2c_smbus_try_get_dmabuf(&msg[1], 0);
 423                 break;
 424         case I2C_SMBUS_I2C_BLOCK_DATA:
 425                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
 426                         dev_err(&adapter->dev, "Invalid block %s size %d\n",
 427                                 read_write == I2C_SMBUS_READ ? "read" : "write",
 428                                 data->block[0]);
 429                         return -EINVAL;
 430                 }
 431
 432                 if (read_write == I2C_SMBUS_READ) {
 433                         msg[1].len = data->block[0];
 434                         i2c_smbus_try_get_dmabuf(&msg[1], 0);
 435                 } else {
 436                         msg[0].len = data->block[0] + 1;
 437
 438                         i2c_smbus_try_get_dmabuf(&msg[0], command);
 439                         memcpy(msg[0].buf + 1, data->block + 1, data->block[0]);
 440                 }
 441                 break;
 442         default:
 443                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
 444                 return -EOPNOTSUPP;
 445         }
 446
 447         if (wants_pec) {
 448                 /* Compute PEC if first message is a write */
 449                 if (!(msg[0].flags & I2C_M_RD)) {
 450                         if (nmsgs == 1) /* Write only */
 451                                 i2c_smbus_add_pec(&msg[0]);
 452                         else /* Write followed by read */
 453                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
 454                 }
 455                 /* Ask for PEC if last message is a read */
 456                 if (msg[nmsgs - 1].flags & I2C_M_RD)
 457                         msg[nmsgs - 1].len++;
 458         }
 459
 460         status = __i2c_transfer(adapter, msg, nmsgs);
 461         if (status < 0)
 462                 goto cleanup;
 463         if (status != nmsgs) {
 464                 status = -EIO;
 465                 goto cleanup;
 466         }
 467         status = 0;
 468
 469         /* Check PEC if last message is a read */
 470         if (wants_pec && (msg[nmsgs - 1].flags & I2C_M_RD)) {
 471                 status = i2c_smbus_check_pec(partial_pec, &msg[nmsgs - 1]);
 472                 if (status < 0)
 473                         goto cleanup;
 474         }
 475
 476         if (read_write == I2C_SMBUS_READ)
 477                 switch (size) {
 478                 case I2C_SMBUS_BYTE:
 479                         data->byte = msgbuf0[0];
 480                         break;
 481                 case I2C_SMBUS_BYTE_DATA:
 482                         data->byte = msgbuf1[0];
 483                         break;
 484                 case I2C_SMBUS_WORD_DATA:
 485                 case I2C_SMBUS_PROC_CALL:
 486                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
 487                         break;
 488                 case I2C_SMBUS_I2C_BLOCK_DATA:
 489                         memcpy(data->block + 1, msg[1].buf, data->block[0]);
 490                         break;
 491                 case I2C_SMBUS_BLOCK_DATA:
 492                 case I2C_SMBUS_BLOCK_PROC_CALL:
 493                         if (msg[1].buf[0] > I2C_SMBUS_BLOCK_MAX) {
 494                                 dev_err(&adapter->dev,
 495                                         "Invalid block size returned: %d\n",
 496                                         msg[1].buf[0]);
 497                                 status = -EPROTO;
 498                                 goto cleanup;
 499                         }
 500                         memcpy(data->block, msg[1].buf, msg[1].buf[0] + 1);
 501                         break;
 502                 }
 503
 504 cleanup:
 505         if (msg[0].flags & I2C_M_DMA_SAFE)
 506                 kfree(msg[0].buf);
 507         if (msg[1].flags & I2C_M_DMA_SAFE)
 508                 kfree(msg[1].buf);
 509
 510         return status;
 511 }
 512
 513 /**
 514  * i2c_smbus_xfer - execute SMBus protocol operations
 515  * @adapter: Handle to I2C bus
 516  * @addr: Address of SMBus slave on that bus
 517  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
 518  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
 519  * @command: Byte interpreted by slave, for protocols which use such bytes
 520  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
 521  * @data: Data to be read or written
 522  *
 523  * This executes an SMBus protocol operation, and returns a negative
 524  * errno code else zero on success.
 525  */
 526 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 527                    unsigned short flags, char read_write,
 528                    u8 command, int protocol, union i2c_smbus_data *data)
 529 {
 530         s32 res;
 531
 532         res = __i2c_lock_bus_helper(adapter);
 533         if (res)
 534                 return res;
 535
 536         res = __i2c_smbus_xfer(adapter, addr, flags, read_write,
 537                                command, protocol, data);
 538         i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
 539
 540         return res;
 541 }
 542 EXPORT_SYMBOL(i2c_smbus_xfer);
 543
 544 s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 545                      unsigned short flags, char read_write,
 546                      u8 command, int protocol, union i2c_smbus_data *data)
 547 {
 548         int (*xfer_func)(struct i2c_adapter *adap, u16 addr,
 549                          unsigned short flags, char read_write,
 550                          u8 command, int size, union i2c_smbus_data *data);
 551         unsigned long orig_jiffies;
 552         int try;
 553         s32 res;
 554
 555         res = __i2c_check_suspended(adapter);
 556         if (res)
 557                 return res;
 558
 559         /* If enabled, the following two tracepoints are conditional on
 560          * read_write and protocol.
 561          */
 562         trace_smbus_write(adapter, addr, flags, read_write,
 563                           command, protocol, data);
 564         trace_smbus_read(adapter, addr, flags, read_write,
 565                          command, protocol);
 566
 567         flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
 568
 569         xfer_func = adapter->algo->smbus_xfer;
 570         if (i2c_in_atomic_xfer_mode()) {
 571                 if (adapter->algo->smbus_xfer_atomic)
 572                         xfer_func = adapter->algo->smbus_xfer_atomic;
 573                 else if (adapter->algo->master_xfer_atomic)
 574                         xfer_func = NULL; /* fallback to I2C emulation */
 575         }
 576
 577         if (xfer_func) {
 578                 /* Retry automatically on arbitration loss */
 579                 orig_jiffies = jiffies;
 580                 for (res = 0, try = 0; try <= adapter->retries; try++) {
 581                         res = xfer_func(adapter, addr, flags, read_write,
 582                                         command, protocol, data);
 583                         if (res != -EAGAIN)
 584                                 break;
 585                         if (time_after(jiffies,
 586                                        orig_jiffies + adapter->timeout))
 587                                 break;
 588                 }
 589
 590                 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
 591                         goto trace;
 592                 /*
 593                  * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
 594                  * implement native support for the SMBus operation.
 595                  */
 596         }
 597
 598         res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
 599                                       command, protocol, data);
 600
 601 trace:
 602         /* If enabled, the reply tracepoint is conditional on read_write. */
 603         trace_smbus_reply(adapter, addr, flags, read_write,
 604                           command, protocol, data, res);
 605         trace_smbus_result(adapter, addr, flags, read_write,
 606                            command, protocol, res);
 607
 608         return res;
 609 }
 610 EXPORT_SYMBOL(__i2c_smbus_xfer);
 611
 612 /**
 613  * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
 614  * @client: Handle to slave device
 615  * @command: Byte interpreted by slave
 616  * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
 617  * @values: Byte array into which data will be read; big enough to hold
 618  *      the data returned by the slave.  SMBus allows at most
 619  *      I2C_SMBUS_BLOCK_MAX bytes.
 620  *
 621  * This executes the SMBus "block read" protocol if supported by the adapter.
 622  * If block read is not supported, it emulates it using either word or byte
 623  * read protocols depending on availability.
 624  *
 625  * The addresses of the I2C slave device that are accessed with this function
 626  * must be mapped to a linear region, so that a block read will have the same
 627  * effect as a byte read. Before using this function you must double-check
 628  * if the I2C slave does support exchanging a block transfer with a byte
 629  * transfer.
 630  */
 631 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
 632                                               u8 command, u8 length, u8 *values)
 633 {
 634         u8 i = 0;
 635         int status;
 636
 637         if (length > I2C_SMBUS_BLOCK_MAX)
 638                 length = I2C_SMBUS_BLOCK_MAX;
 639
 640         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
 641                 return i2c_smbus_read_i2c_block_data(client, command, length, values);
 642
 643         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
 644                 return -EOPNOTSUPP;
 645
 646         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
 647                 while ((i + 2) <= length) {
 648                         status = i2c_smbus_read_word_data(client, command + i);
 649                         if (status < 0)
 650                                 return status;
 651                         values[i] = status & 0xff;
 652                         values[i + 1] = status >> 8;
 653                         i += 2;
 654                 }
 655         }
 656
 657         while (i < length) {
 658                 status = i2c_smbus_read_byte_data(client, command + i);
 659                 if (status < 0)
 660                         return status;
 661                 values[i] = status;
 662                 i++;
 663         }
 664
 665         return i;
 666 }
 667 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
 668
 669 /**
 670  * i2c_new_smbus_alert_device - get ara client for SMBus alert support
 671  * @adapter: the target adapter
 672  * @setup: setup data for the SMBus alert handler
 673  * Context: can sleep
 674  *
 675  * Setup handling of the SMBus alert protocol on a given I2C bus segment.
 676  *
 677  * Handling can be done either through our IRQ handler, or by the
 678  * adapter (from its handler, periodic polling, or whatever).
 679  *
 680  * This returns the ara client, which should be saved for later use with
 681  * i2c_handle_smbus_alert() and ultimately i2c_unregister_device(); or an
 682  * ERRPTR to indicate an error.
 683  */
 684 struct i2c_client *i2c_new_smbus_alert_device(struct i2c_adapter *adapter,
 685                                               struct i2c_smbus_alert_setup *setup)
 686 {
 687         struct i2c_board_info ara_board_info = {
 688                 I2C_BOARD_INFO("smbus_alert", 0x0c),
 689                 .platform_data = setup,
 690         };
 691
 692         return i2c_new_client_device(adapter, &ara_board_info);
 693 }
 694 EXPORT_SYMBOL_GPL(i2c_new_smbus_alert_device);
 695
 696 #if IS_ENABLED(CONFIG_I2C_SMBUS) && IS_ENABLED(CONFIG_OF)
 697 int of_i2c_setup_smbus_alert(struct i2c_adapter *adapter)
 698 {
 699         int irq;
 700
 701         irq = of_property_match_string(adapter->dev.of_node, "interrupt-names",
 702                                        "smbus_alert");
 703         if (irq == -EINVAL || irq == -ENODATA)
 704                 return 0;
 705         else if (irq < 0)
 706                 return irq;
 707
 708         return PTR_ERR_OR_ZERO(i2c_new_smbus_alert_device(adapter, NULL));
 709 }
 710 EXPORT_SYMBOL_GPL(of_i2c_setup_smbus_alert);
 711 #endif