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,
 528                    unsigned short flags, char read_write,
 529                    u8 command, int protocol, union i2c_smbus_data *data)
 530 {
 531         s32 res;
 532
 533         i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
 534         res = __i2c_smbus_xfer(adapter, addr, flags, read_write,
 535                                command, protocol, data);
 536         i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
 537
 538         return res;
 539 }
 540 EXPORT_SYMBOL(i2c_smbus_xfer);
 541
 542 s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
 543                      unsigned short flags, char read_write,
 544                      u8 command, int protocol, union i2c_smbus_data *data)
 545 {
 546         unsigned long orig_jiffies;
 547         int try;
 548         s32 res;
 549
 550         /* If enabled, the following two tracepoints are conditional on
 551          * read_write and protocol.
 552          */
 553         trace_smbus_write(adapter, addr, flags, read_write,
 554                           command, protocol, data);
 555         trace_smbus_read(adapter, addr, flags, read_write,
 556                          command, protocol);
 557
 558         flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
 559
 560         if (adapter->algo->smbus_xfer) {
 561                 /* Retry automatically on arbitration loss */
 562                 orig_jiffies = jiffies;
 563                 for (res = 0, try = 0; try <= adapter->retries; try++) {
 564                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
 565                                                         read_write, command,
 566                                                         protocol, data);
 567                         if (res != -EAGAIN)
 568                                 break;
 569                         if (time_after(jiffies,
 570                                        orig_jiffies + adapter->timeout))
 571                                 break;
 572                 }
 573
 574                 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
 575                         goto trace;
 576                 /*
 577                  * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
 578                  * implement native support for the SMBus operation.
 579                  */
 580         }
 581
 582         res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
 583                                       command, protocol, data);
 584
 585 trace:
 586         /* If enabled, the reply tracepoint is conditional on read_write. */
 587         trace_smbus_reply(adapter, addr, flags, read_write,
 588                           command, protocol, data);
 589         trace_smbus_result(adapter, addr, flags, read_write,
 590                            command, protocol, res);
 591
 592         return res;
 593 }
 594 EXPORT_SYMBOL(__i2c_smbus_xfer);
 595
 596 /**
 597  * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
 598  * @client: Handle to slave device
 599  * @command: Byte interpreted by slave
 600  * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
 601  * @values: Byte array into which data will be read; big enough to hold
 602  *      the data returned by the slave.  SMBus allows at most
 603  *      I2C_SMBUS_BLOCK_MAX bytes.
 604  *
 605  * This executes the SMBus "block read" protocol if supported by the adapter.
 606  * If block read is not supported, it emulates it using either word or byte
 607  * read protocols depending on availability.
 608  *
 609  * The addresses of the I2C slave device that are accessed with this function
 610  * must be mapped to a linear region, so that a block read will have the same
 611  * effect as a byte read. Before using this function you must double-check
 612  * if the I2C slave does support exchanging a block transfer with a byte
 613  * transfer.
 614  */
 615 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
 616                                               u8 command, u8 length, u8 *values)
 617 {
 618         u8 i = 0;
 619         int status;
 620
 621         if (length > I2C_SMBUS_BLOCK_MAX)
 622                 length = I2C_SMBUS_BLOCK_MAX;
 623
 624         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
 625                 return i2c_smbus_read_i2c_block_data(client, command, length, values);
 626
 627         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
 628                 return -EOPNOTSUPP;
 629
 630         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
 631                 while ((i + 2) <= length) {
 632                         status = i2c_smbus_read_word_data(client, command + i);
 633                         if (status < 0)
 634                                 return status;
 635                         values[i] = status & 0xff;
 636                         values[i + 1] = status >> 8;
 637                         i += 2;
 638                 }
 639         }
 640
 641         while (i < length) {
 642                 status = i2c_smbus_read_byte_data(client, command + i);
 643                 if (status < 0)
 644                         return status;
 645                 values[i] = status;
 646                 i++;
 647         }
 648
 649         return i;
 650 }
 651 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
 652
 653 /**
 654  * i2c_setup_smbus_alert - Setup SMBus alert support
 655  * @adapter: the target adapter
 656  * @setup: setup data for the SMBus alert handler
 657  * Context: can sleep
 658  *
 659  * Setup handling of the SMBus alert protocol on a given I2C bus segment.
 660  *
 661  * Handling can be done either through our IRQ handler, or by the
 662  * adapter (from its handler, periodic polling, or whatever).
 663  *
 664  * NOTE that if we manage the IRQ, we *MUST* know if it's level or
 665  * edge triggered in order to hand it to the workqueue correctly.
 666  * If triggering the alert seems to wedge the system, you probably
 667  * should have said it's level triggered.
 668  *
 669  * This returns the ara client, which should be saved for later use with
 670  * i2c_handle_smbus_alert() and ultimately i2c_unregister_device(); or NULL
 671  * to indicate an error.
 672  */
 673 struct i2c_client *i2c_setup_smbus_alert(struct i2c_adapter *adapter,
 674                                          struct i2c_smbus_alert_setup *setup)
 675 {
 676         struct i2c_board_info ara_board_info = {
 677                 I2C_BOARD_INFO("smbus_alert", 0x0c),
 678                 .platform_data = setup,
 679         };
 680
 681         return i2c_new_device(adapter, &ara_board_info);
 682 }
 683 EXPORT_SYMBOL_GPL(i2c_setup_smbus_alert);
 684
 685 #if IS_ENABLED(CONFIG_I2C_SMBUS) && IS_ENABLED(CONFIG_OF)
 686 int of_i2c_setup_smbus_alert(struct i2c_adapter *adapter)
 687 {
 688         struct i2c_client *client;
 689         int irq;
 690
 691         irq = of_property_match_string(adapter->dev.of_node, "interrupt-names",
 692                                        "smbus_alert");
 693         if (irq == -EINVAL || irq == -ENODATA)
 694                 return 0;
 695         else if (irq < 0)
 696                 return irq;
 697
 698         client = i2c_setup_smbus_alert(adapter, NULL);
 699         if (!client)
 700                 return -ENODEV;
 701
 702         return 0;
 703 }
 704 EXPORT_SYMBOL_GPL(of_i2c_setup_smbus_alert);
 705 #endif