1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) 2 // Copyright(c) 2015-17 Intel Corporation. 3 4 #include <linux/acpi.h> 5 #include <linux/mod_devicetable.h> 6 #include <linux/pm_runtime.h> 7 #include <linux/soundwire/sdw_registers.h> 8 #include <linux/soundwire/sdw.h> 9 #include "bus.h" 10 11 /** 12 * sdw_add_bus_master() - add a bus Master instance 13 * @bus: bus instance 14 * 15 * Initializes the bus instance, read properties and create child 16 * devices. 17 */ 18 int sdw_add_bus_master(struct sdw_bus *bus) 19 { 20 int ret; 21 22 if (!bus->dev) { 23 pr_err("SoundWire bus has no device"); 24 return -ENODEV; 25 } 26 27 if (!bus->ops) { 28 dev_err(bus->dev, "SoundWire Bus ops are not set"); 29 return -EINVAL; 30 } 31 32 mutex_init(&bus->msg_lock); 33 mutex_init(&bus->bus_lock); 34 INIT_LIST_HEAD(&bus->slaves); 35 36 if (bus->ops->read_prop) { 37 ret = bus->ops->read_prop(bus); 38 if (ret < 0) { 39 dev_err(bus->dev, "Bus read properties failed:%d", ret); 40 return ret; 41 } 42 } 43 44 /* 45 * Device numbers in SoundWire are 0 thru 15. Enumeration device 46 * number (0), Broadcast device number (15), Group numbers (12 and 47 * 13) and Master device number (14) are not used for assignment so 48 * mask these and other higher bits. 49 */ 50 51 /* Set higher order bits */ 52 *bus->assigned = ~GENMASK(SDW_BROADCAST_DEV_NUM, SDW_ENUM_DEV_NUM); 53 54 /* Set enumuration device number and broadcast device number */ 55 set_bit(SDW_ENUM_DEV_NUM, bus->assigned); 56 set_bit(SDW_BROADCAST_DEV_NUM, bus->assigned); 57 58 /* Set group device numbers and master device number */ 59 set_bit(SDW_GROUP12_DEV_NUM, bus->assigned); 60 set_bit(SDW_GROUP13_DEV_NUM, bus->assigned); 61 set_bit(SDW_MASTER_DEV_NUM, bus->assigned); 62 63 /* 64 * SDW is an enumerable bus, but devices can be powered off. So, 65 * they won't be able to report as present. 66 * 67 * Create Slave devices based on Slaves described in 68 * the respective firmware (ACPI/DT) 69 */ 70 if (IS_ENABLED(CONFIG_ACPI) && ACPI_HANDLE(bus->dev)) 71 ret = sdw_acpi_find_slaves(bus); 72 else 73 ret = -ENOTSUPP; /* No ACPI/DT so error out */ 74 75 if (ret) { 76 dev_err(bus->dev, "Finding slaves failed:%d\n", ret); 77 return ret; 78 } 79 80 return 0; 81 } 82 EXPORT_SYMBOL(sdw_add_bus_master); 83 84 static int sdw_delete_slave(struct device *dev, void *data) 85 { 86 struct sdw_slave *slave = dev_to_sdw_dev(dev); 87 struct sdw_bus *bus = slave->bus; 88 89 mutex_lock(&bus->bus_lock); 90 91 if (slave->dev_num) /* clear dev_num if assigned */ 92 clear_bit(slave->dev_num, bus->assigned); 93 94 list_del_init(&slave->node); 95 mutex_unlock(&bus->bus_lock); 96 97 device_unregister(dev); 98 return 0; 99 } 100 101 /** 102 * sdw_delete_bus_master() - delete the bus master instance 103 * @bus: bus to be deleted 104 * 105 * Remove the instance, delete the child devices. 106 */ 107 void sdw_delete_bus_master(struct sdw_bus *bus) 108 { 109 device_for_each_child(bus->dev, NULL, sdw_delete_slave); 110 } 111 EXPORT_SYMBOL(sdw_delete_bus_master); 112 113 /* 114 * SDW IO Calls 115 */ 116 117 static inline int find_response_code(enum sdw_command_response resp) 118 { 119 switch (resp) { 120 case SDW_CMD_OK: 121 return 0; 122 123 case SDW_CMD_IGNORED: 124 return -ENODATA; 125 126 case SDW_CMD_TIMEOUT: 127 return -ETIMEDOUT; 128 129 default: 130 return -EIO; 131 } 132 } 133 134 static inline int do_transfer(struct sdw_bus *bus, struct sdw_msg *msg) 135 { 136 int retry = bus->prop.err_threshold; 137 enum sdw_command_response resp; 138 int ret = 0, i; 139 140 for (i = 0; i <= retry; i++) { 141 resp = bus->ops->xfer_msg(bus, msg); 142 ret = find_response_code(resp); 143 144 /* if cmd is ok or ignored return */ 145 if (ret == 0 || ret == -ENODATA) 146 return ret; 147 } 148 149 return ret; 150 } 151 152 static inline int do_transfer_defer(struct sdw_bus *bus, 153 struct sdw_msg *msg, struct sdw_defer *defer) 154 { 155 int retry = bus->prop.err_threshold; 156 enum sdw_command_response resp; 157 int ret = 0, i; 158 159 defer->msg = msg; 160 defer->length = msg->len; 161 162 for (i = 0; i <= retry; i++) { 163 resp = bus->ops->xfer_msg_defer(bus, msg, defer); 164 ret = find_response_code(resp); 165 /* if cmd is ok or ignored return */ 166 if (ret == 0 || ret == -ENODATA) 167 return ret; 168 } 169 170 return ret; 171 } 172 173 static int sdw_reset_page(struct sdw_bus *bus, u16 dev_num) 174 { 175 int retry = bus->prop.err_threshold; 176 enum sdw_command_response resp; 177 int ret = 0, i; 178 179 for (i = 0; i <= retry; i++) { 180 resp = bus->ops->reset_page_addr(bus, dev_num); 181 ret = find_response_code(resp); 182 /* if cmd is ok or ignored return */ 183 if (ret == 0 || ret == -ENODATA) 184 return ret; 185 } 186 187 return ret; 188 } 189 190 /** 191 * sdw_transfer() - Synchronous transfer message to a SDW Slave device 192 * @bus: SDW bus 193 * @msg: SDW message to be xfered 194 */ 195 int sdw_transfer(struct sdw_bus *bus, struct sdw_msg *msg) 196 { 197 int ret; 198 199 mutex_lock(&bus->msg_lock); 200 201 ret = do_transfer(bus, msg); 202 if (ret != 0 && ret != -ENODATA) 203 dev_err(bus->dev, "trf on Slave %d failed:%d\n", 204 msg->dev_num, ret); 205 206 if (msg->page) 207 sdw_reset_page(bus, msg->dev_num); 208 209 mutex_unlock(&bus->msg_lock); 210 211 return ret; 212 } 213 214 /** 215 * sdw_transfer_defer() - Asynchronously transfer message to a SDW Slave device 216 * @bus: SDW bus 217 * @msg: SDW message to be xfered 218 * @defer: Defer block for signal completion 219 * 220 * Caller needs to hold the msg_lock lock while calling this 221 */ 222 int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg, 223 struct sdw_defer *defer) 224 { 225 int ret; 226 227 if (!bus->ops->xfer_msg_defer) 228 return -ENOTSUPP; 229 230 ret = do_transfer_defer(bus, msg, defer); 231 if (ret != 0 && ret != -ENODATA) 232 dev_err(bus->dev, "Defer trf on Slave %d failed:%d\n", 233 msg->dev_num, ret); 234 235 if (msg->page) 236 sdw_reset_page(bus, msg->dev_num); 237 238 return ret; 239 } 240 241 242 int sdw_fill_msg(struct sdw_msg *msg, struct sdw_slave *slave, 243 u32 addr, size_t count, u16 dev_num, u8 flags, u8 *buf) 244 { 245 memset(msg, 0, sizeof(*msg)); 246 msg->addr = addr; /* addr is 16 bit and truncated here */ 247 msg->len = count; 248 msg->dev_num = dev_num; 249 msg->flags = flags; 250 msg->buf = buf; 251 msg->ssp_sync = false; 252 msg->page = false; 253 254 if (addr < SDW_REG_NO_PAGE) { /* no paging area */ 255 return 0; 256 } else if (addr >= SDW_REG_MAX) { /* illegal addr */ 257 pr_err("SDW: Invalid address %x passed\n", addr); 258 return -EINVAL; 259 } 260 261 if (addr < SDW_REG_OPTIONAL_PAGE) { /* 32k but no page */ 262 if (slave && !slave->prop.paging_support) 263 return 0; 264 /* no need for else as that will fall thru to paging */ 265 } 266 267 /* paging mandatory */ 268 if (dev_num == SDW_ENUM_DEV_NUM || dev_num == SDW_BROADCAST_DEV_NUM) { 269 pr_err("SDW: Invalid device for paging :%d\n", dev_num); 270 return -EINVAL; 271 } 272 273 if (!slave) { 274 pr_err("SDW: No slave for paging addr\n"); 275 return -EINVAL; 276 } else if (!slave->prop.paging_support) { 277 dev_err(&slave->dev, 278 "address %x needs paging but no support", addr); 279 return -EINVAL; 280 } 281 282 msg->addr_page1 = (addr >> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE1_MASK)); 283 msg->addr_page2 = (addr >> SDW_REG_SHIFT(SDW_SCP_ADDRPAGE2_MASK)); 284 msg->addr |= BIT(15); 285 msg->page = true; 286 287 return 0; 288 } 289 290 /** 291 * sdw_nread() - Read "n" contiguous SDW Slave registers 292 * @slave: SDW Slave 293 * @addr: Register address 294 * @count: length 295 * @val: Buffer for values to be read 296 */ 297 int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val) 298 { 299 struct sdw_msg msg; 300 int ret; 301 302 ret = sdw_fill_msg(&msg, slave, addr, count, 303 slave->dev_num, SDW_MSG_FLAG_READ, val); 304 if (ret < 0) 305 return ret; 306 307 ret = pm_runtime_get_sync(slave->bus->dev); 308 if (ret < 0) 309 return ret; 310 311 ret = sdw_transfer(slave->bus, &msg); 312 pm_runtime_put(slave->bus->dev); 313 314 return ret; 315 } 316 EXPORT_SYMBOL(sdw_nread); 317 318 /** 319 * sdw_nwrite() - Write "n" contiguous SDW Slave registers 320 * @slave: SDW Slave 321 * @addr: Register address 322 * @count: length 323 * @val: Buffer for values to be read 324 */ 325 int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, u8 *val) 326 { 327 struct sdw_msg msg; 328 int ret; 329 330 ret = sdw_fill_msg(&msg, slave, addr, count, 331 slave->dev_num, SDW_MSG_FLAG_WRITE, val); 332 if (ret < 0) 333 return ret; 334 335 ret = pm_runtime_get_sync(slave->bus->dev); 336 if (ret < 0) 337 return ret; 338 339 ret = sdw_transfer(slave->bus, &msg); 340 pm_runtime_put(slave->bus->dev); 341 342 return ret; 343 } 344 EXPORT_SYMBOL(sdw_nwrite); 345 346 /** 347 * sdw_read() - Read a SDW Slave register 348 * @slave: SDW Slave 349 * @addr: Register address 350 */ 351 int sdw_read(struct sdw_slave *slave, u32 addr) 352 { 353 u8 buf; 354 int ret; 355 356 ret = sdw_nread(slave, addr, 1, &buf); 357 if (ret < 0) 358 return ret; 359 else 360 return buf; 361 } 362 EXPORT_SYMBOL(sdw_read); 363 364 /** 365 * sdw_write() - Write a SDW Slave register 366 * @slave: SDW Slave 367 * @addr: Register address 368 * @value: Register value 369 */ 370 int sdw_write(struct sdw_slave *slave, u32 addr, u8 value) 371 { 372 return sdw_nwrite(slave, addr, 1, &value); 373 374 } 375 EXPORT_SYMBOL(sdw_write); 376 377 /* 378 * SDW alert handling 379 */ 380 381 /* called with bus_lock held */ 382 static struct sdw_slave *sdw_get_slave(struct sdw_bus *bus, int i) 383 { 384 struct sdw_slave *slave = NULL; 385 386 list_for_each_entry(slave, &bus->slaves, node) { 387 if (slave->dev_num == i) 388 return slave; 389 } 390 391 return NULL; 392 } 393 394 static int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id) 395 { 396 397 if ((slave->id.unique_id != id.unique_id) || 398 (slave->id.mfg_id != id.mfg_id) || 399 (slave->id.part_id != id.part_id) || 400 (slave->id.class_id != id.class_id)) 401 return -ENODEV; 402 403 return 0; 404 } 405 406 /* called with bus_lock held */ 407 static int sdw_get_device_num(struct sdw_slave *slave) 408 { 409 int bit; 410 411 bit = find_first_zero_bit(slave->bus->assigned, SDW_MAX_DEVICES); 412 if (bit == SDW_MAX_DEVICES) { 413 bit = -ENODEV; 414 goto err; 415 } 416 417 /* 418 * Do not update dev_num in Slave data structure here, 419 * Update once program dev_num is successful 420 */ 421 set_bit(bit, slave->bus->assigned); 422 423 err: 424 return bit; 425 } 426 427 static int sdw_assign_device_num(struct sdw_slave *slave) 428 { 429 int ret, dev_num; 430 431 /* check first if device number is assigned, if so reuse that */ 432 if (!slave->dev_num) { 433 mutex_lock(&slave->bus->bus_lock); 434 dev_num = sdw_get_device_num(slave); 435 mutex_unlock(&slave->bus->bus_lock); 436 if (dev_num < 0) { 437 dev_err(slave->bus->dev, "Get dev_num failed: %d", 438 dev_num); 439 return dev_num; 440 } 441 } else { 442 dev_info(slave->bus->dev, 443 "Slave already registered dev_num:%d", 444 slave->dev_num); 445 446 /* Clear the slave->dev_num to transfer message on device 0 */ 447 dev_num = slave->dev_num; 448 slave->dev_num = 0; 449 450 } 451 452 ret = sdw_write(slave, SDW_SCP_DEVNUMBER, dev_num); 453 if (ret < 0) { 454 dev_err(&slave->dev, "Program device_num failed: %d", ret); 455 return ret; 456 } 457 458 /* After xfer of msg, restore dev_num */ 459 slave->dev_num = dev_num; 460 461 return 0; 462 } 463 464 void sdw_extract_slave_id(struct sdw_bus *bus, 465 u64 addr, struct sdw_slave_id *id) 466 { 467 dev_dbg(bus->dev, "SDW Slave Addr: %llx", addr); 468 469 /* 470 * Spec definition 471 * Register Bit Contents 472 * DevId_0 [7:4] 47:44 sdw_version 473 * DevId_0 [3:0] 43:40 unique_id 474 * DevId_1 39:32 mfg_id [15:8] 475 * DevId_2 31:24 mfg_id [7:0] 476 * DevId_3 23:16 part_id [15:8] 477 * DevId_4 15:08 part_id [7:0] 478 * DevId_5 07:00 class_id 479 */ 480 id->sdw_version = (addr >> 44) & GENMASK(3, 0); 481 id->unique_id = (addr >> 40) & GENMASK(3, 0); 482 id->mfg_id = (addr >> 24) & GENMASK(15, 0); 483 id->part_id = (addr >> 8) & GENMASK(15, 0); 484 id->class_id = addr & GENMASK(7, 0); 485 486 dev_dbg(bus->dev, 487 "SDW Slave class_id %x, part_id %x, mfg_id %x, unique_id %x, version %x", 488 id->class_id, id->part_id, id->mfg_id, 489 id->unique_id, id->sdw_version); 490 491 } 492 493 static int sdw_program_device_num(struct sdw_bus *bus) 494 { 495 u8 buf[SDW_NUM_DEV_ID_REGISTERS] = {0}; 496 struct sdw_slave *slave, *_s; 497 struct sdw_slave_id id; 498 struct sdw_msg msg; 499 bool found = false; 500 int count = 0, ret; 501 u64 addr; 502 503 /* No Slave, so use raw xfer api */ 504 ret = sdw_fill_msg(&msg, NULL, SDW_SCP_DEVID_0, 505 SDW_NUM_DEV_ID_REGISTERS, 0, SDW_MSG_FLAG_READ, buf); 506 if (ret < 0) 507 return ret; 508 509 do { 510 ret = sdw_transfer(bus, &msg); 511 if (ret == -ENODATA) { /* end of device id reads */ 512 ret = 0; 513 break; 514 } 515 if (ret < 0) { 516 dev_err(bus->dev, "DEVID read fail:%d\n", ret); 517 break; 518 } 519 520 /* 521 * Construct the addr and extract. Cast the higher shift 522 * bits to avoid truncation due to size limit. 523 */ 524 addr = buf[5] | (buf[4] << 8) | (buf[3] << 16) | 525 ((u64)buf[2] << 24) | ((u64)buf[1] << 32) | 526 ((u64)buf[0] << 40); 527 528 sdw_extract_slave_id(bus, addr, &id); 529 530 /* Now compare with entries */ 531 list_for_each_entry_safe(slave, _s, &bus->slaves, node) { 532 if (sdw_compare_devid(slave, id) == 0) { 533 found = true; 534 535 /* 536 * Assign a new dev_num to this Slave and 537 * not mark it present. It will be marked 538 * present after it reports ATTACHED on new 539 * dev_num 540 */ 541 ret = sdw_assign_device_num(slave); 542 if (ret) { 543 dev_err(slave->bus->dev, 544 "Assign dev_num failed:%d", 545 ret); 546 return ret; 547 } 548 549 break; 550 } 551 } 552 553 if (found == false) { 554 /* TODO: Park this device in Group 13 */ 555 dev_err(bus->dev, "Slave Entry not found"); 556 } 557 558 count++; 559 560 /* 561 * Check till error out or retry (count) exhausts. 562 * Device can drop off and rejoin during enumeration 563 * so count till twice the bound. 564 */ 565 566 } while (ret == 0 && count < (SDW_MAX_DEVICES * 2)); 567 568 return ret; 569 } 570 571 static void sdw_modify_slave_status(struct sdw_slave *slave, 572 enum sdw_slave_status status) 573 { 574 mutex_lock(&slave->bus->bus_lock); 575 slave->status = status; 576 mutex_unlock(&slave->bus->bus_lock); 577 } 578 579 static int sdw_initialize_slave(struct sdw_slave *slave) 580 { 581 struct sdw_slave_prop *prop = &slave->prop; 582 int ret; 583 u8 val; 584 585 /* 586 * Set bus clash, parity and SCP implementation 587 * defined interrupt mask 588 * TODO: Read implementation defined interrupt mask 589 * from Slave property 590 */ 591 val = SDW_SCP_INT1_IMPL_DEF | SDW_SCP_INT1_BUS_CLASH | 592 SDW_SCP_INT1_PARITY; 593 594 /* Enable SCP interrupts */ 595 ret = sdw_update(slave, SDW_SCP_INTMASK1, val, val); 596 if (ret < 0) { 597 dev_err(slave->bus->dev, 598 "SDW_SCP_INTMASK1 write failed:%d", ret); 599 return ret; 600 } 601 602 /* No need to continue if DP0 is not present */ 603 if (!slave->prop.dp0_prop) 604 return 0; 605 606 /* Enable DP0 interrupts */ 607 val = prop->dp0_prop->device_interrupts; 608 val |= SDW_DP0_INT_PORT_READY | SDW_DP0_INT_BRA_FAILURE; 609 610 ret = sdw_update(slave, SDW_DP0_INTMASK, val, val); 611 if (ret < 0) { 612 dev_err(slave->bus->dev, 613 "SDW_DP0_INTMASK read failed:%d", ret); 614 return val; 615 } 616 617 return 0; 618 } 619 620 static int sdw_handle_dp0_interrupt(struct sdw_slave *slave, u8 *slave_status) 621 { 622 u8 clear = 0, impl_int_mask; 623 int status, status2, ret, count = 0; 624 625 status = sdw_read(slave, SDW_DP0_INT); 626 if (status < 0) { 627 dev_err(slave->bus->dev, 628 "SDW_DP0_INT read failed:%d", status); 629 return status; 630 } 631 632 do { 633 634 if (status & SDW_DP0_INT_TEST_FAIL) { 635 dev_err(&slave->dev, "Test fail for port 0"); 636 clear |= SDW_DP0_INT_TEST_FAIL; 637 } 638 639 /* 640 * Assumption: PORT_READY interrupt will be received only for 641 * ports implementing Channel Prepare state machine (CP_SM) 642 */ 643 644 if (status & SDW_DP0_INT_PORT_READY) { 645 complete(&slave->port_ready[0]); 646 clear |= SDW_DP0_INT_PORT_READY; 647 } 648 649 if (status & SDW_DP0_INT_BRA_FAILURE) { 650 dev_err(&slave->dev, "BRA failed"); 651 clear |= SDW_DP0_INT_BRA_FAILURE; 652 } 653 654 impl_int_mask = SDW_DP0_INT_IMPDEF1 | 655 SDW_DP0_INT_IMPDEF2 | SDW_DP0_INT_IMPDEF3; 656 657 if (status & impl_int_mask) { 658 clear |= impl_int_mask; 659 *slave_status = clear; 660 } 661 662 /* clear the interrupt */ 663 ret = sdw_write(slave, SDW_DP0_INT, clear); 664 if (ret < 0) { 665 dev_err(slave->bus->dev, 666 "SDW_DP0_INT write failed:%d", ret); 667 return ret; 668 } 669 670 /* Read DP0 interrupt again */ 671 status2 = sdw_read(slave, SDW_DP0_INT); 672 if (status2 < 0) { 673 dev_err(slave->bus->dev, 674 "SDW_DP0_INT read failed:%d", status2); 675 return status2; 676 } 677 status &= status2; 678 679 count++; 680 681 /* we can get alerts while processing so keep retrying */ 682 } while (status != 0 && count < SDW_READ_INTR_CLEAR_RETRY); 683 684 if (count == SDW_READ_INTR_CLEAR_RETRY) 685 dev_warn(slave->bus->dev, "Reached MAX_RETRY on DP0 read"); 686 687 return ret; 688 } 689 690 static int sdw_handle_port_interrupt(struct sdw_slave *slave, 691 int port, u8 *slave_status) 692 { 693 u8 clear = 0, impl_int_mask; 694 int status, status2, ret, count = 0; 695 u32 addr; 696 697 if (port == 0) 698 return sdw_handle_dp0_interrupt(slave, slave_status); 699 700 addr = SDW_DPN_INT(port); 701 status = sdw_read(slave, addr); 702 if (status < 0) { 703 dev_err(slave->bus->dev, 704 "SDW_DPN_INT read failed:%d", status); 705 706 return status; 707 } 708 709 do { 710 711 if (status & SDW_DPN_INT_TEST_FAIL) { 712 dev_err(&slave->dev, "Test fail for port:%d", port); 713 clear |= SDW_DPN_INT_TEST_FAIL; 714 } 715 716 /* 717 * Assumption: PORT_READY interrupt will be received only 718 * for ports implementing CP_SM. 719 */ 720 if (status & SDW_DPN_INT_PORT_READY) { 721 complete(&slave->port_ready[port]); 722 clear |= SDW_DPN_INT_PORT_READY; 723 } 724 725 impl_int_mask = SDW_DPN_INT_IMPDEF1 | 726 SDW_DPN_INT_IMPDEF2 | SDW_DPN_INT_IMPDEF3; 727 728 729 if (status & impl_int_mask) { 730 clear |= impl_int_mask; 731 *slave_status = clear; 732 } 733 734 /* clear the interrupt */ 735 ret = sdw_write(slave, addr, clear); 736 if (ret < 0) { 737 dev_err(slave->bus->dev, 738 "SDW_DPN_INT write failed:%d", ret); 739 return ret; 740 } 741 742 /* Read DPN interrupt again */ 743 status2 = sdw_read(slave, addr); 744 if (status2 < 0) { 745 dev_err(slave->bus->dev, 746 "SDW_DPN_INT read failed:%d", status2); 747 return status2; 748 } 749 status &= status2; 750 751 count++; 752 753 /* we can get alerts while processing so keep retrying */ 754 } while (status != 0 && count < SDW_READ_INTR_CLEAR_RETRY); 755 756 if (count == SDW_READ_INTR_CLEAR_RETRY) 757 dev_warn(slave->bus->dev, "Reached MAX_RETRY on port read"); 758 759 return ret; 760 } 761 762 static int sdw_handle_slave_alerts(struct sdw_slave *slave) 763 { 764 struct sdw_slave_intr_status slave_intr; 765 u8 clear = 0, bit, port_status[15]; 766 int port_num, stat, ret, count = 0; 767 unsigned long port; 768 bool slave_notify = false; 769 u8 buf, buf2[2], _buf, _buf2[2]; 770 771 sdw_modify_slave_status(slave, SDW_SLAVE_ALERT); 772 773 /* Read Instat 1, Instat 2 and Instat 3 registers */ 774 buf = ret = sdw_read(slave, SDW_SCP_INT1); 775 if (ret < 0) { 776 dev_err(slave->bus->dev, 777 "SDW_SCP_INT1 read failed:%d", ret); 778 return ret; 779 } 780 781 ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, buf2); 782 if (ret < 0) { 783 dev_err(slave->bus->dev, 784 "SDW_SCP_INT2/3 read failed:%d", ret); 785 return ret; 786 } 787 788 do { 789 /* 790 * Check parity, bus clash and Slave (impl defined) 791 * interrupt 792 */ 793 if (buf & SDW_SCP_INT1_PARITY) { 794 dev_err(&slave->dev, "Parity error detected"); 795 clear |= SDW_SCP_INT1_PARITY; 796 } 797 798 if (buf & SDW_SCP_INT1_BUS_CLASH) { 799 dev_err(&slave->dev, "Bus clash error detected"); 800 clear |= SDW_SCP_INT1_BUS_CLASH; 801 } 802 803 /* 804 * When bus clash or parity errors are detected, such errors 805 * are unlikely to be recoverable errors. 806 * TODO: In such scenario, reset bus. Make this configurable 807 * via sysfs property with bus reset being the default. 808 */ 809 810 if (buf & SDW_SCP_INT1_IMPL_DEF) { 811 dev_dbg(&slave->dev, "Slave impl defined interrupt\n"); 812 clear |= SDW_SCP_INT1_IMPL_DEF; 813 slave_notify = true; 814 } 815 816 /* Check port 0 - 3 interrupts */ 817 port = buf & SDW_SCP_INT1_PORT0_3; 818 819 /* To get port number corresponding to bits, shift it */ 820 port = port >> SDW_REG_SHIFT(SDW_SCP_INT1_PORT0_3); 821 for_each_set_bit(bit, &port, 8) { 822 sdw_handle_port_interrupt(slave, bit, 823 &port_status[bit]); 824 825 } 826 827 /* Check if cascade 2 interrupt is present */ 828 if (buf & SDW_SCP_INT1_SCP2_CASCADE) { 829 port = buf2[0] & SDW_SCP_INTSTAT2_PORT4_10; 830 for_each_set_bit(bit, &port, 8) { 831 /* scp2 ports start from 4 */ 832 port_num = bit + 3; 833 sdw_handle_port_interrupt(slave, 834 port_num, 835 &port_status[port_num]); 836 } 837 } 838 839 /* now check last cascade */ 840 if (buf2[0] & SDW_SCP_INTSTAT2_SCP3_CASCADE) { 841 port = buf2[1] & SDW_SCP_INTSTAT3_PORT11_14; 842 for_each_set_bit(bit, &port, 8) { 843 /* scp3 ports start from 11 */ 844 port_num = bit + 10; 845 sdw_handle_port_interrupt(slave, 846 port_num, 847 &port_status[port_num]); 848 } 849 } 850 851 /* Update the Slave driver */ 852 if (slave_notify && (slave->ops) && 853 (slave->ops->interrupt_callback)) { 854 slave_intr.control_port = clear; 855 memcpy(slave_intr.port, &port_status, 856 sizeof(slave_intr.port)); 857 858 slave->ops->interrupt_callback(slave, &slave_intr); 859 } 860 861 /* Ack interrupt */ 862 ret = sdw_write(slave, SDW_SCP_INT1, clear); 863 if (ret < 0) { 864 dev_err(slave->bus->dev, 865 "SDW_SCP_INT1 write failed:%d", ret); 866 return ret; 867 } 868 869 /* 870 * Read status again to ensure no new interrupts arrived 871 * while servicing interrupts. 872 */ 873 _buf = ret = sdw_read(slave, SDW_SCP_INT1); 874 if (ret < 0) { 875 dev_err(slave->bus->dev, 876 "SDW_SCP_INT1 read failed:%d", ret); 877 return ret; 878 } 879 880 ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, _buf2); 881 if (ret < 0) { 882 dev_err(slave->bus->dev, 883 "SDW_SCP_INT2/3 read failed:%d", ret); 884 return ret; 885 } 886 887 /* Make sure no interrupts are pending */ 888 buf &= _buf; 889 buf2[0] &= _buf2[0]; 890 buf2[1] &= _buf2[1]; 891 stat = buf || buf2[0] || buf2[1]; 892 893 /* 894 * Exit loop if Slave is continuously in ALERT state even 895 * after servicing the interrupt multiple times. 896 */ 897 count++; 898 899 /* we can get alerts while processing so keep retrying */ 900 } while (stat != 0 && count < SDW_READ_INTR_CLEAR_RETRY); 901 902 if (count == SDW_READ_INTR_CLEAR_RETRY) 903 dev_warn(slave->bus->dev, "Reached MAX_RETRY on alert read"); 904 905 return ret; 906 } 907 908 static int sdw_update_slave_status(struct sdw_slave *slave, 909 enum sdw_slave_status status) 910 { 911 if ((slave->ops) && (slave->ops->update_status)) 912 return slave->ops->update_status(slave, status); 913 914 return 0; 915 } 916 917 /** 918 * sdw_handle_slave_status() - Handle Slave status 919 * @bus: SDW bus instance 920 * @status: Status for all Slave(s) 921 */ 922 int sdw_handle_slave_status(struct sdw_bus *bus, 923 enum sdw_slave_status status[]) 924 { 925 enum sdw_slave_status prev_status; 926 struct sdw_slave *slave; 927 int i, ret = 0; 928 929 if (status[0] == SDW_SLAVE_ATTACHED) { 930 ret = sdw_program_device_num(bus); 931 if (ret) 932 dev_err(bus->dev, "Slave attach failed: %d", ret); 933 } 934 935 /* Continue to check other slave statuses */ 936 for (i = 1; i <= SDW_MAX_DEVICES; i++) { 937 mutex_lock(&bus->bus_lock); 938 if (test_bit(i, bus->assigned) == false) { 939 mutex_unlock(&bus->bus_lock); 940 continue; 941 } 942 mutex_unlock(&bus->bus_lock); 943 944 slave = sdw_get_slave(bus, i); 945 if (!slave) 946 continue; 947 948 switch (status[i]) { 949 case SDW_SLAVE_UNATTACHED: 950 if (slave->status == SDW_SLAVE_UNATTACHED) 951 break; 952 953 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED); 954 break; 955 956 case SDW_SLAVE_ALERT: 957 ret = sdw_handle_slave_alerts(slave); 958 if (ret) 959 dev_err(bus->dev, 960 "Slave %d alert handling failed: %d", 961 i, ret); 962 break; 963 964 case SDW_SLAVE_ATTACHED: 965 if (slave->status == SDW_SLAVE_ATTACHED) 966 break; 967 968 prev_status = slave->status; 969 sdw_modify_slave_status(slave, SDW_SLAVE_ATTACHED); 970 971 if (prev_status == SDW_SLAVE_ALERT) 972 break; 973 974 ret = sdw_initialize_slave(slave); 975 if (ret) 976 dev_err(bus->dev, 977 "Slave %d initialization failed: %d", 978 i, ret); 979 980 break; 981 982 default: 983 dev_err(bus->dev, "Invalid slave %d status:%d", 984 i, status[i]); 985 break; 986 } 987 988 ret = sdw_update_slave_status(slave, status[i]); 989 if (ret) 990 dev_err(slave->bus->dev, 991 "Update Slave status failed:%d", ret); 992 993 } 994 995 return ret; 996 } 997 EXPORT_SYMBOL(sdw_handle_slave_status); 998