root/drivers/i2c/i2c-core-smbus.c

DEFINITIONS

1. crc8
2. i2c_smbus_pec
3. i2c_smbus_msg_pec
4. i2c_smbus_add_pec
5. i2c_smbus_check_pec
6. i2c_smbus_read_byte
7. i2c_smbus_write_byte
8. i2c_smbus_read_byte_data
9. i2c_smbus_write_byte_data
10. i2c_smbus_read_word_data
11. i2c_smbus_write_word_data
12. i2c_smbus_read_block_data
13. i2c_smbus_write_block_data
14. i2c_smbus_read_i2c_block_data
15. i2c_smbus_write_i2c_block_data
16. i2c_smbus_try_get_dmabuf
17. i2c_smbus_xfer_emulated
18. i2c_smbus_xfer
19. __i2c_smbus_xfer
20. i2c_smbus_read_i2c_block_data_or_emulated
21. i2c_setup_smbus_alert
22. of_i2c_setup_smbus_alert

   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 seperate 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 num = read_write == I2C_SMBUS_READ ? 2 : 1;
 327         int i;
 328         u8 partial_pec = 0;
 329         int status;
 330         struct i2c_msg msg[2] = {
 331                 {
 332                         .addr = addr,
 333                         .flags = flags,
 334                         .len = 1,
 335                         .buf = msgbuf0,
 336                 }, {
 337                         .addr = addr,
 338                         .flags = flags | I2C_M_RD,
 339                         .len = 0,
 340                         .buf = msgbuf1,
 341                 },
 342         };
 343 
 344         msgbuf0[0] = command;
 345         switch (size) {
 346         case I2C_SMBUS_QUICK:
 347                 msg[0].len = 0;
 348                 /* Special case: The read/write field is used as data */
 349                 msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?
 350                                         I2C_M_RD : 0);
 351                 num = 1;
 352                 break;
 353         case I2C_SMBUS_BYTE:
 354                 if (read_write == I2C_SMBUS_READ) {
 355                         /* Special case: only a read! */
 356                         msg[0].flags = I2C_M_RD | flags;
 357                         num = 1;
 358                 }
 359                 break;
 360         case I2C_SMBUS_BYTE_DATA:
 361                 if (read_write == I2C_SMBUS_READ)
 362                         msg[1].len = 1;
 363                 else {
 364                         msg[0].len = 2;
 365                         msgbuf0[1] = data->byte;
 366                 }
 367                 break;
 368         case I2C_SMBUS_WORD_DATA:
 369                 if (read_write == I2C_SMBUS_READ)
 370                         msg[1].len = 2;
 371                 else {
 372                         msg[0].len = 3;
 373                         msgbuf0[1] = data->word & 0xff;
 374                         msgbuf0[2] = data->word >> 8;
 375                 }
 376                 break;
 377         case I2C_SMBUS_PROC_CALL:
 378                 num = 2; /* Special case */
 379                 read_write = I2C_SMBUS_READ;
 380                 msg[0].len = 3;
 381                 msg[1].len = 2;
 382                 msgbuf0[1] = data->word & 0xff;
 383                 msgbuf0[2] = data->word >> 8;
 384                 break;
 385         case I2C_SMBUS_BLOCK_DATA:
 386                 if (read_write == I2C_SMBUS_READ) {
 387                         msg[1].flags |= I2C_M_RECV_LEN;
 388                         msg[1].len = 1; /* block length will be added by
 389                                            the underlying bus driver */
 390                         i2c_smbus_try_get_dmabuf(&msg[1], 0);
 391                 } else {
 392                         msg[0].len = data->block[0] + 2;
 393                         if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
 394                                 dev_err(&adapter->dev,
 395                                         "Invalid block write size %d\n",
 396                                         data->block[0]);
 397                                 return -EINVAL;
 398                         }
 399 
 400                         i2c_smbus_try_get_dmabuf(&msg[0], command);
 401                         for (i = 1; i < msg[0].len; i++)
 402                                 msg[0].buf[i] = data->block[i - 1];
 403                 }
 404                 break;
 405         case I2C_SMBUS_BLOCK_PROC_CALL:
 406                 num = 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                 for (i = 1; i < msg[0].len; i++)
 418                         msg[0].buf[i] = data->block[i - 1];
 419 
 420                 msg[1].flags |= I2C_M_RECV_LEN;
 421                 msg[1].len = 1; /* block length will be added by
 422                                    the underlying bus driver */
 423                 i2c_smbus_try_get_dmabuf(&msg[1], 0);
 424                 break;
 425         case I2C_SMBUS_I2C_BLOCK_DATA:
 426                 if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
 427                         dev_err(&adapter->dev, "Invalid block %s size %d\n",
 428                                 read_write == I2C_SMBUS_READ ? "read" : "write",
 429                                 data->block[0]);
 430                         return -EINVAL;
 431                 }
 432 
 433                 if (read_write == I2C_SMBUS_READ) {
 434                         msg[1].len = data->block[0];
 435                         i2c_smbus_try_get_dmabuf(&msg[1], 0);
 436                 } else {
 437                         msg[0].len = data->block[0] + 1;
 438 
 439                         i2c_smbus_try_get_dmabuf(&msg[0], command);
 440                         for (i = 1; i <= data->block[0]; i++)
 441                                 msg[0].buf[i] = data->block[i];
 442                 }
 443                 break;
 444         default:
 445                 dev_err(&adapter->dev, "Unsupported transaction %d\n", size);
 446                 return -EOPNOTSUPP;
 447         }
 448 
 449         i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
 450                                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
 451         if (i) {
 452                 /* Compute PEC if first message is a write */
 453                 if (!(msg[0].flags & I2C_M_RD)) {
 454                         if (num == 1) /* Write only */
 455                                 i2c_smbus_add_pec(&msg[0]);
 456                         else /* Write followed by read */
 457                                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
 458                 }
 459                 /* Ask for PEC if last message is a read */
 460                 if (msg[num-1].flags & I2C_M_RD)
 461                         msg[num-1].len++;
 462         }
 463 
 464         status = __i2c_transfer(adapter, msg, num);
 465         if (status < 0)
 466                 goto cleanup;
 467         if (status != num) {
 468                 status = -EIO;
 469                 goto cleanup;
 470         }
 471         status = 0;
 472 
 473         /* Check PEC if last message is a read */
 474         if (i && (msg[num-1].flags & I2C_M_RD)) {
 475                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
 476                 if (status < 0)
 477                         goto cleanup;
 478         }
 479 
 480         if (read_write == I2C_SMBUS_READ)
 481                 switch (size) {
 482                 case I2C_SMBUS_BYTE:
 483                         data->byte = msgbuf0[0];
 484                         break;
 485                 case I2C_SMBUS_BYTE_DATA:
 486                         data->byte = msgbuf1[0];
 487                         break;
 488                 case I2C_SMBUS_WORD_DATA:
 489                 case I2C_SMBUS_PROC_CALL:
 490                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
 491                         break;
 492                 case I2C_SMBUS_I2C_BLOCK_DATA:
 493                         for (i = 0; i < data->block[0]; i++)
 494                                 data->block[i + 1] = msg[1].buf[i];
 495                         break;
 496                 case I2C_SMBUS_BLOCK_DATA:
 497                 case I2C_SMBUS_BLOCK_PROC_CALL:
 498                         for (i = 0; i < msg[1].buf[0] + 1; i++)
 499                                 data->block[i] = msg[1].buf[i];
 500                         break;
 501                 }
 502 
 503 cleanup:
 504         if (msg[0].flags & I2C_M_DMA_SAFE)
 505                 kfree(msg[0].buf);
 506         if (msg[1].flags & I2C_M_DMA_SAFE)
 507                 kfree(msg[1].buf);
 508 
 509         return status;
 510 }
 511 
 512 /**
 513  * i2c_smbus_xfer - execute SMBus protocol operations
 514  * @adapter: Handle to I2C bus
 515  * @addr: Address of SMBus slave on that bus
 516  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
 517  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
 518  * @command: Byte interpreted by slave, for protocols which use such bytes
 519  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
 520  * @data: Data to be read or written
 521  *
 522  * This executes an SMBus protocol operation, and returns a negative
 523  * errno code else zero on success.
 524  */
 525 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 526                    unsigned short flags, char read_write,
 527                    u8 command, int protocol, union i2c_smbus_data *data)
 528 {
 529         s32 res;
 530 
 531         res = __i2c_lock_bus_helper(adapter);
 532         if (res)
 533                 return res;
 534 
 535         res = __i2c_smbus_xfer(adapter, addr, flags, read_write,
 536                                command, protocol, data);
 537         i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
 538 
 539         return res;
 540 }
 541 EXPORT_SYMBOL(i2c_smbus_xfer);
 542 
 543 s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 544                      unsigned short flags, char read_write,
 545                      u8 command, int protocol, union i2c_smbus_data *data)
 546 {
 547         int (*xfer_func)(struct i2c_adapter *adap, u16 addr,
 548                          unsigned short flags, char read_write,
 549                          u8 command, int size, union i2c_smbus_data *data);
 550         unsigned long orig_jiffies;
 551         int try;
 552         s32 res;
 553 
 554         res = __i2c_check_suspended(adapter);
 555         if (res)
 556                 return res;
 557 
 558         /* If enabled, the following two tracepoints are conditional on
 559          * read_write and protocol.
 560          */
 561         trace_smbus_write(adapter, addr, flags, read_write,
 562                           command, protocol, data);
 563         trace_smbus_read(adapter, addr, flags, read_write,
 564                          command, protocol);
 565 
 566         flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
 567 
 568         xfer_func = adapter->algo->smbus_xfer;
 569         if (i2c_in_atomic_xfer_mode()) {
 570                 if (adapter->algo->smbus_xfer_atomic)
 571                         xfer_func = adapter->algo->smbus_xfer_atomic;
 572                 else if (adapter->algo->master_xfer_atomic)
 573                         xfer_func = NULL; /* fallback to I2C emulation */
 574         }
 575 
 576         if (xfer_func) {
 577                 /* Retry automatically on arbitration loss */
 578                 orig_jiffies = jiffies;
 579                 for (res = 0, try = 0; try <= adapter->retries; try++) {
 580                         res = xfer_func(adapter, addr, flags, read_write,
 581                                         command, protocol, data);
 582                         if (res != -EAGAIN)
 583                                 break;
 584                         if (time_after(jiffies,
 585                                        orig_jiffies + adapter->timeout))
 586                                 break;
 587                 }
 588 
 589                 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
 590                         goto trace;
 591                 /*
 592                  * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
 593                  * implement native support for the SMBus operation.
 594                  */
 595         }
 596 
 597         res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
 598                                       command, protocol, data);
 599 
 600 trace:
 601         /* If enabled, the reply tracepoint is conditional on read_write. */
 602         trace_smbus_reply(adapter, addr, flags, read_write,
 603                           command, protocol, data, res);
 604         trace_smbus_result(adapter, addr, flags, read_write,
 605                            command, protocol, res);
 606 
 607         return res;
 608 }
 609 EXPORT_SYMBOL(__i2c_smbus_xfer);
 610 
 611 /**
 612  * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
 613  * @client: Handle to slave device
 614  * @command: Byte interpreted by slave
 615  * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
 616  * @values: Byte array into which data will be read; big enough to hold
 617  *      the data returned by the slave.  SMBus allows at most
 618  *      I2C_SMBUS_BLOCK_MAX bytes.
 619  *
 620  * This executes the SMBus "block read" protocol if supported by the adapter.
 621  * If block read is not supported, it emulates it using either word or byte
 622  * read protocols depending on availability.
 623  *
 624  * The addresses of the I2C slave device that are accessed with this function
 625  * must be mapped to a linear region, so that a block read will have the same
 626  * effect as a byte read. Before using this function you must double-check
 627  * if the I2C slave does support exchanging a block transfer with a byte
 628  * transfer.
 629  */
 630 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
 631                                               u8 command, u8 length, u8 *values)
 632 {
 633         u8 i = 0;
 634         int status;
 635 
 636         if (length > I2C_SMBUS_BLOCK_MAX)
 637                 length = I2C_SMBUS_BLOCK_MAX;
 638 
 639         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
 640                 return i2c_smbus_read_i2c_block_data(client, command, length, values);
 641 
 642         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
 643                 return -EOPNOTSUPP;
 644 
 645         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
 646                 while ((i + 2) <= length) {
 647                         status = i2c_smbus_read_word_data(client, command + i);
 648                         if (status < 0)
 649                                 return status;
 650                         values[i] = status & 0xff;
 651                         values[i + 1] = status >> 8;
 652                         i += 2;
 653                 }
 654         }
 655 
 656         while (i < length) {
 657                 status = i2c_smbus_read_byte_data(client, command + i);
 658                 if (status < 0)
 659                         return status;
 660                 values[i] = status;
 661                 i++;
 662         }
 663 
 664         return i;
 665 }
 666 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
 667 
 668 /**
 669  * i2c_setup_smbus_alert - Setup SMBus alert support
 670  * @adapter: the target adapter
 671  * @setup: setup data for the SMBus alert handler
 672  * Context: can sleep
 673  *
 674  * Setup handling of the SMBus alert protocol on a given I2C bus segment.
 675  *
 676  * Handling can be done either through our IRQ handler, or by the
 677  * adapter (from its handler, periodic polling, or whatever).
 678  *
 679  * NOTE that if we manage the IRQ, we *MUST* know if it's level or
 680  * edge triggered in order to hand it to the workqueue correctly.
 681  * If triggering the alert seems to wedge the system, you probably
 682  * should have said it's level triggered.
 683  *
 684  * This returns the ara client, which should be saved for later use with
 685  * i2c_handle_smbus_alert() and ultimately i2c_unregister_device(); or NULL
 686  * to indicate an error.
 687  */
 688 struct i2c_client *i2c_setup_smbus_alert(struct i2c_adapter *adapter,
 689                                          struct i2c_smbus_alert_setup *setup)
 690 {
 691         struct i2c_board_info ara_board_info = {
 692                 I2C_BOARD_INFO("smbus_alert", 0x0c),
 693                 .platform_data = setup,
 694         };
 695 
 696         return i2c_new_device(adapter, &ara_board_info);
 697 }
 698 EXPORT_SYMBOL_GPL(i2c_setup_smbus_alert);
 699 
 700 #if IS_ENABLED(CONFIG_I2C_SMBUS) && IS_ENABLED(CONFIG_OF)
 701 int of_i2c_setup_smbus_alert(struct i2c_adapter *adapter)
 702 {
 703         struct i2c_client *client;
 704         int irq;
 705 
 706         irq = of_property_match_string(adapter->dev.of_node, "interrupt-names",
 707                                        "smbus_alert");
 708         if (irq == -EINVAL || irq == -ENODATA)
 709                 return 0;
 710         else if (irq < 0)
 711                 return irq;
 712 
 713         client = i2c_setup_smbus_alert(adapter, NULL);
 714         if (!client)
 715                 return -ENODEV;
 716 
 717         return 0;
 718 }
 719 EXPORT_SYMBOL_GPL(of_i2c_setup_smbus_alert);
 720 #endif