Lines Matching refs:slave
150 struct sdw_slave *slave = dev_to_sdw_dev(dev);
151 struct sdw_bus *bus = slave->bus;
155 sdw_slave_debugfs_exit(slave);
159 if (slave->dev_num) /* clear dev_num if assigned */
160 clear_bit(slave->dev_num, bus->assigned);
162 list_del_init(&slave->node);
324 int sdw_fill_msg(struct sdw_msg *msg, struct sdw_slave *slave,
343 if (slave && !slave->prop.paging_support)
354 if (!slave) {
355 pr_err("SDW: No slave for paging addr\n");
359 if (!slave->prop.paging_support) {
360 dev_err(&slave->dev,
381 sdw_nread_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
386 ret = sdw_fill_msg(&msg, slave, addr, count,
387 slave->dev_num, SDW_MSG_FLAG_READ, val);
391 return sdw_transfer(slave->bus, &msg);
395 sdw_nwrite_no_pm(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
400 ret = sdw_fill_msg(&msg, slave, addr, count,
401 slave->dev_num, SDW_MSG_FLAG_WRITE, val);
405 return sdw_transfer(slave->bus, &msg);
408 int sdw_write_no_pm(struct sdw_slave *slave, u32 addr, u8 value)
410 return sdw_nwrite_no_pm(slave, addr, 1, &value);
480 int sdw_read_no_pm(struct sdw_slave *slave, u32 addr)
485 ret = sdw_nread_no_pm(slave, addr, 1, &buf);
493 static int sdw_update_no_pm(struct sdw_slave *slave, u32 addr, u8 mask, u8 val)
497 tmp = sdw_read_no_pm(slave, addr);
502 return sdw_write_no_pm(slave, addr, tmp);
507 * @slave: SDW Slave
512 int sdw_nread(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
516 ret = pm_runtime_get_sync(&slave->dev);
518 pm_runtime_put_noidle(&slave->dev);
522 ret = sdw_nread_no_pm(slave, addr, count, val);
524 pm_runtime_mark_last_busy(&slave->dev);
525 pm_runtime_put(&slave->dev);
533 * @slave: SDW Slave
538 int sdw_nwrite(struct sdw_slave *slave, u32 addr, size_t count, u8 *val)
542 ret = pm_runtime_get_sync(&slave->dev);
544 pm_runtime_put_noidle(&slave->dev);
548 ret = sdw_nwrite_no_pm(slave, addr, count, val);
550 pm_runtime_mark_last_busy(&slave->dev);
551 pm_runtime_put(&slave->dev);
559 * @slave: SDW Slave
562 int sdw_read(struct sdw_slave *slave, u32 addr)
567 ret = sdw_nread(slave, addr, 1, &buf);
577 * @slave: SDW Slave
581 int sdw_write(struct sdw_slave *slave, u32 addr, u8 value)
583 return sdw_nwrite(slave, addr, 1, &value);
594 struct sdw_slave *slave = NULL;
596 list_for_each_entry(slave, &bus->slaves, node) {
597 if (slave->dev_num == i)
598 return slave;
604 static int sdw_compare_devid(struct sdw_slave *slave, struct sdw_slave_id id)
606 if (slave->id.mfg_id != id.mfg_id ||
607 slave->id.part_id != id.part_id ||
608 slave->id.class_id != id.class_id ||
609 (slave->id.unique_id != SDW_IGNORED_UNIQUE_ID &&
610 slave->id.unique_id != id.unique_id))
617 static int sdw_get_device_num(struct sdw_slave *slave)
621 bit = find_first_zero_bit(slave->bus->assigned, SDW_MAX_DEVICES);
631 set_bit(bit, slave->bus->assigned);
637 static int sdw_assign_device_num(struct sdw_slave *slave)
643 if (!slave->dev_num) {
644 if (!slave->dev_num_sticky) {
645 mutex_lock(&slave->bus->bus_lock);
646 dev_num = sdw_get_device_num(slave);
647 mutex_unlock(&slave->bus->bus_lock);
649 dev_err(slave->bus->dev, "Get dev_num failed: %d\n",
653 slave->dev_num = dev_num;
654 slave->dev_num_sticky = dev_num;
657 slave->dev_num = slave->dev_num_sticky;
662 dev_dbg(slave->bus->dev,
664 slave->dev_num);
666 /* Clear the slave->dev_num to transfer message on device 0 */
667 dev_num = slave->dev_num;
668 slave->dev_num = 0;
670 ret = sdw_write_no_pm(slave, SDW_SCP_DEVNUMBER, dev_num);
672 dev_err(&slave->dev, "Program device_num %d failed: %d\n",
678 slave->dev_num = slave->dev_num_sticky;
703 struct sdw_slave *slave, *_s;
740 list_for_each_entry_safe(slave, _s, &bus->slaves, node) {
741 if (sdw_compare_devid(slave, id) == 0) {
750 ret = sdw_assign_device_num(slave);
752 dev_err(slave->bus->dev,
789 static void sdw_modify_slave_status(struct sdw_slave *slave,
792 mutex_lock(&slave->bus->bus_lock);
794 dev_vdbg(&slave->dev,
795 "%s: changing status slave %d status %d new status %d\n",
796 __func__, slave->dev_num, slave->status, status);
799 dev_dbg(&slave->dev,
801 __func__, slave->dev_num);
803 reinit_completion(&slave->enumeration_complete);
804 reinit_completion(&slave->initialization_complete);
807 (slave->status == SDW_SLAVE_UNATTACHED)) {
808 dev_dbg(&slave->dev,
810 __func__, slave->dev_num);
812 complete_all(&slave->enumeration_complete);
814 slave->status = status;
815 mutex_unlock(&slave->bus->bus_lock);
818 static enum sdw_clk_stop_mode sdw_get_clk_stop_mode(struct sdw_slave *slave)
826 if (slave->ops && slave->ops->get_clk_stop_mode) {
827 mode = slave->ops->get_clk_stop_mode(slave);
829 if (slave->prop.clk_stop_mode1)
838 static int sdw_slave_clk_stop_callback(struct sdw_slave *slave,
844 if (slave->ops && slave->ops->clk_stop) {
845 ret = slave->ops->clk_stop(slave, mode, type);
847 dev_err(&slave->dev,
856 static int sdw_slave_clk_stop_prepare(struct sdw_slave *slave,
864 wake_en = slave->prop.wake_capable;
875 val = sdw_read_no_pm(slave, SDW_SCP_SYSTEMCTRL);
880 ret = sdw_write_no_pm(slave, SDW_SCP_SYSTEMCTRL, val);
883 dev_err(&slave->dev,
884 "Clock Stop prepare failed for slave: %d", ret);
898 dev_info(bus->dev, "clock stop prep/de-prep done slave:%d",
907 dev_err(bus->dev, "clock stop prep/de-prep failed slave:%d",
924 struct sdw_slave *slave;
933 list_for_each_entry(slave, &bus->slaves, node) {
934 if (!slave->dev_num)
937 if (slave->status != SDW_SLAVE_ATTACHED &&
938 slave->status != SDW_SLAVE_ALERT)
944 slave_mode = sdw_get_clk_stop_mode(slave);
945 slave->curr_clk_stop_mode = slave_mode;
947 ret = sdw_slave_clk_stop_callback(slave, slave_mode,
950 dev_err(&slave->dev,
955 ret = sdw_slave_clk_stop_prepare(slave,
958 dev_err(&slave->dev,
974 /* Don't need to inform slaves if there is no slave attached */
979 list_for_each_entry(slave, &bus->slaves, node) {
980 if (!slave->dev_num)
983 if (slave->status != SDW_SLAVE_ATTACHED &&
984 slave->status != SDW_SLAVE_ALERT)
987 slave_mode = slave->curr_clk_stop_mode;
990 ret = sdw_slave_clk_stop_callback(slave,
995 dev_err(&slave->dev,
1050 struct sdw_slave *slave;
1059 list_for_each_entry(slave, &bus->slaves, node) {
1060 if (!slave->dev_num)
1063 if (slave->status != SDW_SLAVE_ATTACHED &&
1064 slave->status != SDW_SLAVE_ALERT)
1070 mode = slave->curr_clk_stop_mode;
1077 ret = sdw_slave_clk_stop_callback(slave, mode,
1080 dev_warn(&slave->dev,
1083 ret = sdw_slave_clk_stop_prepare(slave, mode,
1087 dev_warn(&slave->dev,
1095 * Don't need to call slave callback function if there is no slave
1101 list_for_each_entry(slave, &bus->slaves, node) {
1102 if (!slave->dev_num)
1105 if (slave->status != SDW_SLAVE_ATTACHED &&
1106 slave->status != SDW_SLAVE_ALERT)
1109 mode = slave->curr_clk_stop_mode;
1110 sdw_slave_clk_stop_callback(slave, mode,
1118 int sdw_configure_dpn_intr(struct sdw_slave *slave,
1125 if (slave->bus->params.s_data_mode != SDW_PORT_DATA_MODE_NORMAL) {
1126 dev_dbg(&slave->dev, "TEST FAIL interrupt %s\n",
1142 ret = sdw_update(slave, addr, (mask | SDW_DPN_INT_PORT_READY), val);
1144 dev_err(slave->bus->dev,
1150 static int sdw_slave_set_frequency(struct sdw_slave *slave)
1152 u32 mclk_freq = slave->bus->prop.mclk_freq;
1153 u32 curr_freq = slave->bus->params.curr_dr_freq >> 1;
1164 if (!slave->id.class_id)
1168 dev_err(&slave->dev,
1198 dev_err(&slave->dev,
1205 dev_err(&slave->dev,
1220 dev_err(&slave->dev,
1227 ret = sdw_write_no_pm(slave, SDW_SCP_BUS_CLOCK_BASE, base);
1229 dev_err(&slave->dev,
1235 ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B0, scale_index);
1237 dev_err(&slave->dev,
1241 ret = sdw_write_no_pm(slave, SDW_SCP_BUSCLOCK_SCALE_B1, scale_index);
1243 dev_err(&slave->dev,
1246 dev_dbg(&slave->dev,
1253 static int sdw_initialize_slave(struct sdw_slave *slave)
1255 struct sdw_slave_prop *prop = &slave->prop;
1259 ret = sdw_slave_set_frequency(slave);
1270 val = slave->prop.scp_int1_mask;
1273 ret = sdw_update_no_pm(slave, SDW_SCP_INTMASK1, val, val);
1275 dev_err(slave->bus->dev,
1281 if (!slave->prop.dp0_prop)
1288 ret = sdw_update_no_pm(slave, SDW_DP0_INTMASK, val, val);
1290 dev_err(slave->bus->dev,
1295 static int sdw_handle_dp0_interrupt(struct sdw_slave *slave, u8 *slave_status)
1300 status = sdw_read(slave, SDW_DP0_INT);
1302 dev_err(slave->bus->dev,
1309 dev_err(&slave->dev, "Test fail for port 0\n");
1319 complete(&slave->port_ready[0]);
1324 dev_err(&slave->dev, "BRA failed\n");
1337 ret = sdw_write(slave, SDW_DP0_INT, clear);
1339 dev_err(slave->bus->dev,
1345 status2 = sdw_read(slave, SDW_DP0_INT);
1347 dev_err(slave->bus->dev,
1359 dev_warn(slave->bus->dev, "Reached MAX_RETRY on DP0 read\n");
1364 static int sdw_handle_port_interrupt(struct sdw_slave *slave,
1372 return sdw_handle_dp0_interrupt(slave, slave_status);
1375 status = sdw_read(slave, addr);
1377 dev_err(slave->bus->dev,
1385 dev_err(&slave->dev, "Test fail for port:%d\n", port);
1394 complete(&slave->port_ready[port]);
1407 ret = sdw_write(slave, addr, clear);
1409 dev_err(slave->bus->dev,
1415 status2 = sdw_read(slave, addr);
1417 dev_err(slave->bus->dev,
1429 dev_warn(slave->bus->dev, "Reached MAX_RETRY on port read");
1434 static int sdw_handle_slave_alerts(struct sdw_slave *slave)
1445 sdw_modify_slave_status(slave, SDW_SLAVE_ALERT);
1447 ret = pm_runtime_get_sync(&slave->dev);
1449 dev_err(&slave->dev, "Failed to resume device: %d\n", ret);
1450 pm_runtime_put_noidle(&slave->dev);
1455 ret = sdw_read(slave, SDW_SCP_INT1);
1457 dev_err(slave->bus->dev,
1463 ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, buf2);
1465 dev_err(slave->bus->dev,
1476 parity_check = slave->prop.scp_int1_mask & SDW_SCP_INT1_PARITY;
1477 parity_quirk = !slave->first_interrupt_done &&
1478 (slave->prop.quirks & SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY);
1481 dev_err(&slave->dev, "Parity error detected\n");
1486 if (slave->prop.scp_int1_mask & SDW_SCP_INT1_BUS_CLASH)
1487 dev_err(&slave->dev, "Bus clash detected\n");
1499 if (slave->prop.scp_int1_mask & SDW_SCP_INT1_IMPL_DEF) {
1500 dev_dbg(&slave->dev, "Slave impl defined interrupt\n");
1512 sdw_handle_port_interrupt(slave, bit,
1522 sdw_handle_port_interrupt(slave,
1534 sdw_handle_port_interrupt(slave,
1541 if (slave_notify && slave->ops &&
1542 slave->ops->interrupt_callback) {
1547 slave->ops->interrupt_callback(slave, &slave_intr);
1551 ret = sdw_write(slave, SDW_SCP_INT1, clear);
1553 dev_err(slave->bus->dev,
1559 slave->first_interrupt_done = true;
1565 ret = sdw_read(slave, SDW_SCP_INT1);
1567 dev_err(slave->bus->dev,
1573 ret = sdw_nread(slave, SDW_SCP_INTSTAT2, 2, _buf2);
1575 dev_err(slave->bus->dev,
1596 dev_warn(slave->bus->dev, "Reached MAX_RETRY on alert read\n");
1599 pm_runtime_mark_last_busy(&slave->dev);
1600 pm_runtime_put_autosuspend(&slave->dev);
1605 static int sdw_update_slave_status(struct sdw_slave *slave,
1610 if (!slave->probed) {
1612 * the slave status update is typically handled in an
1619 time = wait_for_completion_timeout(&slave->probe_complete,
1622 dev_err(&slave->dev, "Probe not complete, timed out\n");
1627 if (!slave->ops || !slave->ops->update_status)
1630 return slave->ops->update_status(slave, status);
1642 struct sdw_slave *slave;
1655 slave = sdw_get_slave(bus, i);
1656 if (!slave)
1660 slave->status != SDW_SLAVE_UNATTACHED)
1661 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1676 /* Continue to check other slave statuses */
1685 slave = sdw_get_slave(bus, i);
1686 if (!slave)
1693 if (slave->status == SDW_SLAVE_UNATTACHED)
1696 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1700 ret = sdw_handle_slave_alerts(slave);
1708 if (slave->status == SDW_SLAVE_ATTACHED)
1711 prev_status = slave->status;
1712 sdw_modify_slave_status(slave, SDW_SLAVE_ATTACHED);
1719 ret = sdw_initialize_slave(slave);
1728 dev_err(bus->dev, "Invalid slave %d status:%d\n",
1733 ret = sdw_update_slave_status(slave, status[i]);
1735 dev_err(slave->bus->dev,
1738 dev_dbg(&slave->dev,
1740 __func__, slave->dev_num);
1742 complete_all(&slave->initialization_complete);
1754 pm_request_resume(&slave->dev);
1764 struct sdw_slave *slave;
1776 slave = sdw_get_slave(bus, i);
1777 if (!slave)
1780 if (slave->status != SDW_SLAVE_UNATTACHED) {
1781 sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);
1782 slave->first_interrupt_done = false;
1786 slave->unattach_request = request;