5 require "$Bin/gen-common.pm";
10 my $data = get_json();
14 gint8 => "*(int8_t *) get_next(1)",
15 guint8 => "*(uint8_t *) get_next(1)",
16 gint16 => "le16_to_cpu(*(uint16_t *) get_next(2))",
17 guint16 => "le16_to_cpu(*(uint16_t *) get_next(2))",
18 gint32 => "le32_to_cpu(*(uint32_t *) get_next(4))",
19 guint32 => "le32_to_cpu(*(uint32_t *) get_next(4))",
20 gint64 => "le64_to_cpu(*(uint64_t *) get_next(8))",
21 guint64 => "le64_to_cpu(*(uint64_t *) get_next(8))",
22 gfloat => "({ uint32_t data = le32_to_cpu(*(uint32_t *) get_next(4)); float _val; memcpy(&_val, &data, sizeof(_val)); _val; })"
26 gint16 => "be16_to_cpu(*(uint16_t *) get_next(2))",
27 guint16 => "be16_to_cpu(*(uint16_t *) get_next(2))",
28 gint32 => "be32_to_cpu(*(uint32_t *) get_next(4))",
29 guint32 => "be32_to_cpu(*(uint32_t *) get_next(4))",
30 gint64 => "be64_to_cpu(*(uint64_t *) get_next(8))",
31 guint64 => "be64_to_cpu(*(uint64_t *) get_next(8))",
34 sub gen_tlv_parse_field($$$$) {
41 my $indent = "\t" x ($n_indent + 3);
45 my $type = $elem->{"format"};
47 $varsize_field and die "Cannot place fields after a variable-sized field (var: $var, field: $varsize_field)\n";
50 if ($elem->{endian} eq 'network') {
51 $val = $tlv_get_be{$type};
53 $val = $tlv_get{$type};
57 return $indent."$var = $val;\n";
58 } elsif ($type eq "array") {
60 my $cur_varsize_field;
64 if ($elem->{"fixed-size"}) {
65 $size = $elem->{"fixed-size"};
66 $data .= $indent."for ($iterator = 0; $iterator < $size; $iterator\++) {\n";
68 ($var_data, $var_iterator) =
69 gen_tlv_parse_field($var."[$iterator]", $elem->{"array-element"}, $n_indent + 1, "i$iterator");
72 my $prefix = $elem->{"size-prefix-format"};
73 $prefix or $prefix = 'guint8';
75 $size = $tlv_get{$prefix};
76 die "Unknown size element type '$prefix'" if not defined $size;
78 ($var_data, $var_iterator) =
79 gen_tlv_parse_field($var."[$var\_n]", $elem->{"array-element"}, $n_indent + 1, "i$iterator");
81 $var_data .= $indent."\t$var\_n++;\n";
82 $data .= $indent."$iterator = $size;\n";
83 $data .= $indent."$var = __qmi_alloc_static($iterator * sizeof($var\[0]));\n";
84 $data .= $indent."while($iterator\-- > 0) {\n";
87 $var_iterator and $data .= $indent."\tunsigned int i$iterator;\n";
89 $data .= $indent."}\n";
91 $varsize_field = $cur_varsize_field;
94 } elsif ($type eq "struct" or $type eq "sequence") {
95 foreach my $field (@{$elem->{contents}}) {
96 my $field_cname = gen_cname($field->{name});
97 my ($var_data, $var_iterator) =
98 gen_tlv_parse_field("$var.$field_cname", $field, $n_indent, $iterator);
101 $var_iterator and $use_iterator = 1;
103 return $data, $use_iterator;
104 } elsif ($type eq "string") {
105 my $size = $elem->{"fixed-size"};
107 my $prefix = $elem->{"size-prefix-format"};
109 $elem->{type} eq 'TLV' or $prefix = 'guint8';
113 $size = $tlv_get{$prefix};
115 $size = "cur_tlv_len - ofs";
116 $varsize_field = $var;
120 $data .= $indent."$iterator = $size;\n";
121 my $maxsize = $elem->{"max-size"};
123 $data .= $indent."if ($iterator > $maxsize)\n";
124 $data .= $indent."\t$iterator = $maxsize;\n";
126 $data .= $indent.$var." = __qmi_copy_string(get_next($iterator), $iterator);\n";
128 } elsif ($type eq "guint-sized") {
129 my $size = $elem->{"guint-size"};
130 return $indent."$var = ({ uint64_t var; memcpy(&var, get_next($size), $size); le64_to_cpu(var); });\n";
132 die "Invalid type $type for variable $var";
136 sub gen_tlv_type($$$) {
140 my $idx_word = "found[".int($idx / 32)."]";
141 my $idx_bit = "(1 << ".($idx % 32).")";
143 my $type = $elem->{"format"};
144 my $id = $elem->{"id"};
146 undef $varsize_field;
147 my $indent = "\t\t\t";
149 $type or return undef;
153 if ($idx_word & $idx_bit)
156 $idx_word |= $idx_bit;
159 my $val = $tlv_get{$type};
161 print $indent."qmi_set(res, $cname, $val);\n";
162 } elsif ($type eq "string") {
163 my ($var_data, $var_iterator) =
164 gen_tlv_parse_field("res->data.$cname", $elem, 0, "i");
166 } elsif ($type eq "array") {
167 $elem->{"fixed-size"} and $data = $indent."res->set.$cname = 1;\n";
168 my ($var_data, $var_iterator) =
169 gen_tlv_parse_field("res->data.$cname", $elem, 0, "i");
170 print "$data$var_data\n";
171 } elsif ($type eq "sequence" or $type eq "struct") {
172 my ($var_data, $var_iterator) =
173 gen_tlv_parse_field("res->data.$cname", $elem, 0, "i");
175 print $indent."res->set.$cname = 1;\n".$var_data;
183 sub gen_parse_func($$)
189 $ctl and $type = "ctl";
191 print gen_tlv_parse_func($name, $data)."\n";
194 void *tlv_buf = &msg->$type.tlv;
195 unsigned int tlv_len = le16_to_cpu(msg->$type.tlv_len);
198 if (gen_has_types($data)) {
199 my $n_bits = scalar @$data;
200 my $n_words = int(($n_bits + 31) / 32);
206 uint32_t found[$n_words] = {};
208 memset(res, 0, sizeof(*res));
211 while ((tlv = tlv_get_next(&tlv_buf, &tlv_len)) != NULL) {
212 unsigned int cur_tlv_len = le16_to_cpu(tlv->len);
213 unsigned int ofs = 0;
217 foreach my $field (@$data) {
218 my $cname = gen_cname($field->{name});
219 gen_tlv_type($cname, $field, $i++);
231 fprintf(stderr, "%s: Invalid TLV length in message, tlv=0x%02x, len=%d\\n",
232 __func__, tlv->type, le16_to_cpu(tlv->len));
233 return QMI_ERROR_INVALID_DATA;
238 return qmi_check_message_status(tlv_buf, tlv_len);
249 guint8 => sub { my $a = shift; my $b = shift; print "*(uint8_t *) $a = $b;\n" },
250 guint16 => sub { my $a = shift; my $b = shift; print "*(uint16_t *) $a = cpu_to_le16($b);\n" },
251 guint32 => sub { my $a = shift; my $b = shift; print "*(uint32_t *) $a = cpu_to_le32($b);\n" },
255 gint8 => sub { my $a = shift; "put_tlv_var(uint8_t, $a, 1);\n" },
256 guint8 => sub { my $a = shift; "put_tlv_var(uint8_t, $a, 1);\n" },
257 gint16 => sub { my $a = shift; "put_tlv_var(uint16_t, cpu_to_le16($a), 2);\n" },
258 guint16 => sub { my $a = shift; "put_tlv_var(uint16_t, cpu_to_le16($a), 2);\n" },
259 gint32 => sub { my $a = shift; "put_tlv_var(uint32_t, cpu_to_le32($a), 4);\n" },
260 guint32 => sub { my $a = shift; "put_tlv_var(uint32_t, cpu_to_le32($a), 4);\n" },
261 gint64 => sub { my $a = shift; "put_tlv_var(uint64_t, cpu_to_le64($a), 8);\n" },
262 guint64 => sub { my $a = shift; "put_tlv_var(uint64_t, cpu_to_le64($a), 8);\n" },
266 gint16 => sub { my $a = shift; "put_tlv_var(uint16_t, cpu_to_be16($a), 2);\n" },
267 guint16 => sub { my $a = shift; "put_tlv_var(uint16_t, cpu_to_be16($a), 2);\n" },
268 gint32 => sub { my $a = shift; "put_tlv_var(uint32_t, cpu_to_be32($a), 4);\n" },
269 guint32 => sub { my $a = shift; "put_tlv_var(uint32_t, cpu_to_be32($a), 4);\n" },
270 gint64 => sub { my $a = shift; "put_tlv_var(uint64_t, cpu_to_be64($a), 8);\n" },
271 guint64 => sub { my $a = shift; "put_tlv_var(uint64_t, cpu_to_be64($a), 8);\n" },
274 sub gen_tlv_val_set($$$$$)
279 my $iterator = shift;
283 my $type = $elem->{format};
287 if ($elem->{endian} eq 'network') {
288 $put = $tlv_put_be{$type};
290 $put = $tlv_put{$type};
292 $put and return $indent.&$put($cname);
294 $type eq 'array' and do {
295 my $size = $elem->{"fixed-size"};
298 $cond and $$cond = $cname;
301 my $prefix = $elem->{"size-prefix-format"};
302 $prefix or $prefix = 'gint8';
304 $put = $tlv_put{$prefix};
305 $put or die "Unknown size prefix type $prefix\n";
307 $data .= $indent.&$put($size);
310 $data .= $indent."for ($iterator = 0; $iterator < $size; $iterator++) {\n";
311 my ($var_data, $var_iterator) =
312 gen_tlv_val_set($cname."[$iterator]", $elem->{"array-element"}, "$indent\t", "i$iterator", undef);
314 $var_iterator and $data .= $indent."\tunsigned int i$iterator;\n";
316 $data .= $indent."}\n";
321 $type eq 'string' and do {
322 $cond and $$cond = $cname;
324 my $len = $elem->{"fixed-size"};
325 $len or $len = "strlen($cname)";
327 $data .= $indent."$iterator = $len;\n";
329 $len = $elem->{"max-size"};
331 $data .= $indent."if ($iterator > $len)\n";
332 $data .= $indent."\t$iterator = $len;\n";
335 my $prefix = $elem->{"size-prefix-format"};
337 $elem->{"type"} eq 'TLV' or $prefix = 'guint8';
341 my $put = $tlv_put{$prefix} or die "Unknown size prefix format $prefix";
342 $data .= $indent.&$put("$iterator");
345 $data .= $indent."strncpy(__qmi_alloc_static($iterator), $cname, $iterator);\n";
350 ($type eq 'sequence' or $type eq 'struct') and do {
353 foreach my $field (@{$elem->{contents}}) {
354 my $field_cname = gen_cname($field->{name});
355 my ($var_data, $var_iterator) =
356 gen_tlv_val_set("$cname.$field_cname", $field, $indent, $iterator, undef);
358 $var_iterator and $use_iterator = 1;
361 return $data, $use_iterator;
364 die "Unknown type $type";
367 sub gen_tlv_attr_set($$)
375 my $id = $elem->{id};
377 my $cond = "req->set.$cname";
378 my ($var_data, $use_iterator) =
379 gen_tlv_val_set("req->data.$cname", $elem, "\t\t", "i", \$cond);
380 $use_iterator and $iterator = "\t\tunsigned int i;\n";
389 buf = __qmi_get_buf(&ofs);
390 tlv_new(msg, $id, ofs, buf);
404 my $service = $data->{service};
405 my $id = $data->{id};
407 $service eq 'CTL' and $type = 'ctl';
409 print gen_tlv_set_func($name, $fields)."\n";
412 qmi_init_request_message(msg, QMI_SERVICE_$service);
413 msg->$type.message = cpu_to_le16($id);
416 foreach my $field (@$fields) {
417 my $cname = gen_cname($field->{name});
418 gen_tlv_attr_set($cname, $field);
429 /* generated by uqmi gen-code.pl */
432 #include "qmi-message.h"
434 #define get_next(_size) ({ void *_buf = &tlv->data[ofs]; ofs += _size; if (ofs > cur_tlv_len) goto error_len; _buf; })
435 #define copy_tlv(_val, _size) \\
437 unsigned int __size = _size; \\
439 memcpy(__qmi_alloc_static(__size), _val, __size); \\
442 #define put_tlv_var(_type, _val, _size) \\
444 _type __var = _val; \\
445 copy_tlv(&__var, _size); \\
450 gen_foreach_message_type($data, \&gen_set_func, \&gen_parse_func);