Lines Matching defs:client
103 const struct i2c_client *client)
105 if (!(id && client))
109 if (strcmp(client->name, id->name) == 0)
117 const void *i2c_get_match_data(const struct i2c_client *client)
119 struct i2c_driver *driver = to_i2c_driver(client->dev.driver);
123 data = device_get_match_data(&client->dev);
125 match = i2c_match_id(driver->id_table, client);
138 struct i2c_client *client = i2c_verify_client(dev);
143 if (i2c_of_match_device(drv->of_match_table, client))
153 if (i2c_match_id(driver->id_table, client))
161 const struct i2c_client *client = to_i2c_client(dev);
172 return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
472 static int i2c_smbus_host_notify_to_irq(const struct i2c_client *client)
474 struct i2c_adapter *adap = client->adapter;
480 if (client->flags & I2C_CLIENT_TEN)
483 irq = irq_create_mapping(adap->host_notify_domain, client->addr);
490 struct i2c_client *client = i2c_verify_client(dev);
495 if (!client)
498 client->irq = client->init_irq;
500 if (!client->irq) {
503 if (client->flags & I2C_CLIENT_HOST_NOTIFY) {
506 pm_runtime_get_sync(&client->adapter->dev);
507 irq = i2c_smbus_host_notify_to_irq(client);
515 irq = i2c_acpi_get_irq(client, &wake_capable);
517 client->flags |= I2C_CLIENT_WAKE;
527 client->irq = irq;
538 !i2c_of_match_device(dev->driver->of_match_table, client)) {
543 if (client->flags & I2C_CLIENT_WAKE) {
552 device_init_wakeup(&client->dev, true);
554 if (wakeirq > 0 && wakeirq != client->irq)
556 else if (client->irq > 0)
557 status = dev_pm_set_wake_irq(dev, client->irq);
562 dev_warn(&client->dev, "failed to set up wakeup irq\n");
572 status = dev_pm_domain_attach(&client->dev, do_power_on);
576 client->devres_group_id = devres_open_group(&client->dev, NULL,
578 if (!client->devres_group_id) {
584 status = driver->probe(client);
602 devres_release_group(&client->dev, client->devres_group_id);
604 dev_pm_domain_detach(&client->dev, do_power_on);
606 dev_pm_clear_wake_irq(&client->dev);
607 device_init_wakeup(&client->dev, false);
609 if (client->flags & I2C_CLIENT_HOST_NOTIFY)
610 pm_runtime_put_sync(&client->adapter->dev);
617 struct i2c_client *client = to_i2c_client(dev);
624 driver->remove(client);
627 devres_release_group(&client->dev, client->devres_group_id);
629 dev_pm_domain_detach(&client->dev, true);
631 dev_pm_clear_wake_irq(&client->dev);
632 device_init_wakeup(&client->dev, false);
634 client->irq = 0;
635 if (client->flags & I2C_CLIENT_HOST_NOTIFY)
636 pm_runtime_put(&client->adapter->dev);
641 struct i2c_client *client = i2c_verify_client(dev);
644 if (!client || !dev->driver)
648 driver->shutdown(client);
649 else if (client->irq > 0)
650 disable_irq(client->irq);
669 struct i2c_client *client = to_i2c_client(dev);
680 return sprintf(buf, "%s%s\n", I2C_MODULE_PREFIX, client->name);
727 /* Return a unique address which takes the flags of the client into account */
728 static unsigned short i2c_encode_flags_to_addr(struct i2c_client *client)
730 unsigned short addr = client->addr;
732 /* For some client flags, add an arbitrary offset to avoid collisions */
733 if (client->flags & I2C_CLIENT_TEN)
736 if (client->flags & I2C_CLIENT_SLAVE)
781 struct i2c_client *client = i2c_verify_client(dev);
784 if (client && i2c_encode_flags_to_addr(client) == addr)
870 struct i2c_client *client,
873 struct acpi_device *adev = ACPI_COMPANION(&client->dev);
876 dev_set_name(&client->dev, "i2c-%s", info->dev_name);
881 dev_set_name(&client->dev, "i2c-%s", acpi_dev_name(adev));
885 dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
886 i2c_encode_flags_to_addr(client));
928 * This returns the new i2c client, which may be saved for later use with
934 struct i2c_client *client;
938 client = kzalloc(sizeof *client, GFP_KERNEL);
939 if (!client)
942 client->adapter = adap;
944 client->dev.platform_data = info->platform_data;
945 client->flags = info->flags;
946 client->addr = info->addr;
948 client->init_irq = info->irq;
949 if (!client->init_irq)
950 client->init_irq = i2c_dev_irq_from_resources(info->resources,
953 strscpy(client->name, info->type, sizeof(client->name));
955 status = i2c_check_addr_validity(client->addr, client->flags);
958 client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
963 status = i2c_check_addr_busy(adap, i2c_encode_flags_to_addr(client));
967 client->dev.parent = &client->adapter->dev;
968 client->dev.bus = &i2c_bus_type;
969 client->dev.type = &i2c_client_type;
970 client->dev.of_node = of_node_get(info->of_node);
971 client->dev.fwnode = info->fwnode;
973 device_enable_async_suspend(&client->dev);
976 status = device_add_software_node(&client->dev, info->swnode);
979 "Failed to add software node to client %s: %d\n",
980 client->name, status);
985 i2c_dev_set_name(adap, client, info);
986 status = device_register(&client->dev);
990 dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
991 client->name, dev_name(&client->dev));
993 return client;
996 device_remove_software_node(&client->dev);
1002 "Failed to register i2c client %s at 0x%02x (%d)\n",
1003 client->name, client->addr, status);
1006 put_device(&client->dev);
1008 kfree(client);
1015 * @client: value returned from i2c_new_*_device()
1018 void i2c_unregister_device(struct i2c_client *client)
1020 if (IS_ERR_OR_NULL(client))
1023 if (client->dev.of_node) {
1024 of_node_clear_flag(client->dev.of_node, OF_POPULATED);
1025 of_node_put(client->dev.of_node);
1028 if (ACPI_COMPANION(&client->dev))
1029 acpi_device_clear_enumerated(ACPI_COMPANION(&client->dev));
1030 device_remove_software_node(&client->dev);
1031 device_unregister(&client->dev);
1040 * If no client can be found, or @fwnode is NULL, this returns NULL.
1042 * The user must call put_device(&client->dev) once done with the i2c client.
1046 struct i2c_client *client;
1056 client = i2c_verify_client(dev);
1057 if (!client)
1060 return client;
1070 static int dummy_probe(struct i2c_client *client)
1087 * This returns an I2C client bound to the "dummy" driver, intended for use
1092 * except i2c_transfer() need a client handle; the dummy will be that handle.
1096 * This returns the new i2c client, which should be saved for later use with
1109 static void devm_i2c_release_dummy(void *client)
1111 i2c_unregister_device(client);
1122 * new i2c client or an ERR_PTR in case of an error.
1128 struct i2c_client *client;
1131 client = i2c_new_dummy_device(adapter, address);
1132 if (IS_ERR(client))
1133 return client;
1135 ret = devm_add_action_or_reset(dev, devm_i2c_release_dummy, client);
1139 return client;
1146 * @client: Handle to the primary client
1152 * component. The I2C client driver then binds to the master I2C slave and needs
1155 * This function creates and returns an I2C dummy client whose I2C address is
1162 * This returns the new i2c client, which should be saved for later use with
1165 struct i2c_client *i2c_new_ancillary_device(struct i2c_client *client,
1169 struct device_node *np = client->dev.of_node;
1179 dev_dbg(&client->adapter->dev, "Address for %s : 0x%x\n", name, addr);
1180 return i2c_new_dummy_device(client->adapter, addr);
1224 struct i2c_client *client;
1262 client = i2c_new_client_device(adap, &info);
1263 if (IS_ERR(client))
1264 return PTR_ERR(client);
1268 list_add_tail(&client->detected, &adap->userspace_clients);
1291 struct i2c_client *client, *next;
1311 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1313 if (i2c_encode_flags_to_addr(client) == addr) {
1315 "delete_device", client->name, client->addr);
1317 list_del(&client->detected);
1318 i2c_unregister_device(client);
1451 * I2C client.
1669 struct i2c_client *client, *_n;
1673 list_for_each_entry_safe(client, _n, &driver->clients, detected) {
1674 if (client->adapter == adapter) {
1676 client->name, client->addr);
1677 list_del(&client->detected);
1678 i2c_unregister_device(client);
1685 struct i2c_client *client = i2c_verify_client(dev);
1686 if (client && strcmp(client->name, "dummy"))
1687 i2c_unregister_device(client);
1693 struct i2c_client *client = i2c_verify_client(dev);
1694 i2c_unregister_device(client);
1715 struct i2c_client *client, *next;
1736 list_for_each_entry_safe(client, next, &adap->userspace_clients,
1738 dev_dbg(&adap->dev, "Removing %s at 0x%x\n", client->name,
1739 client->addr);
1740 list_del(&client->detected);
1741 i2c_unregister_device(client);
2022 struct i2c_client *client = i2c_verify_client(dev);
2026 if (!client || !client->dev.driver)
2029 driver = to_i2c_driver(client->dev.driver);
2031 driver->command(client, arg->cmd, arg->arg);
2298 * @client: Handle to slave device
2305 int i2c_transfer_buffer_flags(const struct i2c_client *client, char *buf,
2310 .addr = client->addr,
2311 .flags = flags | (client->flags & I2C_M_TEN),
2316 ret = i2c_transfer(client->adapter, &msg, 1);
2328 * @client: The device to query
2333 int i2c_get_device_id(const struct i2c_client *client,
2336 struct i2c_adapter *adap = client->adapter;
2345 I2C_SMBUS_READ, client->addr << 1,
2359 * @client: the device to query. The device must be bound to a driver
2363 const struct i2c_device_id *i2c_client_get_device_id(const struct i2c_client *client)
2365 const struct i2c_driver *drv = to_i2c_driver(client->dev.driver);
2367 return i2c_match_id(drv->id_table, client);
2457 struct i2c_client *client;
2463 "Please make sure client 0x%02x gets instantiated by other means. "
2469 client = i2c_new_client_device(adapter, &info);
2470 if (!IS_ERR(client))
2471 list_add_tail(&client->detected, &driver->clients);
2502 /* Set up a temporary client to help detect callback */