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;
137 dev_err(&intf->dev, "failed to allocate device id: %d\n", ret);
144 dev_err(&intf->dev, "failed to set device id %u: %d\n",
153 dev_err(&intf->dev, "failed to create route: %d\n", ret);
157 intf->device_id = device_id;
172 static void gb_interface_route_destroy(struct gb_interface *intf)
174 struct gb_svc *svc = intf->hd->svc;
176 if (intf->device_id == GB_INTERFACE_DEVICE_ID_BAD)
179 gb_svc_route_destroy(svc, svc->ap_intf_id, intf->interface_id);
180 ida_free(&svc->device_id_map, intf->device_id);
181 intf->device_id = GB_INTERFACE_DEVICE_ID_BAD;
185 static int gb_interface_legacy_mode_switch(struct gb_interface *intf)
189 dev_info(&intf->dev, "legacy mode switch detected\n");
192 intf->disconnected = true;
193 gb_interface_disable(intf);
194 intf->disconnected = false;
196 ret = gb_interface_enable(intf);
198 dev_err(&intf->dev, "failed to re-enable interface: %d\n", ret);
199 gb_interface_deactivate(intf);
205 void gb_interface_mailbox_event(struct gb_interface *intf, u16 result,
208 mutex_lock(&intf->mutex);
211 dev_warn(&intf->dev,
218 dev_warn(&intf->dev,
224 if (intf->quirks & GB_INTERFACE_QUIRK_LEGACY_MODE_SWITCH) {
225 gb_interface_legacy_mode_switch(intf);
229 if (!intf->mode_switch) {
230 dev_warn(&intf->dev, "unexpected mailbox event: 0x%08x\n",
235 dev_info(&intf->dev, "mode switch detected\n");
237 complete(&intf->mode_switch_completion);
240 mutex_unlock(&intf->mutex);
245 gb_interface_disable(intf);
246 gb_interface_deactivate(intf);
247 mutex_unlock(&intf->mutex);
252 struct gb_interface *intf;
257 intf = container_of(work, struct gb_interface, mode_switch_work);
259 mutex_lock(&intf->mutex);
261 if (!intf->enabled) {
262 dev_dbg(&intf->dev, "mode switch aborted\n");
263 intf->mode_switch = false;
264 mutex_unlock(&intf->mutex);
272 control = gb_control_get(intf->control);
274 gb_interface_disable(intf);
275 mutex_unlock(&intf->mutex);
279 &intf->mode_switch_completion, timeout);
286 dev_err(&intf->dev, "mode switch interrupted\n");
289 dev_err(&intf->dev, "mode switch timed out\n");
294 mutex_lock(&intf->mutex);
295 intf->mode_switch = false;
296 if (intf->active) {
297 ret = gb_interface_enable(intf);
299 dev_err(&intf->dev, "failed to re-enable interface: %d\n",
301 gb_interface_deactivate(intf);
304 mutex_unlock(&intf->mutex);
307 gb_interface_put(intf);
312 mutex_lock(&intf->mutex);
313 intf->mode_switch = false;
314 gb_interface_deactivate(intf);
315 mutex_unlock(&intf->mutex);
317 gb_interface_put(intf);
320 int gb_interface_request_mode_switch(struct gb_interface *intf)
324 mutex_lock(&intf->mutex);
325 if (intf->mode_switch) {
330 intf->mode_switch = true;
331 reinit_completion(&intf->mode_switch_completion);
337 get_device(&intf->dev);
339 if (!queue_work(system_long_wq, &intf->mode_switch_work)) {
340 put_device(&intf->dev);
346 mutex_unlock(&intf->mutex);
360 static int gb_interface_read_and_clear_init_status(struct gb_interface *intf)
362 struct gb_host_device *hd = intf->hd;
375 if (intf->quirks & GB_INTERFACE_QUIRK_NO_INIT_STATUS)
380 ret = gb_svc_dme_peer_get(hd->svc, intf->interface_id, attr,
390 dev_err(&intf->dev, "invalid init status\n");
402 if (intf->quirks & GB_INTERFACE_QUIRK_NO_INIT_STATUS)
421 intf->quirks |= bootrom_quirks;
425 intf->quirks &= ~bootrom_quirks;
426 intf->quirks |= s2l_quirks;
429 intf->quirks &= ~bootrom_quirks;
430 intf->quirks &= ~s2l_quirks;
434 return gb_svc_dme_peer_set(hd->svc, intf->interface_id, attr,
444 struct gb_interface *intf = to_gb_interface(dev); \
445 return scnprintf(buf, PAGE_SIZE, type"\n", intf->field); \
459 struct gb_interface *intf = to_gb_interface(dev);
463 ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
467 dev_err(&intf->dev, "failed to get voltage sample (%d)\n", ret);
478 struct gb_interface *intf = to_gb_interface(dev);
482 ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
486 dev_err(&intf->dev, "failed to get current sample (%d)\n", ret);
497 struct gb_interface *intf = to_gb_interface(dev);
501 ret = gb_svc_pwrmon_intf_sample_get(intf->hd->svc, intf->interface_id,
505 dev_err(&intf->dev, "failed to get power sample (%d)\n", ret);
516 struct gb_interface *intf = to_gb_interface(dev);
518 if (intf->active)
528 struct gb_interface *intf = to_gb_interface(dev);
535 mutex_lock(&intf->mutex);
537 if (activate == intf->active)
541 ret = gb_interface_activate(intf);
543 dev_err(&intf->dev,
548 ret = gb_interface_enable(intf);
550 dev_err(&intf->dev,
552 gb_interface_deactivate(intf);
556 gb_interface_disable(intf);
557 gb_interface_deactivate(intf);
561 mutex_unlock(&intf->mutex);
570 static const char *gb_interface_type_string(struct gb_interface *intf)
580 return types[intf->type];
586 struct gb_interface *intf = to_gb_interface(dev);
588 return sprintf(buf, "%s\n", gb_interface_type_string(intf));
623 struct gb_interface *intf = to_gb_interface(dev);
625 switch (intf->type) {
638 struct gb_interface *intf = to_gb_interface(dev);
640 switch (intf->type) {
652 struct gb_interface *intf = to_gb_interface(dev);
654 switch (intf->type) {
692 struct gb_interface *intf = to_gb_interface(dev);
694 trace_gb_interface_release(intf);
696 kfree(intf);
702 struct gb_interface *intf = to_gb_interface(dev);
705 ret = gb_control_interface_suspend_prepare(intf->control);
709 ret = gb_control_suspend(intf->control);
713 ret = gb_interface_hibernate_link(intf);
720 ret = gb_interface_refclk_set(intf, false);
727 gb_control_interface_hibernate_abort(intf->control);
734 struct gb_interface *intf = to_gb_interface(dev);
735 struct gb_svc *svc = intf->hd->svc;
738 ret = gb_interface_refclk_set(intf, true);
742 ret = gb_svc_intf_resume(svc, intf->interface_id);
746 ret = gb_control_resume(intf->control);
789 struct gb_interface *intf;
791 intf = kzalloc(sizeof(*intf), GFP_KERNEL);
792 if (!intf)
795 intf->hd = hd; /* XXX refcount? */
796 intf->module = module;
797 intf->interface_id = interface_id;
798 INIT_LIST_HEAD(&intf->bundles);
799 INIT_LIST_HEAD(&intf->manifest_descs);
800 mutex_init(&intf->mutex);
801 INIT_WORK(&intf->mode_switch_work, gb_interface_mode_switch_work);
802 init_completion(&intf->mode_switch_completion);
805 intf->device_id = GB_INTERFACE_DEVICE_ID_BAD;
807 intf->dev.parent = &module->dev;
808 intf->dev.bus = &greybus_bus_type;
809 intf->dev.type = &greybus_interface_type;
810 intf->dev.groups = interface_groups;
811 intf->dev.dma_mask = module->dev.dma_mask;
812 device_initialize(&intf->dev);
813 dev_set_name(&intf->dev, "%s.%u", dev_name(&module->dev),
816 pm_runtime_set_autosuspend_delay(&intf->dev,
819 trace_gb_interface_create(intf);
821 return intf;
824 static int gb_interface_vsys_set(struct gb_interface *intf, bool enable)
826 struct gb_svc *svc = intf->hd->svc;
829 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
831 ret = gb_svc_intf_vsys_set(svc, intf->interface_id, enable);
833 dev_err(&intf->dev, "failed to set v_sys: %d\n", ret);
840 static int gb_interface_refclk_set(struct gb_interface *intf, bool enable)
842 struct gb_svc *svc = intf->hd->svc;
845 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
847 ret = gb_svc_intf_refclk_set(svc, intf->interface_id, enable);
849 dev_err(&intf->dev, "failed to set refclk: %d\n", ret);
856 static int gb_interface_unipro_set(struct gb_interface *intf, bool enable)
858 struct gb_svc *svc = intf->hd->svc;
861 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
863 ret = gb_svc_intf_unipro_set(svc, intf->interface_id, enable);
865 dev_err(&intf->dev, "failed to set UniPro: %d\n", ret);
872 static int gb_interface_activate_operation(struct gb_interface *intf,
875 struct gb_svc *svc = intf->hd->svc;
879 dev_dbg(&intf->dev, "%s\n", __func__);
881 ret = gb_svc_intf_activate(svc, intf->interface_id, &type);
883 dev_err(&intf->dev, "failed to activate: %d\n", ret);
894 dev_err(&intf->dev, "interface type UniPro not supported\n");
901 dev_err(&intf->dev, "unknown interface type: %u\n", type);
909 static int gb_interface_hibernate_link(struct gb_interface *intf)
911 struct gb_svc *svc = intf->hd->svc;
913 return gb_svc_intf_set_power_mode_hibernate(svc, intf->interface_id);
916 static int _gb_interface_activate(struct gb_interface *intf,
923 if (intf->ejected || intf->removed)
926 ret = gb_interface_vsys_set(intf, true);
930 ret = gb_interface_refclk_set(intf, true);
934 ret = gb_interface_unipro_set(intf, true);
938 ret = gb_interface_activate_operation(intf, type);
949 ret = gb_interface_read_dme(intf);
953 ret = gb_interface_route_create(intf);
957 intf->active = true;
959 trace_gb_interface_activate(intf);
964 gb_interface_hibernate_link(intf);
966 gb_interface_unipro_set(intf, false);
968 gb_interface_refclk_set(intf, false);
970 gb_interface_vsys_set(intf, false);
982 static int _gb_interface_activate_es3_hack(struct gb_interface *intf,
989 ret = _gb_interface_activate(intf, type);
1004 int gb_interface_activate(struct gb_interface *intf)
1009 switch (intf->type) {
1012 ret = _gb_interface_activate_es3_hack(intf, &type);
1015 ret = _gb_interface_activate(intf, &type);
1019 if (intf->type != GB_INTERFACE_TYPE_INVALID) {
1020 if (type != intf->type) {
1021 dev_err(&intf->dev, "failed to detect interface type\n");
1024 gb_interface_deactivate(intf);
1029 intf->type = type;
1040 void gb_interface_deactivate(struct gb_interface *intf)
1042 if (!intf->active)
1045 trace_gb_interface_deactivate(intf);
1048 if (intf->mode_switch)
1049 complete(&intf->mode_switch_completion);
1051 gb_interface_route_destroy(intf);
1052 gb_interface_hibernate_link(intf);
1053 gb_interface_unipro_set(intf, false);
1054 gb_interface_refclk_set(intf, false);
1055 gb_interface_vsys_set(intf, false);
1057 intf->active = false;
1067 int gb_interface_enable(struct gb_interface *intf)
1074 ret = gb_interface_read_and_clear_init_status(intf);
1076 dev_err(&intf->dev, "failed to clear init status: %d\n", ret);
1081 control = gb_control_create(intf);
1083 dev_err(&intf->dev, "failed to create control device: %ld\n",
1087 intf->control = control;
1089 ret = gb_control_enable(intf->control);
1094 size = gb_control_get_manifest_size_operation(intf);
1096 dev_err(&intf->dev, "failed to get manifest size: %d\n", size);
1113 ret = gb_control_get_manifest_operation(intf, manifest, size);
1115 dev_err(&intf->dev, "failed to get manifest: %d\n", ret);
1123 if (!gb_manifest_parse(intf, manifest, size)) {
1124 dev_err(&intf->dev, "failed to parse manifest\n");
1129 ret = gb_control_get_bundle_versions(intf->control);
1134 ret = gb_control_add(intf->control);
1138 pm_runtime_use_autosuspend(&intf->dev);
1139 pm_runtime_get_noresume(&intf->dev);
1140 pm_runtime_set_active(&intf->dev);
1141 pm_runtime_enable(&intf->dev);
1143 list_for_each_entry_safe_reverse(bundle, tmp, &intf->bundles, links) {
1153 intf->enabled = true;
1155 pm_runtime_put(&intf->dev);
1157 trace_gb_interface_enable(intf);
1162 list_for_each_entry_safe(bundle, tmp, &intf->bundles, links)
1167 gb_control_disable(intf->control);
1169 gb_control_put(intf->control);
1170 intf->control = NULL;
1180 void gb_interface_disable(struct gb_interface *intf)
1185 if (!intf->enabled)
1188 trace_gb_interface_disable(intf);
1190 pm_runtime_get_sync(&intf->dev);
1193 if (intf->quirks & GB_INTERFACE_QUIRK_FORCED_DISABLE)
1194 intf->disconnected = true;
1196 list_for_each_entry_safe(bundle, next, &intf->bundles, links)
1199 if (!intf->mode_switch && !intf->disconnected)
1200 gb_control_interface_deactivate_prepare(intf->control);
1202 gb_control_del(intf->control);
1203 gb_control_disable(intf->control);
1204 gb_control_put(intf->control);
1205 intf->control = NULL;
1207 intf->enabled = false;
1209 pm_runtime_disable(&intf->dev);
1210 pm_runtime_set_suspended(&intf->dev);
1211 pm_runtime_dont_use_autosuspend(&intf->dev);
1212 pm_runtime_put_noidle(&intf->dev);
1216 int gb_interface_add(struct gb_interface *intf)
1220 ret = device_add(&intf->dev);
1222 dev_err(&intf->dev, "failed to register interface: %d\n", ret);
1226 trace_gb_interface_add(intf);
1228 dev_info(&intf->dev, "Interface added (%s)\n",
1229 gb_interface_type_string(intf));
1231 switch (intf->type) {
1233 dev_info(&intf->dev, "GMP VID=0x%08x, PID=0x%08x\n",
1234 intf->vendor_id, intf->product_id);
1237 dev_info(&intf->dev, "DDBL1 Manufacturer=0x%08x, Product=0x%08x\n",
1238 intf->ddbl1_manufacturer_id,
1239 intf->ddbl1_product_id);
1249 void gb_interface_del(struct gb_interface *intf)
1251 if (device_is_registered(&intf->dev)) {
1252 trace_gb_interface_del(intf);
1254 device_del(&intf->dev);
1255 dev_info(&intf->dev, "Interface removed\n");
1259 void gb_interface_put(struct gb_interface *intf)
1261 put_device(&intf->dev);