Lines Matching refs:slave
168 struct sdw_slave *slave = dev_to_sdw_dev(dev);
169 struct sdw_bus *bus = slave->bus;
173 sdw_slave_debugfs_exit(slave);
177 if (slave->dev_num) { /* clear dev_num if assigned */
178 clear_bit(slave->dev_num, bus->assigned);
180 bus->ops->put_device_num(bus, slave);
182 list_del_init(&slave->node);
358 int sdw_fill_msg(struct sdw_msg *msg, struct sdw_slave *slave,
377 if (slave && !slave->prop.paging_support)
388 if (!slave) {
389 pr_err("SDW: No slave for paging addr\n");
393 if (!slave->prop.paging_support) {
394 dev_err(&slave->dev,
411 static int sdw_ntransfer_no_pm(struct sdw_slave *slave, u32 addr, u8 flags,
422 ret = sdw_fill_msg(&msg, slave, addr, size, slave->dev_num, flags, val);
426 ret = sdw_transfer(slave->bus, &msg);
427 if (ret < 0 && !slave->is_mockup_device)
440 * @slave: SDW Slave
448 int sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
450 return sdw_ntransfer_no_pm(slave, addr, SDW_MSG_FLAG_READ, count, val);
456 * @slave: SDW Slave
464 int sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
466 return sdw_ntransfer_no_pm(slave, addr, SDW_MSG_FLAG_WRITE, count, (u8 *)val);
472 * @slave: SDW Slave
476 int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value)
478 return sdw_nwrite_no_pm(slave, addr, 1, &value);
550 * @slave: SDW Slave
553 int sdw_read_no_pm(struct sdw_slave *slave, u32 addr)
558 ret = sdw_nread_no_pm(slave, addr, 1, &buf);
566 int sdw_update_no_pm(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
570 tmp = sdw_read_no_pm(slave, addr);
575 return sdw_write_no_pm(slave, addr, tmp);
580 int sdw_update(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
584 tmp = sdw_read(slave, addr);
589 return sdw_write(slave, addr, tmp);
595 * @slave: SDW Slave
600 * This version of the function will take a PM reference to the slave
605 int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
609 ret = pm_runtime_get_sync(&slave->dev);
611 pm_runtime_put_noidle(&slave->dev);
615 ret = sdw_nread_no_pm(slave, addr, count, val);
617 pm_runtime_mark_last_busy(&slave->dev);
618 pm_runtime_put(&slave->dev);
626 * @slave: SDW Slave
631 * This version of the function will take a PM reference to the slave
636 int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, const u8 *val)
640 ret = pm_runtime_get_sync(&slave->dev);
642 pm_runtime_put_noidle(&slave->dev);
646 ret = sdw_nwrite_no_pm(slave, addr, count, val);
648 pm_runtime_mark_last_busy(&slave->dev);
649 pm_runtime_put(&slave->dev);
657 * @slave: SDW Slave
660 * This version of the function will take a PM reference to the slave
663 int sdw_read(struct sdw_slave *slave, u32 addr)
668 ret = sdw_nread(slave, addr, 1, &buf);
678 * @slave: SDW Slave
682 * This version of the function will take a PM reference to the slave
685 int sdw_write(struct sdw_slave *slave, u32 addr, u8 value)
687 return sdw_nwrite(slave, addr, 1, &value);
698 struct sdw_slave *slave;
700 list_for_each_entry(slave, &bus->slaves, node) {
701 if (slave->dev_num == i)
702 return slave;
708 int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id)
710 if (slave->id.mfg_id != id.mfg_id ||
711 slave->id.part_id != id.part_id ||
712 slave->id.class_id != id.class_id ||
713 (slave->id.unique_id != SDW_IGNORED_UNIQUE_ID &&
714 slave->id.unique_id != id.unique_id))
722 static int sdw_get_device_num(struct sdw_slave *slave)
724 struct sdw_bus *bus = slave->bus;
728 bit = bus->ops->get_device_num(bus, slave);
749 static int sdw_assign_device_num(struct sdw_slave *slave)
751 struct sdw_bus *bus = slave->bus;
756 if (!slave->dev_num) {
757 if (!slave->dev_num_sticky) {
758 mutex_lock(&slave->bus->bus_lock);
759 dev_num = sdw_get_device_num(slave);
760 mutex_unlock(&slave->bus->bus_lock);
766 slave->dev_num = dev_num;
767 slave->dev_num_sticky = dev_num;
770 slave->dev_num = slave->dev_num_sticky;
777 slave->dev_num);
779 /* Clear the slave->dev_num to transfer message on device 0 */
780 dev_num = slave->dev_num;
781 slave->dev_num = 0;
783 ret = sdw_write_no_pm(slave, SDW_SCP_DEVNUMBER, dev_num);
791 slave->dev_num = slave->dev_num_sticky;
794 bus->ops->new_peripheral_assigned(bus, slave, dev_num);
819 struct sdw_slave *slave, *_s;
858 list_for_each_entry_safe(slave, _s, &bus->slaves, node) {
859 if (sdw_compare_devid(slave, id) == 0) {
869 if (slave->status != SDW_SLAVE_UNATTACHED)
878 ret = sdw_assign_device_num(slave);
919 static void sdw_modify_slave_status(struct sdw_slave *slave,
922 struct sdw_bus *bus = slave->bus;
927 "changing status slave %d status %d new status %d\n",
928 slave->dev_num, slave->status, status);
931 dev_dbg(&slave->dev,
933 slave->dev_num);
935 reinit_completion(&slave->enumeration_complete);
936 reinit_completion(&slave->initialization_complete);
939 (slave->status == SDW_SLAVE_UNATTACHED)) {
940 dev_dbg(&slave->dev,
942 slave->dev_num);
944 complete_all(&slave->enumeration_complete);
946 slave->status = status;
950 static int sdw_slave_clk_stop_callback(struct sdw_slave *slave,
956 mutex_lock(&slave->sdw_dev_lock);
958 if (slave->probed) {
959 struct device *dev = &slave->dev;
963 ret = drv->ops->clk_stop(slave, mode, type);
966 mutex_unlock(&slave->sdw_dev_lock);
971 static int sdw_slave_clk_stop_prepare(struct sdw_slave *slave,
979 wake_en = slave->prop.wake_capable;
990 ret = sdw_read_no_pm(slave, SDW_SCP_SYSTEMCTRL);
993 dev_err(&slave->dev, "SDW_SCP_SYSTEMCTRL read failed:%d\n", ret);
1000 ret = sdw_write_no_pm(slave, SDW_SCP_SYSTEMCTRL, val);
1003 dev_err(&slave->dev, "SDW_SCP_SYSTEMCTRL write failed:%d\n", ret);
1022 dev_dbg(bus->dev, "clock stop %s done slave:%d\n",
1032 dev_dbg(bus->dev, "clock stop %s did not complete for slave:%d\n",
1049 struct sdw_slave *slave;
1061 list_for_each_entry(slave, &bus->slaves, node) {
1062 if (!slave->dev_num)
1065 if (slave->status != SDW_SLAVE_ATTACHED &&
1066 slave->status != SDW_SLAVE_ALERT)
1072 ret = sdw_slave_clk_stop_callback(slave,
1076 dev_err(&slave->dev, "clock stop pre-prepare cb failed:%d\n", ret);
1081 if (!slave->prop.simple_clk_stop_capable) {
1084 ret = sdw_slave_clk_stop_prepare(slave,
1088 dev_err(&slave->dev, "clock stop prepare failed:%d\n", ret);
1116 list_for_each_entry(slave, &bus->slaves, node) {
1117 if (!slave->dev_num)
1120 if (slave->status != SDW_SLAVE_ATTACHED &&
1121 slave->status != SDW_SLAVE_ALERT)
1124 ret = sdw_slave_clk_stop_callback(slave,
1129 dev_err(&slave->dev, "clock stop post-prepare cb failed:%d\n", ret);
1178 struct sdw_slave *slave;
1187 list_for_each_entry(slave, &bus->slaves, node) {
1188 if (!slave->dev_num)
1191 if (slave->status != SDW_SLAVE_ATTACHED &&
1192 slave->status != SDW_SLAVE_ALERT)
1198 ret = sdw_slave_clk_stop_callback(slave, SDW_CLK_STOP_MODE0,
1201 dev_warn(&slave->dev, "clock stop pre-deprepare cb failed:%d\n", ret);
1204 if (!slave->prop.simple_clk_stop_capable) {
1207 ret = sdw_slave_clk_stop_prepare(slave, SDW_CLK_STOP_MODE0,
1211 dev_warn(&slave->dev, "clock stop deprepare failed:%d\n", ret);
1229 list_for_each_entry(slave, &bus->slaves, node) {
1230 if (!slave->dev_num)
1233 if (slave->status != SDW_SLAVE_ATTACHED &&
1234 slave->status != SDW_SLAVE_ALERT)
1237 ret = sdw_slave_clk_stop_callback(slave, SDW_CLK_STOP_MODE0,
1240 dev_warn(&slave->dev, "clock stop post-deprepare cb failed:%d\n", ret);
1247 int sdw_configure_dpn_intr(struct sdw_slave *slave,
1254 if (slave->bus->params.s_data_mode != SDW_PORT_DATA_MODE_NORMAL) {
1255 dev_dbg(&slave->dev, "TEST FAIL interrupt %s\n",
1271 ret = sdw_update_no_pm(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val);
1273 dev_err(&slave->dev,
1279 static int sdw_slave_set_frequency(struct sdw_slave *slave)
1281 u32 mclk_freq = slave->bus->prop.mclk_freq;
1282 u32 curr_freq = slave->bus->params.curr_dr_freq >> 1;
1294 if (!slave->id.class_id && !slave->prop.clock_reg_supported)
1298 dev_err(&slave->dev,
1328 dev_err(&slave->dev,
1335 dev_err(&slave->dev,
1350 dev_err(&slave->dev,
1357 ret = sdw_write_no_pm(slave, SDW_SCP_BUS_CLOCK_BASE, base);
1359 dev_err(&slave->dev,
1365 ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B0, scale_index);
1367 dev_err(&slave->dev,
1371 ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B1, scale_index);
1373 dev_err(&slave->dev,
1376 dev_dbg(&slave->dev,
1383 static int sdw_initialize_slave(struct sdw_slave *slave)
1385 struct sdw_slave_prop *prop = &slave->prop;
1390 ret = sdw_slave_set_frequency(slave);
1394 if (slave->bus->prop.quirks & SDW_MASTER_QUIRKS_CLEAR_INITIAL_CLASH) {
1396 status = sdw_read_no_pm(slave, SDW_SCP_INT1);
1398 dev_err(&slave->dev,
1403 dev_warn(&slave->dev, "Bus clash detected before INT mask is enabled\n");
1404 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, SDW_SCP_INT1_BUS_CLASH);
1406 dev_err(&slave->dev,
1412 if ((slave->bus->prop.quirks & SDW_MASTER_QUIRKS_CLEAR_INITIAL_PARITY) &&
1413 !(slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY)) {
1415 status = sdw_read_no_pm(slave, SDW_SCP_INT1);
1417 dev_err(&slave->dev,
1422 dev_warn(&slave->dev, "PARITY error detected before INT mask is enabled\n");
1423 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, SDW_SCP_INT1_PARITY);
1425 dev_err(&slave->dev,
1439 val = slave->prop.scp_int1_mask;
1442 ret = sdw_update_no_pm(slave, SDW_SCP_INTMASK1, val, val);
1444 dev_err(&slave->dev,
1450 if (!slave->prop.dp0_prop)
1457 ret = sdw_update_no_pm(slave, SDW_DP0_INTMASK, val, val);
1459 dev_err(&slave->dev,
1464 static int sdw_handle_dp0_interrupt(struct sdw_slave *slave, u8 *slave_status)
1469 status = sdw_read_no_pm(slave, SDW_DP0_INT);
1471 dev_err(&slave->dev,
1480 dev_err(&slave->dev, "Test fail for port 0\n");
1490 complete(&slave->port_ready[0]);
1495 dev_err(&slave->dev, "BRA failed\n");
1508 ret = sdw_write_no_pm(slave, SDW_DP0_INT, clear);
1510 dev_err(&slave->dev,
1516 status2 = sdw_read_no_pm(slave, SDW_DP0_INT);
1518 dev_err(&slave->dev,
1531 dev_warn(&slave->dev, "Reached MAX_RETRY on DP0 read\n");
1536 static int sdw_handle_port_interrupt(struct sdw_slave *slave,
1544 return sdw_handle_dp0_interrupt(slave, slave_status);
1547 status = sdw_read_no_pm(slave, addr);
1549 dev_err(&slave->dev,
1559 dev_err(&slave->dev, "Test fail for port:%d\n", port);
1568 complete(&slave->port_ready[port]);
1581 ret = sdw_write_no_pm(slave, addr, clear);
1583 dev_err(&slave->dev,
1589 status2 = sdw_read_no_pm(slave, addr);
1591 dev_err(&slave->dev,
1604 dev_warn(&slave->dev, "Reached MAX_RETRY on port read");
1609 static int sdw_handle_slave_alerts(struct sdw_slave *slave)
1621 sdw_modify_slave_status(slave, SDW_SLAVE_ALERT);
1623 ret = pm_runtime_get_sync(&slave->dev);
1625 dev_err(&slave->dev, "Failed to resume device: %d\n", ret);
1626 pm_runtime_put_noidle(&slave->dev);
1631 ret = sdw_read_no_pm(slave, SDW_SCP_INT1);
1633 dev_err(&slave->dev,
1639 ret = sdw_nread_no_pm(slave, SDW_SCP_INTSTAT2, 2, buf2);
1641 dev_err(&slave->dev,
1646 if (slave->id.class_id) {
1647 ret = sdw_read_no_pm(slave, SDW_DP0_INT);
1649 dev_err(&slave->dev,
1664 parity_check = slave->prop.scp_int1_mask & SDW_SCP_INT1_PARITY;
1665 parity_quirk = !slave->first_interrupt_done &&
1666 (slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY);
1669 dev_err(&slave->dev, "Parity error detected\n");
1674 if (slave->prop.scp_int1_mask & SDW_SCP_INT1_BUS_CLASH)
1675 dev_err(&slave->dev, "Bus clash detected\n");
1687 if (slave->prop.scp_int1_mask & SDW_SCP_INT1_IMPL_DEF) {
1688 dev_dbg(&slave->dev, "Slave impl defined interrupt\n");
1704 sdw_handle_port_interrupt(slave, bit,
1714 sdw_handle_port_interrupt(slave,
1726 sdw_handle_port_interrupt(slave,
1734 mutex_lock(&slave->sdw_dev_lock);
1736 if (slave->probed) {
1737 struct device *dev = &slave->dev;
1740 if (slave->prop.use_domain_irq && slave->irq)
1741 handle_nested_irq(slave->irq);
1749 drv->ops->interrupt_callback(slave, &slave_intr);
1753 mutex_unlock(&slave->sdw_dev_lock);
1757 ret = sdw_write_no_pm(slave, SDW_SCP_INT1, clear);
1759 dev_err(&slave->dev,
1765 slave->first_interrupt_done = true;
1771 ret = sdw_read_no_pm(slave, SDW_SCP_INT1);
1773 dev_err(&slave->dev,
1779 ret = sdw_nread_no_pm(slave, SDW_SCP_INTSTAT2, 2, buf2);
1781 dev_err(&slave->dev,
1786 if (slave->id.class_id) {
1787 ret = sdw_read_no_pm(slave, SDW_DP0_INT);
1789 dev_err(&slave->dev,
1811 dev_warn(&slave->dev, "Reached MAX_RETRY on alert read\n");
1814 pm_runtime_mark_last_busy(&slave->dev);
1815 pm_runtime_put_autosuspend(&slave->dev);
1820 static int sdw_update_slave_status(struct sdw_slave *slave,
1825 mutex_lock(&slave->sdw_dev_lock);
1827 if (slave->probed) {
1828 struct device *dev = &slave->dev;
1832 ret = drv->ops->update_status(slave, status);
1835 mutex_unlock(&slave->sdw_dev_lock);
1849 struct sdw_slave *slave;
1862 slave = sdw_get_slave(bus, i);
1863 if (!slave)
1867 slave->status != SDW_SLAVE_UNATTACHED) {
1868 dev_warn(&slave->dev, "Slave %d state check1: UNATTACHED, status was %d\n",
1869 i, slave->status);
1870 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1873 ret = sdw_update_slave_status(slave, status[i]);
1875 dev_warn(&slave->dev, "Update Slave status failed:%d\n", ret);
1900 /* Continue to check other slave statuses */
1909 slave = sdw_get_slave(bus, i);
1910 if (!slave)
1917 if (slave->status == SDW_SLAVE_UNATTACHED)
1920 dev_warn(&slave->dev, "Slave %d state check2: UNATTACHED, status was %d\n",
1921 i, slave->status);
1923 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1927 ret = sdw_handle_slave_alerts(slave);
1929 dev_err(&slave->dev,
1935 if (slave->status == SDW_SLAVE_ATTACHED)
1938 prev_status = slave->status;
1939 sdw_modify_slave_status(slave, SDW_SLAVE_ATTACHED);
1946 ret = sdw_initialize_slave(slave);
1948 dev_err(&slave->dev,
1955 dev_err(&slave->dev, "Invalid slave %d status:%d\n",
1960 ret = sdw_update_slave_status(slave, status[i]);
1962 dev_err(&slave->dev,
1965 dev_dbg(&slave->dev,
1967 slave->dev_num);
1969 complete_all(&slave->initialization_complete);
1981 pm_request_resume(&slave->dev);
1991 struct sdw_slave *slave;
2003 slave = sdw_get_slave(bus, i);
2004 if (!slave)
2007 if (slave->status != SDW_SLAVE_UNATTACHED) {
2008 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
2009 slave->first_interrupt_done = false;
2010 sdw_update_slave_status(slave, SDW_SLAVE_UNATTACHED);
2014 slave->unattach_request = request;