Lines Matching defs:edev
204 * @edev: the extcon device
205 * @cable_index: the index of this cable in the edev
220 struct extcon_dev *edev;
246 static int check_mutually_exclusive(struct extcon_dev *edev, u32 new_state)
250 if (!edev->mutually_exclusive)
253 for (i = 0; edev->mutually_exclusive[i]; i++) {
255 u32 correspondants = new_state & edev->mutually_exclusive[i];
266 static int find_cable_index_by_id(struct extcon_dev *edev, const unsigned int id)
270 /* Find the index of extcon cable in edev->supported_cable */
271 for (i = 0; i < edev->max_supported; i++) {
272 if (edev->supported_cable[i] == id)
295 static bool is_extcon_attached(struct extcon_dev *edev, unsigned int index)
297 return !!(edev->state & BIT(index));
300 static bool is_extcon_changed(struct extcon_dev *edev, int index,
303 int state = !!(edev->state & BIT(index));
320 static int is_extcon_property_capability(struct extcon_dev *edev,
331 cable = &edev->cables[index];
353 static void init_property(struct extcon_dev *edev, unsigned int id, int index)
356 struct extcon_cable *cable = &edev->cables[index];
372 struct extcon_dev *edev = dev_get_drvdata(dev);
374 if (edev->max_supported == 0)
375 return sysfs_emit(buf, "%u\n", edev->state);
377 for (i = 0; i < edev->max_supported; i++) {
379 extcon_info[edev->supported_cable[i]].name,
380 !!(edev->state & BIT(i)));
390 struct extcon_dev *edev = dev_get_drvdata(dev);
392 return sysfs_emit(buf, "%s\n", edev->name);
404 extcon_info[cable->edev->supported_cable[i]].name);
416 extcon_get_state(cable->edev, cable->edev->supported_cable[i]));
421 * @edev: the extcon device
429 int extcon_sync(struct extcon_dev *edev, unsigned int id)
441 if (!edev)
444 index = find_cable_index_by_id(edev, id);
448 spin_lock_irqsave(&edev->lock, flags);
449 state = !!(edev->state & BIT(index));
450 spin_unlock_irqrestore(&edev->lock, flags);
456 raw_notifier_call_chain(&edev->nh[index], state, edev);
462 raw_notifier_call_chain(&edev->nh_all, state, edev);
464 spin_lock_irqsave(&edev->lock, flags);
469 spin_unlock_irqrestore(&edev->lock, flags);
471 dev_err(&edev->dev, "out of memory in extcon_set_state\n");
472 kobject_uevent(&edev->dev.kobj, KOBJ_CHANGE);
477 length = name_show(&edev->dev, NULL, prop_buf);
485 length = state_show(&edev->dev, NULL, prop_buf);
495 spin_unlock_irqrestore(&edev->lock, flags);
496 kobject_uevent_env(&edev->dev.kobj, KOBJ_CHANGE, envp);
505 * @edev: the extcon device
510 int extcon_get_state(struct extcon_dev *edev, const unsigned int id)
515 if (!edev)
518 index = find_cable_index_by_id(edev, id);
522 spin_lock_irqsave(&edev->lock, flags);
523 state = is_extcon_attached(edev, index);
524 spin_unlock_irqrestore(&edev->lock, flags);
532 * @edev: the extcon device
543 int extcon_set_state(struct extcon_dev *edev, unsigned int id, bool state)
548 if (!edev)
551 index = find_cable_index_by_id(edev, id);
555 spin_lock_irqsave(&edev->lock, flags);
558 if (!is_extcon_changed(edev, index, state))
561 if (check_mutually_exclusive(edev,
562 (edev->state & ~BIT(index)) | (state & BIT(index)))) {
572 init_property(edev, id, index);
576 edev->state |= BIT(index);
578 edev->state &= ~(BIT(index));
580 spin_unlock_irqrestore(&edev->lock, flags);
588 * @edev: the extcon device
598 int extcon_set_state_sync(struct extcon_dev *edev, unsigned int id, bool state)
602 ret = extcon_set_state(edev, id, state);
606 return extcon_sync(edev, id);
612 * @edev: the extcon device
624 int extcon_get_property(struct extcon_dev *edev, unsigned int id,
634 if (!edev)
642 index = find_cable_index_by_id(edev, id);
646 spin_lock_irqsave(&edev->lock, flags);
649 if (!is_extcon_property_capability(edev, id, index, prop)) {
650 spin_unlock_irqrestore(&edev->lock, flags);
659 if (!is_extcon_attached(edev, index)) {
660 spin_unlock_irqrestore(&edev->lock, flags);
664 cable = &edev->cables[index];
685 spin_unlock_irqrestore(&edev->lock, flags);
693 * @edev: the extcon device
703 int extcon_set_property(struct extcon_dev *edev, unsigned int id,
711 if (!edev)
719 index = find_cable_index_by_id(edev, id);
723 spin_lock_irqsave(&edev->lock, flags);
726 if (!is_extcon_property_capability(edev, id, index, prop)) {
727 spin_unlock_irqrestore(&edev->lock, flags);
731 cable = &edev->cables[index];
752 spin_unlock_irqrestore(&edev->lock, flags);
760 * @edev: the extcon device
771 int extcon_set_property_sync(struct extcon_dev *edev, unsigned int id,
777 ret = extcon_set_property(edev, id, prop, prop_val);
781 return extcon_sync(edev, id);
788 * @edev: the extcon device
794 int extcon_get_property_capability(struct extcon_dev *edev, unsigned int id,
799 if (!edev)
807 index = find_cable_index_by_id(edev, id);
811 return is_extcon_property_capability(edev, id, index, prop);
818 * @edev: the extcon device
828 int extcon_set_property_capability(struct extcon_dev *edev, unsigned int id,
834 if (!edev)
842 index = find_cable_index_by_id(edev, id);
850 cable = &edev->cables[index];
903 * @edev: the extcon device
913 int extcon_register_notifier(struct extcon_dev *edev, unsigned int id,
919 if (!edev || !nb)
922 idx = find_cable_index_by_id(edev, id);
926 spin_lock_irqsave(&edev->lock, flags);
927 ret = raw_notifier_chain_register(&edev->nh[idx], nb);
928 spin_unlock_irqrestore(&edev->lock, flags);
936 * @edev: the extcon device
942 int extcon_unregister_notifier(struct extcon_dev *edev, unsigned int id,
948 if (!edev || !nb)
951 idx = find_cable_index_by_id(edev, id);
955 spin_lock_irqsave(&edev->lock, flags);
956 ret = raw_notifier_chain_unregister(&edev->nh[idx], nb);
957 spin_unlock_irqrestore(&edev->lock, flags);
965 * @edev: the extcon device
975 int extcon_register_notifier_all(struct extcon_dev *edev,
981 if (!edev || !nb)
984 spin_lock_irqsave(&edev->lock, flags);
985 ret = raw_notifier_chain_register(&edev->nh_all, nb);
986 spin_unlock_irqrestore(&edev->lock, flags);
994 * @edev: the extcon device
999 int extcon_unregister_notifier_all(struct extcon_dev *edev,
1005 if (!edev || !nb)
1008 spin_lock_irqsave(&edev->lock, flags);
1009 ret = raw_notifier_chain_unregister(&edev->nh_all, nb);
1010 spin_unlock_irqrestore(&edev->lock, flags);
1058 struct extcon_dev *edev;
1063 edev = kzalloc(sizeof(*edev), GFP_KERNEL);
1064 if (!edev)
1067 edev->max_supported = 0;
1068 edev->supported_cable = supported_cable;
1070 return edev;
1075 * @edev: the extcon device
1077 void extcon_dev_free(struct extcon_dev *edev)
1079 kfree(edev);
1085 * @edev: extcon device which has cables
1089 static int extcon_alloc_cables(struct extcon_dev *edev)
1095 if (!edev)
1098 if (!edev->max_supported)
1101 edev->cables = kcalloc(edev->max_supported, sizeof(*edev->cables),
1103 if (!edev->cables)
1106 for (index = 0; index < edev->max_supported; index++) {
1107 cable = &edev->cables[index];
1112 cable = &edev->cables[index];
1116 kfree(edev->cables);
1120 cable->edev = edev;
1144 * @edev: extcon device
1148 static int extcon_alloc_muex(struct extcon_dev *edev)
1153 if (!edev)
1156 if (!(edev->max_supported && edev->mutually_exclusive))
1160 for (index = 0; edev->mutually_exclusive[index]; index++)
1163 edev->attrs_muex = kcalloc(index + 1, sizeof(*edev->attrs_muex),
1165 if (!edev->attrs_muex)
1168 edev->d_attrs_muex = kcalloc(index, sizeof(*edev->d_attrs_muex),
1170 if (!edev->d_attrs_muex) {
1171 kfree(edev->attrs_muex);
1175 for (index = 0; edev->mutually_exclusive[index]; index++) {
1177 edev->mutually_exclusive[index]);
1180 kfree(edev->d_attrs_muex[index].attr.name);
1182 kfree(edev->d_attrs_muex);
1183 kfree(edev->attrs_muex);
1186 sysfs_attr_init(&edev->d_attrs_muex[index].attr);
1187 edev->d_attrs_muex[index].attr.name = name;
1188 edev->d_attrs_muex[index].attr.mode = 0000;
1189 edev->attrs_muex[index] = &edev->d_attrs_muex[index].attr;
1191 edev->attr_g_muex.name = muex_name;
1192 edev->attr_g_muex.attrs = edev->attrs_muex;
1199 * @edev: extcon device
1203 static int extcon_alloc_groups(struct extcon_dev *edev)
1207 if (!edev)
1210 if (!edev->max_supported)
1213 edev->extcon_dev_type.groups = kcalloc(edev->max_supported + 2,
1214 sizeof(*edev->extcon_dev_type.groups),
1216 if (!edev->extcon_dev_type.groups)
1219 edev->extcon_dev_type.name = dev_name(&edev->dev);
1220 edev->extcon_dev_type.release = dummy_sysfs_dev_release;
1222 for (index = 0; index < edev->max_supported; index++)
1223 edev->extcon_dev_type.groups[index] = &edev->cables[index].attr_g;
1225 if (edev->mutually_exclusive)
1226 edev->extcon_dev_type.groups[index] = &edev->attr_g_muex;
1228 edev->dev.type = &edev->extcon_dev_type;
1235 * @edev: the extcon device to be registered
1237 * Among the members of edev struct, please set the "user initializing data"
1247 int extcon_dev_register(struct extcon_dev *edev)
1255 if (!edev || !edev->supported_cable)
1258 for (index = 0; edev->supported_cable[index] != EXTCON_NONE; index++);
1260 edev->max_supported = index;
1262 dev_err(&edev->dev,
1267 edev->dev.class = extcon_class;
1268 edev->dev.release = extcon_dev_release;
1270 edev->name = dev_name(edev->dev.parent);
1271 if (IS_ERR_OR_NULL(edev->name)) {
1272 dev_err(&edev->dev,
1281 edev->id = ret;
1283 ret = extcon_alloc_cables(edev);
1287 ret = extcon_alloc_muex(edev);
1291 ret = extcon_alloc_groups(edev);
1295 spin_lock_init(&edev->lock);
1296 if (edev->max_supported) {
1297 edev->nh = kcalloc(edev->max_supported, sizeof(*edev->nh),
1299 if (!edev->nh) {
1305 for (index = 0; index < edev->max_supported; index++)
1306 RAW_INIT_NOTIFIER_HEAD(&edev->nh[index]);
1308 RAW_INIT_NOTIFIER_HEAD(&edev->nh_all);
1310 dev_set_drvdata(&edev->dev, edev);
1311 dev_set_name(&edev->dev, "extcon%d", edev->id);
1312 edev->state = 0;
1314 ret = device_register(&edev->dev);
1316 put_device(&edev->dev);
1321 list_add(&edev->entry, &extcon_dev_list);
1327 if (edev->max_supported)
1328 kfree(edev->nh);
1330 if (edev->max_supported)
1331 kfree(edev->extcon_dev_type.groups);
1333 if (edev->max_supported && edev->mutually_exclusive) {
1334 for (index = 0; edev->mutually_exclusive[index]; index++)
1335 kfree(edev->d_attrs_muex[index].attr.name);
1336 kfree(edev->d_attrs_muex);
1337 kfree(edev->attrs_muex);
1340 for (index = 0; index < edev->max_supported; index++)
1341 kfree(edev->cables[index].attr_g.name);
1342 if (edev->max_supported)
1343 kfree(edev->cables);
1345 ida_free(&extcon_dev_ids, edev->id);
1353 * @edev: the extcon device to be unregistered.
1355 * Note that this does not call kfree(edev) because edev was not allocated
1358 void extcon_dev_unregister(struct extcon_dev *edev)
1362 if (!edev)
1366 list_del(&edev->entry);
1369 if (!get_device(&edev->dev)) {
1370 dev_err(&edev->dev, "Failed to unregister extcon_dev\n");
1374 ida_free(&extcon_dev_ids, edev->id);
1376 device_unregister(&edev->dev);
1378 if (edev->mutually_exclusive && edev->max_supported) {
1379 for (index = 0; edev->mutually_exclusive[index];
1381 kfree(edev->d_attrs_muex[index].attr.name);
1382 kfree(edev->d_attrs_muex);
1383 kfree(edev->attrs_muex);
1386 for (index = 0; index < edev->max_supported; index++)
1387 kfree(edev->cables[index].attr_g.name);
1389 if (edev->max_supported) {
1390 kfree(edev->extcon_dev_type.groups);
1391 kfree(edev->cables);
1392 kfree(edev->nh);
1395 put_device(&edev->dev);
1403 * @node : OF node identifying edev
1409 struct extcon_dev *edev;
1412 list_for_each_entry(edev, &extcon_dev_list, entry)
1413 if (edev->dev.parent && device_match_of_node(edev->dev.parent, node))
1415 edev = ERR_PTR(-EPROBE_DEFER);
1419 return edev;
1432 struct extcon_dev *edev;
1445 edev = extcon_find_edev_by_node(node);
1448 return edev;
1470 * @edev: the extcon device
1472 const char *extcon_get_edev_name(struct extcon_dev *edev)
1474 return !edev ? NULL : edev->name;