#define SVC_INTF_EJECT_TIMEOUT 9000
#define SVC_INTF_ACTIVATE_TIMEOUT 6000
-#define SVC_INTF_RESUME_TIMEOUT 3000
+#define SVC_INTF_RESUME_TIMEOUT 3000
struct gb_svc_deferred_request {
struct work_struct work;
}
static DEVICE_ATTR_RW(watchdog);
+static ssize_t watchdog_action_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+{
+ struct gb_svc *svc = to_gb_svc(dev);
+
+ if (svc->action == GB_SVC_WATCHDOG_BITE_PANIC_KERNEL)
+ return sprintf(buf, "panic\n");
+ else if (svc->action == GB_SVC_WATCHDOG_BITE_RESET_UNIPRO)
+ return sprintf(buf, "reset\n");
+
+ return -EINVAL;
+}
+
+static ssize_t watchdog_action_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t len)
+{
+ struct gb_svc *svc = to_gb_svc(dev);
+
+ if (sysfs_streq(buf, "panic"))
+ svc->action = GB_SVC_WATCHDOG_BITE_PANIC_KERNEL;
+ else if (sysfs_streq(buf, "reset"))
+ svc->action = GB_SVC_WATCHDOG_BITE_RESET_UNIPRO;
+ else
+ return -EINVAL;
+
+ return len;
+}
+static DEVICE_ATTR_RW(watchdog_action);
+
static int gb_svc_pwrmon_rail_count_get(struct gb_svc *svc, u8 *value)
{
struct gb_svc_pwrmon_rail_count_get_response response;
&dev_attr_ap_intf_id.attr,
&dev_attr_intf_eject.attr,
&dev_attr_watchdog.attr,
+ &dev_attr_watchdog_action.attr,
NULL,
};
ATTRIBUTE_GROUPS(svc);
return 0;
}
-EXPORT_SYMBOL_GPL(gb_svc_dme_peer_get);
int gb_svc_dme_peer_set(struct gb_svc *svc, u8 intf_id, u16 attr, u16 selector,
u32 value)
return 0;
}
-EXPORT_SYMBOL_GPL(gb_svc_dme_peer_set);
int gb_svc_connection_create(struct gb_svc *svc,
u8 intf1_id, u16 cport1_id,
return gb_operation_sync(svc->connection, GB_SVC_TYPE_CONN_CREATE,
&request, sizeof(request), NULL, 0);
}
-EXPORT_SYMBOL_GPL(gb_svc_connection_create);
-
-void gb_svc_connection_quiescing(struct gb_svc *svc, u8 intf1_id, u16 cport1_id,
- u8 intf2_id, u16 cport2_id)
-{
- struct gb_svc_conn_quiescing_request request;
- struct gb_svc_conn_quiescing_response response;
- int ret;
-
- dev_dbg(&svc->dev, "%s - (%u:%u %u:%u)\n", __func__,
- intf1_id, cport1_id, intf2_id, cport2_id);
-
- request.intf1_id = intf1_id;
- request.cport1_id = cpu_to_le16(cport1_id);
- request.intf2_id = intf2_id;
- request.cport2_id = cpu_to_le16(cport2_id);
-
- ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_CONN_QUIESCING,
- &request, sizeof(request),
- &response, sizeof(response));
- if (ret < 0)
- return;
- if (response.status != GB_SVC_OP_SUCCESS) {
- dev_err(&svc->dev, "quiescing connection failed (%u:%u %u:%u): %u\n",
- intf1_id, cport1_id, intf2_id, cport2_id,
- response.status);
- return;
- }
-
- return;
-}
-EXPORT_SYMBOL_GPL(gb_svc_connection_quiescing);
void gb_svc_connection_destroy(struct gb_svc *svc, u8 intf1_id, u16 cport1_id,
u8 intf2_id, u16 cport2_id)
intf1_id, cport1_id, intf2_id, cport2_id, ret);
}
}
-EXPORT_SYMBOL_GPL(gb_svc_connection_destroy);
int gb_svc_timesync_enable(struct gb_svc *svc, u8 count, u64 frame_time,
u32 strobe_delay, u32 refclk)
GB_SVC_TYPE_TIMESYNC_ENABLE,
&request, sizeof(request), NULL, 0);
}
-EXPORT_SYMBOL_GPL(gb_svc_timesync_enable);
int gb_svc_timesync_disable(struct gb_svc *svc)
{
GB_SVC_TYPE_TIMESYNC_DISABLE,
NULL, 0, NULL, 0);
}
-EXPORT_SYMBOL_GPL(gb_svc_timesync_disable);
int gb_svc_timesync_authoritative(struct gb_svc *svc, u64 *frame_time)
{
frame_time[i] = le64_to_cpu(response.frame_time[i]);
return 0;
}
-EXPORT_SYMBOL_GPL(gb_svc_timesync_authoritative);
int gb_svc_timesync_ping(struct gb_svc *svc, u64 *frame_time)
{
*frame_time = le64_to_cpu(response.frame_time);
return 0;
}
-EXPORT_SYMBOL_GPL(gb_svc_timesync_ping);
int gb_svc_timesync_wake_pins_acquire(struct gb_svc *svc, u32 strobe_mask)
{
&request, sizeof(request),
NULL, 0);
}
-EXPORT_SYMBOL_GPL(gb_svc_timesync_wake_pins_acquire);
int gb_svc_timesync_wake_pins_release(struct gb_svc *svc)
{
GB_SVC_TYPE_TIMESYNC_WAKE_PINS_RELEASE,
NULL, 0, NULL, 0);
}
-EXPORT_SYMBOL_GPL(gb_svc_timesync_wake_pins_release);
/* Creates bi-directional routes between the devices */
int gb_svc_route_create(struct gb_svc *svc, u8 intf1_id, u8 dev1_id,
}
EXPORT_SYMBOL_GPL(gb_svc_intf_set_power_mode);
+int gb_svc_intf_set_power_mode_hibernate(struct gb_svc *svc, u8 intf_id)
+{
+ struct gb_svc_intf_set_pwrm_request request;
+ struct gb_svc_intf_set_pwrm_response response;
+ int ret;
+ u16 result_code;
+
+ memset(&request, 0, sizeof(request));
+
+ request.intf_id = intf_id;
+ request.hs_series = GB_SVC_UNIPRO_HS_SERIES_A;
+ request.tx_mode = GB_SVC_UNIPRO_HIBERNATE_MODE;
+ request.rx_mode = GB_SVC_UNIPRO_HIBERNATE_MODE;
+
+ ret = gb_operation_sync(svc->connection, GB_SVC_TYPE_INTF_SET_PWRM,
+ &request, sizeof(request),
+ &response, sizeof(response));
+ if (ret < 0) {
+ dev_err(&svc->dev,
+ "failed to send set power mode operation to interface %u: %d\n",
+ intf_id, ret);
+ return ret;
+ }
+
+ result_code = response.result_code;
+ if (result_code != GB_SVC_SETPWRM_PWR_OK) {
+ dev_err(&svc->dev,
+ "failed to hibernate the link for interface %u: %u\n",
+ intf_id, result_code);
+ return -EIO;
+ }
+
+ return 0;
+}
+
int gb_svc_ping(struct gb_svc *svc)
{
return gb_operation_sync_timeout(svc->connection, GB_SVC_TYPE_PING,
NULL, 0, NULL, 0,
GB_OPERATION_TIMEOUT_DEFAULT * 2);
}
-EXPORT_SYMBOL_GPL(gb_svc_ping);
static int gb_svc_version_request(struct gb_operation *op)
{
gb_module_put(module);
}
+static void gb_svc_process_intf_oops(struct gb_operation *operation)
+{
+ struct gb_svc_intf_oops_request *request;
+ struct gb_connection *connection = operation->connection;
+ struct gb_svc *svc = gb_connection_get_data(connection);
+ struct gb_interface *intf;
+ u8 intf_id;
+ u8 reason;
+
+ /* The request message size has already been verified. */
+ request = operation->request->payload;
+ intf_id = request->intf_id;
+ reason = request->reason;
+
+ intf = gb_svc_interface_lookup(svc, intf_id);
+ if (!intf) {
+ dev_warn(&svc->dev, "unexpected interface-oops event %u\n",
+ intf_id);
+ return;
+ }
+
+ dev_info(&svc->dev, "Deactivating interface %u, interface oops reason = %u\n",
+ intf_id, reason);
+
+ mutex_lock(&intf->mutex);
+ intf->disconnected = true;
+ gb_interface_disable(intf);
+ gb_interface_deactivate(intf);
+ mutex_unlock(&intf->mutex);
+}
+
static void gb_svc_process_intf_mailbox_event(struct gb_operation *operation)
{
struct gb_svc_intf_mailbox_event_request *request;
case GB_SVC_TYPE_INTF_MAILBOX_EVENT:
gb_svc_process_intf_mailbox_event(operation);
break;
+ case GB_SVC_TYPE_INTF_OOPS:
+ gb_svc_process_intf_oops(operation);
+ break;
default:
dev_err(&svc->dev, "bad deferred request type: 0x%02x\n", type);
}
return gb_svc_queue_deferred_request(op);
}
+static int gb_svc_intf_oops_recv(struct gb_operation *op)
+{
+ struct gb_svc *svc = gb_connection_get_data(op->connection);
+ struct gb_svc_intf_oops_request *request;
+
+ if (op->request->payload_size < sizeof(*request)) {
+ dev_warn(&svc->dev, "short intf-oops request received (%zu < %zu)\n",
+ op->request->payload_size, sizeof(*request));
+ return -EINVAL;
+ }
+
+ return gb_svc_queue_deferred_request(op);
+}
+
static int gb_svc_intf_mailbox_event_recv(struct gb_operation *op)
{
struct gb_svc *svc = gb_connection_get_data(op->connection);
return gb_svc_module_removed_recv(op);
case GB_SVC_TYPE_INTF_MAILBOX_EVENT:
return gb_svc_intf_mailbox_event_recv(op);
+ case GB_SVC_TYPE_INTF_OOPS:
+ return gb_svc_intf_oops_recv(op);
default:
dev_warn(&svc->dev, "unsupported request 0x%02x\n", type);
return -EINVAL;
projects / cascardo / linux.git / blobdiff