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 kfree(intf);
703 struct gb_interface *intf = to_gb_interface(dev);
706 ret = gb_control_interface_suspend_prepare(intf->control);
710 ret = gb_control_suspend(intf->control);
714 ret = gb_interface_hibernate_link(intf);
721 ret = gb_interface_refclk_set(intf, false);
728 gb_control_interface_hibernate_abort(intf->control);
735 struct gb_interface *intf = to_gb_interface(dev);
736 struct gb_svc *svc = intf->hd->svc;
739 ret = gb_interface_refclk_set(intf, true);
743 ret = gb_svc_intf_resume(svc, intf->interface_id);
747 ret = gb_control_resume(intf->control);
790 struct gb_interface *intf;
792 intf = kzalloc(sizeof(*intf), GFP_KERNEL);
793 if (!intf)
796 intf->hd = hd; /* XXX refcount? */
797 intf->module = module;
798 intf->interface_id = interface_id;
799 INIT_LIST_HEAD(&intf->bundles);
800 INIT_LIST_HEAD(&intf->manifest_descs);
801 mutex_init(&intf->mutex);
802 INIT_WORK(&intf->mode_switch_work, gb_interface_mode_switch_work);
803 init_completion(&intf->mode_switch_completion);
806 intf->device_id = GB_INTERFACE_DEVICE_ID_BAD;
808 intf->dev.parent = &module->dev;
809 intf->dev.bus = &greybus_bus_type;
810 intf->dev.type = &greybus_interface_type;
811 intf->dev.groups = interface_groups;
812 intf->dev.dma_mask = module->dev.dma_mask;
813 device_initialize(&intf->dev);
814 dev_set_name(&intf->dev, "%s.%u", dev_name(&module->dev),
817 pm_runtime_set_autosuspend_delay(&intf->dev,
820 trace_gb_interface_create(intf);
822 return intf;
825 static int gb_interface_vsys_set(struct gb_interface *intf, bool enable)
827 struct gb_svc *svc = intf->hd->svc;
830 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
832 ret = gb_svc_intf_vsys_set(svc, intf->interface_id, enable);
834 dev_err(&intf->dev, "failed to set v_sys: %d\n", ret);
841 static int gb_interface_refclk_set(struct gb_interface *intf, bool enable)
843 struct gb_svc *svc = intf->hd->svc;
846 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
848 ret = gb_svc_intf_refclk_set(svc, intf->interface_id, enable);
850 dev_err(&intf->dev, "failed to set refclk: %d\n", ret);
857 static int gb_interface_unipro_set(struct gb_interface *intf, bool enable)
859 struct gb_svc *svc = intf->hd->svc;
862 dev_dbg(&intf->dev, "%s - %d\n", __func__, enable);
864 ret = gb_svc_intf_unipro_set(svc, intf->interface_id, enable);
866 dev_err(&intf->dev, "failed to set UniPro: %d\n", ret);
873 static int gb_interface_activate_operation(struct gb_interface *intf,
876 struct gb_svc *svc = intf->hd->svc;
880 dev_dbg(&intf->dev, "%s\n", __func__);
882 ret = gb_svc_intf_activate(svc, intf->interface_id, &type);
884 dev_err(&intf->dev, "failed to activate: %d\n", ret);
895 dev_err(&intf->dev, "interface type UniPro not supported\n");
902 dev_err(&intf->dev, "unknown interface type: %u\n", type);
910 static int gb_interface_hibernate_link(struct gb_interface *intf)
912 struct gb_svc *svc = intf->hd->svc;
914 return gb_svc_intf_set_power_mode_hibernate(svc, intf->interface_id);
917 static int _gb_interface_activate(struct gb_interface *intf,
924 if (intf->ejected || intf->removed)
927 ret = gb_interface_vsys_set(intf, true);
931 ret = gb_interface_refclk_set(intf, true);
935 ret = gb_interface_unipro_set(intf, true);
939 ret = gb_interface_activate_operation(intf, type);
950 ret = gb_interface_read_dme(intf);
954 ret = gb_interface_route_create(intf);
958 intf->active = true;
960 trace_gb_interface_activate(intf);
965 gb_interface_hibernate_link(intf);
967 gb_interface_unipro_set(intf, false);
969 gb_interface_refclk_set(intf, false);
971 gb_interface_vsys_set(intf, false);
983 static int _gb_interface_activate_es3_hack(struct gb_interface *intf,
990 ret = _gb_interface_activate(intf, type);
1005 int gb_interface_activate(struct gb_interface *intf)
1010 switch (intf->type) {
1013 ret = _gb_interface_activate_es3_hack(intf, &type);
1016 ret = _gb_interface_activate(intf, &type);
1020 if (intf->type != GB_INTERFACE_TYPE_INVALID) {
1021 if (type != intf->type) {
1022 dev_err(&intf->dev, "failed to detect interface type\n");
1025 gb_interface_deactivate(intf);
1030 intf->type = type;
1041 void gb_interface_deactivate(struct gb_interface *intf)
1043 if (!intf->active)
1046 trace_gb_interface_deactivate(intf);
1049 if (intf->mode_switch)
1050 complete(&intf->mode_switch_completion);
1052 gb_interface_route_destroy(intf);
1053 gb_interface_hibernate_link(intf);
1054 gb_interface_unipro_set(intf, false);
1055 gb_interface_refclk_set(intf, false);
1056 gb_interface_vsys_set(intf, false);
1058 intf->active = false;
1068 int gb_interface_enable(struct gb_interface *intf)
1075 ret = gb_interface_read_and_clear_init_status(intf);
1077 dev_err(&intf->dev, "failed to clear init status: %d\n", ret);
1082 control = gb_control_create(intf);
1084 dev_err(&intf->dev, "failed to create control device: %ld\n",
1088 intf->control = control;
1090 ret = gb_control_enable(intf->control);
1095 size = gb_control_get_manifest_size_operation(intf);
1097 dev_err(&intf->dev, "failed to get manifest size: %d\n", size);
1114 ret = gb_control_get_manifest_operation(intf, manifest, size);
1116 dev_err(&intf->dev, "failed to get manifest: %d\n", ret);
1124 if (!gb_manifest_parse(intf, manifest, size)) {
1125 dev_err(&intf->dev, "failed to parse manifest\n");
1130 ret = gb_control_get_bundle_versions(intf->control);
1135 ret = gb_control_add(intf->control);
1139 pm_runtime_use_autosuspend(&intf->dev);
1140 pm_runtime_get_noresume(&intf->dev);
1141 pm_runtime_set_active(&intf->dev);
1142 pm_runtime_enable(&intf->dev);
1144 list_for_each_entry_safe_reverse(bundle, tmp, &intf->bundles, links) {
1154 intf->enabled = true;
1156 pm_runtime_put(&intf->dev);
1158 trace_gb_interface_enable(intf);
1163 list_for_each_entry_safe(bundle, tmp, &intf->bundles, links)
1168 gb_control_disable(intf->control);
1170 gb_control_put(intf->control);
1171 intf->control = NULL;
1181 void gb_interface_disable(struct gb_interface *intf)
1186 if (!intf->enabled)
1189 trace_gb_interface_disable(intf);
1191 pm_runtime_get_sync(&intf->dev);
1194 if (intf->quirks & GB_INTERFACE_QUIRK_FORCED_DISABLE)
1195 intf->disconnected = true;
1197 list_for_each_entry_safe(bundle, next, &intf->bundles, links)
1200 if (!intf->mode_switch && !intf->disconnected)
1201 gb_control_interface_deactivate_prepare(intf->control);
1203 gb_control_del(intf->control);
1204 gb_control_disable(intf->control);
1205 gb_control_put(intf->control);
1206 intf->control = NULL;
1208 intf->enabled = false;
1210 pm_runtime_disable(&intf->dev);
1211 pm_runtime_set_suspended(&intf->dev);
1212 pm_runtime_dont_use_autosuspend(&intf->dev);
1213 pm_runtime_put_noidle(&intf->dev);
1217 int gb_interface_add(struct gb_interface *intf)
1221 ret = device_add(&intf->dev);
1223 dev_err(&intf->dev, "failed to register interface: %d\n", ret);
1227 trace_gb_interface_add(intf);
1229 dev_info(&intf->dev, "Interface added (%s)\n",
1230 gb_interface_type_string(intf));
1232 switch (intf->type) {
1234 dev_info(&intf->dev, "GMP VID=0x%08x, PID=0x%08x\n",
1235 intf->vendor_id, intf->product_id);
1238 dev_info(&intf->dev, "DDBL1 Manufacturer=0x%08x, Product=0x%08x\n",
1239 intf->ddbl1_manufacturer_id,
1240 intf->ddbl1_product_id);
1250 void gb_interface_del(struct gb_interface *intf)
1252 if (device_is_registered(&intf->dev)) {
1253 trace_gb_interface_del(intf);
1255 device_del(&intf->dev);
1256 dev_info(&intf->dev, "Interface removed\n");
1260 void gb_interface_put(struct gb_interface *intf)
1262 put_device(&intf->dev);