static void mcl_connected(struct mcap_mcl *mcap_mcl, gpointer data)
{
printf("%s\n", __func__);
if (mcl) {
mcap_sync_stop(mcl);
mcap_mcl_unref(mcl);
}
mcl = mcap_mcl_ref(mcap_mcl);
trigger_mdl_action(data_mode);
}
gboolean mcap_create_mdl(struct mcap_mcl *mcl,
uint8_t mdepid,
uint8_t conf,
mcap_mdl_operation_conf_cb connect_cb,
gpointer user_data,
GDestroyNotify destroy,
GError **err)
{
struct mcap_mdl *mdl;
struct mcap_mdl_op_cb *con;
mcap_md_create_mdl_req *cmd;
uint16_t id;
id = generate_mdlid(mcl);
if (!id) {
g_set_error(err, MCAP_ERROR, MCAP_ERROR_FAILED,
"Not more mdlids available");
return FALSE;
}
mdl = g_new0(struct mcap_mdl, 1);
mdl->mcl = mcap_mcl_ref(mcl);
mdl->mdlid = id;
mdl->mdep_id = mdepid;
mdl->state = MDL_WAITING;
con = g_new0(struct mcap_mdl_op_cb, 1);
con->mdl = mcap_mdl_ref(mdl);
con->cb.op_conf = connect_cb;
con->destroy = destroy;
con->user_data = user_data;
cmd = create_mdl_req(id, mdepid, conf);
if (!mcap_send_std_opcode(mcl, cmd, sizeof(mcap_md_create_mdl_req),
err)) {
mcap_mdl_unref(con->mdl);
g_free(con);
g_free(cmd);
return FALSE;
}
mcl->state = MCL_ACTIVE;
mcl->priv_data = con;
mcl->mdls = g_slist_insert_sorted(mcl->mdls, mcap_mdl_ref(mdl),
compare_mdl);
mcl->tid = g_timeout_add_seconds(RESPONSE_TIMER, wait_response_timer,
mcl);
return TRUE;
}
static void create_mcl_cb(struct mcap_mcl *mcl, GError *err, gpointer data)
{
struct conn_mcl_data *conn_data = data;
struct hdp_device *device = conn_data->dev;
GError *gerr = NULL;
if (err != NULL) {
conn_data->func(conn_data->data, err);
return;
}
if (device->mcl == NULL)
device->mcl = mcap_mcl_ref(mcl);
device->mcl_conn = TRUE;
hdp_set_mcl_cb(device, &gerr);
conn_data->func(conn_data->data, gerr);
if (gerr != NULL)
g_error_free(gerr);
}
static void create_mcl_cb(struct mcap_mcl *mcap_mcl, GError *err, gpointer data)
{
printf("%s\n", __func__);
if (err) {
printf("Could not connect MCL: %s\n", err->message);
if (!no_close)
g_main_loop_quit(mloop);
return;
}
if (mcl) {
mcap_sync_stop(mcl);
mcap_mcl_unref(mcl);
}
mcl = mcap_mcl_ref(mcap_mcl);
trigger_mdl_action(data_mode);
}
static void process_md_create_mdl_req(struct mcap_mcl *mcl, void *cmd,
uint32_t len)
{
mcap_md_create_mdl_req *req;
struct mcap_mdl *mdl;
uint16_t mdl_id;
uint8_t mdep_id;
uint8_t cfga, conf;
uint8_t rsp;
if (!check_cmd_req_length(mcl, cmd, len, sizeof(mcap_md_create_mdl_req),
MCAP_MD_CREATE_MDL_RSP))
return;
req = cmd;
mdl_id = ntohs(req->mdl);
if (mdl_id < MCAP_MDLID_INITIAL || mdl_id > MCAP_MDLID_FINAL) {
mcap_send_cmd(mcl, MCAP_MD_CREATE_MDL_RSP, MCAP_INVALID_MDL,
mdl_id, NULL, 0);
return;
}
mdep_id = req->mdep;
if (mdep_id > MCAP_MDEPID_FINAL) {
mcap_send_cmd(mcl, MCAP_MD_CREATE_MDL_RSP, MCAP_INVALID_MDEP,
mdl_id, NULL, 0);
return;
}
mdl = get_mdl(mcl, mdl_id);
if (mdl && (mdl->state == MDL_WAITING || mdl->state == MDL_DELETING )) {
/* Creation request arrives for a MDL that is being managed
* at current moment */
mcap_send_cmd(mcl, MCAP_MD_CREATE_MDL_RSP, MCAP_MDL_BUSY,
mdl_id, NULL, 0);
return;
}
cfga = conf = req->conf;
/* Callback to upper layer */
rsp = mcl->cb->mdl_conn_req(mcl, mdep_id, mdl_id, &conf,
mcl->cb->user_data);
if (mcl->state == MCL_IDLE) {
/* MCL has been closed int the callback */
return;
}
if (cfga != 0 && cfga != conf) {
/* Remote device set default configuration but upper profile */
/* has changed it. Protocol Error: force closing the MCL by */
/* remote device using UNSPECIFIED_ERROR response */
mcap_send_cmd(mcl, MCAP_MD_CREATE_MDL_RSP,
MCAP_UNSPECIFIED_ERROR, mdl_id, NULL, 0);
return;
}
if (rsp != MCAP_SUCCESS) {
mcap_send_cmd(mcl, MCAP_MD_CREATE_MDL_RSP, rsp, mdl_id,
NULL, 0);
return;
}
if (!mdl) {
mdl = g_new0(struct mcap_mdl, 1);
mdl->mcl = mcap_mcl_ref(mcl);
mdl->mdlid = mdl_id;
mcl->mdls = g_slist_insert_sorted(mcl->mdls, mcap_mdl_ref(mdl),
compare_mdl);
} else if (mdl->state == MDL_CONNECTED) {
