Lines Matching defs:adap

176 static int get_scl_gpio_value(struct i2c_adapter *adap)
178 return gpiod_get_value_cansleep(adap->bus_recovery_info->scl_gpiod);
181 static void set_scl_gpio_value(struct i2c_adapter *adap, int val)
183 gpiod_set_value_cansleep(adap->bus_recovery_info->scl_gpiod, val);
186 static int get_sda_gpio_value(struct i2c_adapter *adap)
188 return gpiod_get_value_cansleep(adap->bus_recovery_info->sda_gpiod);
191 static void set_sda_gpio_value(struct i2c_adapter *adap, int val)
193 gpiod_set_value_cansleep(adap->bus_recovery_info->sda_gpiod, val);
196 static int i2c_generic_bus_free(struct i2c_adapter *adap)
198 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
202 ret = bri->get_bus_free(adap);
204 ret = bri->get_sda(adap);
220 int i2c_generic_scl_recovery(struct i2c_adapter *adap)
222 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
226 bri->prepare_recovery(adap);
237 bri->set_scl(adap, scl);
240 bri->set_sda(adap, scl);
249 if (!bri->get_scl(adap)) {
250 dev_err(&adap->dev,
258 bri->set_scl(adap, scl);
268 bri->set_sda(adap, scl);
272 ret = i2c_generic_bus_free(adap);
283 bri->unprepare_recovery(adap);
291 int i2c_recover_bus(struct i2c_adapter *adap)
293 if (!adap->bus_recovery_info)
296 dev_dbg(&adap->dev, "Trying i2c bus recovery\n");
297 return adap->bus_recovery_info->recover_bus(adap);
301 static void i2c_gpio_init_pinctrl_recovery(struct i2c_adapter *adap)
303 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
304 struct device *dev = &adap->dev;
348 static int i2c_gpio_init_generic_recovery(struct i2c_adapter *adap)
350 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
351 struct device *dev = &adap->dev;
416 static int i2c_gpio_init_recovery(struct i2c_adapter *adap)
418 i2c_gpio_init_pinctrl_recovery(adap);
419 return i2c_gpio_init_generic_recovery(adap);
422 static int i2c_init_recovery(struct i2c_adapter *adap)
424 struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;
431 if (i2c_gpio_init_recovery(adap) == -EPROBE_DEFER)
464 dev_err(&adap->dev, "Not using recovery: %s\n", err_str);
466 dev_dbg(&adap->dev, "Not using recovery: %s\n", err_str);
467 adap->bus_recovery_info = NULL;
474 struct i2c_adapter *adap = client->adapter;
477 if (!adap->host_notify_domain)
483 irq = irq_create_mapping(adap->host_notify_domain, client->addr);
869 static void i2c_dev_set_name(struct i2c_adapter *adap,
885 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
917 * @adap: the adapter managing the device
932 i2c_new_client_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
942 client->adapter = adap;
957 dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
963 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
978 dev_err(&adap->dev,
985 i2c_dev_set_name(adap, client, info);
990 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
1001 dev_err(&adap->dev,
1190 struct i2c_adapter *adap = to_i2c_adapter(dev);
1191 complete(&adap->dev_released);
1222 struct i2c_adapter *adap = to_i2c_adapter(dev);
1262 client = i2c_new_client_device(adap, &info);
1267 mutex_lock(&adap->userspace_clients_lock);
1268 list_add_tail(&client->detected, &adap->userspace_clients);
1269 mutex_unlock(&adap->userspace_clients_lock);
1290 struct i2c_adapter *adap = to_i2c_adapter(dev);
1309 mutex_lock_nested(&adap->userspace_clients_lock,
1310 i2c_adapter_depth(adap));
1311 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1323 mutex_unlock(&adap->userspace_clients_lock);
1384 struct i2c_adapter *adap)
1387 i2c_detect(adap, driver);
1403 static void i2c_host_notify_irq_teardown(struct i2c_adapter *adap)
1405 struct irq_domain *domain = adap->host_notify_domain;
1415 adap->host_notify_domain = NULL;
1431 static int i2c_setup_host_notify_irq_domain(struct i2c_adapter *adap)
1435 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_HOST_NOTIFY))
1438 domain = irq_domain_create_linear(adap->dev.parent->fwnode,
1440 &i2c_host_notify_irq_ops, adap);
1444 adap->host_notify_domain = domain;
1452 * @adap: the adapter
1459 int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr)
1463 if (!adap)
1466 irq = irq_find_mapping(adap->host_notify_domain, addr);
1476 static int i2c_register_adapter(struct i2c_adapter *adap)
1487 if (WARN(!adap->name[0], "i2c adapter has no name"))
1490 if (!adap->algo) {
1491 pr_err("adapter '%s': no algo supplied!\n", adap->name);
1495 if (!adap->lock_ops)
1496 adap->lock_ops = &i2c_adapter_lock_ops;
1498 adap->locked_flags = 0;
1499 rt_mutex_init(&adap->bus_lock);
1500 rt_mutex_init(&adap->mux_lock);
1501 mutex_init(&adap->userspace_clients_lock);
1502 INIT_LIST_HEAD(&adap->userspace_clients);
1505 if (adap->timeout == 0)
1506 adap->timeout = HZ;
1509 res = i2c_setup_host_notify_irq_domain(adap);
1512 adap->name, res);
1516 dev_set_name(&adap->dev, "i2c-%d", adap->nr);
1517 adap->dev.bus = &i2c_bus_type;
1518 adap->dev.type = &i2c_adapter_type;
1519 res = device_register(&adap->dev);
1521 pr_err("adapter '%s': can't register device (%d)\n", adap->name, res);
1525 res = i2c_setup_smbus_alert(adap);
1529 device_enable_async_suspend(&adap->dev);
1530 pm_runtime_no_callbacks(&adap->dev);
1531 pm_suspend_ignore_children(&adap->dev, true);
1532 pm_runtime_enable(&adap->dev);
1534 res = i2c_init_recovery(adap);
1538 dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
1541 res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
1542 adap->dev.parent);
1544 dev_warn(&adap->dev,
1549 of_i2c_register_devices(adap);
1550 i2c_acpi_install_space_handler(adap);
1551 i2c_acpi_register_devices(adap);
1553 if (adap->nr < __i2c_first_dynamic_bus_num)
1554 i2c_scan_static_board_info(adap);
1558 bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
1564 init_completion(&adap->dev_released);
1565 device_unregister(&adap->dev);
1566 wait_for_completion(&adap->dev_released);
1569 idr_remove(&i2c_adapter_idr, adap->nr);
1576 * @adap: the adapter to register (with adap->nr initialized)
1581 static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)
1586 id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1, GFP_KERNEL);
1591 return i2c_register_adapter(adap);
1605 * in adap->nr, and the specified adapter became available for clients.
1636 * @adap: the adapter to register (with adap->nr initialized)
1652 * clients using the bus number provided in adap->nr. Also, the table
1657 int i2c_add_numbered_adapter(struct i2c_adapter *adap)
1659 if (adap->nr == -1) /* -1 means dynamically assign bus id */
1660 return i2c_add_adapter(adap);
1662 return __i2c_add_numbered_adapter(adap);
1706 * @adap: the adapter being unregistered
1712 void i2c_del_adapter(struct i2c_adapter *adap)
1719 found = idr_find(&i2c_adapter_idr, adap->nr);
1721 if (found != adap) {
1722 pr_debug("attempting to delete unregistered adapter [%s]\n", adap->name);
1726 i2c_acpi_remove_space_handler(adap);
1729 bus_for_each_drv(&i2c_bus_type, NULL, adap,
1734 mutex_lock_nested(&adap->userspace_clients_lock,
1735 i2c_adapter_depth(adap));
1736 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1738 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1743 mutex_unlock(&adap->userspace_clients_lock);
1750 device_for_each_child(&adap->dev, NULL, __unregister_client);
1751 device_for_each_child(&adap->dev, NULL, __unregister_dummy);
1754 class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
1755 adap->dev.parent);
1759 dev_dbg(&adap->dev, "adapter [%s] unregistered\n", adap->name);
1761 pm_runtime_disable(&adap->dev);
1763 i2c_host_notify_irq_teardown(adap);
1772 init_completion(&adap->dev_released);
1773 device_unregister(&adap->dev);
1774 wait_for_completion(&adap->dev_released);
1778 idr_remove(&i2c_adapter_idr, adap->nr);
1783 memset(&adap->dev, 0, sizeof(adap->dev));
2035 void i2c_clients_command(struct i2c_adapter *adap, unsigned int cmd, void *arg)
2041 device_for_each_child(&adap->dev, &cmd_arg, i2c_cmd);
2118 static int i2c_quirk_error(struct i2c_adapter *adap, struct i2c_msg *msg, char *err_msg)
2120 dev_err_ratelimited(&adap->dev, "adapter quirk: %s (addr 0x%04x, size %u, %s)\n",
2126 static int i2c_check_for_quirks(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2128 const struct i2c_adapter_quirks *q = adap->quirks;
2138 return i2c_quirk_error(adap, &msgs[0], "1st comb msg must be write");
2141 return i2c_quirk_error(adap, &msgs[1], "2nd comb msg must be read");
2144 return i2c_quirk_error(adap, &msgs[0], "comb msg only to same addr");
2147 return i2c_quirk_error(adap, &msgs[0], "msg too long");
2150 return i2c_quirk_error(adap, &msgs[1], "msg too long");
2157 return i2c_quirk_error(adap, &msgs[0], "too many messages");
2164 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2167 return i2c_quirk_error(adap, &msgs[i], "no zero length");
2170 return i2c_quirk_error(adap, &msgs[i], "msg too long");
2173 return i2c_quirk_error(adap, &msgs[i], "no zero length");
2182 * @adap: Handle to I2C bus
2190 * takes place. adap->algo->master_xfer existence isn't checked.
2192 int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2200 ret = __i2c_check_suspended(adap);
2204 if (adap->quirks && i2c_check_for_quirks(adap, msgs, num))
2216 trace_i2c_read(adap, &msgs[i], i);
2218 trace_i2c_write(adap, &msgs[i], i);
2223 for (ret = 0, try = 0; try <= adap->retries; try++) {
2224 if (i2c_in_atomic_xfer_mode() && adap->algo->master_xfer_atomic)
2225 ret = adap->algo->master_xfer_atomic(adap, msgs, num);
2227 ret = adap->algo->master_xfer(adap, msgs, num);
2231 if (time_after(jiffies, orig_jiffies + adap->timeout))
2239 trace_i2c_reply(adap, &msgs[i], i);
2240 trace_i2c_result(adap, num, ret);
2249 * @adap: Handle to I2C bus
2259 int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
2263 if (!adap->algo->master_xfer) {
2264 dev_dbg(&adap->dev, "I2C level transfers not supported\n");
2284 ret = __i2c_lock_bus_helper(adap);
2288 ret = __i2c_transfer(adap, msgs, num);
2289 i2c_unlock_bus(adap, I2C_LOCK_SEGMENT);
2336 struct i2c_adapter *adap = client->adapter;
2340 if (!i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_I2C_BLOCK))
2344 ret = i2c_smbus_xfer(adap, I2C_ADDR_DEVICE_ID, 0,
2389 static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)
2395 if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)
2396 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))
2397 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2402 && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK))
2403 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,
2405 else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE))
2406 err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2409 dev_warn(&adap->dev, "No suitable probing method supported for address 0x%02X\n",
2522 int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr)
2524 return i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,
2530 i2c_new_scanned_device(struct i2c_adapter *adap,
2533 int (*probe)(struct i2c_adapter *adap, unsigned short addr))
2543 dev_warn(&adap->dev, "Invalid 7-bit address 0x%02x\n",
2549 if (i2c_check_addr_busy(adap, addr_list[i])) {
2550 dev_dbg(&adap->dev,
2557 if (probe(adap, addr_list[i]))
2562 dev_dbg(&adap->dev, "Probing failed, no device found\n");
2567 return i2c_new_client_device(adap, info);
2591 void i2c_put_adapter(struct i2c_adapter *adap)
2593 if (!adap)
2596 module_put(adap->owner);
2597 /* Should be last, otherwise we risk use-after-free with 'adap' */
2598 put_device(&adap->dev);