Lines Matching full:slave
135 * Create Slave devices based on Slaves described in
172 struct sdw_slave *slave = dev_to_sdw_dev(dev);
173 struct sdw_bus *bus = slave->bus;
177 sdw_slave_debugfs_exit(slave);
181 if (slave->dev_num) { /* clear dev_num if assigned */
182 clear_bit(slave->dev_num, bus->assigned);
184 bus->ops->put_device_num(bus, slave);
186 list_del_init(&slave->node);
282 dev_err(bus->dev, "trf on Slave %d failed:%d %s addr %x count %d\n",
291 * sdw_transfer() - Synchronous transfer message to a SDW Slave device
341 * sdw_transfer_defer() - Asynchronously transfer message to a SDW Slave device
356 dev_err(bus->dev, "Defer trf on Slave %d failed:%d\n",
362 int sdw_fill_msg(struct sdw_msg *msg, struct sdw_slave *slave,
381 if (slave && !slave->prop.paging_support)
392 if (!slave) {
393 pr_err("SDW: No slave for paging addr\n");
397 if (!slave->prop.paging_support) {
398 dev_err(&slave->dev,
415 static int sdw_ntransfer_no_pm(struct sdw_slave *slave, u32 addr, u8 flags,
426 ret = sdw_fill_msg(&msg, slave, addr, size, slave->dev_num, flags, val);
430 ret = sdw_transfer(slave->bus, &msg);
431 if (ret < 0 && !slave->is_mockup_device)
443 * sdw_nread_no_pm() - Read "n" contiguous SDW Slave registers with no PM
444 * @slave: SDW Slave
452 int sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
454 return sdw_ntransfer_no_pm(slave, addr, SDW_MSG_FLAG_READ, count, val);
459 * sdw_nwrite_no_pm() - Write "n" contiguous SDW Slave registers with no PM
460 * @slave: SDW Slave
468 int sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
470 return sdw_ntransfer_no_pm(slave, addr, SDW_MSG_FLAG_WRITE, count, (u8 *)val);
475 * sdw_write_no_pm() - Write a SDW Slave register with no PM
476 * @slave: SDW Slave
480 int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value)
482 return sdw_nwrite_no_pm(slave, addr, 1, &value);
553 * sdw_read_no_pm() - Read a SDW Slave register with no PM
554 * @slave: SDW Slave
557 int sdw_read_no_pm(struct sdw_slave *slave, u32 addr)
562 ret = sdw_nread_no_pm(slave, addr, 1, &buf);
570 int sdw_update_no_pm(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
574 tmp = sdw_read_no_pm(slave, addr);
579 return sdw_write_no_pm(slave, addr, tmp);
583 /* Read-Modify-Write Slave register */
584 int sdw_update(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
588 tmp = sdw_read(slave, addr);
593 return sdw_write(slave, addr, tmp);
598 * sdw_nread() - Read "n" contiguous SDW Slave registers
599 * @slave: SDW Slave
604 * This version of the function will take a PM reference to the slave
609 int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
613 ret = pm_runtime_get_sync(&slave->dev);
615 pm_runtime_put_noidle(&slave->dev);
619 ret = sdw_nread_no_pm(slave, addr, count, val);
621 pm_runtime_mark_last_busy(&slave->dev);
622 pm_runtime_put(&slave->dev);
629 * sdw_nwrite() - Write "n" contiguous SDW Slave registers
630 * @slave: SDW Slave
635 * This version of the function will take a PM reference to the slave
640 int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
644 ret = pm_runtime_get_sync(&slave->dev);
646 pm_runtime_put_noidle(&slave->dev);
650 ret = sdw_nwrite_no_pm(slave, addr, count, val);
652 pm_runtime_mark_last_busy(&slave->dev);
653 pm_runtime_put(&slave->dev);
660 * sdw_read() - Read a SDW Slave register
661 * @slave: SDW Slave
664 * This version of the function will take a PM reference to the slave
667 int sdw_read(struct sdw_slave *slave, u32 addr)
672 ret = sdw_nread(slave, addr, 1, &buf);
681 * sdw_write() - Write a SDW Slave register
682 * @slave: SDW Slave
686 * This version of the function will take a PM reference to the slave
689 int sdw_write(struct sdw_slave *slave, u32 addr, u8 value)
691 return sdw_nwrite(slave, addr, 1, &value);
702 struct sdw_slave *slave;
704 list_for_each_entry(slave, &bus->slaves, node) {
705 if (slave->dev_num == i)
706 return slave;
712 int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id)
714 if (slave->id.mfg_id != id.mfg_id ||
715 slave->id.part_id != id.part_id ||
716 slave->id.class_id != id.class_id ||
717 (slave->id.unique_id != SDW_IGNORED_UNIQUE_ID &&
718 slave->id.unique_id != id.unique_id))
726 static int sdw_get_device_num(struct sdw_slave *slave)
728 struct sdw_bus *bus = slave->bus;
732 bit = bus->ops->get_device_num(bus, slave);
744 * Do not update dev_num in Slave data structure here,
753 static int sdw_assign_device_num(struct sdw_slave *slave)
755 struct sdw_bus *bus = slave->bus;
760 if (!slave->dev_num) {
761 if (!slave->dev_num_sticky) {
764 mutex_lock(&slave->bus->bus_lock);
765 dev_num = sdw_get_device_num(slave);
766 mutex_unlock(&slave->bus->bus_lock);
772 slave->dev_num_sticky = dev_num;
774 dev_dbg(dev, "Slave already registered, reusing dev_num: %d\n",
775 slave->dev_num_sticky);
779 /* Clear the slave->dev_num to transfer message on device 0 */
780 slave->dev_num = 0;
782 ret = sdw_write_no_pm(slave, SDW_SCP_DEVNUMBER, slave->dev_num_sticky);
785 slave->dev_num_sticky, ret);
790 slave->dev_num = slave->dev_num_sticky;
793 bus->ops->new_peripheral_assigned(bus, slave, slave->dev_num);
801 dev_dbg(bus->dev, "SDW Slave Addr: %llx\n", addr);
810 "SDW Slave class_id 0x%02x, mfg_id 0x%04x, part_id 0x%04x, unique_id 0x%x, version 0x%x\n",
815 bool is_clock_scaling_supported_by_slave(struct sdw_slave *slave)
821 return slave->id.class_id;
828 struct sdw_slave *slave, *_s;
837 /* No Slave, so use raw xfer api */
867 list_for_each_entry_safe(slave, _s, &bus->slaves, node) {
868 if (sdw_compare_devid(slave, id) == 0) {
878 if (slave->status != SDW_SLAVE_UNATTACHED)
882 * Assign a new dev_num to this Slave and
887 ret = sdw_assign_device_num(slave);
905 * add Slave device even if there is no platform
912 dev_err(bus->dev, "Slave Entry not found\n");
928 static void sdw_modify_slave_status(struct sdw_slave *slave,
931 struct sdw_bus *bus = slave->bus;
936 "changing status slave %d status %d new status %d\n",
937 slave->dev_num, slave->status, status);
940 dev_dbg(&slave->dev,
941 "initializing enumeration and init completion for Slave %d\n",
942 slave->dev_num);
944 reinit_completion(&slave->enumeration_complete);
945 reinit_completion(&slave->initialization_complete);
948 (slave->status == SDW_SLAVE_UNATTACHED)) {
949 dev_dbg(&slave->dev,
950 "signaling enumeration completion for Slave %d\n",
951 slave->dev_num);
953 complete_all(&slave->enumeration_complete);
955 slave->status = status;
959 static int sdw_slave_clk_stop_callback(struct sdw_slave *slave,
965 mutex_lock(&slave->sdw_dev_lock);
967 if (slave->probed) {
968 struct device *dev = &slave->dev;
972 ret = drv->ops->clk_stop(slave, mode, type);
975 mutex_unlock(&slave->sdw_dev_lock);
980 static int sdw_slave_clk_stop_prepare(struct sdw_slave *slave,
988 wake_en = slave->prop.wake_capable;
999 ret = sdw_read_no_pm(slave, SDW_SCP_SYSTEMCTRL);
1002 dev_err(&slave->dev, "SDW_SCP_SYSTEMCTRL read failed:%d\n", ret);
1009 ret = sdw_write_no_pm(slave, SDW_SCP_SYSTEMCTRL, val);
1012 dev_err(&slave->dev, "SDW_SCP_SYSTEMCTRL write failed:%d\n", ret);
1031 dev_dbg(bus->dev, "clock stop %s done slave:%d\n",
1041 dev_dbg(bus->dev, "clock stop %s did not complete for slave:%d\n",
1049 * sdw_bus_prep_clk_stop: prepare Slave(s) for clock stop
1053 * Query Slave for clock stop mode and prepare for that mode.
1058 struct sdw_slave *slave;
1064 * each Slave and then wait for all Slave(s) to be
1066 * If one of the Slave devices has lost sync and
1070 list_for_each_entry(slave, &bus->slaves, node) {
1071 if (!slave->dev_num)
1074 if (slave->status != SDW_SLAVE_ATTACHED &&
1075 slave->status != SDW_SLAVE_ALERT)
1078 /* Identify if Slave(s) are available on Bus */
1081 ret = sdw_slave_clk_stop_callback(slave,
1085 dev_err(&slave->dev, "clock stop pre-prepare cb failed:%d\n", ret);
1089 /* Only prepare a Slave device if needed */
1090 if (!slave->prop.simple_clk_stop_capable) {
1093 ret = sdw_slave_clk_stop_prepare(slave,
1097 dev_err(&slave->dev, "clock stop prepare failed:%d\n", ret);
1103 /* Skip remaining clock stop preparation if no Slave is attached */
1115 * if there are no Slave devices present and the reply is
1125 list_for_each_entry(slave, &bus->slaves, node) {
1126 if (!slave->dev_num)
1129 if (slave->status != SDW_SLAVE_ATTACHED &&
1130 slave->status != SDW_SLAVE_ALERT)
1133 ret = sdw_slave_clk_stop_callback(slave,
1138 dev_err(&slave->dev, "clock stop post-prepare cb failed:%d\n", ret);
1187 struct sdw_slave *slave;
1193 * each Slave and then wait for all Slave(s) to be
1196 list_for_each_entry(slave, &bus->slaves, node) {
1197 if (!slave->dev_num)
1200 if (slave->status != SDW_SLAVE_ATTACHED &&
1201 slave->status != SDW_SLAVE_ALERT)
1204 /* Identify if Slave(s) are available on Bus */
1207 ret = sdw_slave_clk_stop_callback(slave, SDW_CLK_STOP_MODE0,
1210 dev_warn(&slave->dev, "clock stop pre-deprepare cb failed:%d\n", ret);
1212 /* Only de-prepare a Slave device if needed */
1213 if (!slave->prop.simple_clk_stop_capable) {
1216 ret = sdw_slave_clk_stop_prepare(slave, SDW_CLK_STOP_MODE0,
1220 dev_warn(&slave->dev, "clock stop deprepare failed:%d\n", ret);
1224 /* Skip remaining clock stop de-preparation if no Slave is attached */
1238 list_for_each_entry(slave, &bus->slaves, node) {
1239 if (!slave->dev_num)
1242 if (slave->status != SDW_SLAVE_ATTACHED &&
1243 slave->status != SDW_SLAVE_ALERT)
1246 ret = sdw_slave_clk_stop_callback(slave, SDW_CLK_STOP_MODE0,
1249 dev_warn(&slave->dev, "clock stop post-deprepare cb failed:%d\n", ret);
1256 int sdw_configure_dpn_intr(struct sdw_slave *slave,
1263 if (slave->bus->params.s_data_mode != SDW_PORT_DATA_MODE_NORMAL) {
1264 dev_dbg(&slave->dev, "TEST FAIL interrupt %s\n",
1280 ret = sdw_update_no_pm(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val);
1282 dev_err(&slave->dev,
1288 int sdw_slave_get_scale_index(struct sdw_slave *slave, u8 *base)
1290 u32 mclk_freq = slave->bus->prop.mclk_freq;
1291 u32 curr_freq = slave->bus->params.curr_dr_freq >> 1;
1296 dev_err(&slave->dev,
1326 dev_err(&slave->dev,
1333 dev_err(&slave->dev,
1348 dev_err(&slave->dev,
1355 dev_dbg(&slave->dev,
1363 int sdw_slave_get_current_bank(struct sdw_slave *slave)
1367 tmp = sdw_read(slave, SDW_SCP_CTRL);
1375 static int sdw_slave_set_frequency(struct sdw_slave *slave)
1388 if (!slave->id.class_id && !slave->prop.clock_reg_supported)
1391 scale_index = sdw_slave_get_scale_index(slave, &base);
1395 ret = sdw_write_no_pm(slave, SDW_SCP_BUS_CLOCK_BASE, base);
1397 dev_err(&slave->dev,
1403 ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B0, scale_index);
1405 dev_err(&slave->dev,
1409 ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B1, scale_index);
1411 dev_err(&slave->dev,
1417 static int sdw_initialize_slave(struct sdw_slave *slave)
1419 struct sdw_slave_prop *prop = &slave->prop;
1424 ret = sdw_slave_set_frequency(slave);
1428 if (slave->bus->prop.quirks & SDW_MASTER_QUIRKS_CLEAR_INITIAL_CLASH) {
1430 status = sdw_read_no_pm(slave, SDW_SCP_INT1);
1432 dev_err(&slave->dev,
1437 dev_warn(&slave->dev, "Bus clash detected before INT mask is enabled\n");
1438 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, SDW_SCP_INT1_BUS_CLASH);
1440 dev_err(&slave->dev,
1446 if ((slave->bus->prop.quirks & SDW_MASTER_QUIRKS_CLEAR_INITIAL_PARITY) &&
1449 status = sdw_read_no_pm(slave, SDW_SCP_INT1);
1451 dev_err(&slave->dev,
1456 dev_warn(&slave->dev, "PARITY error detected before INT mask is enabled\n");
1457 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, SDW_SCP_INT1_PARITY);
1459 dev_err(&slave->dev,
1476 ret = sdw_update_no_pm(slave, SDW_SCP_INTMASK1, val, val);
1478 dev_err(&slave->dev,
1491 ret = sdw_update_no_pm(slave, SDW_DP0_INTMASK, val, val);
1493 dev_err(&slave->dev,
1498 static int sdw_handle_dp0_interrupt(struct sdw_slave *slave, u8 *slave_status)
1503 status = sdw_read_no_pm(slave, SDW_DP0_INT);
1505 dev_err(&slave->dev,
1514 dev_err(&slave->dev, "Test fail for port 0\n");
1524 complete(&slave->port_ready[0]);
1529 dev_err(&slave->dev, "BRA failed\n");
1542 ret = sdw_write_no_pm(slave, SDW_DP0_INT, clear);
1544 dev_err(&slave->dev,
1550 status2 = sdw_read_no_pm(slave, SDW_DP0_INT);
1552 dev_err(&slave->dev,
1565 dev_warn(&slave->dev, "Reached MAX_RETRY on DP0 read\n");
1570 static int sdw_handle_port_interrupt(struct sdw_slave *slave,
1578 return sdw_handle_dp0_interrupt(slave, slave_status);
1581 status = sdw_read_no_pm(slave, addr);
1583 dev_err(&slave->dev,
1593 dev_err(&slave->dev, "Test fail for port:%d\n", port);
1602 complete(&slave->port_ready[port]);
1615 ret = sdw_write_no_pm(slave, addr, clear);
1617 dev_err(&slave->dev,
1623 status2 = sdw_read_no_pm(slave, addr);
1625 dev_err(&slave->dev,
1638 dev_warn(&slave->dev, "Reached MAX_RETRY on port read");
1643 static int sdw_handle_slave_alerts(struct sdw_slave *slave)
1655 sdw_modify_slave_status(slave, SDW_SLAVE_ALERT);
1657 ret = pm_runtime_get_sync(&slave->dev);
1659 dev_err(&slave->dev, "Failed to resume device: %d\n", ret);
1660 pm_runtime_put_noidle(&slave->dev);
1665 ret = sdw_read_no_pm(slave, SDW_SCP_INT1);
1667 dev_err(&slave->dev,
1673 ret = sdw_nread_no_pm(slave, SDW_SCP_INTSTAT2, 2, buf2);
1675 dev_err(&slave->dev,
1680 if (slave->id.class_id) {
1681 ret = sdw_read_no_pm(slave, SDW_DP0_INT);
1683 dev_err(&slave->dev,
1694 * Check parity, bus clash and Slave (impl defined)
1698 parity_check = slave->prop.scp_int1_mask & SDW_SCP_INT1_PARITY;
1699 parity_quirk = !slave->first_interrupt_done &&
1700 (slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY);
1703 dev_err(&slave->dev, "Parity error detected\n");
1708 if (slave->prop.scp_int1_mask & SDW_SCP_INT1_BUS_CLASH)
1709 dev_err(&slave->dev, "Bus clash detected\n");
1721 if (slave->prop.scp_int1_mask & SDW_SCP_INT1_IMPL_DEF) {
1722 dev_dbg(&slave->dev, "Slave impl defined interrupt\n");
1738 sdw_handle_port_interrupt(slave, bit,
1748 sdw_handle_port_interrupt(slave,
1760 sdw_handle_port_interrupt(slave,
1766 /* Update the Slave driver */
1768 if (slave->prop.use_domain_irq && slave->irq)
1769 handle_nested_irq(slave->irq);
1771 mutex_lock(&slave->sdw_dev_lock);
1773 if (slave->probed) {
1774 struct device *dev = &slave->dev;
1783 drv->ops->interrupt_callback(slave, &slave_intr);
1787 mutex_unlock(&slave->sdw_dev_lock);
1791 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, clear);
1793 dev_err(&slave->dev,
1799 slave->first_interrupt_done = true;
1805 ret = sdw_read_no_pm(slave, SDW_SCP_INT1);
1807 dev_err(&slave->dev,
1813 ret = sdw_nread_no_pm(slave, SDW_SCP_INTSTAT2, 2, buf2);
1815 dev_err(&slave->dev,
1820 if (slave->id.class_id) {
1821 ret = sdw_read_no_pm(slave, SDW_DP0_INT);
1823 dev_err(&slave->dev,
1836 * Exit loop if Slave is continuously in ALERT state even
1845 dev_warn(&slave->dev, "Reached MAX_RETRY on alert read\n");
1848 pm_runtime_mark_last_busy(&slave->dev);
1849 pm_runtime_put_autosuspend(&slave->dev);
1854 static int sdw_update_slave_status(struct sdw_slave *slave,
1859 mutex_lock(&slave->sdw_dev_lock);
1861 if (slave->probed) {
1862 struct device *dev = &slave->dev;
1866 ret = drv->ops->update_status(slave, status);
1869 mutex_unlock(&slave->sdw_dev_lock);
1875 * sdw_handle_slave_status() - Handle Slave status
1877 * @status: Status for all Slave(s)
1883 struct sdw_slave *slave;
1896 slave = sdw_get_slave(bus, i);
1897 if (!slave)
1901 slave->status != SDW_SLAVE_UNATTACHED) {
1902 dev_dbg(&slave->dev, "Slave %d state check1: UNATTACHED, status was %d\n",
1903 i, slave->status);
1904 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1907 ret = sdw_update_slave_status(slave, status[i]);
1909 dev_warn(&slave->dev, "Update Slave status failed:%d\n", ret);
1914 dev_dbg(bus->dev, "Slave attached, programming device number\n");
1934 /* Continue to check other slave statuses */
1943 slave = sdw_get_slave(bus, i);
1944 if (!slave)
1951 if (slave->status == SDW_SLAVE_UNATTACHED)
1954 dev_dbg(&slave->dev, "Slave %d state check2: UNATTACHED, status was %d\n",
1955 i, slave->status);
1957 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1961 ret = sdw_handle_slave_alerts(slave);
1963 dev_err(&slave->dev,
1964 "Slave %d alert handling failed: %d\n",
1969 if (slave->status == SDW_SLAVE_ATTACHED)
1972 prev_status = slave->status;
1973 sdw_modify_slave_status(slave, SDW_SLAVE_ATTACHED);
1980 ret = sdw_initialize_slave(slave);
1982 dev_err(&slave->dev,
1983 "Slave %d initialization failed: %d\n",
1989 dev_err(&slave->dev, "Invalid slave %d status:%d\n",
1994 ret = sdw_update_slave_status(slave, status[i]);
1996 dev_err(&slave->dev,
1997 "Update Slave status failed:%d\n", ret);
1999 dev_dbg(&slave->dev,
2000 "signaling initialization completion for Slave %d\n",
2001 slave->dev_num);
2003 complete_all(&slave->initialization_complete);
2015 pm_request_resume(&slave->dev);
2025 struct sdw_slave *slave;
2037 slave = sdw_get_slave(bus, i);
2038 if (!slave)
2041 if (slave->status != SDW_SLAVE_UNATTACHED) {
2042 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
2043 slave->first_interrupt_done = false;
2044 sdw_update_slave_status(slave, SDW_SLAVE_UNATTACHED);
2048 slave->unattach_request = request;
2053 int sdw_bpt_send_async(struct sdw_bus *bus, struct sdw_slave *slave, struct sdw_bpt_msg *msg)
2067 if (slave->dev_num == SDW_ENUM_DEV_NUM ||
2068 slave->dev_num > SDW_MAX_DEVICES) {
2069 dev_err(&slave->dev, "Invalid device number %d\n", slave->dev_num);
2080 return bus->ops->bpt_send_async(bus, slave, msg);
2084 int sdw_bpt_wait(struct sdw_bus *bus, struct sdw_slave *slave, struct sdw_bpt_msg *msg)
2086 return bus->ops->bpt_wait(bus, slave, msg);
2090 int sdw_bpt_send_sync(struct sdw_bus *bus, struct sdw_slave *slave, struct sdw_bpt_msg *msg)
2094 ret = sdw_bpt_send_async(bus, slave, msg);
2098 return sdw_bpt_wait(bus, slave, msg);