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