Lines Matching defs:master

71  * In other words, transfer requests passed to the I3C master can be submitted
72 * in parallel and I3C master drivers have to use their own locking to make
109 struct i3c_master_controller *master;
114 master = dev_to_i3cmaster(dev);
116 return &master->bus;
121 struct i3c_master_controller *master;
126 master = dev_to_i3cmaster(dev);
128 return master->this;
536 struct i3c_master_controller *master = dev_to_i3cmaster(dev);
539 if (master->wq)
540 destroy_workqueue(master->wq);
555 struct i3c_master_controller *master = i3c_bus_to_i3c_master(i3cbus);
582 dev_dbg(&master->dev, "i2c-scl = %ld Hz i3c-scl = %ld Hz\n",
603 i3c_master_to_i2c_adapter(struct i3c_master_controller *master)
605 return &master->i2c;
614 i3c_master_alloc_i2c_dev(struct i3c_master_controller *master,
623 dev->common.master = master;
660 static int i3c_master_send_ccc_cmd_locked(struct i3c_master_controller *master,
665 if (!cmd || !master)
668 if (WARN_ON(master->init_done &&
669 !rwsem_is_locked(&master->bus.lock)))
672 if (!master->ops->send_ccc_cmd)
678 if (master->ops->supports_ccc_cmd &&
679 !master->ops->supports_ccc_cmd(master, cmd))
682 ret = master->ops->send_ccc_cmd(master, cmd);
694 i3c_master_find_i2c_dev_by_addr(const struct i3c_master_controller *master,
699 i3c_bus_for_each_i2cdev(&master->bus, dev) {
709 * @master: I3C master object
717 int i3c_master_get_free_addr(struct i3c_master_controller *master,
720 return i3c_bus_get_free_addr(&master->bus, start_addr);
740 i3c_master_alloc_i3c_dev(struct i3c_master_controller *master,
749 dev->common.master = master;
756 static int i3c_master_rstdaa_locked(struct i3c_master_controller *master,
764 if (!master)
767 addrstat = i3c_bus_get_addr_slot_status(&master->bus, addr);
775 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
784 * @master: master used to send frames on the bus
789 * behind dynamic address assignment has to be handled in the I3C master
797 int i3c_master_entdaa_locked(struct i3c_master_controller *master)
805 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
812 static int i3c_master_enec_disec_locked(struct i3c_master_controller *master,
830 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
838 * @master: master used to send frames on the bus
850 int i3c_master_disec_locked(struct i3c_master_controller *master, u8 addr,
853 return i3c_master_enec_disec_locked(master, addr, false, evts);
859 * @master: master used to send frames on the bus
871 int i3c_master_enec_locked(struct i3c_master_controller *master, u8 addr,
874 return i3c_master_enec_disec_locked(master, addr, true, evts);
880 * @master: master used to send frames on the bus
882 * Send a DEFSLVS CCC command containing all the devices known to the @master.
889 * It should also be called if a master ACKed an Hot-Join request and assigned
897 int i3c_master_defslvs_locked(struct i3c_master_controller *master)
909 if (!master)
912 bus = i3c_master_get_bus(master);
916 if (i3cdev == master->this)
924 /* No other master on the bus, skip DEFSLVS. */
938 defslvs->master.bcr = master->this->info.bcr;
939 defslvs->master.dcr = master->this->info.dcr;
940 defslvs->master.dyn_addr = master->this->info.dyn_addr << 1;
941 defslvs->master.static_addr = I3C_BROADCAST_ADDR << 1;
951 /* Skip the I3C dev representing this master. */
952 if (i3cdev == master->this)
963 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
970 static int i3c_master_setda_locked(struct i3c_master_controller *master,
989 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
995 static int i3c_master_setdasa_locked(struct i3c_master_controller *master,
998 return i3c_master_setda_locked(master, static_addr, dyn_addr, true);
1001 static int i3c_master_setnewda_locked(struct i3c_master_controller *master,
1004 return i3c_master_setda_locked(master, oldaddr, newaddr, false);
1007 static int i3c_master_getmrl_locked(struct i3c_master_controller *master,
1027 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1049 static int i3c_master_getmwl_locked(struct i3c_master_controller *master,
1062 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1079 static int i3c_master_getmxds_locked(struct i3c_master_controller *master,
1093 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1115 static int i3c_master_gethdrcap_locked(struct i3c_master_controller *master,
1129 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1146 static int i3c_master_getpid_locked(struct i3c_master_controller *master,
1159 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1176 static int i3c_master_getbcr_locked(struct i3c_master_controller *master,
1189 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1201 static int i3c_master_getdcr_locked(struct i3c_master_controller *master,
1214 ret = i3c_master_send_ccc_cmd_locked(master, &cmd);
1228 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1235 slot_status = i3c_bus_get_addr_slot_status(&master->bus,
1241 ret = i3c_master_getpid_locked(master, &dev->info);
1245 ret = i3c_master_getbcr_locked(master, &dev->info);
1249 ret = i3c_master_getdcr_locked(master, &dev->info);
1254 ret = i3c_master_getmxds_locked(master, &dev->info);
1262 i3c_master_getmrl_locked(master, &dev->info);
1263 i3c_master_getmwl_locked(master, &dev->info);
1266 ret = i3c_master_gethdrcap_locked(master, &dev->info);
1276 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1279 i3c_bus_set_addr_slot_status(&master->bus,
1284 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1288 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1294 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1301 status = i3c_bus_get_addr_slot_status(&master->bus,
1306 i3c_bus_set_addr_slot_status(&master->bus,
1319 status = i3c_bus_get_addr_slot_status(&master->bus,
1324 i3c_bus_set_addr_slot_status(&master->bus, dev->info.dyn_addr,
1332 i3c_bus_set_addr_slot_status(&master->bus,
1339 static int i3c_master_attach_i3c_dev(struct i3c_master_controller *master,
1355 /* Do not attach the master device itself. */
1356 if (master->this != dev && master->ops->attach_i3c_dev) {
1357 ret = master->ops->attach_i3c_dev(dev);
1364 list_add_tail(&dev->common.node, &master->bus.devs.i3c);
1372 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1379 status = i3c_bus_get_addr_slot_status(&master->bus,
1383 i3c_bus_set_addr_slot_status(&master->bus,
1388 if (master->ops->reattach_i3c_dev) {
1389 ret = master->ops->reattach_i3c_dev(dev, old_dyn_addr);
1401 struct i3c_master_controller *master = i3c_dev_get_master(dev);
1403 /* Do not detach the master device itself. */
1404 if (master->this != dev && master->ops->detach_i3c_dev)
1405 master->ops->detach_i3c_dev(dev);
1411 static int i3c_master_attach_i2c_dev(struct i3c_master_controller *master,
1416 if (master->ops->attach_i2c_dev) {
1417 ret = master->ops->attach_i2c_dev(dev);
1422 list_add_tail(&dev->common.node, &master->bus.devs.i2c);
1429 struct i3c_master_controller *master = i2c_dev_get_master(dev);
1433 if (master->ops->detach_i2c_dev)
1434 master->ops->detach_i2c_dev(dev);
1437 static int i3c_master_early_i3c_dev_add(struct i3c_master_controller *master,
1446 i3cdev = i3c_master_alloc_i3c_dev(master, &info);
1452 ret = i3c_master_attach_i3c_dev(master, i3cdev);
1456 ret = i3c_master_setdasa_locked(master, i3cdev->info.static_addr,
1473 i3c_master_rstdaa_locked(master, i3cdev->boardinfo->init_dyn_addr);
1483 i3c_master_register_new_i3c_devs(struct i3c_master_controller *master)
1488 if (!master->init_done)
1491 i3c_bus_for_each_i3cdev(&master->bus, desc) {
1492 if (desc->dev || !desc->info.dyn_addr || desc == master->this)
1499 desc->dev->bus = &master->bus;
1501 desc->dev->dev.parent = &master->dev;
1505 dev_set_name(&desc->dev->dev, "%d-%llx", master->bus.id,
1513 dev_err(&master->dev,
1522 * @master: master doing the DAA
1528 * The I3C device object is returned in case the master wants to attach
1535 int i3c_master_do_daa(struct i3c_master_controller *master)
1539 i3c_bus_maintenance_lock(&master->bus);
1540 ret = master->ops->do_daa(master);
1541 i3c_bus_maintenance_unlock(&master->bus);
1546 i3c_bus_normaluse_lock(&master->bus);
1547 i3c_master_register_new_i3c_devs(master);
1548 i3c_bus_normaluse_unlock(&master->bus);
1555 * i3c_master_set_info() - set master device information
1556 * @master: master used to send frames on the bus
1559 * Set master device info. This should be called from
1562 * Not all &i3c_device_info fields are meaningful for a master device.
1578 int i3c_master_set_info(struct i3c_master_controller *master,
1584 if (!i3c_bus_dev_addr_is_avail(&master->bus, info->dyn_addr))
1588 master->secondary)
1591 if (master->this)
1594 i3cdev = i3c_master_alloc_i3c_dev(master, info);
1598 master->this = i3cdev;
1599 master->bus.cur_master = master->this;
1601 ret = i3c_master_attach_i3c_dev(master, i3cdev);
1614 static void i3c_master_detach_free_devs(struct i3c_master_controller *master)
1619 list_for_each_entry_safe(i3cdev, i3ctmp, &master->bus.devs.i3c,
1624 i3c_bus_set_addr_slot_status(&master->bus,
1631 list_for_each_entry_safe(i2cdev, i2ctmp, &master->bus.devs.i2c,
1634 i3c_bus_set_addr_slot_status(&master->bus,
1643 * @master: main master initializing the bus
1648 * 1. Attach I2C devs to the master so that the master can fill its internal
1652 * the master controller. That's usually where the bus mode is selected
1664 * devices to the master.
1673 static int i3c_master_bus_init(struct i3c_master_controller *master)
1685 list_for_each_entry(i2cboardinfo, &master->boardinfo.i2c, node) {
1686 status = i3c_bus_get_addr_slot_status(&master->bus,
1693 i3c_bus_set_addr_slot_status(&master->bus,
1697 i2cdev = i3c_master_alloc_i2c_dev(master, i2cboardinfo);
1703 ret = i3c_master_attach_i2c_dev(master, i2cdev);
1714 ret = master->ops->bus_init(master);
1719 * The master device should have been instantiated in ->bus_init(),
1722 if (!master->this) {
1723 dev_err(&master->dev,
1733 ret = i3c_master_rstdaa_locked(master, I3C_BROADCAST_ADDR);
1738 ret = i3c_master_disec_locked(master, I3C_BROADCAST_ADDR,
1751 list_for_each_entry(i3cboardinfo, &master->boardinfo.i3c, node) {
1760 ret = i3c_bus_get_addr_slot_status(&master->bus,
1767 i3c_bus_set_addr_slot_status(&master->bus,
1780 i3c_master_early_i3c_dev_add(master, i3cboardinfo);
1783 ret = i3c_master_do_daa(master);
1790 i3c_master_rstdaa_locked(master, I3C_BROADCAST_ADDR);
1793 if (master->ops->bus_cleanup)
1794 master->ops->bus_cleanup(master);
1797 i3c_master_detach_free_devs(master);
1802 static void i3c_master_bus_cleanup(struct i3c_master_controller *master)
1804 if (master->ops->bus_cleanup)
1805 master->ops->bus_cleanup(master);
1807 i3c_master_detach_free_devs(master);
1812 struct i3c_master_controller *master = i3cdev->common.master;
1815 list_for_each_entry(i3cboardinfo, &master->boardinfo.i3c, node) {
1828 struct i3c_master_controller *master = i3c_dev_get_master(refdev);
1831 i3c_bus_for_each_i3cdev(&master->bus, i3cdev) {
1841 * @master: master used to send frames on the bus
1848 * The I3C device object is returned in case the master wants to attach
1855 int i3c_master_add_i3c_dev_locked(struct i3c_master_controller *master,
1865 if (!master)
1868 newdev = i3c_master_alloc_i3c_dev(master, &info);
1872 ret = i3c_master_attach_i3c_dev(master, newdev);
1927 * master
1939 * the address assigned by the master.
1941 ret = i3c_master_setnewda_locked(master,
1949 dev_err(&master->dev,
1951 master->bus.id, newdev->info.pid);
1966 dev_err(&master->dev,
1968 master->bus.id, newdev->info.pid);
1972 dev_err(&master->dev,
1974 master->bus.id, newdev->info.pid);
1997 of_i3c_master_add_i2c_boardinfo(struct i3c_master_controller *master,
2001 struct device *dev = &master->dev;
2025 list_add_tail(&boardinfo->node, &master->boardinfo.i2c);
2032 of_i3c_master_add_i3c_boardinfo(struct i3c_master_controller *master,
2036 struct device *dev = &master->dev;
2048 addrstatus = i3c_bus_get_addr_slot_status(&master->bus,
2060 addrstatus = i3c_bus_get_addr_slot_status(&master->bus,
2074 list_add_tail(&boardinfo->node, &master->boardinfo.i3c);
2079 static int of_i3c_master_add_dev(struct i3c_master_controller *master,
2085 if (!master || !node)
2097 ret = of_i3c_master_add_i2c_boardinfo(master, node, reg);
2099 ret = of_i3c_master_add_i3c_boardinfo(master, node, reg);
2104 static int of_populate_i3c_bus(struct i3c_master_controller *master)
2106 struct device *dev = &master->dev;
2116 ret = of_i3c_master_add_dev(master, node);
2129 master->bus.scl_rate.i2c = val;
2132 master->bus.scl_rate.i3c = val;
2140 struct i3c_master_controller *master = i2c_adapter_to_i3c_master(adap);
2145 if (!xfers || !master || nxfers <= 0)
2148 if (!master->ops->i2c_xfers)
2158 i3c_bus_normaluse_lock(&master->bus);
2159 dev = i3c_master_find_i2c_dev_by_addr(master, addr);
2163 ret = master->ops->i2c_xfers(dev, xfers, nxfers);
2164 i3c_bus_normaluse_unlock(&master->bus);
2179 static int i3c_master_i2c_adapter_init(struct i3c_master_controller *master)
2181 struct i2c_adapter *adap = i3c_master_to_i2c_adapter(master);
2185 adap->dev.parent = master->dev.parent;
2186 adap->owner = master->dev.parent->driver->owner;
2188 strncpy(adap->name, dev_name(master->dev.parent), sizeof(adap->name));
2202 i3c_bus_for_each_i2cdev(&master->bus, i2cdev)
2208 static void i3c_master_i2c_adapter_cleanup(struct i3c_master_controller *master)
2212 i2c_del_adapter(&master->i2c);
2214 i3c_bus_for_each_i2cdev(&master->bus, i2cdev)
2218 static void i3c_master_unregister_i3c_devs(struct i3c_master_controller *master)
2222 i3c_bus_for_each_i3cdev(&master->bus, i3cdev) {
2246 queue_work(dev->common.master->wq, &slot->work);
2255 struct i3c_master_controller *master = i3c_dev_get_master(dev);
2264 master->ops->recycle_ibi_slot(dev, slot);
2414 * master driver struct_master_controller_ops->recycle_ibi() method.
2447 * i3c_master_register() - register an I3C master
2448 * @master: master used to send frames on the bus
2449 * @parent: the parent device (the one that provides this I3C master
2451 * @ops: the master controller operations
2452 * @secondary: true if you are registering a secondary master. Will return
2467 int i3c_master_register(struct i3c_master_controller *master,
2473 struct i3c_bus *i3cbus = i3c_master_get_bus(master);
2486 master->dev.parent = parent;
2487 master->dev.of_node = of_node_get(parent->of_node);
2488 master->dev.bus = &i3c_bus_type;
2489 master->dev.type = &i3c_masterdev_type;
2490 master->dev.release = i3c_masterdev_release;
2491 master->ops = ops;
2492 master->secondary = secondary;
2493 INIT_LIST_HEAD(&master->boardinfo.i2c);
2494 INIT_LIST_HEAD(&master->boardinfo.i3c);
2500 device_initialize(&master->dev);
2501 dev_set_name(&master->dev, "i3c-%d", i3cbus->id);
2503 ret = of_populate_i3c_bus(master);
2507 list_for_each_entry(i2cbi, &master->boardinfo.i2c, node) {
2534 master->wq = alloc_workqueue("%s", 0, 0, dev_name(parent));
2535 if (!master->wq) {
2540 ret = i3c_master_bus_init(master);
2544 ret = device_add(&master->dev);
2552 ret = i3c_master_i2c_adapter_init(master);
2560 master->init_done = true;
2561 i3c_bus_normaluse_lock(&master->bus);
2562 i3c_master_register_new_i3c_devs(master);
2563 i3c_bus_normaluse_unlock(&master->bus);
2568 device_del(&master->dev);
2571 i3c_master_bus_cleanup(master);
2574 put_device(&master->dev);
2581 * i3c_master_unregister() - unregister an I3C master
2582 * @master: master used to send frames on the bus
2588 int i3c_master_unregister(struct i3c_master_controller *master)
2590 i3c_master_i2c_adapter_cleanup(master);
2591 i3c_master_unregister_i3c_devs(master);
2592 i3c_master_bus_cleanup(master);
2593 device_unregister(&master->dev);
2603 struct i3c_master_controller *master;
2608 master = i3c_dev_get_master(dev);
2609 if (!master || !xfers)
2612 if (!master->ops->priv_xfers)
2615 return master->ops->priv_xfers(dev, xfers, nxfers);
2620 struct i3c_master_controller *master;
2626 master = i3c_dev_get_master(dev);
2627 ret = master->ops->disable_ibi(dev);
2642 struct i3c_master_controller *master = i3c_dev_get_master(dev);
2648 ret = master->ops->enable_ibi(dev);
2658 struct i3c_master_controller *master = i3c_dev_get_master(dev);
2662 if (!master->ops->request_ibi)
2679 ret = master->ops->request_ibi(dev, req);
2690 struct i3c_master_controller *master = i3c_dev_get_master(dev);
2698 master->ops->free_ibi(dev);