mirrors/qmic
0
0
Fork 0
mirror of https://github.com/linux-msm/qmic.git synced 2024-11-23 09:44:06 +08:00
Code Issues Packages Projects Releases Wiki Activity

kernel: Introduce kernel-style generator

Browse Source 
Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
This commit is contained in:
Bjorn Andersson 2018-01-31 12:59:05 -08:00
parent 06a2c5a19b
commit 8e5daab4a6
6 changed files with 372 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -4,7 +4,7 @@ CFLAGS := -Wall -g -O2
LDFLAGS :=
prefix := /usr/local
SRCS := accessor.c parser.c qmic.c
SRCS := accessor.c kernel.c parser.c qmic.c
OBJS := $(SRCS:.c=.o)
$(OUT): $(OBJS)

14
accessor.c
View File

@ -162,7 +162,7 @@ static void qmi_message_emit_simple_prototype(FILE *fp,
const char *message,
struct qmi_message_member *qmm)
{
if (qmm->array) {
if (qmm->array_size) {
fprintf(fp, "int %1$s_%2$s_set_%3$s(struct %1$s_%2$s *%2$s, %4$s *val, size_t count);\n",
package, message, qmm->name, sz_simple_types[qmm->type]);
@ -183,12 +183,12 @@ static void qmi_message_emit_simple_accessors(FILE *fp,
const char *message,
struct qmi_message_member *qmm)
{
if (qmm->array) {
if (qmm->array_size) {
fprintf(fp, "int %1$s_%2$s_set_%3$s(struct %1$s_%2$s *%2$s, %4$s *val, size_t count)\n"
"{\n"
" return qmi_tlv_set_array((struct qmi_tlv*)%2$s, %5$d, %6$d, val, count, sizeof(%4$s));\n"
"}\n\n",
package, message, qmm->name, sz_simple_types[qmm->type], qmm->id, qmm->array);
package, message, qmm->name, sz_simple_types[qmm->type], qmm->id, qmm->array_size);
fprintf(fp, "%4$s *%1$s_%2$s_get_%3$s(struct %1$s_%2$s *%2$s, size_t *count)\n"
"{\n"
@ -206,7 +206,7 @@ static void qmi_message_emit_simple_accessors(FILE *fp,
" *count = len;\n"
" return ptr;\n"
"}\n\n",
package, message, qmm->name, sz_simple_types[qmm->type], qmm->id, qmm->array);
package, message, qmm->name, sz_simple_types[qmm->type], qmm->id, qmm->array_size);
} else {
fprintf(fp, "int %1$s_%2$s_set_%3$s(struct %1$s_%2$s *%2$s, %4$s val)\n"
"{\n"
@ -238,7 +238,7 @@ static void qmi_message_emit_string_prototype(FILE *fp,
const char *message,
struct qmi_message_member *qmm)
{
if (qmm->array) {
if (qmm->array_size) {
fprintf(stderr, "Dont' know how to encode string arrays yet");
exit(1);
} else {
@ -301,7 +301,7 @@ static void qmi_message_source(FILE *fp, const char *package)
qmi_message_emit_string_accessors(fp, package, qm->name, qmm);
break;
case TYPE_STRUCT:
qmi_struct_emit_accessors(fp, package, qm->name, qmm->name, qmm->id, qmm->array, qmm->qmi_struct);
qmi_struct_emit_accessors(fp, package, qm->name, qmm->name, qmm->id, qmm->array_size, qmm->qmi_struct);
break;
};
}
@ -333,7 +333,7 @@ static void qmi_message_header(FILE *fp, const char *package)
qmi_message_emit_string_prototype(fp, package, qm->name, qmm);
break;
case TYPE_STRUCT:
qmi_struct_emit_prototype(fp, package, qm->name, qmm->name, qmm->array, qmm->qmi_struct);
qmi_struct_emit_prototype(fp, package, qm->name, qmm->name, qmm->array_size, qmm->qmi_struct);
break;
};
}

328
kernel.c Normal file
View File

@ -0,0 +1,328 @@
#include <stdio.h>
#include <stdlib.h>
#include "qmic.h"
static const char *sz_native_types[] = {
[TYPE_U8] = "uint8_t",
[TYPE_U16] = "uint16_t",
[TYPE_U32] = "uint32_t",
[TYPE_U64] = "uint64_t",
};
static const char *sz_data_types[] = {
[TYPE_U8] = "QMI_UNSIGNED_1_BYTE",
[TYPE_U16] = "QMI_UNSIGNED_2_BYTE",
[TYPE_U32] = "QMI_UNSIGNED_4_BYTE",
[TYPE_U64] = "QMI_UNSIGNED_8_BYTE"
};
static void emit_struct_definition(FILE *fp, const char *package,
struct qmi_struct *qs)
{
struct qmi_struct_member *qsm;
fprintf(fp, "struct %s_%s {\n", package, qs->name);
list_for_each_entry(qsm, &qs->members, node) {
switch (qsm->type) {
case TYPE_U8:
case TYPE_U16:
case TYPE_U32:
case TYPE_U64:
fprintf(fp, "\t%s %s;\n", sz_native_types[qsm->type], qsm->name);
break;
}
}
fprintf(fp, "};\n");
fprintf(fp, "\n");
}
static void emit_struct_native_ei(FILE *fp, const char *package,
struct qmi_struct *qs,
struct qmi_struct_member *qsm)
{
fprintf(fp, "\t{\n"
"\t\t.data_type = %4$s,\n"
"\t\t.elem_len = 1,\n"
"\t\t.elem_size = sizeof(%5$s),\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s),\n"
"\t},\n",
package, qs->name, qsm->name,
sz_data_types[qsm->type], sz_native_types[qsm->type]);
}
static void emit_struct_ei(FILE *fp, const char *package, struct qmi_struct *qs)
{
struct qmi_struct_member *qsm;
fprintf(fp, "struct qmi_elem_info %s_%s_ei[] = {\n", package, qs->name);
list_for_each_entry(qsm, &qs->members, node) {
switch (qsm->type) {
case TYPE_U8:
case TYPE_U16:
case TYPE_U32:
case TYPE_U64:
emit_struct_native_ei(fp, package, qs, qsm);
break;
}
}
fprintf(fp, "\t{}\n");
fprintf(fp, "};\n");
fprintf(fp, "\n");
}
static void emit_native_type(FILE *fp, const char *package, struct qmi_message *qm,
struct qmi_message_member *qmm)
{
static const char *sz_types[] = {
[TYPE_U8] = "uint8_t",
[TYPE_U16] = "uint16_t",
[TYPE_U32] = "uint32_t",
[TYPE_U64] = "uint64_t",
};
if (!qmm->required)
fprintf(fp, "\tbool %s_valid;\n", qmm->name);
if (qmm->array_size) {
fprintf(fp, "\tuint32_t %s_len;\n", qmm->name);
fprintf(fp, "\t%s %s[%d];\n", sz_types[qmm->type],
qmm->name, qmm->array_size);
} else {
fprintf(fp, "\t%s %s;\n", sz_types[qmm->type],
qmm->name);
}
}
static void emit_struct_type(FILE *fp, const char *package, struct qmi_message *qm,
struct qmi_message_member *qmm)
{
struct qmi_struct *qs = qmm->qmi_struct;
if (!qmm->required)
fprintf(fp, "\tbool %s_valid;\n", qmm->name);
if (qmm->array_size) {
fprintf(fp, "\tuint32_t %s_len;\n", qmm->name);
fprintf(fp, "\tstruct %s_%s %s[%d];\n", package, qs->name,
qmm->name, qmm->array_size);
} else {
fprintf(fp, "\tstruct %s_%s %s;\n", package, qs->name, qmm->name);
}
}
static void emit_msg_struct(FILE *fp, const char *package, struct qmi_message *qm)
{
struct qmi_message_member *qmm;
fprintf(fp, "struct %1$s_%2$s {\n", package, qm->name);
list_for_each_entry(qmm, &qm->members, node) {
switch (qmm->type) {
case TYPE_U8:
case TYPE_U16:
case TYPE_U32:
case TYPE_U64:
emit_native_type(fp, package, qm, qmm);
break;
case TYPE_STRING:
fprintf(fp, "\tuint32_t %s_len;\n", qmm->name);
fprintf(fp, "\tchar %s[256];\n", qmm->name);
break;
case TYPE_STRUCT:
emit_struct_type(fp, package, qm, qmm);
break;
}
}
fprintf(fp, "};\n");
fprintf(fp, "\n");
}
static void emit_native_ei(FILE *fp, const char *package, struct qmi_message *qm,
struct qmi_message_member *qmm)
{
if (!qmm->required) {
fprintf(fp, "\t{\n"
"\t\t.data_type = QMI_OPT_FLAG,\n"
"\t\t.elem_len = 1,\n"
"\t\t.elem_size = sizeof(bool),\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s_valid),\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id);
}
if (qmm->array_size) {
fprintf(fp, "\t{\n"
"\t\t.data_type = QMI_DATA_LEN,\n"
"\t\t.elem_len = 1,\n"
"\t\t.elem_size = sizeof(%5$s),\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s_len),\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id,
qmm->array_size >= 256 ? "uint16_t" : "uint8_t");
fprintf(fp, "\t{\n"
"\t\t.data_type = QMI_UNSIGNED_1_BYTE,\n"
"\t\t.elem_len = %5$d,\n"
"\t\t.elem_size = sizeof(%6$s),\n"
"\t\t.array_type = VAR_LEN_ARRAY,\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s),\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id, qmm->array_size,
sz_native_types[qmm->type]);
} else {
fprintf(fp, "\t{\n"
"\t\t.data_type = %5$s,\n"
"\t\t.elem_len = 1,\n"
"\t\t.elem_size = sizeof(%6$s),\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s),\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id,
sz_data_types[qmm->type],
sz_native_types[qmm->type]);
}
}
static void emit_struct_ref_ei(FILE *fp, const char *package, struct qmi_message *qm,
struct qmi_message_member *qmm)
{
struct qmi_struct *qs = qmm->qmi_struct;
if (!qmm->required) {
fprintf(fp, "\t{\n"
"\t\t.data_type = QMI_OPT_FLAG,\n"
"\t\t.elem_len = 1,\n"
"\t\t.elem_size = sizeof(bool),\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s_valid),\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id);
}
if (qmm->array_size) {
fprintf(fp, "\t{\n"
"\t\t.data_type = QMI_DATA_LEN,\n"
"\t\t.elem_len = 1,\n"
"\t\t.elem_size = sizeof(%5$s),\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s_len),\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id,
qmm->array_size >= 256 ? "uint16_t" : "uint8_t");
fprintf(fp, "\t{\n"
"\t\t.data_type = QMI_STRUCT,\n"
"\t\t.elem_len = %6$d,\n"
"\t\t.elem_size = sizeof(struct %1$s_%5$s),\n"
"\t\t.array_type = VAR_LEN_ARRAY,\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s),\n"
"\t\t.ei_array = %1$s_%5$s_ei,\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id, qs->name, qmm->array_size);
} else {
fprintf(fp, "\t{\n"
"\t\t.data_type = QMI_STRUCT,\n"
"\t\t.elem_len = 1,\n"
"\t\t.elem_size = sizeof(struct %1$s_%5$s),\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s),\n"
"\t\t.ei_array = %1$s_%5$s_ei,\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id, qs->name);
}
}
static void emit_elem_info_array_decl(FILE *fp, const char *package, struct qmi_message *qm)
{
fprintf(fp, "extern struct qmi_elem_info %1$s_%2$s_ei[];\n",
package, qm->name);
}
static void emit_elem_info_array(FILE *fp, const char *package, struct qmi_message *qm)
{
struct qmi_message_member *qmm;
fprintf(fp, "struct qmi_elem_info %1$s_%2$s_ei[] = {\n",
package, qm->name);
list_for_each_entry(qmm, &qm->members, node) {
switch (qmm->type) {
case TYPE_U8:
case TYPE_U16:
case TYPE_U32:
case TYPE_U64:
emit_native_ei(fp, package, qm, qmm);
break;
case TYPE_STRUCT:
emit_struct_ref_ei(fp, package, qm, qmm);
break;
case TYPE_STRING:
fprintf(fp, "\t{\n"
"\t\t.data_type = QMI_STRING,\n"
"\t\t.elem_len = 256,\n"
"\t\t.elem_size = sizeof(char),\n"
"\t\t.array_type = VAR_LEN_ARRAY,\n"
"\t\t.tlv_type = %4$d,\n"
"\t\t.offset = offsetof(struct %1$s_%2$s, %3$s)\n"
"\t},\n",
package, qm->name, qmm->name, qmm->id);
break;
}
}
fprintf(fp, "\t{}\n");
fprintf(fp, "};\n");
fprintf(fp, "\n");
}
static void emit_h_file_header(FILE *fp)
{
fprintf(fp, "#include <stdint.h>\n"
"#include <stdbool.h>\n"
"\n"
"#include \"libqrtr.h\"\n"
"\n");
};
void kernel_emit_c(FILE *fp, const char *package)
{
struct qmi_message *qm;
struct qmi_struct *qs;
emit_source_includes(fp, package);
list_for_each_entry(qs, &qmi_structs, node)
emit_struct_ei(fp, package, qs);
list_for_each_entry(qm, &qmi_messages, node)
emit_elem_info_array(fp, package, qm);
}
void kernel_emit_h(FILE *fp, const char *package)
{
struct qmi_message *qm;
struct qmi_struct *qs;
guard_header(fp, package);
emit_h_file_header(fp);
qmi_const_header(fp);
list_for_each_entry(qs, &qmi_structs, node)
emit_struct_definition(fp, package, qs);
list_for_each_entry(qm, &qmi_messages, node)
emit_msg_struct(fp, package, qm);
list_for_each_entry(qm, &qmi_messages, node)
emit_elem_info_array_decl(fp, package, qm);
fprintf(fp, "\n");
guard_footer(fp);
}

30
parser.c
View File

@ -280,20 +280,19 @@ static void qmi_message_parse(enum message_type message_type)
struct token type_tok;
struct token num_tok;
struct token id_tok;
unsigned array;
unsigned int array_size;
bool array_fixed = false;
bool required;
token_expect(TOK_ID, &msg_id_tok);
token_expect('{', NULL);
qm = malloc(sizeof(struct qmi_message));
qm = calloc(1, sizeof(struct qmi_message));
qm->name = msg_id_tok.str;
qm->type = message_type;
list_init(&qm->members);
while (!token_accept('}', NULL)) {
array = 0;
if (token_accept(TOK_REQUIRED, NULL))
required = true;
else if (token_accept(TOK_OPTIONAL, NULL))
@ -305,28 +304,31 @@ static void qmi_message_parse(enum message_type message_type)
token_expect(TOK_ID, &id_tok);
if (token_accept('[', NULL)) {
array = 1;
if (token_accept(TOK_NUM, &num_tok)) {
if (num_tok.num & 0xffff0000)
array = 4;
else if (num_tok.num & 0xff00)
array = 2;
}
token_expect(TOK_NUM, &num_tok);
array_size = num_tok.num;
token_expect(']', NULL);
array_fixed = true;
} else if(token_accept('(', NULL)) {
token_expect(TOK_NUM, &num_tok);
array_size = num_tok.num;
token_expect(')', NULL);
} else {
array_size = 0;
}
token_expect('=', NULL);
token_expect(TOK_NUM, &num_tok);
token_expect(';', NULL);
qmm = malloc(sizeof(struct qmi_message_member));
qmm = calloc(1, sizeof(struct qmi_message_member));
qmm->name = id_tok.str;
qmm->type = type_tok.num;
qmm->qmi_struct = type_tok.qmi_struct;
qmm->id = num_tok.num;
qmm->required = required;
qmm->array = array;
qmm->array_size = array_size;
qmm->array_fixed = array_fixed;
list_add(&qm->members, &qmm->node);
}

22
qmic.c
View File

@ -66,7 +66,7 @@ static void usage(void)
{
extern const char *__progname;
fprintf(stderr, "Usage: %s -a\n", __progname);
fprintf(stderr, "Usage: %s [-ak]\n", __progname);
exit(1);
}
@ -78,9 +78,12 @@ int main(int argc, char **argv)
int method = 0;
int opt;
while ((opt = getopt(argc, argv, "a")) != -1) {
while ((opt = getopt(argc, argv, "ak")) != -1) {
switch (opt) {
case 'a':
method = 0;
break;
case 'k':
method = 1;
break;
default:
@ -88,9 +91,6 @@ int main(int argc, char **argv)
}
}
if (!method)
usage();
qmi_parse();
snprintf(fname, sizeof(fname), "qmi_%s.c", qmi_package);
@ -103,8 +103,16 @@ int main(int argc, char **argv)
if (!hfp)
err(1, "failed to open %s", fname);
accessor_emit_c(sfp, qmi_package);
accessor_emit_h(hfp, qmi_package);
switch (method) {
case 0:
accessor_emit_c(sfp, qmi_package);
accessor_emit_h(hfp, qmi_package);
break;
case 1:
kernel_emit_c(sfp, qmi_package);
kernel_emit_h(hfp, qmi_package);
break;
}
fclose(hfp);
fclose(sfp);

6
qmic.h
View File

@ -39,7 +39,8 @@ struct qmi_message_member {
struct qmi_struct *qmi_struct;
int id;
bool required;
unsigned array;
unsigned array_size;
bool array_fixed;
struct list_head node;
};
@ -83,4 +84,7 @@ void qmi_const_header(FILE *fp);
void accessor_emit_c(FILE *fp, const char *package);
void accessor_emit_h(FILE *fp, const char *package);
void kernel_emit_c(FILE *fp, const char *package);
void kernel_emit_h(FILE *fp, const char *package);
#endif