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/delay.h> 6 #include <linux/mod_devicetable.h> 7 #include <linux/pm_runtime.h> 8 #include <linux/soundwire/sdw_registers.h> 9 #include <linux/soundwire/sdw.h> 10 #include "bus.h" 11 #include "sysfs_local.h" 12 13 static DEFINE_IDA(sdw_ida); 14 15 static int sdw_get_id(struct sdw_bus *bus) 16 { 17 int rc = ida_alloc(&sdw_ida, GFP_KERNEL); 18 19 if (rc < 0) 20 return rc; 21 22 bus->id = rc; 23 return 0; 24 } 25 26 /** 27 * sdw_bus_master_add() - add a bus Master instance 28 * @bus: bus instance 29 * @parent: parent device 30 * @fwnode: firmware node handle 31 * 32 * Initializes the bus instance, read properties and create child 33 * devices. 34 */ 35 int sdw_bus_master_add(struct sdw_bus *bus, struct device *parent, 36 struct fwnode_handle *fwnode) 37 { 38 struct sdw_master_prop *prop = NULL; 39 int ret; 40 41 if (!parent) { 42 pr_err("SoundWire parent device is not set\n"); 43 return -ENODEV; 44 } 45 46 ret = sdw_get_id(bus); 47 if (ret < 0) { 48 dev_err(parent, "Failed to get bus id\n"); 49 return ret; 50 } 51 52 ret = sdw_master_device_add(bus, parent, fwnode); 53 if (ret < 0) { 54 dev_err(parent, "Failed to add master device at link %d\n", 55 bus->link_id); 56 return ret; 57 } 58 59 if (!bus->ops) { 60 dev_err(bus->dev, "SoundWire Bus ops are not set\n"); 61 return -EINVAL; 62 } 63 64 if (!bus->compute_params) { 65 dev_err(bus->dev, 66 "Bandwidth allocation not configured, compute_params no set\n"); 67 return -EINVAL; 68 } 69 70 mutex_init(&bus->msg_lock); 71 mutex_init(&bus->bus_lock); 72 INIT_LIST_HEAD(&bus->slaves); 73 INIT_LIST_HEAD(&bus->m_rt_list); 74 75 /* 76 * Initialize multi_link flag 77 * TODO: populate this flag by reading property from FW node 78 */ 79 bus->multi_link = false; 80 if (bus->ops->read_prop) { 81 ret = bus->ops->read_prop(bus); 82 if (ret < 0) { 83 dev_err(bus->dev, 84 "Bus read properties failed:%d\n", ret); 85 return ret; 86 } 87 } 88 89 sdw_bus_debugfs_init(bus); 90 91 /* 92 * Device numbers in SoundWire are 0 through 15. Enumeration device 93 * number (0), Broadcast device number (15), Group numbers (12 and 94 * 13) and Master device number (14) are not used for assignment so 95 * mask these and other higher bits. 96 */ 97 98 /* Set higher order bits */ 99 *bus->assigned = ~GENMASK(SDW_BROADCAST_DEV_NUM, SDW_ENUM_DEV_NUM); 100 101 /* Set enumuration device number and broadcast device number */ 102 set_bit(SDW_ENUM_DEV_NUM, bus->assigned); 103 set_bit(SDW_BROADCAST_DEV_NUM, bus->assigned); 104 105 /* Set group device numbers and master device number */ 106 set_bit(SDW_GROUP12_DEV_NUM, bus->assigned); 107 set_bit(SDW_GROUP13_DEV_NUM, bus->assigned); 108 set_bit(SDW_MASTER_DEV_NUM, bus->assigned); 109 110 /* 111 * SDW is an enumerable bus, but devices can be powered off. So, 112 * they won't be able to report as present. 113 * 114 * Create Slave devices based on Slaves described in 115 * the respective firmware (ACPI/DT) 116 */ 117 if (IS_ENABLED(CONFIG_ACPI) && ACPI_HANDLE(bus->dev)) 118 ret = sdw_acpi_find_slaves(bus); 119 else if (IS_ENABLED(CONFIG_OF) && bus->dev->of_node) 120 ret = sdw_of_find_slaves(bus); 121 else 122 ret = -ENOTSUPP; /* No ACPI/DT so error out */ 123 124 if (ret < 0) { 125 dev_err(bus->dev, "Finding slaves failed:%d\n", ret); 126 return ret; 127 } 128 129 /* 130 * Initialize clock values based on Master properties. The max 131 * frequency is read from max_clk_freq property. Current assumption 132 * is that the bus will start at highest clock frequency when 133 * powered on. 134 * 135 * Default active bank will be 0 as out of reset the Slaves have 136 * to start with bank 0 (Table 40 of Spec) 137 */ 138 prop = &bus->prop; 139 bus->params.max_dr_freq = prop->max_clk_freq * SDW_DOUBLE_RATE_FACTOR; 140 bus->params.curr_dr_freq = bus->params.max_dr_freq; 141 bus->params.curr_bank = SDW_BANK0; 142 bus->params.next_bank = SDW_BANK1; 143 144 return 0; 145 } 146 EXPORT_SYMBOL(sdw_bus_master_add); 147 148 static int sdw_delete_slave(struct device *dev, void *data) 149 { 150 struct sdw_slave *slave = dev_to_sdw_dev(dev); 151 struct sdw_bus *bus = slave->bus; 152 153 pm_runtime_disable(dev); 154 155 sdw_slave_debugfs_exit(slave); 156 157 mutex_lock(&bus->bus_lock); 158 159 if (slave->dev_num) /* clear dev_num if assigned */ 160 clear_bit(slave->dev_num, bus->assigned); 161 162 list_del_init(&slave->node); 163 mutex_unlock(&bus->bus_lock); 164 165 device_unregister(dev); 166 return 0; 167 } 168 169 /** 170 * sdw_bus_master_delete() - delete the bus master instance 171 * @bus: bus to be deleted 172 * 173 * Remove the instance, delete the child devices. 174 */ 175 void sdw_bus_master_delete(struct sdw_bus *bus) 176 { 177 device_for_each_child(bus->dev, NULL, sdw_delete_slave); 178 sdw_master_device_del(bus); 179 180 sdw_bus_debugfs_exit(bus); 181 ida_free(&sdw_ida, bus->id); 182 } 183 EXPORT_SYMBOL(sdw_bus_master_delete); 184 185 /* 186 * SDW IO Calls 187 */ 188 189 static inline int find_response_code(enum sdw_command_response resp) 190 { 191 switch (resp) { 192 case SDW_CMD_OK: 193 return 0; 194 195 case SDW_CMD_IGNORED: 196 return -ENODATA; 197 198 case SDW_CMD_TIMEOUT: 199 return -ETIMEDOUT; 200 201 default: 202 return -EIO; 203 } 204 } 205 206 static inline int do_transfer(struct sdw_bus *bus, struct sdw_msg *msg) 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->xfer_msg(bus, msg); 214 ret = find_response_code(resp); 215 216 /* if cmd is ok or ignored return */ 217 if (ret == 0 || ret == -ENODATA) 218 return ret; 219 } 220 221 return ret; 222 } 223 224 static inline int do_transfer_defer(struct sdw_bus *bus, 225 struct sdw_msg *msg, 226 struct sdw_defer *defer) 227 { 228 int retry = bus->prop.err_threshold; 229 enum sdw_command_response resp; 230 int ret = 0, i; 231 232 defer->msg = msg; 233 defer->length = msg->len; 234 init_completion(&defer->complete); 235 236 for (i = 0; i <= retry; i++) { 237 resp = bus->ops->xfer_msg_defer(bus, msg, defer); 238 ret = find_response_code(resp); 239 /* if cmd is ok or ignored return */ 240 if (ret == 0 || ret == -ENODATA) 241 return ret; 242 } 243 244 return ret; 245 } 246 247 static int sdw_reset_page(struct sdw_bus *bus, u16 dev_num) 248 { 249 int retry = bus->prop.err_threshold; 250 enum sdw_command_response resp; 251 int ret = 0, i; 252 253 for (i = 0; i <= retry; i++) { 254 resp = bus->ops->reset_page_addr(bus, dev_num); 255 ret = find_response_code(resp); 256 /* if cmd is ok or ignored return */ 257 if (ret == 0 || ret == -ENODATA) 258 return ret; 259 } 260 261 return ret; 262 } 263 264 static int sdw_transfer_unlocked(struct sdw_bus *bus, struct sdw_msg *msg) 265 { 266 int ret; 267 268 ret = do_transfer(bus, msg); 269 if (ret != 0 && ret != -ENODATA) 270 dev_err(bus->dev, "trf on Slave %d failed:%d %s addr %x count %d\n", 271 msg->dev_num, ret, 272 (msg->flags & SDW_MSG_FLAG_WRITE) ? "write" : "read", 273 msg->addr, msg->len); 274 275 if (msg->page) 276 sdw_reset_page(bus, msg->dev_num); 277 278 return ret; 279 } 280 281 /** 282 * sdw_transfer() - Synchronous transfer message to a SDW Slave device 283 * @bus: SDW bus 284 * @msg: SDW message to be xfered 285 */ 286 int sdw_transfer(struct sdw_bus *bus, struct sdw_msg *msg) 287 { 288 int ret; 289 290 mutex_lock(&bus->msg_lock); 291 292 ret = sdw_transfer_unlocked(bus, msg); 293 294 mutex_unlock(&bus->msg_lock); 295 296 return ret; 297 } 298 299 /** 300 * sdw_transfer_defer() - Asynchronously transfer message to a SDW Slave device 301 * @bus: SDW bus 302 * @msg: SDW message to be xfered 303 * @defer: Defer block for signal completion 304 * 305 * Caller needs to hold the msg_lock lock while calling this 306 */ 307 int sdw_transfer_defer(struct sdw_bus *bus, struct sdw_msg *msg, 308 struct sdw_defer *defer) 309 { 310 int ret; 311 312 if (!bus->ops->xfer_msg_defer) 313 return -ENOTSUPP; 314 315 ret = do_transfer_defer(bus, msg, defer); 316 if (ret != 0 && ret != -ENODATA) 317 dev_err(bus->dev, "Defer trf on Slave %d failed:%d\n", 318 msg->dev_num, ret); 319 320 if (msg->page) 321 sdw_reset_page(bus, msg->dev_num); 322 323 return ret; 324 } 325 326 int sdw_fill_msg(struct sdw_msg *msg, struct sdw_slave *slave, 327 u32 addr, size_t count, u16 dev_num, u8 flags, u8 *buf) 328 { 329 memset(msg, 0, sizeof(*msg)); 330 msg->addr = addr; /* addr is 16 bit and truncated here */ 331 msg->len = count; 332 msg->dev_num = dev_num; 333 msg->flags = flags; 334 msg->buf = buf; 335 336 if (addr < SDW_REG_NO_PAGE) /* no paging area */ 337 return 0; 338 339 if (addr >= SDW_REG_MAX) { /* illegal addr */ 340 pr_err("SDW: Invalid address %x passed\n", addr); 341 return -EINVAL; 342 } 343 344 if (addr < SDW_REG_OPTIONAL_PAGE) { /* 32k but no page */ 345 if (slave && !slave->prop.paging_support) 346 return 0; 347 /* no need for else as that will fall-through to paging */ 348 } 349 350 /* paging mandatory */ 351 if (dev_num == SDW_ENUM_DEV_NUM || dev_num == SDW_BROADCAST_DEV_NUM) { 352 pr_err("SDW: Invalid device for paging :%d\n", dev_num); 353 return -EINVAL; 354 } 355 356 if (!slave) { 357 pr_err("SDW: No slave for paging addr\n"); 358 return -EINVAL; 359 } 360 361 if (!slave->prop.paging_support) { 362 dev_err(&slave->dev, 363 "address %x needs paging but no support\n", addr); 364 return -EINVAL; 365 } 366 367 msg->addr_page1 = FIELD_GET(SDW_SCP_ADDRPAGE1_MASK, addr); 368 msg->addr_page2 = FIELD_GET(SDW_SCP_ADDRPAGE2_MASK, addr); 369 msg->addr |= BIT(15); 370 msg->page = true; 371 372 return 0; 373 } 374 375 /* 376 * Read/Write IO functions. 377 * no_pm versions can only be called by the bus, e.g. while enumerating or 378 * handling suspend-resume sequences. 379 * all clients need to use the pm versions 380 */ 381 382 static int 383 sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val) 384 { 385 struct sdw_msg msg; 386 int ret; 387 388 ret = sdw_fill_msg(&msg, slave, addr, count, 389 slave->dev_num, SDW_MSG_FLAG_READ, val); 390 if (ret < 0) 391 return ret; 392 393 return sdw_transfer(slave->bus, &msg); 394 } 395 396 static int 397 sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val) 398 { 399 struct sdw_msg msg; 400 int ret; 401 402 ret = sdw_fill_msg(&msg, slave, addr, count, 403 slave->dev_num, SDW_MSG_FLAG_WRITE, (u8 *)val); 404 if (ret < 0) 405 return ret; 406 407 return sdw_transfer(slave->bus, &msg); 408 } 409 410 int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value) 411 { 412 return sdw_nwrite_no_pm(slave, addr, 1, &value); 413 } 414 EXPORT_SYMBOL(sdw_write_no_pm); 415 416 static int 417 sdw_bread_no_pm(struct sdw_bus *bus, u16 dev_num, u32 addr) 418 { 419 struct sdw_msg msg; 420 u8 buf; 421 int ret; 422 423 ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num, 424 SDW_MSG_FLAG_READ, &buf); 425 if (ret < 0) 426 return ret; 427 428 ret = sdw_transfer(bus, &msg); 429 if (ret < 0) 430 return ret; 431 432 return buf; 433 } 434 435 static int 436 sdw_bwrite_no_pm(struct sdw_bus *bus, u16 dev_num, u32 addr, u8 value) 437 { 438 struct sdw_msg msg; 439 int ret; 440 441 ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num, 442 SDW_MSG_FLAG_WRITE, &value); 443 if (ret < 0) 444 return ret; 445 446 return sdw_transfer(bus, &msg); 447 } 448 449 int sdw_bread_no_pm_unlocked(struct sdw_bus *bus, u16 dev_num, u32 addr) 450 { 451 struct sdw_msg msg; 452 u8 buf; 453 int ret; 454 455 ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num, 456 SDW_MSG_FLAG_READ, &buf); 457 if (ret < 0) 458 return ret; 459 460 ret = sdw_transfer_unlocked(bus, &msg); 461 if (ret < 0) 462 return ret; 463 464 return buf; 465 } 466 EXPORT_SYMBOL(sdw_bread_no_pm_unlocked); 467 468 int sdw_bwrite_no_pm_unlocked(struct sdw_bus *bus, u16 dev_num, u32 addr, u8 value) 469 { 470 struct sdw_msg msg; 471 int ret; 472 473 ret = sdw_fill_msg(&msg, NULL, addr, 1, dev_num, 474 SDW_MSG_FLAG_WRITE, &value); 475 if (ret < 0) 476 return ret; 477 478 return sdw_transfer_unlocked(bus, &msg); 479 } 480 EXPORT_SYMBOL(sdw_bwrite_no_pm_unlocked); 481 482 int sdw_read_no_pm(struct sdw_slave *slave, u32 addr) 483 { 484 u8 buf; 485 int ret; 486 487 ret = sdw_nread_no_pm(slave, addr, 1, &buf); 488 if (ret < 0) 489 return ret; 490 else 491 return buf; 492 } 493 EXPORT_SYMBOL(sdw_read_no_pm); 494 495 static int sdw_update_no_pm(struct sdw_slave *slave, u32 addr, u8 mask, u8 val) 496 { 497 int tmp; 498 499 tmp = sdw_read_no_pm(slave, addr); 500 if (tmp < 0) 501 return tmp; 502 503 tmp = (tmp & ~mask) | val; 504 return sdw_write_no_pm(slave, addr, tmp); 505 } 506 507 /** 508 * sdw_nread() - Read "n" contiguous SDW Slave registers 509 * @slave: SDW Slave 510 * @addr: Register address 511 * @count: length 512 * @val: Buffer for values to be read 513 */ 514 int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val) 515 { 516 int ret; 517 518 ret = pm_runtime_get_sync(&slave->dev); 519 if (ret < 0 && ret != -EACCES) { 520 pm_runtime_put_noidle(&slave->dev); 521 return ret; 522 } 523 524 ret = sdw_nread_no_pm(slave, addr, count, val); 525 526 pm_runtime_mark_last_busy(&slave->dev); 527 pm_runtime_put(&slave->dev); 528 529 return ret; 530 } 531 EXPORT_SYMBOL(sdw_nread); 532 533 /** 534 * sdw_nwrite() - Write "n" contiguous SDW Slave registers 535 * @slave: SDW Slave 536 * @addr: Register address 537 * @count: length 538 * @val: Buffer for values to be written 539 */ 540 int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val) 541 { 542 int ret; 543 544 ret = pm_runtime_get_sync(&slave->dev); 545 if (ret < 0 && ret != -EACCES) { 546 pm_runtime_put_noidle(&slave->dev); 547 return ret; 548 } 549 550 ret = sdw_nwrite_no_pm(slave, addr, count, val); 551 552 pm_runtime_mark_last_busy(&slave->dev); 553 pm_runtime_put(&slave->dev); 554 555 return ret; 556 } 557 EXPORT_SYMBOL(sdw_nwrite); 558 559 /** 560 * sdw_read() - Read a SDW Slave register 561 * @slave: SDW Slave 562 * @addr: Register address 563 */ 564 int sdw_read(struct sdw_slave *slave, u32 addr) 565 { 566 u8 buf; 567 int ret; 568 569 ret = sdw_nread(slave, addr, 1, &buf); 570 if (ret < 0) 571 return ret; 572 573 return buf; 574 } 575 EXPORT_SYMBOL(sdw_read); 576 577 /** 578 * sdw_write() - Write a SDW Slave register 579 * @slave: SDW Slave 580 * @addr: Register address 581 * @value: Register value 582 */ 583 int sdw_write(struct sdw_slave *slave, u32 addr, u8 value) 584 { 585 return sdw_nwrite(slave, addr, 1, &value); 586 } 587 EXPORT_SYMBOL(sdw_write); 588 589 /* 590 * SDW alert handling 591 */ 592 593 /* called with bus_lock held */ 594 static struct sdw_slave *sdw_get_slave(struct sdw_bus *bus, int i) 595 { 596 struct sdw_slave *slave; 597 598 list_for_each_entry(slave, &bus->slaves, node) { 599 if (slave->dev_num == i) 600 return slave; 601 } 602 603 return NULL; 604 } 605 606 int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id) 607 { 608 if (slave->id.mfg_id != id.mfg_id || 609 slave->id.part_id != id.part_id || 610 slave->id.class_id != id.class_id || 611 (slave->id.unique_id != SDW_IGNORED_UNIQUE_ID && 612 slave->id.unique_id != id.unique_id)) 613 return -ENODEV; 614 615 return 0; 616 } 617 EXPORT_SYMBOL(sdw_compare_devid); 618 619 /* called with bus_lock held */ 620 static int sdw_get_device_num(struct sdw_slave *slave) 621 { 622 int bit; 623 624 bit = find_first_zero_bit(slave->bus->assigned, SDW_MAX_DEVICES); 625 if (bit == SDW_MAX_DEVICES) { 626 bit = -ENODEV; 627 goto err; 628 } 629 630 /* 631 * Do not update dev_num in Slave data structure here, 632 * Update once program dev_num is successful 633 */ 634 set_bit(bit, slave->bus->assigned); 635 636 err: 637 return bit; 638 } 639 640 static int sdw_assign_device_num(struct sdw_slave *slave) 641 { 642 struct sdw_bus *bus = slave->bus; 643 int ret, dev_num; 644 bool new_device = false; 645 646 /* check first if device number is assigned, if so reuse that */ 647 if (!slave->dev_num) { 648 if (!slave->dev_num_sticky) { 649 mutex_lock(&slave->bus->bus_lock); 650 dev_num = sdw_get_device_num(slave); 651 mutex_unlock(&slave->bus->bus_lock); 652 if (dev_num < 0) { 653 dev_err(bus->dev, "Get dev_num failed: %d\n", 654 dev_num); 655 return dev_num; 656 } 657 slave->dev_num = dev_num; 658 slave->dev_num_sticky = dev_num; 659 new_device = true; 660 } else { 661 slave->dev_num = slave->dev_num_sticky; 662 } 663 } 664 665 if (!new_device) 666 dev_dbg(bus->dev, 667 "Slave already registered, reusing dev_num:%d\n", 668 slave->dev_num); 669 670 /* Clear the slave->dev_num to transfer message on device 0 */ 671 dev_num = slave->dev_num; 672 slave->dev_num = 0; 673 674 ret = sdw_write_no_pm(slave, SDW_SCP_DEVNUMBER, dev_num); 675 if (ret < 0) { 676 dev_err(bus->dev, "Program device_num %d failed: %d\n", 677 dev_num, ret); 678 return ret; 679 } 680 681 /* After xfer of msg, restore dev_num */ 682 slave->dev_num = slave->dev_num_sticky; 683 684 return 0; 685 } 686 687 void sdw_extract_slave_id(struct sdw_bus *bus, 688 u64 addr, struct sdw_slave_id *id) 689 { 690 dev_dbg(bus->dev, "SDW Slave Addr: %llx\n", addr); 691 692 id->sdw_version = SDW_VERSION(addr); 693 id->unique_id = SDW_UNIQUE_ID(addr); 694 id->mfg_id = SDW_MFG_ID(addr); 695 id->part_id = SDW_PART_ID(addr); 696 id->class_id = SDW_CLASS_ID(addr); 697 698 dev_dbg(bus->dev, 699 "SDW Slave class_id 0x%02x, mfg_id 0x%04x, part_id 0x%04x, unique_id 0x%x, version 0x%x\n", 700 id->class_id, id->mfg_id, id->part_id, id->unique_id, id->sdw_version); 701 } 702 EXPORT_SYMBOL(sdw_extract_slave_id); 703 704 static int sdw_program_device_num(struct sdw_bus *bus) 705 { 706 u8 buf[SDW_NUM_DEV_ID_REGISTERS] = {0}; 707 struct sdw_slave *slave, *_s; 708 struct sdw_slave_id id; 709 struct sdw_msg msg; 710 bool found; 711 int count = 0, ret; 712 u64 addr; 713 714 /* No Slave, so use raw xfer api */ 715 ret = sdw_fill_msg(&msg, NULL, SDW_SCP_DEVID_0, 716 SDW_NUM_DEV_ID_REGISTERS, 0, SDW_MSG_FLAG_READ, buf); 717 if (ret < 0) 718 return ret; 719 720 do { 721 ret = sdw_transfer(bus, &msg); 722 if (ret == -ENODATA) { /* end of device id reads */ 723 dev_dbg(bus->dev, "No more devices to enumerate\n"); 724 ret = 0; 725 break; 726 } 727 if (ret < 0) { 728 dev_err(bus->dev, "DEVID read fail:%d\n", ret); 729 break; 730 } 731 732 /* 733 * Construct the addr and extract. Cast the higher shift 734 * bits to avoid truncation due to size limit. 735 */ 736 addr = buf[5] | (buf[4] << 8) | (buf[3] << 16) | 737 ((u64)buf[2] << 24) | ((u64)buf[1] << 32) | 738 ((u64)buf[0] << 40); 739 740 sdw_extract_slave_id(bus, addr, &id); 741 742 found = false; 743 /* Now compare with entries */ 744 list_for_each_entry_safe(slave, _s, &bus->slaves, node) { 745 if (sdw_compare_devid(slave, id) == 0) { 746 found = true; 747 748 /* 749 * Assign a new dev_num to this Slave and 750 * not mark it present. It will be marked 751 * present after it reports ATTACHED on new 752 * dev_num 753 */ 754 ret = sdw_assign_device_num(slave); 755 if (ret < 0) { 756 dev_err(bus->dev, 757 "Assign dev_num failed:%d\n", 758 ret); 759 return ret; 760 } 761 762 break; 763 } 764 } 765 766 if (!found) { 767 /* TODO: Park this device in Group 13 */ 768 769 /* 770 * add Slave device even if there is no platform 771 * firmware description. There will be no driver probe 772 * but the user/integration will be able to see the 773 * device, enumeration status and device number in sysfs 774 */ 775 sdw_slave_add(bus, &id, NULL); 776 777 dev_err(bus->dev, "Slave Entry not found\n"); 778 } 779 780 count++; 781 782 /* 783 * Check till error out or retry (count) exhausts. 784 * Device can drop off and rejoin during enumeration 785 * so count till twice the bound. 786 */ 787 788 } while (ret == 0 && count < (SDW_MAX_DEVICES * 2)); 789 790 return ret; 791 } 792 793 static void sdw_modify_slave_status(struct sdw_slave *slave, 794 enum sdw_slave_status status) 795 { 796 struct sdw_bus *bus = slave->bus; 797 798 mutex_lock(&bus->bus_lock); 799 800 dev_vdbg(bus->dev, 801 "%s: changing status slave %d status %d new status %d\n", 802 __func__, slave->dev_num, slave->status, status); 803 804 if (status == SDW_SLAVE_UNATTACHED) { 805 dev_dbg(&slave->dev, 806 "%s: initializing enumeration and init completion for Slave %d\n", 807 __func__, slave->dev_num); 808 809 init_completion(&slave->enumeration_complete); 810 init_completion(&slave->initialization_complete); 811 812 } else if ((status == SDW_SLAVE_ATTACHED) && 813 (slave->status == SDW_SLAVE_UNATTACHED)) { 814 dev_dbg(&slave->dev, 815 "%s: signaling enumeration completion for Slave %d\n", 816 __func__, slave->dev_num); 817 818 complete(&slave->enumeration_complete); 819 } 820 slave->status = status; 821 mutex_unlock(&bus->bus_lock); 822 } 823 824 static int sdw_slave_clk_stop_callback(struct sdw_slave *slave, 825 enum sdw_clk_stop_mode mode, 826 enum sdw_clk_stop_type type) 827 { 828 int ret; 829 830 if (slave->ops && slave->ops->clk_stop) { 831 ret = slave->ops->clk_stop(slave, mode, type); 832 if (ret < 0) 833 return ret; 834 } 835 836 return 0; 837 } 838 839 static int sdw_slave_clk_stop_prepare(struct sdw_slave *slave, 840 enum sdw_clk_stop_mode mode, 841 bool prepare) 842 { 843 bool wake_en; 844 u32 val = 0; 845 int ret; 846 847 wake_en = slave->prop.wake_capable; 848 849 if (prepare) { 850 val = SDW_SCP_SYSTEMCTRL_CLK_STP_PREP; 851 852 if (mode == SDW_CLK_STOP_MODE1) 853 val |= SDW_SCP_SYSTEMCTRL_CLK_STP_MODE1; 854 855 if (wake_en) 856 val |= SDW_SCP_SYSTEMCTRL_WAKE_UP_EN; 857 } else { 858 ret = sdw_read_no_pm(slave, SDW_SCP_SYSTEMCTRL); 859 if (ret < 0) { 860 if (ret != -ENODATA) 861 dev_err(&slave->dev, "SDW_SCP_SYSTEMCTRL read failed:%d\n", ret); 862 return ret; 863 } 864 val = ret; 865 val &= ~(SDW_SCP_SYSTEMCTRL_CLK_STP_PREP); 866 } 867 868 ret = sdw_write_no_pm(slave, SDW_SCP_SYSTEMCTRL, val); 869 870 if (ret < 0 && ret != -ENODATA) 871 dev_err(&slave->dev, "SDW_SCP_SYSTEMCTRL write failed:%d\n", ret); 872 873 return ret; 874 } 875 876 static int sdw_bus_wait_for_clk_prep_deprep(struct sdw_bus *bus, u16 dev_num) 877 { 878 int retry = bus->clk_stop_timeout; 879 int val; 880 881 do { 882 val = sdw_bread_no_pm(bus, dev_num, SDW_SCP_STAT); 883 if (val < 0) { 884 dev_err(bus->dev, "SDW_SCP_STAT bread failed:%d\n", val); 885 return val; 886 } 887 val &= SDW_SCP_STAT_CLK_STP_NF; 888 if (!val) { 889 dev_dbg(bus->dev, "clock stop prep/de-prep done slave:%d\n", 890 dev_num); 891 return 0; 892 } 893 894 usleep_range(1000, 1500); 895 retry--; 896 } while (retry); 897 898 dev_err(bus->dev, "clock stop prep/de-prep failed slave:%d\n", 899 dev_num); 900 901 return -ETIMEDOUT; 902 } 903 904 /** 905 * sdw_bus_prep_clk_stop: prepare Slave(s) for clock stop 906 * 907 * @bus: SDW bus instance 908 * 909 * Query Slave for clock stop mode and prepare for that mode. 910 */ 911 int sdw_bus_prep_clk_stop(struct sdw_bus *bus) 912 { 913 bool simple_clk_stop = true; 914 struct sdw_slave *slave; 915 bool is_slave = false; 916 int ret = 0; 917 918 /* 919 * In order to save on transition time, prepare 920 * each Slave and then wait for all Slave(s) to be 921 * prepared for clock stop. 922 * If one of the Slave devices has lost sync and 923 * replies with Command Ignored/-ENODATA, we continue 924 * the loop 925 */ 926 list_for_each_entry(slave, &bus->slaves, node) { 927 if (!slave->dev_num) 928 continue; 929 930 if (slave->status != SDW_SLAVE_ATTACHED && 931 slave->status != SDW_SLAVE_ALERT) 932 continue; 933 934 /* Identify if Slave(s) are available on Bus */ 935 is_slave = true; 936 937 ret = sdw_slave_clk_stop_callback(slave, 938 SDW_CLK_STOP_MODE0, 939 SDW_CLK_PRE_PREPARE); 940 if (ret < 0 && ret != -ENODATA) { 941 dev_err(&slave->dev, "clock stop pre-prepare cb failed:%d\n", ret); 942 return ret; 943 } 944 945 /* Only prepare a Slave device if needed */ 946 if (!slave->prop.simple_clk_stop_capable) { 947 simple_clk_stop = false; 948 949 ret = sdw_slave_clk_stop_prepare(slave, 950 SDW_CLK_STOP_MODE0, 951 true); 952 if (ret < 0 && ret != -ENODATA) { 953 dev_err(&slave->dev, "clock stop prepare failed:%d\n", ret); 954 return ret; 955 } 956 } 957 } 958 959 /* Skip remaining clock stop preparation if no Slave is attached */ 960 if (!is_slave) 961 return 0; 962 963 /* 964 * Don't wait for all Slaves to be ready if they follow the simple 965 * state machine 966 */ 967 if (!simple_clk_stop) { 968 ret = sdw_bus_wait_for_clk_prep_deprep(bus, 969 SDW_BROADCAST_DEV_NUM); 970 /* 971 * if there are no Slave devices present and the reply is 972 * Command_Ignored/-ENODATA, we don't need to continue with the 973 * flow and can just return here. The error code is not modified 974 * and its handling left as an exercise for the caller. 975 */ 976 if (ret < 0) 977 return ret; 978 } 979 980 /* Inform slaves that prep is done */ 981 list_for_each_entry(slave, &bus->slaves, node) { 982 if (!slave->dev_num) 983 continue; 984 985 if (slave->status != SDW_SLAVE_ATTACHED && 986 slave->status != SDW_SLAVE_ALERT) 987 continue; 988 989 ret = sdw_slave_clk_stop_callback(slave, 990 SDW_CLK_STOP_MODE0, 991 SDW_CLK_POST_PREPARE); 992 993 if (ret < 0 && ret != -ENODATA) { 994 dev_err(&slave->dev, "clock stop post-prepare cb failed:%d\n", ret); 995 return ret; 996 } 997 } 998 999 return 0; 1000 } 1001 EXPORT_SYMBOL(sdw_bus_prep_clk_stop); 1002 1003 /** 1004 * sdw_bus_clk_stop: stop bus clock 1005 * 1006 * @bus: SDW bus instance 1007 * 1008 * After preparing the Slaves for clock stop, stop the clock by broadcasting 1009 * write to SCP_CTRL register. 1010 */ 1011 int sdw_bus_clk_stop(struct sdw_bus *bus) 1012 { 1013 int ret; 1014 1015 /* 1016 * broadcast clock stop now, attached Slaves will ACK this, 1017 * unattached will ignore 1018 */ 1019 ret = sdw_bwrite_no_pm(bus, SDW_BROADCAST_DEV_NUM, 1020 SDW_SCP_CTRL, SDW_SCP_CTRL_CLK_STP_NOW); 1021 if (ret < 0) { 1022 if (ret != -ENODATA) 1023 dev_err(bus->dev, "ClockStopNow Broadcast msg failed %d\n", ret); 1024 return ret; 1025 } 1026 1027 return 0; 1028 } 1029 EXPORT_SYMBOL(sdw_bus_clk_stop); 1030 1031 /** 1032 * sdw_bus_exit_clk_stop: Exit clock stop mode 1033 * 1034 * @bus: SDW bus instance 1035 * 1036 * This De-prepares the Slaves by exiting Clock Stop Mode 0. For the Slaves 1037 * exiting Clock Stop Mode 1, they will be de-prepared after they enumerate 1038 * back. 1039 */ 1040 int sdw_bus_exit_clk_stop(struct sdw_bus *bus) 1041 { 1042 bool simple_clk_stop = true; 1043 struct sdw_slave *slave; 1044 bool is_slave = false; 1045 int ret; 1046 1047 /* 1048 * In order to save on transition time, de-prepare 1049 * each Slave and then wait for all Slave(s) to be 1050 * de-prepared after clock resume. 1051 */ 1052 list_for_each_entry(slave, &bus->slaves, node) { 1053 if (!slave->dev_num) 1054 continue; 1055 1056 if (slave->status != SDW_SLAVE_ATTACHED && 1057 slave->status != SDW_SLAVE_ALERT) 1058 continue; 1059 1060 /* Identify if Slave(s) are available on Bus */ 1061 is_slave = true; 1062 1063 ret = sdw_slave_clk_stop_callback(slave, SDW_CLK_STOP_MODE0, 1064 SDW_CLK_PRE_DEPREPARE); 1065 if (ret < 0) 1066 dev_warn(&slave->dev, "clock stop pre-deprepare cb failed:%d\n", ret); 1067 1068 /* Only de-prepare a Slave device if needed */ 1069 if (!slave->prop.simple_clk_stop_capable) { 1070 simple_clk_stop = false; 1071 1072 ret = sdw_slave_clk_stop_prepare(slave, SDW_CLK_STOP_MODE0, 1073 false); 1074 1075 if (ret < 0) 1076 dev_warn(&slave->dev, "clock stop deprepare failed:%d\n", ret); 1077 } 1078 } 1079 1080 /* Skip remaining clock stop de-preparation if no Slave is attached */ 1081 if (!is_slave) 1082 return 0; 1083 1084 /* 1085 * Don't wait for all Slaves to be ready if they follow the simple 1086 * state machine 1087 */ 1088 if (!simple_clk_stop) { 1089 ret = sdw_bus_wait_for_clk_prep_deprep(bus, SDW_BROADCAST_DEV_NUM); 1090 if (ret < 0) 1091 dev_warn(&slave->dev, "clock stop deprepare wait failed:%d\n", ret); 1092 } 1093 1094 list_for_each_entry(slave, &bus->slaves, node) { 1095 if (!slave->dev_num) 1096 continue; 1097 1098 if (slave->status != SDW_SLAVE_ATTACHED && 1099 slave->status != SDW_SLAVE_ALERT) 1100 continue; 1101 1102 ret = sdw_slave_clk_stop_callback(slave, SDW_CLK_STOP_MODE0, 1103 SDW_CLK_POST_DEPREPARE); 1104 if (ret < 0) 1105 dev_warn(&slave->dev, "clock stop post-deprepare cb failed:%d\n", ret); 1106 } 1107 1108 return 0; 1109 } 1110 EXPORT_SYMBOL(sdw_bus_exit_clk_stop); 1111 1112 int sdw_configure_dpn_intr(struct sdw_slave *slave, 1113 int port, bool enable, int mask) 1114 { 1115 u32 addr; 1116 int ret; 1117 u8 val = 0; 1118 1119 if (slave->bus->params.s_data_mode != SDW_PORT_DATA_MODE_NORMAL) { 1120 dev_dbg(&slave->dev, "TEST FAIL interrupt %s\n", 1121 enable ? "on" : "off"); 1122 mask |= SDW_DPN_INT_TEST_FAIL; 1123 } 1124 1125 addr = SDW_DPN_INTMASK(port); 1126 1127 /* Set/Clear port ready interrupt mask */ 1128 if (enable) { 1129 val |= mask; 1130 val |= SDW_DPN_INT_PORT_READY; 1131 } else { 1132 val &= ~(mask); 1133 val &= ~SDW_DPN_INT_PORT_READY; 1134 } 1135 1136 ret = sdw_update(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val); 1137 if (ret < 0) 1138 dev_err(&slave->dev, 1139 "SDW_DPN_INTMASK write failed:%d\n", val); 1140 1141 return ret; 1142 } 1143 1144 static int sdw_slave_set_frequency(struct sdw_slave *slave) 1145 { 1146 u32 mclk_freq = slave->bus->prop.mclk_freq; 1147 u32 curr_freq = slave->bus->params.curr_dr_freq >> 1; 1148 unsigned int scale; 1149 u8 scale_index; 1150 u8 base; 1151 int ret; 1152 1153 /* 1154 * frequency base and scale registers are required for SDCA 1155 * devices. They may also be used for 1.2+/non-SDCA devices, 1156 * but we will need a DisCo property to cover this case 1157 */ 1158 if (!slave->id.class_id) 1159 return 0; 1160 1161 if (!mclk_freq) { 1162 dev_err(&slave->dev, 1163 "no bus MCLK, cannot set SDW_SCP_BUS_CLOCK_BASE\n"); 1164 return -EINVAL; 1165 } 1166 1167 /* 1168 * map base frequency using Table 89 of SoundWire 1.2 spec. 1169 * The order of the tests just follows the specification, this 1170 * is not a selection between possible values or a search for 1171 * the best value but just a mapping. Only one case per platform 1172 * is relevant. 1173 * Some BIOS have inconsistent values for mclk_freq but a 1174 * correct root so we force the mclk_freq to avoid variations. 1175 */ 1176 if (!(19200000 % mclk_freq)) { 1177 mclk_freq = 19200000; 1178 base = SDW_SCP_BASE_CLOCK_19200000_HZ; 1179 } else if (!(24000000 % mclk_freq)) { 1180 mclk_freq = 24000000; 1181 base = SDW_SCP_BASE_CLOCK_24000000_HZ; 1182 } else if (!(24576000 % mclk_freq)) { 1183 mclk_freq = 24576000; 1184 base = SDW_SCP_BASE_CLOCK_24576000_HZ; 1185 } else if (!(22579200 % mclk_freq)) { 1186 mclk_freq = 22579200; 1187 base = SDW_SCP_BASE_CLOCK_22579200_HZ; 1188 } else if (!(32000000 % mclk_freq)) { 1189 mclk_freq = 32000000; 1190 base = SDW_SCP_BASE_CLOCK_32000000_HZ; 1191 } else { 1192 dev_err(&slave->dev, 1193 "Unsupported clock base, mclk %d\n", 1194 mclk_freq); 1195 return -EINVAL; 1196 } 1197 1198 if (mclk_freq % curr_freq) { 1199 dev_err(&slave->dev, 1200 "mclk %d is not multiple of bus curr_freq %d\n", 1201 mclk_freq, curr_freq); 1202 return -EINVAL; 1203 } 1204 1205 scale = mclk_freq / curr_freq; 1206 1207 /* 1208 * map scale to Table 90 of SoundWire 1.2 spec - and check 1209 * that the scale is a power of two and maximum 64 1210 */ 1211 scale_index = ilog2(scale); 1212 1213 if (BIT(scale_index) != scale || scale_index > 6) { 1214 dev_err(&slave->dev, 1215 "No match found for scale %d, bus mclk %d curr_freq %d\n", 1216 scale, mclk_freq, curr_freq); 1217 return -EINVAL; 1218 } 1219 scale_index++; 1220 1221 ret = sdw_write_no_pm(slave, SDW_SCP_BUS_CLOCK_BASE, base); 1222 if (ret < 0) { 1223 dev_err(&slave->dev, 1224 "SDW_SCP_BUS_CLOCK_BASE write failed:%d\n", ret); 1225 return ret; 1226 } 1227 1228 /* initialize scale for both banks */ 1229 ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B0, scale_index); 1230 if (ret < 0) { 1231 dev_err(&slave->dev, 1232 "SDW_SCP_BUSCLOCK_SCALE_B0 write failed:%d\n", ret); 1233 return ret; 1234 } 1235 ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B1, scale_index); 1236 if (ret < 0) 1237 dev_err(&slave->dev, 1238 "SDW_SCP_BUSCLOCK_SCALE_B1 write failed:%d\n", ret); 1239 1240 dev_dbg(&slave->dev, 1241 "Configured bus base %d, scale %d, mclk %d, curr_freq %d\n", 1242 base, scale_index, mclk_freq, curr_freq); 1243 1244 return ret; 1245 } 1246 1247 static int sdw_initialize_slave(struct sdw_slave *slave) 1248 { 1249 struct sdw_slave_prop *prop = &slave->prop; 1250 int status; 1251 int ret; 1252 u8 val; 1253 1254 ret = sdw_slave_set_frequency(slave); 1255 if (ret < 0) 1256 return ret; 1257 1258 if (slave->bus->prop.quirks & SDW_MASTER_QUIRKS_CLEAR_INITIAL_CLASH) { 1259 /* Clear bus clash interrupt before enabling interrupt mask */ 1260 status = sdw_read_no_pm(slave, SDW_SCP_INT1); 1261 if (status < 0) { 1262 dev_err(&slave->dev, 1263 "SDW_SCP_INT1 (BUS_CLASH) read failed:%d\n", status); 1264 return status; 1265 } 1266 if (status & SDW_SCP_INT1_BUS_CLASH) { 1267 dev_warn(&slave->dev, "Bus clash detected before INT mask is enabled\n"); 1268 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, SDW_SCP_INT1_BUS_CLASH); 1269 if (ret < 0) { 1270 dev_err(&slave->dev, 1271 "SDW_SCP_INT1 (BUS_CLASH) write failed:%d\n", ret); 1272 return ret; 1273 } 1274 } 1275 } 1276 if ((slave->bus->prop.quirks & SDW_MASTER_QUIRKS_CLEAR_INITIAL_PARITY) && 1277 !(slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY)) { 1278 /* Clear parity interrupt before enabling interrupt mask */ 1279 status = sdw_read_no_pm(slave, SDW_SCP_INT1); 1280 if (status < 0) { 1281 dev_err(&slave->dev, 1282 "SDW_SCP_INT1 (PARITY) read failed:%d\n", status); 1283 return status; 1284 } 1285 if (status & SDW_SCP_INT1_PARITY) { 1286 dev_warn(&slave->dev, "PARITY error detected before INT mask is enabled\n"); 1287 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, SDW_SCP_INT1_PARITY); 1288 if (ret < 0) { 1289 dev_err(&slave->dev, 1290 "SDW_SCP_INT1 (PARITY) write failed:%d\n", ret); 1291 return ret; 1292 } 1293 } 1294 } 1295 1296 /* 1297 * Set SCP_INT1_MASK register, typically bus clash and 1298 * implementation-defined interrupt mask. The Parity detection 1299 * may not always be correct on startup so its use is 1300 * device-dependent, it might e.g. only be enabled in 1301 * steady-state after a couple of frames. 1302 */ 1303 val = slave->prop.scp_int1_mask; 1304 1305 /* Enable SCP interrupts */ 1306 ret = sdw_update_no_pm(slave, SDW_SCP_INTMASK1, val, val); 1307 if (ret < 0) { 1308 dev_err(&slave->dev, 1309 "SDW_SCP_INTMASK1 write failed:%d\n", ret); 1310 return ret; 1311 } 1312 1313 /* No need to continue if DP0 is not present */ 1314 if (!slave->prop.dp0_prop) 1315 return 0; 1316 1317 /* Enable DP0 interrupts */ 1318 val = prop->dp0_prop->imp_def_interrupts; 1319 val |= SDW_DP0_INT_PORT_READY | SDW_DP0_INT_BRA_FAILURE; 1320 1321 ret = sdw_update_no_pm(slave, SDW_DP0_INTMASK, val, val); 1322 if (ret < 0) 1323 dev_err(&slave->dev, 1324 "SDW_DP0_INTMASK read failed:%d\n", ret); 1325 return ret; 1326 } 1327 1328 static int sdw_handle_dp0_interrupt(struct sdw_slave *slave, u8 *slave_status) 1329 { 1330 u8 clear, impl_int_mask; 1331 int status, status2, ret, count = 0; 1332 1333 status = sdw_read_no_pm(slave, SDW_DP0_INT); 1334 if (status < 0) { 1335 dev_err(&slave->dev, 1336 "SDW_DP0_INT read failed:%d\n", status); 1337 return status; 1338 } 1339 1340 do { 1341 clear = status & ~SDW_DP0_INTERRUPTS; 1342 1343 if (status & SDW_DP0_INT_TEST_FAIL) { 1344 dev_err(&slave->dev, "Test fail for port 0\n"); 1345 clear |= SDW_DP0_INT_TEST_FAIL; 1346 } 1347 1348 /* 1349 * Assumption: PORT_READY interrupt will be received only for 1350 * ports implementing Channel Prepare state machine (CP_SM) 1351 */ 1352 1353 if (status & SDW_DP0_INT_PORT_READY) { 1354 complete(&slave->port_ready[0]); 1355 clear |= SDW_DP0_INT_PORT_READY; 1356 } 1357 1358 if (status & SDW_DP0_INT_BRA_FAILURE) { 1359 dev_err(&slave->dev, "BRA failed\n"); 1360 clear |= SDW_DP0_INT_BRA_FAILURE; 1361 } 1362 1363 impl_int_mask = SDW_DP0_INT_IMPDEF1 | 1364 SDW_DP0_INT_IMPDEF2 | SDW_DP0_INT_IMPDEF3; 1365 1366 if (status & impl_int_mask) { 1367 clear |= impl_int_mask; 1368 *slave_status = clear; 1369 } 1370 1371 /* clear the interrupts but don't touch reserved and SDCA_CASCADE fields */ 1372 ret = sdw_write_no_pm(slave, SDW_DP0_INT, clear); 1373 if (ret < 0) { 1374 dev_err(&slave->dev, 1375 "SDW_DP0_INT write failed:%d\n", ret); 1376 return ret; 1377 } 1378 1379 /* Read DP0 interrupt again */ 1380 status2 = sdw_read_no_pm(slave, SDW_DP0_INT); 1381 if (status2 < 0) { 1382 dev_err(&slave->dev, 1383 "SDW_DP0_INT read failed:%d\n", status2); 1384 return status2; 1385 } 1386 /* filter to limit loop to interrupts identified in the first status read */ 1387 status &= status2; 1388 1389 count++; 1390 1391 /* we can get alerts while processing so keep retrying */ 1392 } while ((status & SDW_DP0_INTERRUPTS) && (count < SDW_READ_INTR_CLEAR_RETRY)); 1393 1394 if (count == SDW_READ_INTR_CLEAR_RETRY) 1395 dev_warn(&slave->dev, "Reached MAX_RETRY on DP0 read\n"); 1396 1397 return ret; 1398 } 1399 1400 static int sdw_handle_port_interrupt(struct sdw_slave *slave, 1401 int port, u8 *slave_status) 1402 { 1403 u8 clear, impl_int_mask; 1404 int status, status2, ret, count = 0; 1405 u32 addr; 1406 1407 if (port == 0) 1408 return sdw_handle_dp0_interrupt(slave, slave_status); 1409 1410 addr = SDW_DPN_INT(port); 1411 status = sdw_read_no_pm(slave, addr); 1412 if (status < 0) { 1413 dev_err(&slave->dev, 1414 "SDW_DPN_INT read failed:%d\n", status); 1415 1416 return status; 1417 } 1418 1419 do { 1420 clear = status & ~SDW_DPN_INTERRUPTS; 1421 1422 if (status & SDW_DPN_INT_TEST_FAIL) { 1423 dev_err(&slave->dev, "Test fail for port:%d\n", port); 1424 clear |= SDW_DPN_INT_TEST_FAIL; 1425 } 1426 1427 /* 1428 * Assumption: PORT_READY interrupt will be received only 1429 * for ports implementing CP_SM. 1430 */ 1431 if (status & SDW_DPN_INT_PORT_READY) { 1432 complete(&slave->port_ready[port]); 1433 clear |= SDW_DPN_INT_PORT_READY; 1434 } 1435 1436 impl_int_mask = SDW_DPN_INT_IMPDEF1 | 1437 SDW_DPN_INT_IMPDEF2 | SDW_DPN_INT_IMPDEF3; 1438 1439 if (status & impl_int_mask) { 1440 clear |= impl_int_mask; 1441 *slave_status = clear; 1442 } 1443 1444 /* clear the interrupt but don't touch reserved fields */ 1445 ret = sdw_write_no_pm(slave, addr, clear); 1446 if (ret < 0) { 1447 dev_err(&slave->dev, 1448 "SDW_DPN_INT write failed:%d\n", ret); 1449 return ret; 1450 } 1451 1452 /* Read DPN interrupt again */ 1453 status2 = sdw_read_no_pm(slave, addr); 1454 if (status2 < 0) { 1455 dev_err(&slave->dev, 1456 "SDW_DPN_INT read failed:%d\n", status2); 1457 return status2; 1458 } 1459 /* filter to limit loop to interrupts identified in the first status read */ 1460 status &= status2; 1461 1462 count++; 1463 1464 /* we can get alerts while processing so keep retrying */ 1465 } while ((status & SDW_DPN_INTERRUPTS) && (count < SDW_READ_INTR_CLEAR_RETRY)); 1466 1467 if (count == SDW_READ_INTR_CLEAR_RETRY) 1468 dev_warn(&slave->dev, "Reached MAX_RETRY on port read"); 1469 1470 return ret; 1471 } 1472 1473 static int sdw_handle_slave_alerts(struct sdw_slave *slave) 1474 { 1475 struct sdw_slave_intr_status slave_intr; 1476 u8 clear = 0, bit, port_status[15] = {0}; 1477 int port_num, stat, ret, count = 0; 1478 unsigned long port; 1479 bool slave_notify; 1480 u8 sdca_cascade = 0; 1481 u8 buf, buf2[2], _buf, _buf2[2]; 1482 bool parity_check; 1483 bool parity_quirk; 1484 1485 sdw_modify_slave_status(slave, SDW_SLAVE_ALERT); 1486 1487 ret = pm_runtime_get_sync(&slave->dev); 1488 if (ret < 0 && ret != -EACCES) { 1489 dev_err(&slave->dev, "Failed to resume device: %d\n", ret); 1490 pm_runtime_put_noidle(&slave->dev); 1491 return ret; 1492 } 1493 1494 /* Read Intstat 1, Intstat 2 and Intstat 3 registers */ 1495 ret = sdw_read_no_pm(slave, SDW_SCP_INT1); 1496 if (ret < 0) { 1497 dev_err(&slave->dev, 1498 "SDW_SCP_INT1 read failed:%d\n", ret); 1499 goto io_err; 1500 } 1501 buf = ret; 1502 1503 ret = sdw_nread_no_pm(slave, SDW_SCP_INTSTAT2, 2, buf2); 1504 if (ret < 0) { 1505 dev_err(&slave->dev, 1506 "SDW_SCP_INT2/3 read failed:%d\n", ret); 1507 goto io_err; 1508 } 1509 1510 if (slave->prop.is_sdca) { 1511 ret = sdw_read_no_pm(slave, SDW_DP0_INT); 1512 if (ret < 0) { 1513 dev_err(&slave->dev, 1514 "SDW_DP0_INT read failed:%d\n", ret); 1515 goto io_err; 1516 } 1517 sdca_cascade = ret & SDW_DP0_SDCA_CASCADE; 1518 } 1519 1520 do { 1521 slave_notify = false; 1522 1523 /* 1524 * Check parity, bus clash and Slave (impl defined) 1525 * interrupt 1526 */ 1527 if (buf & SDW_SCP_INT1_PARITY) { 1528 parity_check = slave->prop.scp_int1_mask & SDW_SCP_INT1_PARITY; 1529 parity_quirk = !slave->first_interrupt_done && 1530 (slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY); 1531 1532 if (parity_check && !parity_quirk) 1533 dev_err(&slave->dev, "Parity error detected\n"); 1534 clear |= SDW_SCP_INT1_PARITY; 1535 } 1536 1537 if (buf & SDW_SCP_INT1_BUS_CLASH) { 1538 if (slave->prop.scp_int1_mask & SDW_SCP_INT1_BUS_CLASH) 1539 dev_err(&slave->dev, "Bus clash detected\n"); 1540 clear |= SDW_SCP_INT1_BUS_CLASH; 1541 } 1542 1543 /* 1544 * When bus clash or parity errors are detected, such errors 1545 * are unlikely to be recoverable errors. 1546 * TODO: In such scenario, reset bus. Make this configurable 1547 * via sysfs property with bus reset being the default. 1548 */ 1549 1550 if (buf & SDW_SCP_INT1_IMPL_DEF) { 1551 if (slave->prop.scp_int1_mask & SDW_SCP_INT1_IMPL_DEF) { 1552 dev_dbg(&slave->dev, "Slave impl defined interrupt\n"); 1553 slave_notify = true; 1554 } 1555 clear |= SDW_SCP_INT1_IMPL_DEF; 1556 } 1557 1558 /* the SDCA interrupts are cleared in the codec driver .interrupt_callback() */ 1559 if (sdca_cascade) 1560 slave_notify = true; 1561 1562 /* Check port 0 - 3 interrupts */ 1563 port = buf & SDW_SCP_INT1_PORT0_3; 1564 1565 /* To get port number corresponding to bits, shift it */ 1566 port = FIELD_GET(SDW_SCP_INT1_PORT0_3, port); 1567 for_each_set_bit(bit, &port, 8) { 1568 sdw_handle_port_interrupt(slave, bit, 1569 &port_status[bit]); 1570 } 1571 1572 /* Check if cascade 2 interrupt is present */ 1573 if (buf & SDW_SCP_INT1_SCP2_CASCADE) { 1574 port = buf2[0] & SDW_SCP_INTSTAT2_PORT4_10; 1575 for_each_set_bit(bit, &port, 8) { 1576 /* scp2 ports start from 4 */ 1577 port_num = bit + 3; 1578 sdw_handle_port_interrupt(slave, 1579 port_num, 1580 &port_status[port_num]); 1581 } 1582 } 1583 1584 /* now check last cascade */ 1585 if (buf2[0] & SDW_SCP_INTSTAT2_SCP3_CASCADE) { 1586 port = buf2[1] & SDW_SCP_INTSTAT3_PORT11_14; 1587 for_each_set_bit(bit, &port, 8) { 1588 /* scp3 ports start from 11 */ 1589 port_num = bit + 10; 1590 sdw_handle_port_interrupt(slave, 1591 port_num, 1592 &port_status[port_num]); 1593 } 1594 } 1595 1596 /* Update the Slave driver */ 1597 if (slave_notify && slave->ops && 1598 slave->ops->interrupt_callback) { 1599 slave_intr.sdca_cascade = sdca_cascade; 1600 slave_intr.control_port = clear; 1601 memcpy(slave_intr.port, &port_status, 1602 sizeof(slave_intr.port)); 1603 1604 slave->ops->interrupt_callback(slave, &slave_intr); 1605 } 1606 1607 /* Ack interrupt */ 1608 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, clear); 1609 if (ret < 0) { 1610 dev_err(&slave->dev, 1611 "SDW_SCP_INT1 write failed:%d\n", ret); 1612 goto io_err; 1613 } 1614 1615 /* at this point all initial interrupt sources were handled */ 1616 slave->first_interrupt_done = true; 1617 1618 /* 1619 * Read status again to ensure no new interrupts arrived 1620 * while servicing interrupts. 1621 */ 1622 ret = sdw_read_no_pm(slave, SDW_SCP_INT1); 1623 if (ret < 0) { 1624 dev_err(&slave->dev, 1625 "SDW_SCP_INT1 recheck read failed:%d\n", ret); 1626 goto io_err; 1627 } 1628 _buf = ret; 1629 1630 ret = sdw_nread_no_pm(slave, SDW_SCP_INTSTAT2, 2, _buf2); 1631 if (ret < 0) { 1632 dev_err(&slave->dev, 1633 "SDW_SCP_INT2/3 recheck read failed:%d\n", ret); 1634 goto io_err; 1635 } 1636 1637 if (slave->prop.is_sdca) { 1638 ret = sdw_read_no_pm(slave, SDW_DP0_INT); 1639 if (ret < 0) { 1640 dev_err(&slave->dev, 1641 "SDW_DP0_INT recheck read failed:%d\n", ret); 1642 goto io_err; 1643 } 1644 sdca_cascade = ret & SDW_DP0_SDCA_CASCADE; 1645 } 1646 1647 /* 1648 * Make sure no interrupts are pending, but filter to limit loop 1649 * to interrupts identified in the first status read 1650 */ 1651 buf &= _buf; 1652 buf2[0] &= _buf2[0]; 1653 buf2[1] &= _buf2[1]; 1654 stat = buf || buf2[0] || buf2[1] || sdca_cascade; 1655 1656 /* 1657 * Exit loop if Slave is continuously in ALERT state even 1658 * after servicing the interrupt multiple times. 1659 */ 1660 count++; 1661 1662 /* we can get alerts while processing so keep retrying */ 1663 } while (stat != 0 && count < SDW_READ_INTR_CLEAR_RETRY); 1664 1665 if (count == SDW_READ_INTR_CLEAR_RETRY) 1666 dev_warn(&slave->dev, "Reached MAX_RETRY on alert read\n"); 1667 1668 io_err: 1669 pm_runtime_mark_last_busy(&slave->dev); 1670 pm_runtime_put_autosuspend(&slave->dev); 1671 1672 return ret; 1673 } 1674 1675 static int sdw_update_slave_status(struct sdw_slave *slave, 1676 enum sdw_slave_status status) 1677 { 1678 unsigned long time; 1679 1680 if (!slave->probed) { 1681 /* 1682 * the slave status update is typically handled in an 1683 * interrupt thread, which can race with the driver 1684 * probe, e.g. when a module needs to be loaded. 1685 * 1686 * make sure the probe is complete before updating 1687 * status. 1688 */ 1689 time = wait_for_completion_timeout(&slave->probe_complete, 1690 msecs_to_jiffies(DEFAULT_PROBE_TIMEOUT)); 1691 if (!time) { 1692 dev_err(&slave->dev, "Probe not complete, timed out\n"); 1693 return -ETIMEDOUT; 1694 } 1695 } 1696 1697 if (!slave->ops || !slave->ops->update_status) 1698 return 0; 1699 1700 return slave->ops->update_status(slave, status); 1701 } 1702 1703 /** 1704 * sdw_handle_slave_status() - Handle Slave status 1705 * @bus: SDW bus instance 1706 * @status: Status for all Slave(s) 1707 */ 1708 int sdw_handle_slave_status(struct sdw_bus *bus, 1709 enum sdw_slave_status status[]) 1710 { 1711 enum sdw_slave_status prev_status; 1712 struct sdw_slave *slave; 1713 bool attached_initializing; 1714 int i, ret = 0; 1715 1716 /* first check if any Slaves fell off the bus */ 1717 for (i = 1; i <= SDW_MAX_DEVICES; i++) { 1718 mutex_lock(&bus->bus_lock); 1719 if (test_bit(i, bus->assigned) == false) { 1720 mutex_unlock(&bus->bus_lock); 1721 continue; 1722 } 1723 mutex_unlock(&bus->bus_lock); 1724 1725 slave = sdw_get_slave(bus, i); 1726 if (!slave) 1727 continue; 1728 1729 if (status[i] == SDW_SLAVE_UNATTACHED && 1730 slave->status != SDW_SLAVE_UNATTACHED) 1731 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED); 1732 } 1733 1734 if (status[0] == SDW_SLAVE_ATTACHED) { 1735 dev_dbg(bus->dev, "Slave attached, programming device number\n"); 1736 ret = sdw_program_device_num(bus); 1737 if (ret < 0) 1738 dev_err(bus->dev, "Slave attach failed: %d\n", ret); 1739 /* 1740 * programming a device number will have side effects, 1741 * so we deal with other devices at a later time 1742 */ 1743 return ret; 1744 } 1745 1746 /* Continue to check other slave statuses */ 1747 for (i = 1; i <= SDW_MAX_DEVICES; i++) { 1748 mutex_lock(&bus->bus_lock); 1749 if (test_bit(i, bus->assigned) == false) { 1750 mutex_unlock(&bus->bus_lock); 1751 continue; 1752 } 1753 mutex_unlock(&bus->bus_lock); 1754 1755 slave = sdw_get_slave(bus, i); 1756 if (!slave) 1757 continue; 1758 1759 attached_initializing = false; 1760 1761 switch (status[i]) { 1762 case SDW_SLAVE_UNATTACHED: 1763 if (slave->status == SDW_SLAVE_UNATTACHED) 1764 break; 1765 1766 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED); 1767 break; 1768 1769 case SDW_SLAVE_ALERT: 1770 ret = sdw_handle_slave_alerts(slave); 1771 if (ret < 0) 1772 dev_err(&slave->dev, 1773 "Slave %d alert handling failed: %d\n", 1774 i, ret); 1775 break; 1776 1777 case SDW_SLAVE_ATTACHED: 1778 if (slave->status == SDW_SLAVE_ATTACHED) 1779 break; 1780 1781 prev_status = slave->status; 1782 sdw_modify_slave_status(slave, SDW_SLAVE_ATTACHED); 1783 1784 if (prev_status == SDW_SLAVE_ALERT) 1785 break; 1786 1787 attached_initializing = true; 1788 1789 ret = sdw_initialize_slave(slave); 1790 if (ret < 0) 1791 dev_err(&slave->dev, 1792 "Slave %d initialization failed: %d\n", 1793 i, ret); 1794 1795 break; 1796 1797 default: 1798 dev_err(&slave->dev, "Invalid slave %d status:%d\n", 1799 i, status[i]); 1800 break; 1801 } 1802 1803 ret = sdw_update_slave_status(slave, status[i]); 1804 if (ret < 0) 1805 dev_err(&slave->dev, 1806 "Update Slave status failed:%d\n", ret); 1807 if (attached_initializing) { 1808 dev_dbg(&slave->dev, 1809 "%s: signaling initialization completion for Slave %d\n", 1810 __func__, slave->dev_num); 1811 1812 complete(&slave->initialization_complete); 1813 } 1814 } 1815 1816 return ret; 1817 } 1818 EXPORT_SYMBOL(sdw_handle_slave_status); 1819 1820 void sdw_clear_slave_status(struct sdw_bus *bus, u32 request) 1821 { 1822 struct sdw_slave *slave; 1823 int i; 1824 1825 /* Check all non-zero devices */ 1826 for (i = 1; i <= SDW_MAX_DEVICES; i++) { 1827 mutex_lock(&bus->bus_lock); 1828 if (test_bit(i, bus->assigned) == false) { 1829 mutex_unlock(&bus->bus_lock); 1830 continue; 1831 } 1832 mutex_unlock(&bus->bus_lock); 1833 1834 slave = sdw_get_slave(bus, i); 1835 if (!slave) 1836 continue; 1837 1838 if (slave->status != SDW_SLAVE_UNATTACHED) { 1839 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED); 1840 slave->first_interrupt_done = false; 1841 } 1842 1843 /* keep track of request, used in pm_runtime resume */ 1844 slave->unattach_request = request; 1845 } 1846 } 1847 EXPORT_SYMBOL(sdw_clear_slave_status); 1848