drivers/i2c/i2c-core-smbus.c

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