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