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