+/*
+ * uqmi -- tiny QMI support implementation
+ *
+ * Copyright (C) 2014-2015 Felix Fietkau <nbd@openwrt.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ */
+
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include "uqmi.h"
#include "qmi-errors.h"
#include "qmi-errors.c"
+#include "mbim.h"
bool cancel_all_requests = false;
};
#undef __qmi_service
-static union {
- char buf[512];
- struct qmi_msg msg;
-} msgbuf;
-
#ifdef DEBUG_PACKET
void dump_packet(const char *prefix, void *ptr, int len)
{
{
void *tlv_buf;
int tlv_len;
- int ret;
if (!req->pending)
return;
struct qmi_request *req;
uint16_t tid;
+ if (msg->flags != QMI_CTL_FLAG_RESPONSE && msg->flags != QMI_SERVICE_FLAG_RESPONSE)
+ return;
+
if (msg->qmux.service == QMI_SERVICE_CTL)
tid = msg->ctl.transaction;
else
struct qmi_msg *msg;
char *buf;
int len, msg_len;
- int i;
+
while (1) {
buf = ustream_get_read_buf(us, &len);
if (!buf || !len)
return;
- if (len < offsetof(struct qmi_msg, flags))
- return;
+ dump_packet("Received packet", buf, len);
+ if (qmi->is_mbim) {
+ struct mbim_command_message *mbim = (void *) buf;
+
+ if (len < sizeof(*mbim))
+ return;
+ msg = (struct qmi_msg *) (buf + sizeof(*mbim));
+ msg_len = le32_to_cpu(mbim->header.length);
+ if (!is_mbim_qmi(mbim)) {
+ /* must consume other MBIM packets */
+ ustream_consume(us, msg_len);
+ return;
+ }
+ } else {
+ if (len < offsetof(struct qmi_msg, flags))
+ return;
+ msg = (struct qmi_msg *) buf;
+ msg_len = le16_to_cpu(msg->qmux.len) + 1;
+ }
- msg = (struct qmi_msg *) buf;
- msg_len = le16_to_cpu(msg->qmux.len) + 1;
if (len < msg_len)
return;
- dump_packet("Received packet", msg, msg_len);
qmi_process_msg(qmi, msg);
ustream_consume(us, msg_len);
}
}
-int qmi_request_start(struct qmi_dev *qmi, struct qmi_request *req, struct qmi_msg *msg, request_cb cb)
+int qmi_request_start(struct qmi_dev *qmi, struct qmi_request *req, request_cb cb)
{
+ struct qmi_msg *msg = qmi->buf;
int len = qmi_complete_request_message(msg);
uint16_t tid;
- int ret;
- int i;
+ void *buf = (void *) qmi->buf;
memset(req, 0, sizeof(*req));
req->ret = -1;
req->pending = true;
list_add(&req->list, &qmi->req);
- dump_packet("Send packet", msg, len);
- ustream_write(&qmi->sf.stream, (void *) msg, len, false);
+ if (qmi->is_mbim) {
+ buf -= sizeof(struct mbim_command_message);
+ mbim_qmi_cmd((struct mbim_command_message *) buf, len, tid);
+ len += sizeof(struct mbim_command_message);
+ }
+
+ dump_packet("Send packet", buf, len);
+ ustream_write(&qmi->sf.stream, buf, len, false);
return 0;
}
};
struct qmi_connect_request req;
int idx = qmi_get_service_idx(svc);
- struct qmi_msg *msg = &msgbuf.msg;
+ struct qmi_msg *msg = qmi->buf;
if (idx < 0)
return -1;
if (client_id < 0) {
qmi_set_ctl_allocate_cid_request(msg, &creq);
- qmi_request_start(qmi, &req.req, msg, qmi_connect_service_cb);
+ qmi_request_start(qmi, &req.req, qmi_connect_service_cb);
qmi_request_wait(qmi, &req.req);
if (req.req.ret)
return req.req.ret;
client_id = req.cid;
+ } else {
+ qmi->service_keep_cid |= (1 << idx);
}
qmi->service_data[idx].connected = true;
)
};
struct qmi_request req;
- struct qmi_msg *msg = &msgbuf.msg;
+ struct qmi_msg *msg = qmi->buf;
qmi->service_connected &= ~(1 << idx);
qmi->service_data[idx].client_id = -1;
qmi->service_data[idx].tid = 0;
qmi_set_ctl_release_cid_request(msg, &creq);
- qmi_request_start(qmi, &req, msg, NULL);
+ qmi_request_start(qmi, &req, NULL);
qmi_request_wait(qmi, &req);
}
+int qmi_service_release_client_id(struct qmi_dev *qmi, QmiService svc)
+{
+ int idx = qmi_get_service_idx(svc);
+ qmi->service_release_cid |= 1 << idx;
+ return 0;
+}
+
static void qmi_close_all_services(struct qmi_dev *qmi)
{
uint32_t connected = qmi->service_connected;
int idx;
+ qmi->service_keep_cid &= ~qmi->service_release_cid;
for (idx = 0; connected; idx++, connected >>= 1) {
if (!(connected & 1))
continue;
int qmi_device_open(struct qmi_dev *qmi, const char *path)
{
+ static struct {
+ struct mbim_command_message mbim;
+ union {
+ char buf[2048];
+ struct qmi_msg msg;
+ } u;
+ } __packed msgbuf;
struct ustream *us = &qmi->sf.stream;
int fd;
ustream_fd_init(&qmi->sf, fd);
INIT_LIST_HEAD(&qmi->req);
qmi->ctl_tid = 1;
+ qmi->buf = msgbuf.u.buf;
return 0;
}
void qmi_device_close(struct qmi_dev *qmi)
{
struct qmi_request *req;
- int idx;
qmi_close_all_services(qmi);
ustream_free(&qmi->sf.stream);
{ "pds", QMI_SERVICE_PDS },
{ "wds", QMI_SERVICE_WDS },
{ "wms", QMI_SERVICE_WMS },
+ { "wda", QMI_SERVICE_WDA },
+ { "uim", QMI_SERVICE_UIM },
};
int i;