Lines Matching refs:intf
45 static int gb_interface_hibernate_link(struct gb_interface *intf);
46 static int gb_interface_refclk_set(struct gb_interface *intf, bool enable);
48 static int gb_interface_dme_attr_get(struct gb_interface *intf,
51 return gb_svc_dme_peer_get(intf->hd->svc, intf->interface_id,
55 static int gb_interface_read_ara_dme(struct gb_interface *intf)
64 if (intf->ddbl1_manufacturer_id != TOSHIBA_DMID) {
65 dev_err(&intf->dev, "unknown manufacturer %08x\n",
66 intf->ddbl1_manufacturer_id);
70 ret = gb_interface_dme_attr_get(intf, DME_TOSHIBA_GMP_VID,
71 &intf->vendor_id);
75 ret = gb_interface_dme_attr_get(intf, DME_TOSHIBA_GMP_PID,
76 &intf->product_id);
80 ret = gb_interface_dme_attr_get(intf, DME_TOSHIBA_GMP_SN0, &sn0);
84 ret = gb_interface_dme_attr_get(intf, DME_TOSHIBA_GMP_SN1, &sn1);
88 intf->serial_number = (u64)sn1 << 32 | sn0;
93 static int gb_interface_read_dme(struct gb_interface *intf)
98 if (intf->dme_read)
101 ret = gb_interface_dme_attr_get(intf, DME_DDBL1_MANUFACTURERID,
102 &intf->ddbl1_manufacturer_id);
106 ret = gb_interface_dme_attr_get(intf, DME_DDBL1_PRODUCTID,
107 &intf->ddbl1_product_id);
111 if (intf->ddbl1_manufacturer_id == TOSHIBA_DMID &&
112 intf->ddbl1_product_id == TOSHIBA_ES2_BRIDGE_DPID) {
113 intf->quirks |= GB_INTERFACE_QUIRK_NO_GMP_IDS;
114 intf->quirks |= GB_INTERFACE_QUIRK_NO_INIT_STATUS;
117 ret = gb_interface_read_ara_dme(intf);
121 intf->dme_read = true;
126 static int gb_interface_route_create(struct gb_interface *intf)
128 struct gb_svc *svc = intf->hd->svc;
129 u8 intf_id = intf->interface_id;
138 dev_err(&intf->dev, "failed to allocate device id: %d\n", ret);
145 dev_err(&intf->dev, "failed to set device id %u: %d\n",
154 dev_err(&intf->dev, "failed to create route: %d\n", ret);
158 intf->device_id = device_id;
173 static void gb_interface_route_destroy(struct gb_interface *intf)
175 struct gb_svc *svc = intf->hd->svc;
177 if (intf->device_id == GB_INTERFACE_DEVICE_ID_BAD)
180 gb_svc_route_destroy(svc, svc->ap_intf_id, intf->interface_id);
181 ida_simple_remove(&svc->device_id_map, intf->device_id);
182 intf->device_id = GB_INTERFACE_DEVICE_ID_BAD;
186 static int gb_interface_legacy_mode_switch(struct gb_interface *intf)
190 dev_info(&intf->dev, "legacy mode switch detected\n");
193 intf->disconnected = true;
194 gb_interface_disable(intf);
195 intf->disconnected = false;
197 ret = gb_interface_enable(intf);
199 dev_err(&intf->dev, "failed to re-enable interface: %d\n", ret);
200 gb_interface_deactivate(intf);
206 void gb_interface_mailbox_event(struct gb_interface *intf, u16 result,
209 mutex_lock(&intf->mutex);
212 dev_warn(&intf->dev,
219 dev_warn(&intf->dev,
225 if (intf->quirks & GB_INTERFACE_QUIRK_LEGACY_MODE_SWITCH) {
226 gb_interface_legacy_mode_switch(intf);
230 if (!intf->mode_switch) {
231 dev_warn(&intf->dev, "unexpected mailbox event: 0x%08x\n",
236 dev_info(&intf->dev, "mode switch detected\n");
238 complete(&intf->mode_switch_completion);
241 mutex_unlock(&intf->mutex);
246 gb_interface_disable(intf);
247 gb_interface_deactivate(intf);
248 mutex_unlock(&intf->mutex);
253 struct gb_interface *intf;
258 intf = container_of(work, struct gb_interface, mode_switch_work);
260 mutex_lock(&intf->mutex);
262 if (!intf->enabled) {
263 dev_dbg(&intf->dev, "mode switch aborted\n");
264 intf->mode_switch = false;
265 mutex_unlock(&intf->mutex);
273 control = gb_control_get(intf->control);
275 gb_interface_disable(intf);
276 mutex_unlock(&intf->mutex);
280 &intf->mode_switch_completion, timeout);
287 dev_err(&intf->dev, "mode switch interrupted\n");
290 dev_err(&intf->dev, "mode switch timed out\n");
295 mutex_lock(&intf->mutex);
296 intf->mode_switch = false;
297 if (intf->active) {
298 ret = gb_interface_enable(intf);
300 dev_err(&intf->dev, "failed to re-enable interface: %d\n",
302 gb_interface_deactivate(intf);
305 mutex_unlock(&intf->mutex);
308 gb_interface_put(intf);
313 mutex_lock(&intf->mutex);
314 intf->mode_switch = false;
315 gb_interface_deactivate(intf);
316 mutex_unlock(&intf->mutex);
318 gb_interface_put(intf);
321 int gb_interface_request_mode_switch(struct gb_interface *intf)
325 mutex_lock(&intf->mutex);
326 if (intf->mode_switch) {
331 intf->mode_switch = true;
332 reinit_completion(&intf->mode_switch_completion);
338 get_device(&intf->dev);
340 if (!queue_work(system_long_wq, &intf->mode_switch_work)) {
341 put_device(&intf->dev);
347 mutex_unlock(&intf->mutex);
361 static int gb_interface_read_and_clear_init_status(struct gb_interface *intf)
363 struct gb_host_device *hd = intf->hd;
376 if (intf->quirks & GB_INTERFACE_QUIRK_NO_INIT_STATUS)
381 ret = gb_svc_dme_peer_get(hd->svc, intf->interface_id, attr,
391 dev_err(&intf->dev, "invalid init status\n");
403 if (intf->quirks & GB_INTERFACE_QUIRK_NO_INIT_STATUS)
422 intf->quirks |= bootrom_quirks;
426 intf->quirks &= ~bootrom_quirks;
427 intf->quirks |= s2l_quirks;
430 intf->quirks &= ~bootrom_quirks;
431 intf->quirks &= ~s2l_quirks;
435 return gb_svc_dme_peer_set(hd->svc, intf->interface_id, attr,
445 struct gb_interface *intf = to_gb_interface(dev); \
446 return scnprintf(buf, PAGE_SIZE, type"\n", intf->field); \
460 struct gb_interface *intf = to_gb_interface(dev);
464 ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
468 dev_err(&intf->dev, "failed to get voltage sample (%d)\n", ret);
479 struct gb_interface *intf = to_gb_interface(dev);
483 ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
487 dev_err(&intf->dev, "failed to get current sample (%d)\n", ret);
498 struct gb_interface *intf = to_gb_interface(dev);
502 ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
506 dev_err(&intf->dev, "failed to get power sample (%d)\n", ret);
517 struct gb_interface *intf = to_gb_interface(dev);
519 if (intf->active)
529 struct gb_interface *intf = to_gb_interface(dev);
536 mutex_lock(&intf->mutex);
538 if (activate == intf->active)
542 ret = gb_interface_activate(intf);
544 dev_err(&intf->dev,
549 ret = gb_interface_enable(intf);
551 dev_err(&intf->dev,
553 gb_interface_deactivate(intf);
557 gb_interface_disable(intf);
558 gb_interface_deactivate(intf);
562 mutex_unlock(&intf->mutex);
571 static const char *gb_interface_type_string(struct gb_interface *intf)
581 return types[intf->type];
587 struct gb_interface *intf = to_gb_interface(dev);
589 return sprintf(buf, "%s\n", gb_interface_type_string(intf));
624 struct gb_interface *intf = to_gb_interface(dev);
626 switch (intf->type) {
639 struct gb_interface *intf = to_gb_interface(dev);
641 switch (intf->type) {
653 struct gb_interface *intf = to_gb_interface(dev);
655 switch (intf->type) {
693 struct gb_interface *intf = to_gb_interface(dev);
695 trace_gb_interface_release(intf);
697 cancel_work_sync(&intf->mode_switch_work);
698 kfree(intf);
704 struct gb_interface *intf = to_gb_interface(dev);
707 ret = gb_control_interface_suspend_prepare(intf->control);
711 ret = gb_control_suspend(intf->control);
715 ret = gb_interface_hibernate_link(intf);
722 ret = gb_interface_refclk_set(intf, false);
729 gb_control_interface_hibernate_abort(intf->control);
736 struct gb_interface *intf = to_gb_interface(dev);
737 struct gb_svc *svc = intf->hd->svc;
740 ret = gb_interface_refclk_set(intf, true);
744 ret = gb_svc_intf_resume(svc, intf->interface_id);
748 ret = gb_control_resume(intf->control);
791 struct gb_interface *intf;
793 intf = kzalloc(sizeof(*intf), GFP_KERNEL);
794 if (!intf)
797 intf->hd = hd; /* XXX refcount? */
798 intf->module = module;
799 intf->interface_id = interface_id;
800 INIT_LIST_HEAD(&intf->bundles);
801 INIT_LIST_HEAD(&intf->manifest_descs);
802 mutex_init(&intf->mutex);
803 INIT_WORK(&intf->mode_switch_work, gb_interface_mode_switch_work);
804 init_completion(&intf->mode_switch_completion);
807 intf->device_id = GB_INTERFACE_DEVICE_ID_BAD;
809 intf->dev.parent = &module->dev;
810 intf->dev.bus = &greybus_bus_type;
811 intf->dev.type = &greybus_interface_type;
812 intf->dev.groups = interface_groups;
813 intf->dev.dma_mask = module->dev.dma_mask;
814 device_initialize(&intf->dev);
815 dev_set_name(&intf->dev, "%s.%u", dev_name(&module->dev),
818 pm_runtime_set_autosuspend_delay(&intf->dev,
821 trace_gb_interface_create(intf);
823 return intf;
826 static int gb_interface_vsys_set(struct gb_interface *intf, bool enable)
828 struct gb_svc *svc = intf->hd->svc;
831 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
833 ret = gb_svc_intf_vsys_set(svc, intf->interface_id, enable);
835 dev_err(&intf->dev, "failed to set v_sys: %d\n", ret);
842 static int gb_interface_refclk_set(struct gb_interface *intf, bool enable)
844 struct gb_svc *svc = intf->hd->svc;
847 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
849 ret = gb_svc_intf_refclk_set(svc, intf->interface_id, enable);
851 dev_err(&intf->dev, "failed to set refclk: %d\n", ret);
858 static int gb_interface_unipro_set(struct gb_interface *intf, bool enable)
860 struct gb_svc *svc = intf->hd->svc;
863 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
865 ret = gb_svc_intf_unipro_set(svc, intf->interface_id, enable);
867 dev_err(&intf->dev, "failed to set UniPro: %d\n", ret);
874 static int gb_interface_activate_operation(struct gb_interface *intf,
877 struct gb_svc *svc = intf->hd->svc;
881 dev_dbg(&intf->dev, "%s\n", __func__);
883 ret = gb_svc_intf_activate(svc, intf->interface_id, &type);
885 dev_err(&intf->dev, "failed to activate: %d\n", ret);
896 dev_err(&intf->dev, "interface type UniPro not supported\n");
903 dev_err(&intf->dev, "unknown interface type: %u\n", type);
911 static int gb_interface_hibernate_link(struct gb_interface *intf)
913 struct gb_svc *svc = intf->hd->svc;
915 return gb_svc_intf_set_power_mode_hibernate(svc, intf->interface_id);
918 static int _gb_interface_activate(struct gb_interface *intf,
925 if (intf->ejected || intf->removed)
928 ret = gb_interface_vsys_set(intf, true);
932 ret = gb_interface_refclk_set(intf, true);
936 ret = gb_interface_unipro_set(intf, true);
940 ret = gb_interface_activate_operation(intf, type);
951 ret = gb_interface_read_dme(intf);
955 ret = gb_interface_route_create(intf);
959 intf->active = true;
961 trace_gb_interface_activate(intf);
966 gb_interface_hibernate_link(intf);
968 gb_interface_unipro_set(intf, false);
970 gb_interface_refclk_set(intf, false);
972 gb_interface_vsys_set(intf, false);
984 static int _gb_interface_activate_es3_hack(struct gb_interface *intf,
991 ret = _gb_interface_activate(intf, type);
1006 int gb_interface_activate(struct gb_interface *intf)
1011 switch (intf->type) {
1014 ret = _gb_interface_activate_es3_hack(intf, &type);
1017 ret = _gb_interface_activate(intf, &type);
1021 if (intf->type != GB_INTERFACE_TYPE_INVALID) {
1022 if (type != intf->type) {
1023 dev_err(&intf->dev, "failed to detect interface type\n");
1026 gb_interface_deactivate(intf);
1031 intf->type = type;
1042 void gb_interface_deactivate(struct gb_interface *intf)
1044 if (!intf->active)
1047 trace_gb_interface_deactivate(intf);
1050 if (intf->mode_switch)
1051 complete(&intf->mode_switch_completion);
1053 gb_interface_route_destroy(intf);
1054 gb_interface_hibernate_link(intf);
1055 gb_interface_unipro_set(intf, false);
1056 gb_interface_refclk_set(intf, false);
1057 gb_interface_vsys_set(intf, false);
1059 intf->active = false;
1069 int gb_interface_enable(struct gb_interface *intf)
1076 ret = gb_interface_read_and_clear_init_status(intf);
1078 dev_err(&intf->dev, "failed to clear init status: %d\n", ret);
1083 control = gb_control_create(intf);
1085 dev_err(&intf->dev, "failed to create control device: %ld\n",
1089 intf->control = control;
1091 ret = gb_control_enable(intf->control);
1096 size = gb_control_get_manifest_size_operation(intf);
1098 dev_err(&intf->dev, "failed to get manifest size: %d\n", size);
1115 ret = gb_control_get_manifest_operation(intf, manifest, size);
1117 dev_err(&intf->dev, "failed to get manifest: %d\n", ret);
1125 if (!gb_manifest_parse(intf, manifest, size)) {
1126 dev_err(&intf->dev, "failed to parse manifest\n");
1131 ret = gb_control_get_bundle_versions(intf->control);
1136 ret = gb_control_add(intf->control);
1140 pm_runtime_use_autosuspend(&intf->dev);
1141 pm_runtime_get_noresume(&intf->dev);
1142 pm_runtime_set_active(&intf->dev);
1143 pm_runtime_enable(&intf->dev);
1145 list_for_each_entry_safe_reverse(bundle, tmp, &intf->bundles, links) {
1155 intf->enabled = true;
1157 pm_runtime_put(&intf->dev);
1159 trace_gb_interface_enable(intf);
1164 list_for_each_entry_safe(bundle, tmp, &intf->bundles, links)
1169 gb_control_disable(intf->control);
1171 gb_control_put(intf->control);
1172 intf->control = NULL;
1182 void gb_interface_disable(struct gb_interface *intf)
1187 if (!intf->enabled)
1190 trace_gb_interface_disable(intf);
1192 pm_runtime_get_sync(&intf->dev);
1195 if (intf->quirks & GB_INTERFACE_QUIRK_FORCED_DISABLE)
1196 intf->disconnected = true;
1198 list_for_each_entry_safe(bundle, next, &intf->bundles, links)
1201 if (!intf->mode_switch && !intf->disconnected)
1202 gb_control_interface_deactivate_prepare(intf->control);
1204 gb_control_del(intf->control);
1205 gb_control_disable(intf->control);
1206 gb_control_put(intf->control);
1207 intf->control = NULL;
1209 intf->enabled = false;
1211 pm_runtime_disable(&intf->dev);
1212 pm_runtime_set_suspended(&intf->dev);
1213 pm_runtime_dont_use_autosuspend(&intf->dev);
1214 pm_runtime_put_noidle(&intf->dev);
1218 int gb_interface_add(struct gb_interface *intf)
1222 ret = device_add(&intf->dev);
1224 dev_err(&intf->dev, "failed to register interface: %d\n", ret);
1228 trace_gb_interface_add(intf);
1230 dev_info(&intf->dev, "Interface added (%s)\n",
1231 gb_interface_type_string(intf));
1233 switch (intf->type) {
1235 dev_info(&intf->dev, "GMP VID=0x%08x, PID=0x%08x\n",
1236 intf->vendor_id, intf->product_id);
1239 dev_info(&intf->dev, "DDBL1 Manufacturer=0x%08x, Product=0x%08x\n",
1240 intf->ddbl1_manufacturer_id,
1241 intf->ddbl1_product_id);
1251 void gb_interface_del(struct gb_interface *intf)
1253 if (device_is_registered(&intf->dev)) {
1254 trace_gb_interface_del(intf);
1256 device_del(&intf->dev);
1257 dev_info(&intf->dev, "Interface removed\n");
1261 void gb_interface_put(struct gb_interface *intf)
1263 put_device(&intf->dev);