Lines Matching defs:master
72 * In other words, transfer requests passed to the I3C master can be submitted
73 * in parallel and I3C master drivers have to use their own locking to make
110 struct i3c_master_controller *master;
115 master = dev_to_i3cmaster(dev);
117 return &master->bus;
122 struct i3c_master_controller *master;
127 master = dev_to_i3cmaster(dev);
129 return master->this;
545 struct i3c_master_controller *master = dev_to_i3cmaster(dev);
548 if (master->wq)
549 destroy_workqueue(master->wq);
564 struct i3c_master_controller *master = i3c_bus_to_i3c_master(i3cbus);
591 dev_dbg(&master->dev, "i2c-scl = %ld Hz i3c-scl = %ld Hz\n",
612 i3c_master_to_i2c_adapter(struct i3c_master_controller *master)
614 return &master->i2c;
623 i3c_master_alloc_i2c_dev(struct i3c_master_controller *master,
632 dev->common.master = master;
668 static int i3c_master_send_ccc_cmd_locked(struct i3c_master_controller *master,
673 if (!cmd || !master)
676 if (WARN_ON(master->init_done &&
677 !rwsem_is_locked(&master->bus.lock)))
680 if (!master->ops->send_ccc_cmd)
686 if (master->ops->supports_ccc_cmd &&
687 !master->ops->supports_ccc_cmd(master, cmd))
690 ret = master->ops->send_ccc_cmd(master, cmd);
702 i3c_master_find_i2c_dev_by_addr(const struct i3c_master_controller *master,
707 i3c_bus_for_each_i2cdev(&master->bus, dev) {
717 * @master: I3C master object
725 int i3c_master_get_free_addr(struct i3c_master_controller *master,
728 return i3c_bus_get_free_addr(&master->bus, start_addr);
748 i3c_master_alloc_i3c_dev(struct i3c_master_controller *master,
757 dev->common.master = master;
764 static int i3c_master_rstdaa_locked(struct i3c_master_controller *master,
772 if (!master)
775 addrstat = i3c_bus_get_addr_slot_status(&master->bus, addr);
783 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
792 * @master: master used to send frames on the bus
797 * behind dynamic address assignment has to be handled in the I3C master
805 int i3c_master_entdaa_locked(struct i3c_master_controller *master)
813 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
820 static int i3c_master_enec_disec_locked(struct i3c_master_controller *master,
838 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
846 * @master: master used to send frames on the bus
858 int i3c_master_disec_locked(struct i3c_master_controller *master, u8 addr,
861 return i3c_master_enec_disec_locked(master, addr, false, evts);
867 * @master: master used to send frames on the bus
879 int i3c_master_enec_locked(struct i3c_master_controller *master, u8 addr,
882 return i3c_master_enec_disec_locked(master, addr, true, evts);
888 * @master: master used to send frames on the bus
890 * Send a DEFSLVS CCC command containing all the devices known to the @master.
897 * It should also be called if a master ACKed an Hot-Join request and assigned
905 int i3c_master_defslvs_locked(struct i3c_master_controller *master)
917 if (!master)
920 bus = i3c_master_get_bus(master);
924 if (i3cdev == master->this)
932 /* No other master on the bus, skip DEFSLVS. */
946 defslvs->master.bcr = master->this->info.bcr;
947 defslvs->master.dcr = master->this->info.dcr;
948 defslvs->master.dyn_addr = master->this->info.dyn_addr << 1;
949 defslvs->master.static_addr = I3C_BROADCAST_ADDR << 1;
959 /* Skip the I3C dev representing this master. */
960 if (i3cdev == master->this)
971 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
978 static int i3c_master_setda_locked(struct i3c_master_controller *master,
997 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1003 static int i3c_master_setdasa_locked(struct i3c_master_controller *master,
1006 return i3c_master_setda_locked(master, static_addr, dyn_addr, true);
1009 static int i3c_master_setnewda_locked(struct i3c_master_controller *master,
1012 return i3c_master_setda_locked(master, oldaddr, newaddr, false);
1015 static int i3c_master_getmrl_locked(struct i3c_master_controller *master,
1035 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1057 static int i3c_master_getmwl_locked(struct i3c_master_controller *master,
1070 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1087 static int i3c_master_getmxds_locked(struct i3c_master_controller *master,
1101 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1123 static int i3c_master_gethdrcap_locked(struct i3c_master_controller *master,
1137 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1154 static int i3c_master_getpid_locked(struct i3c_master_controller *master,
1167 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1184 static int i3c_master_getbcr_locked(struct i3c_master_controller *master,
1197 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1209 static int i3c_master_getdcr_locked(struct i3c_master_controller *master,
1222 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1236 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1243 slot_status = i3c_bus_get_addr_slot_status(&master->bus,
1249 ret = i3c_master_getpid_locked(master, &dev->info);
1253 ret = i3c_master_getbcr_locked(master, &dev->info);
1257 ret = i3c_master_getdcr_locked(master, &dev->info);
1262 ret = i3c_master_getmxds_locked(master, &dev->info);
1270 i3c_master_getmrl_locked(master, &dev->info);
1271 i3c_master_getmwl_locked(master, &dev->info);
1274 ret = i3c_master_gethdrcap_locked(master, &dev->info);
1284 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1287 i3c_bus_set_addr_slot_status(&master->bus,
1292 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1296 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1302 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1309 status = i3c_bus_get_addr_slot_status(&master->bus,
1318 i3c_bus_set_addr_slot_status(&master->bus,
1331 status = i3c_bus_get_addr_slot_status(&master->bus,
1336 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1344 i3c_bus_set_addr_slot_status(&master->bus,
1351 static int i3c_master_attach_i3c_dev(struct i3c_master_controller *master,
1367 /* Do not attach the master device itself. */
1368 if (master->this != dev && master->ops->attach_i3c_dev) {
1369 ret = master->ops->attach_i3c_dev(dev);
1376 list_add_tail(&dev->common.node, &master->bus.devs.i3c);
1384 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1391 status = i3c_bus_get_addr_slot_status(&master->bus,
1395 i3c_bus_set_addr_slot_status(&master->bus,
1399 i3c_bus_set_addr_slot_status(&master->bus, old_dyn_addr,
1403 if (master->ops->reattach_i3c_dev) {
1404 ret = master->ops->reattach_i3c_dev(dev, old_dyn_addr);
1416 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1418 /* Do not detach the master device itself. */
1419 if (master->this != dev && master->ops->detach_i3c_dev)
1420 master->ops->detach_i3c_dev(dev);
1426 static int i3c_master_attach_i2c_dev(struct i3c_master_controller *master,
1431 if (master->ops->attach_i2c_dev) {
1432 ret = master->ops->attach_i2c_dev(dev);
1437 list_add_tail(&dev->common.node, &master->bus.devs.i2c);
1444 struct i3c_master_controller *master = i2c_dev_get_master(dev);
1448 if (master->ops->detach_i2c_dev)
1449 master->ops->detach_i2c_dev(dev);
1452 static int i3c_master_early_i3c_dev_add(struct i3c_master_controller *master,
1462 i3cdev = i3c_master_alloc_i3c_dev(master, &info);
1468 ret = i3c_master_attach_i3c_dev(master, i3cdev);
1472 ret = i3c_master_setdasa_locked(master, i3cdev->info.static_addr,
1489 i3c_master_rstdaa_locked(master, i3cdev->boardinfo->init_dyn_addr);
1499 i3c_master_register_new_i3c_devs(struct i3c_master_controller *master)
1504 if (!master->init_done)
1507 i3c_bus_for_each_i3cdev(&master->bus, desc) {
1508 if (desc->dev || !desc->info.dyn_addr || desc == master->this)
1515 desc->dev->bus = &master->bus;
1517 desc->dev->dev.parent = &master->dev;
1521 dev_set_name(&desc->dev->dev, "%d-%llx", master->bus.id,
1529 dev_err(&master->dev,
1538 * @master: master doing the DAA
1544 * The I3C device object is returned in case the master wants to attach
1551 int i3c_master_do_daa(struct i3c_master_controller *master)
1555 i3c_bus_maintenance_lock(&master->bus);
1556 ret = master->ops->do_daa(master);
1557 i3c_bus_maintenance_unlock(&master->bus);
1562 i3c_bus_normaluse_lock(&master->bus);
1563 i3c_master_register_new_i3c_devs(master);
1564 i3c_bus_normaluse_unlock(&master->bus);
1571 * i3c_master_set_info() - set master device information
1572 * @master: master used to send frames on the bus
1575 * Set master device info. This should be called from
1578 * Not all &i3c_device_info fields are meaningful for a master device.
1594 int i3c_master_set_info(struct i3c_master_controller *master,
1600 if (!i3c_bus_dev_addr_is_avail(&master->bus, info->dyn_addr))
1604 master->secondary)
1607 if (master->this)
1610 i3cdev = i3c_master_alloc_i3c_dev(master, info);
1614 master->this = i3cdev;
1615 master->bus.cur_master = master->this;
1617 ret = i3c_master_attach_i3c_dev(master, i3cdev);
1630 static void i3c_master_detach_free_devs(struct i3c_master_controller *master)
1635 list_for_each_entry_safe(i3cdev, i3ctmp, &master->bus.devs.i3c,
1640 i3c_bus_set_addr_slot_status(&master->bus,
1647 list_for_each_entry_safe(i2cdev, i2ctmp, &master->bus.devs.i2c,
1650 i3c_bus_set_addr_slot_status(&master->bus,
1659 * @master: main master initializing the bus
1664 * 1. Attach I2C devs to the master so that the master can fill its internal
1668 * the master controller. That's usually where the bus mode is selected
1680 * devices to the master.
1689 static int i3c_master_bus_init(struct i3c_master_controller *master)
1701 list_for_each_entry(i2cboardinfo, &master->boardinfo.i2c, node) {
1702 status = i3c_bus_get_addr_slot_status(&master->bus,
1709 i3c_bus_set_addr_slot_status(&master->bus,
1713 i2cdev = i3c_master_alloc_i2c_dev(master,
1721 ret = i3c_master_attach_i2c_dev(master, i2cdev);
1732 ret = master->ops->bus_init(master);
1737 * The master device should have been instantiated in ->bus_init(),
1740 if (!master->this) {
1741 dev_err(&master->dev,
1751 ret = i3c_master_rstdaa_locked(master, I3C_BROADCAST_ADDR);
1756 ret = i3c_master_disec_locked(master, I3C_BROADCAST_ADDR,
1769 list_for_each_entry(i3cboardinfo, &master->boardinfo.i3c, node) {
1778 ret = i3c_bus_get_addr_slot_status(&master->bus,
1785 i3c_bus_set_addr_slot_status(&master->bus,
1798 i3c_master_early_i3c_dev_add(master, i3cboardinfo);
1801 ret = i3c_master_do_daa(master);
1808 i3c_master_rstdaa_locked(master, I3C_BROADCAST_ADDR);
1811 if (master->ops->bus_cleanup)
1812 master->ops->bus_cleanup(master);
1815 i3c_master_detach_free_devs(master);
1820 static void i3c_master_bus_cleanup(struct i3c_master_controller *master)
1822 if (master->ops->bus_cleanup)
1823 master->ops->bus_cleanup(master);
1825 i3c_master_detach_free_devs(master);
1830 struct i3c_master_controller *master = i3cdev->common.master;
1833 list_for_each_entry(i3cboardinfo, &master->boardinfo.i3c, node) {
1846 struct i3c_master_controller *master = i3c_dev_get_master(refdev);
1849 i3c_bus_for_each_i3cdev(&master->bus, i3cdev) {
1859 * @master: master used to send frames on the bus
1866 * The I3C device object is returned in case the master wants to attach
1873 int i3c_master_add_i3c_dev_locked(struct i3c_master_controller *master,
1883 if (!master)
1886 newdev = i3c_master_alloc_i3c_dev(master, &info);
1890 ret = i3c_master_attach_i3c_dev(master, newdev);
1941 * master
1953 * the address assigned by the master.
1955 ret = i3c_master_setnewda_locked(master,
1963 dev_err(&master->dev,
1965 master->bus.id, newdev->info.pid);
1980 dev_err(&master->dev,
1982 master->bus.id, newdev->info.pid);
1986 dev_err(&master->dev,
1988 master->bus.id, newdev->info.pid);
2011 of_i3c_master_add_i2c_boardinfo(struct i3c_master_controller *master,
2015 struct device *dev = &master->dev;
2039 list_add_tail(&boardinfo->node, &master->boardinfo.i2c);
2046 of_i3c_master_add_i3c_boardinfo(struct i3c_master_controller *master,
2050 struct device *dev = &master->dev;
2062 addrstatus = i3c_bus_get_addr_slot_status(&master->bus,
2074 addrstatus = i3c_bus_get_addr_slot_status(&master->bus,
2088 list_add_tail(&boardinfo->node, &master->boardinfo.i3c);
2093 static int of_i3c_master_add_dev(struct i3c_master_controller *master,
2099 if (!master || !node)
2111 ret = of_i3c_master_add_i2c_boardinfo(master, node, reg);
2113 ret = of_i3c_master_add_i3c_boardinfo(master, node, reg);
2118 static int of_populate_i3c_bus(struct i3c_master_controller *master)
2120 struct device *dev = &master->dev;
2130 ret = of_i3c_master_add_dev(master, node);
2143 master->bus.scl_rate.i2c = val;
2146 master->bus.scl_rate.i3c = val;
2154 struct i3c_master_controller *master = i2c_adapter_to_i3c_master(adap);
2159 if (!xfers || !master || nxfers <= 0)
2162 if (!master->ops->i2c_xfers)
2172 i3c_bus_normaluse_lock(&master->bus);
2173 dev = i3c_master_find_i2c_dev_by_addr(master, addr);
2177 ret = master->ops->i2c_xfers(dev, xfers, nxfers);
2178 i3c_bus_normaluse_unlock(&master->bus);
2206 struct i3c_master_controller *master = i2c_adapter_to_i3c_master(adap);
2212 if (i3c_master_find_i2c_dev_by_addr(master, client->addr))
2215 status = i3c_bus_get_addr_slot_status(&master->bus, client->addr);
2219 i3c_bus_set_addr_slot_status(&master->bus, client->addr,
2222 i2cdev = i3c_master_alloc_i2c_dev(master, client->addr,
2229 ret = i3c_master_attach_i2c_dev(master, i2cdev);
2238 i3c_bus_set_addr_slot_status(&master->bus, client->addr,
2246 struct i3c_master_controller *master = i2c_adapter_to_i3c_master(adap);
2249 dev = i3c_master_find_i2c_dev_by_addr(master, client->addr);
2254 i3c_bus_set_addr_slot_status(&master->bus, dev->addr,
2272 struct i3c_master_controller *master;
2284 master = i2c_adapter_to_i3c_master(adap);
2286 i3c_bus_maintenance_lock(&master->bus);
2295 i3c_bus_maintenance_unlock(&master->bus);
2304 static int i3c_master_i2c_adapter_init(struct i3c_master_controller *master)
2306 struct i2c_adapter *adap = i3c_master_to_i2c_adapter(master);
2311 adap->dev.parent = master->dev.parent;
2312 adap->owner = master->dev.parent->driver->owner;
2314 strncpy(adap->name, dev_name(master->dev.parent), sizeof(adap->name));
2328 list_for_each_entry(i2cboardinfo, &master->boardinfo.i2c, node) {
2329 i2cdev = i3c_master_find_i2c_dev_by_addr(master,
2339 static void i3c_master_i2c_adapter_cleanup(struct i3c_master_controller *master)
2343 i2c_del_adapter(&master->i2c);
2345 i3c_bus_for_each_i2cdev(&master->bus, i2cdev)
2349 static void i3c_master_unregister_i3c_devs(struct i3c_master_controller *master)
2353 i3c_bus_for_each_i3cdev(&master->bus, i3cdev) {
2377 queue_work(dev->common.master->wq, &slot->work);
2386 struct i3c_master_controller *master = i3c_dev_get_master(dev);
2395 master->ops->recycle_ibi_slot(dev, slot);
2545 * master driver struct_master_controller_ops->recycle_ibi() method.
2578 * i3c_master_register() - register an I3C master
2579 * @master: master used to send frames on the bus
2580 * @parent: the parent device (the one that provides this I3C master
2582 * @ops: the master controller operations
2583 * @secondary: true if you are registering a secondary master. Will return
2598 int i3c_master_register(struct i3c_master_controller *master,
2604 struct i3c_bus *i3cbus = i3c_master_get_bus(master);
2617 master->dev.parent = parent;
2618 master->dev.of_node = of_node_get(parent->of_node);
2619 master->dev.bus = &i3c_bus_type;
2620 master->dev.type = &i3c_masterdev_type;
2621 master->dev.release = i3c_masterdev_release;
2622 master->ops = ops;
2623 master->secondary = secondary;
2624 INIT_LIST_HEAD(&master->boardinfo.i2c);
2625 INIT_LIST_HEAD(&master->boardinfo.i3c);
2627 ret = i3c_bus_init(i3cbus, master->dev.of_node);
2631 device_initialize(&master->dev);
2632 dev_set_name(&master->dev, "i3c-%d", i3cbus->id);
2634 ret = of_populate_i3c_bus(master);
2638 list_for_each_entry(i2cbi, &master->boardinfo.i2c, node) {
2665 master->wq = alloc_workqueue("%s", 0, 0, dev_name(parent));
2666 if (!master->wq) {
2671 ret = i3c_master_bus_init(master);
2675 ret = device_add(&master->dev);
2683 ret = i3c_master_i2c_adapter_init(master);
2691 master->init_done = true;
2692 i3c_bus_normaluse_lock(&master->bus);
2693 i3c_master_register_new_i3c_devs(master);
2694 i3c_bus_normaluse_unlock(&master->bus);
2699 device_del(&master->dev);
2702 i3c_master_bus_cleanup(master);
2705 put_device(&master->dev);
2712 * i3c_master_unregister() - unregister an I3C master
2713 * @master: master used to send frames on the bus
2717 void i3c_master_unregister(struct i3c_master_controller *master)
2719 i3c_master_i2c_adapter_cleanup(master);
2720 i3c_master_unregister_i3c_devs(master);
2721 i3c_master_bus_cleanup(master);
2722 device_unregister(&master->dev);
2728 struct i3c_master_controller *master;
2733 master = i3c_dev_get_master(dev);
2734 if (!master)
2741 return i3c_master_setdasa_locked(master, dev->info.static_addr,
2749 struct i3c_master_controller *master;
2754 master = i3c_dev_get_master(dev);
2755 if (!master || !xfers)
2758 if (!master->ops->priv_xfers)
2761 return master->ops->priv_xfers(dev, xfers, nxfers);
2766 struct i3c_master_controller *master;
2772 master = i3c_dev_get_master(dev);
2773 ret = master->ops->disable_ibi(dev);
2788 struct i3c_master_controller *master = i3c_dev_get_master(dev);
2794 ret = master->ops->enable_ibi(dev);
2804 struct i3c_master_controller *master = i3c_dev_get_master(dev);
2808 if (!master->ops->request_ibi)
2825 ret = master->ops->request_ibi(dev, req);
2836 struct i3c_master_controller *master = i3c_dev_get_master(dev);
2844 master->ops->free_ibi(dev);