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