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                 return status;
 469         if (status != num)
 470                 return -EIO;
 471
 472         /* Check PEC if last message is a read */
 473         if (i && (msg[num-1].flags & I2C_M_RD)) {
 474                 status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);
 475                 if (status < 0)
 476                         return status;
 477         }
 478
 479         if (read_write == I2C_SMBUS_READ)
 480                 switch (size) {
 481                 case I2C_SMBUS_BYTE:
 482                         data->byte = msgbuf0[0];
 483                         break;
 484                 case I2C_SMBUS_BYTE_DATA:
 485                         data->byte = msgbuf1[0];
 486                         break;
 487                 case I2C_SMBUS_WORD_DATA:
 488                 case I2C_SMBUS_PROC_CALL:
 489                         data->word = msgbuf1[0] | (msgbuf1[1] << 8);
 490                         break;
 491                 case I2C_SMBUS_I2C_BLOCK_DATA:
 492                         for (i = 0; i < data->block[0]; i++)
 493                                 data->block[i + 1] = msg[1].buf[i];
 494                         break;
 495                 case I2C_SMBUS_BLOCK_DATA:
 496                 case I2C_SMBUS_BLOCK_PROC_CALL:
 497                         for (i = 0; i < msg[1].buf[0] + 1; i++)
 498                                 data->block[i] = msg[1].buf[i];
 499                         break;
 500                 }
 501
 502         if (msg[0].flags & I2C_M_DMA_SAFE)
 503                 kfree(msg[0].buf);
 504         if (msg[1].flags & I2C_M_DMA_SAFE)
 505                 kfree(msg[1].buf);
 506
 507         return 0;
 508 }
 509
 510 /**
 511  * i2c_smbus_xfer - execute SMBus protocol operations
 512  * @adapter: Handle to I2C bus
 513  * @addr: Address of SMBus slave on that bus
 514  * @flags: I2C_CLIENT_* flags (usually zero or I2C_CLIENT_PEC)
 515  * @read_write: I2C_SMBUS_READ or I2C_SMBUS_WRITE
 516  * @command: Byte interpreted by slave, for protocols which use such bytes
 517  * @protocol: SMBus protocol operation to execute, such as I2C_SMBUS_PROC_CALL
 518  * @data: Data to be read or written
 519  *
 520  * This executes an SMBus protocol operation, and returns a negative
 521  * errno code else zero on success.
 522  */
 523 s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,
 524                    char read_write, u8 command, int protocol,
 525                    union i2c_smbus_data *data)
 526 {
 527         unsigned long orig_jiffies;
 528         int try;
 529         s32 res;
 530
 531         /* If enabled, the following two tracepoints are conditional on
 532          * read_write and protocol.
 533          */
 534         trace_smbus_write(adapter, addr, flags, read_write,
 535                           command, protocol, data);
 536         trace_smbus_read(adapter, addr, flags, read_write,
 537                          command, protocol);
 538
 539         flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;
 540
 541         if (adapter->algo->smbus_xfer) {
 542                 i2c_lock_bus(adapter, I2C_LOCK_SEGMENT);
 543
 544                 /* Retry automatically on arbitration loss */
 545                 orig_jiffies = jiffies;
 546                 for (res = 0, try = 0; try <= adapter->retries; try++) {
 547                         res = adapter->algo->smbus_xfer(adapter, addr, flags,
 548                                                         read_write, command,
 549                                                         protocol, data);
 550                         if (res != -EAGAIN)
 551                                 break;
 552                         if (time_after(jiffies,
 553                                        orig_jiffies + adapter->timeout))
 554                                 break;
 555                 }
 556                 i2c_unlock_bus(adapter, I2C_LOCK_SEGMENT);
 557
 558                 if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)
 559                         goto trace;
 560                 /*
 561                  * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't
 562                  * implement native support for the SMBus operation.
 563                  */
 564         }
 565
 566         res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
 567                                       command, protocol, data);
 568
 569 trace:
 570         /* If enabled, the reply tracepoint is conditional on read_write. */
 571         trace_smbus_reply(adapter, addr, flags, read_write,
 572                           command, protocol, data);
 573         trace_smbus_result(adapter, addr, flags, read_write,
 574                            command, protocol, res);
 575
 576         return res;
 577 }
 578 EXPORT_SYMBOL(i2c_smbus_xfer);
 579
 580 /**
 581  * i2c_smbus_read_i2c_block_data_or_emulated - read block or emulate
 582  * @client: Handle to slave device
 583  * @command: Byte interpreted by slave
 584  * @length: Size of data block; SMBus allows at most I2C_SMBUS_BLOCK_MAX bytes
 585  * @values: Byte array into which data will be read; big enough to hold
 586  *      the data returned by the slave.  SMBus allows at most
 587  *      I2C_SMBUS_BLOCK_MAX bytes.
 588  *
 589  * This executes the SMBus "block read" protocol if supported by the adapter.
 590  * If block read is not supported, it emulates it using either word or byte
 591  * read protocols depending on availability.
 592  *
 593  * The addresses of the I2C slave device that are accessed with this function
 594  * must be mapped to a linear region, so that a block read will have the same
 595  * effect as a byte read. Before using this function you must double-check
 596  * if the I2C slave does support exchanging a block transfer with a byte
 597  * transfer.
 598  */
 599 s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
 600                                               u8 command, u8 length, u8 *values)
 601 {
 602         u8 i = 0;
 603         int status;
 604
 605         if (length > I2C_SMBUS_BLOCK_MAX)
 606                 length = I2C_SMBUS_BLOCK_MAX;
 607
 608         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
 609                 return i2c_smbus_read_i2c_block_data(client, command, length, values);
 610
 611         if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA))
 612                 return -EOPNOTSUPP;
 613
 614         if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_WORD_DATA)) {
 615                 while ((i + 2) <= length) {
 616                         status = i2c_smbus_read_word_data(client, command + i);
 617                         if (status < 0)
 618                                 return status;
 619                         values[i] = status & 0xff;
 620                         values[i + 1] = status >> 8;
 621                         i += 2;
 622                 }
 623         }
 624
 625         while (i < length) {
 626                 status = i2c_smbus_read_byte_data(client, command + i);
 627                 if (status < 0)
 628                         return status;
 629                 values[i] = status;
 630                 i++;
 631         }
 632
 633         return i;
 634 }
 635 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data_or_emulated);
 636
 637 /**
 638  * i2c_setup_smbus_alert - Setup SMBus alert support
 639  * @adapter: the target adapter
 640  * @setup: setup data for the SMBus alert handler
 641  * Context: can sleep
 642  *
 643  * Setup handling of the SMBus alert protocol on a given I2C bus segment.
 644  *
 645  * Handling can be done either through our IRQ handler, or by the
 646  * adapter (from its handler, periodic polling, or whatever).
 647  *
 648  * NOTE that if we manage the IRQ, we *MUST* know if it's level or
 649  * edge triggered in order to hand it to the workqueue correctly.
 650  * If triggering the alert seems to wedge the system, you probably
 651  * should have said it's level triggered.
 652  *
 653  * This returns the ara client, which should be saved for later use with
 654  * i2c_handle_smbus_alert() and ultimately i2c_unregister_device(); or NULL
 655  * to indicate an error.
 656  */
 657 struct i2c_client *i2c_setup_smbus_alert(struct i2c_adapter *adapter,
 658                                          struct i2c_smbus_alert_setup *setup)
 659 {
 660         struct i2c_board_info ara_board_info = {
 661                 I2C_BOARD_INFO("smbus_alert", 0x0c),
 662                 .platform_data = setup,
 663         };
 664
 665         return i2c_new_device(adapter, &ara_board_info);
 666 }
 667 EXPORT_SYMBOL_GPL(i2c_setup_smbus_alert);
 668
 669 #if IS_ENABLED(CONFIG_I2C_SMBUS) && IS_ENABLED(CONFIG_OF)
 670 int of_i2c_setup_smbus_alert(struct i2c_adapter *adapter)
 671 {
 672         struct i2c_client *client;
 673         int irq;
 674
 675         irq = of_property_match_string(adapter->dev.of_node, "interrupt-names",
 676                                        "smbus_alert");
 677         if (irq == -EINVAL || irq == -ENODATA)
 678                 return 0;
 679         else if (irq < 0)
 680                 return irq;
 681
 682         client = i2c_setup_smbus_alert(adapter, NULL);
 683         if (!client)
 684                 return -ENODEV;
 685
 686         return 0;
 687 }
 688 EXPORT_SYMBOL_GPL(of_i2c_setup_smbus_alert);
 689 #endif