CoCalc -- qmi_wlfw

GitHub Repository: freebsd/freebsd-src
Path: blob/main/sys/contrib/dev/athk/ath10k/qmi_wlfw_v01.c
¹¹⁰¹⁰⁰ views
1
// SPDX-License-Identifier: ISC
2
/*
3
 * Copyright (c) 2018 The Linux Foundation. All rights reserved.
4
 * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
5
 */
6

7
#include <linux/soc/qcom/qmi.h>
8
#include <linux/types.h>
9
#include "qmi_wlfw_v01.h"
10

11
static const struct qmi_elem_info wlfw_ce_tgt_pipe_cfg_s_v01_ei[] = {
12
	{
13
		.data_type      = QMI_UNSIGNED_4_BYTE,
14
		.elem_len       = 1,
15
		.elem_size      = sizeof(u32),
16
		.array_type     = NO_ARRAY,
17
		.tlv_type       = 0,
18
		.offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
19
					   pipe_num),
20
	},
21
	{
22
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
23
		.elem_len       = 1,
24
		.elem_size      = sizeof(enum wlfw_pipedir_enum_v01),
25
		.array_type     = NO_ARRAY,
26
		.tlv_type       = 0,
27
		.offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
28
					   pipe_dir),
29
	},
30
	{
31
		.data_type      = QMI_UNSIGNED_4_BYTE,
32
		.elem_len       = 1,
33
		.elem_size      = sizeof(u32),
34
		.array_type     = NO_ARRAY,
35
		.tlv_type       = 0,
36
		.offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
37
					   nentries),
38
	},
39
	{
40
		.data_type      = QMI_UNSIGNED_4_BYTE,
41
		.elem_len       = 1,
42
		.elem_size      = sizeof(u32),
43
		.array_type     = NO_ARRAY,
44
		.tlv_type       = 0,
45
		.offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
46
					   nbytes_max),
47
	},
48
	{
49
		.data_type      = QMI_UNSIGNED_4_BYTE,
50
		.elem_len       = 1,
51
		.elem_size      = sizeof(u32),
52
		.array_type     = NO_ARRAY,
53
		.tlv_type       = 0,
54
		.offset         = offsetof(struct wlfw_ce_tgt_pipe_cfg_s_v01,
55
					   flags),
56
	},
57
	{}
58
};
59

60
static const struct qmi_elem_info wlfw_ce_svc_pipe_cfg_s_v01_ei[] = {
61
	{
62
		.data_type      = QMI_UNSIGNED_4_BYTE,
63
		.elem_len       = 1,
64
		.elem_size      = sizeof(u32),
65
		.array_type     = NO_ARRAY,
66
		.tlv_type       = 0,
67
		.offset         = offsetof(struct wlfw_ce_svc_pipe_cfg_s_v01,
68
					   service_id),
69
	},
70
	{
71
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
72
		.elem_len       = 1,
73
		.elem_size      = sizeof(enum wlfw_pipedir_enum_v01),
74
		.array_type     = NO_ARRAY,
75
		.tlv_type       = 0,
76
		.offset         = offsetof(struct wlfw_ce_svc_pipe_cfg_s_v01,
77
					   pipe_dir),
78
	},
79
	{
80
		.data_type      = QMI_UNSIGNED_4_BYTE,
81
		.elem_len       = 1,
82
		.elem_size      = sizeof(u32),
83
		.array_type     = NO_ARRAY,
84
		.tlv_type       = 0,
85
		.offset         = offsetof(struct wlfw_ce_svc_pipe_cfg_s_v01,
86
					   pipe_num),
87
	},
88
	{}
89
};
90

91
static const struct qmi_elem_info wlfw_shadow_reg_cfg_s_v01_ei[] = {
92
	{
93
		.data_type      = QMI_UNSIGNED_2_BYTE,
94
		.elem_len       = 1,
95
		.elem_size      = sizeof(u16),
96
		.array_type     = NO_ARRAY,
97
		.tlv_type       = 0,
98
		.offset         = offsetof(struct wlfw_shadow_reg_cfg_s_v01,
99
					   id),
100
	},
101
	{
102
		.data_type      = QMI_UNSIGNED_2_BYTE,
103
		.elem_len       = 1,
104
		.elem_size      = sizeof(u16),
105
		.array_type     = NO_ARRAY,
106
		.tlv_type       = 0,
107
		.offset         = offsetof(struct wlfw_shadow_reg_cfg_s_v01,
108
					   offset),
109
	},
110
	{}
111
};
112

113
static const struct qmi_elem_info wlfw_shadow_reg_v2_cfg_s_v01_ei[] = {
114
	{
115
		.data_type      = QMI_UNSIGNED_4_BYTE,
116
		.elem_len       = 1,
117
		.elem_size      = sizeof(u32),
118
		.array_type     = NO_ARRAY,
119
		.tlv_type       = 0,
120
		.offset         = offsetof(struct wlfw_shadow_reg_v2_cfg_s_v01,
121
					   addr),
122
	},
123
	{}
124
};
125

126
static const struct qmi_elem_info wlfw_memory_region_info_s_v01_ei[] = {
127
	{
128
		.data_type      = QMI_UNSIGNED_8_BYTE,
129
		.elem_len       = 1,
130
		.elem_size      = sizeof(u64),
131
		.array_type     = NO_ARRAY,
132
		.tlv_type       = 0,
133
		.offset         = offsetof(struct wlfw_memory_region_info_s_v01,
134
					   region_addr),
135
	},
136
	{
137
		.data_type      = QMI_UNSIGNED_4_BYTE,
138
		.elem_len       = 1,
139
		.elem_size      = sizeof(u32),
140
		.array_type     = NO_ARRAY,
141
		.tlv_type       = 0,
142
		.offset         = offsetof(struct wlfw_memory_region_info_s_v01,
143
					   size),
144
	},
145
	{
146
		.data_type      = QMI_UNSIGNED_1_BYTE,
147
		.elem_len       = 1,
148
		.elem_size      = sizeof(u8),
149
		.array_type     = NO_ARRAY,
150
		.tlv_type       = 0,
151
		.offset         = offsetof(struct wlfw_memory_region_info_s_v01,
152
					   secure_flag),
153
	},
154
	{}
155
};
156

157
static const struct qmi_elem_info wlfw_mem_cfg_s_v01_ei[] = {
158
	{
159
		.data_type      = QMI_UNSIGNED_8_BYTE,
160
		.elem_len       = 1,
161
		.elem_size      = sizeof(u64),
162
		.array_type     = NO_ARRAY,
163
		.tlv_type       = 0,
164
		.offset         = offsetof(struct wlfw_mem_cfg_s_v01,
165
					   offset),
166
	},
167
	{
168
		.data_type      = QMI_UNSIGNED_4_BYTE,
169
		.elem_len       = 1,
170
		.elem_size      = sizeof(u32),
171
		.array_type     = NO_ARRAY,
172
		.tlv_type       = 0,
173
		.offset         = offsetof(struct wlfw_mem_cfg_s_v01,
174
					   size),
175
	},
176
	{
177
		.data_type      = QMI_UNSIGNED_1_BYTE,
178
		.elem_len       = 1,
179
		.elem_size      = sizeof(u8),
180
		.array_type     = NO_ARRAY,
181
		.tlv_type       = 0,
182
		.offset         = offsetof(struct wlfw_mem_cfg_s_v01,
183
					   secure_flag),
184
	},
185
	{}
186
};
187

188
static const struct qmi_elem_info wlfw_mem_seg_s_v01_ei[] = {
189
	{
190
		.data_type      = QMI_UNSIGNED_4_BYTE,
191
		.elem_len       = 1,
192
		.elem_size      = sizeof(u32),
193
		.array_type     = NO_ARRAY,
194
		.tlv_type       = 0,
195
		.offset         = offsetof(struct wlfw_mem_seg_s_v01,
196
					   size),
197
	},
198
	{
199
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
200
		.elem_len       = 1,
201
		.elem_size      = sizeof(enum wlfw_mem_type_enum_v01),
202
		.array_type     = NO_ARRAY,
203
		.tlv_type       = 0,
204
		.offset         = offsetof(struct wlfw_mem_seg_s_v01,
205
					   type),
206
	},
207
	{
208
		.data_type      = QMI_DATA_LEN,
209
		.elem_len       = 1,
210
		.elem_size      = sizeof(u8),
211
		.array_type     = NO_ARRAY,
212
		.tlv_type       = 0,
213
		.offset         = offsetof(struct wlfw_mem_seg_s_v01,
214
					   mem_cfg_len),
215
	},
216
	{
217
		.data_type      = QMI_STRUCT,
218
		.elem_len       = QMI_WLFW_MAX_NUM_MEM_CFG_V01,
219
		.elem_size      = sizeof(struct wlfw_mem_cfg_s_v01),
220
		.array_type       = VAR_LEN_ARRAY,
221
		.tlv_type       = 0,
222
		.offset         = offsetof(struct wlfw_mem_seg_s_v01,
223
					   mem_cfg),
224
		.ei_array      = wlfw_mem_cfg_s_v01_ei,
225
	},
226
	{}
227
};
228

229
static const struct qmi_elem_info wlfw_mem_seg_resp_s_v01_ei[] = {
230
	{
231
		.data_type      = QMI_UNSIGNED_8_BYTE,
232
		.elem_len       = 1,
233
		.elem_size      = sizeof(u64),
234
		.array_type     = NO_ARRAY,
235
		.tlv_type       = 0,
236
		.offset         = offsetof(struct wlfw_mem_seg_resp_s_v01,
237
					   addr),
238
	},
239
	{
240
		.data_type      = QMI_UNSIGNED_4_BYTE,
241
		.elem_len       = 1,
242
		.elem_size      = sizeof(u32),
243
		.array_type     = NO_ARRAY,
244
		.tlv_type       = 0,
245
		.offset         = offsetof(struct wlfw_mem_seg_resp_s_v01,
246
					   size),
247
	},
248
	{
249
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
250
		.elem_len       = 1,
251
		.elem_size      = sizeof(enum wlfw_mem_type_enum_v01),
252
		.array_type     = NO_ARRAY,
253
		.tlv_type       = 0,
254
		.offset         = offsetof(struct wlfw_mem_seg_resp_s_v01,
255
					   type),
256
	},
257
	{}
258
};
259

260
static const struct qmi_elem_info wlfw_rf_chip_info_s_v01_ei[] = {
261
	{
262
		.data_type      = QMI_UNSIGNED_4_BYTE,
263
		.elem_len       = 1,
264
		.elem_size      = sizeof(u32),
265
		.array_type     = NO_ARRAY,
266
		.tlv_type       = 0,
267
		.offset         = offsetof(struct wlfw_rf_chip_info_s_v01,
268
					   chip_id),
269
	},
270
	{
271
		.data_type      = QMI_UNSIGNED_4_BYTE,
272
		.elem_len       = 1,
273
		.elem_size      = sizeof(u32),
274
		.array_type     = NO_ARRAY,
275
		.tlv_type       = 0,
276
		.offset         = offsetof(struct wlfw_rf_chip_info_s_v01,
277
					   chip_family),
278
	},
279
	{}
280
};
281

282
static const struct qmi_elem_info wlfw_rf_board_info_s_v01_ei[] = {
283
	{
284
		.data_type      = QMI_UNSIGNED_4_BYTE,
285
		.elem_len       = 1,
286
		.elem_size      = sizeof(u32),
287
		.array_type     = NO_ARRAY,
288
		.tlv_type       = 0,
289
		.offset         = offsetof(struct wlfw_rf_board_info_s_v01,
290
					   board_id),
291
	},
292
	{}
293
};
294

295
static const struct qmi_elem_info wlfw_soc_info_s_v01_ei[] = {
296
	{
297
		.data_type      = QMI_UNSIGNED_4_BYTE,
298
		.elem_len       = 1,
299
		.elem_size      = sizeof(u32),
300
		.array_type     = NO_ARRAY,
301
		.tlv_type       = 0,
302
		.offset         = offsetof(struct wlfw_soc_info_s_v01,
303
					   soc_id),
304
	},
305
	{}
306
};
307

308
static const struct qmi_elem_info wlfw_fw_version_info_s_v01_ei[] = {
309
	{
310
		.data_type      = QMI_UNSIGNED_4_BYTE,
311
		.elem_len       = 1,
312
		.elem_size      = sizeof(u32),
313
		.array_type     = NO_ARRAY,
314
		.tlv_type       = 0,
315
		.offset         = offsetof(struct wlfw_fw_version_info_s_v01,
316
					   fw_version),
317
	},
318
	{
319
		.data_type      = QMI_STRING,
320
		.elem_len       = QMI_WLFW_MAX_TIMESTAMP_LEN_V01 + 1,
321
		.elem_size      = sizeof(char),
322
		.array_type     = NO_ARRAY,
323
		.tlv_type       = 0,
324
		.offset         = offsetof(struct wlfw_fw_version_info_s_v01,
325
					   fw_build_timestamp),
326
	},
327
	{}
328
};
329

330
const struct qmi_elem_info wlfw_ind_register_req_msg_v01_ei[] = {
331
	{
332
		.data_type      = QMI_OPT_FLAG,
333
		.elem_len       = 1,
334
		.elem_size      = sizeof(u8),
335
		.array_type     = NO_ARRAY,
336
		.tlv_type       = 0x10,
337
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
338
					   fw_ready_enable_valid),
339
	},
340
	{
341
		.data_type      = QMI_UNSIGNED_1_BYTE,
342
		.elem_len       = 1,
343
		.elem_size      = sizeof(u8),
344
		.array_type     = NO_ARRAY,
345
		.tlv_type       = 0x10,
346
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
347
					   fw_ready_enable),
348
	},
349
	{
350
		.data_type      = QMI_OPT_FLAG,
351
		.elem_len       = 1,
352
		.elem_size      = sizeof(u8),
353
		.array_type     = NO_ARRAY,
354
		.tlv_type       = 0x11,
355
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
356
					   initiate_cal_download_enable_valid),
357
	},
358
	{
359
		.data_type      = QMI_UNSIGNED_1_BYTE,
360
		.elem_len       = 1,
361
		.elem_size      = sizeof(u8),
362
		.array_type     = NO_ARRAY,
363
		.tlv_type       = 0x11,
364
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
365
					   initiate_cal_download_enable),
366
	},
367
	{
368
		.data_type      = QMI_OPT_FLAG,
369
		.elem_len       = 1,
370
		.elem_size      = sizeof(u8),
371
		.array_type     = NO_ARRAY,
372
		.tlv_type       = 0x12,
373
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
374
					   initiate_cal_update_enable_valid),
375
	},
376
	{
377
		.data_type      = QMI_UNSIGNED_1_BYTE,
378
		.elem_len       = 1,
379
		.elem_size      = sizeof(u8),
380
		.array_type     = NO_ARRAY,
381
		.tlv_type       = 0x12,
382
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
383
					   initiate_cal_update_enable),
384
	},
385
	{
386
		.data_type      = QMI_OPT_FLAG,
387
		.elem_len       = 1,
388
		.elem_size      = sizeof(u8),
389
		.array_type     = NO_ARRAY,
390
		.tlv_type       = 0x13,
391
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
392
					   msa_ready_enable_valid),
393
	},
394
	{
395
		.data_type      = QMI_UNSIGNED_1_BYTE,
396
		.elem_len       = 1,
397
		.elem_size      = sizeof(u8),
398
		.array_type     = NO_ARRAY,
399
		.tlv_type       = 0x13,
400
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
401
					   msa_ready_enable),
402
	},
403
	{
404
		.data_type      = QMI_OPT_FLAG,
405
		.elem_len       = 1,
406
		.elem_size      = sizeof(u8),
407
		.array_type     = NO_ARRAY,
408
		.tlv_type       = 0x14,
409
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
410
					   pin_connect_result_enable_valid),
411
	},
412
	{
413
		.data_type      = QMI_UNSIGNED_1_BYTE,
414
		.elem_len       = 1,
415
		.elem_size      = sizeof(u8),
416
		.array_type     = NO_ARRAY,
417
		.tlv_type       = 0x14,
418
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
419
					   pin_connect_result_enable),
420
	},
421
	{
422
		.data_type      = QMI_OPT_FLAG,
423
		.elem_len       = 1,
424
		.elem_size      = sizeof(u8),
425
		.array_type     = NO_ARRAY,
426
		.tlv_type       = 0x15,
427
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
428
					   client_id_valid),
429
	},
430
	{
431
		.data_type      = QMI_UNSIGNED_4_BYTE,
432
		.elem_len       = 1,
433
		.elem_size      = sizeof(u32),
434
		.array_type     = NO_ARRAY,
435
		.tlv_type       = 0x15,
436
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
437
					   client_id),
438
	},
439
	{
440
		.data_type      = QMI_OPT_FLAG,
441
		.elem_len       = 1,
442
		.elem_size      = sizeof(u8),
443
		.array_type     = NO_ARRAY,
444
		.tlv_type       = 0x16,
445
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
446
					   request_mem_enable_valid),
447
	},
448
	{
449
		.data_type      = QMI_UNSIGNED_1_BYTE,
450
		.elem_len       = 1,
451
		.elem_size      = sizeof(u8),
452
		.array_type     = NO_ARRAY,
453
		.tlv_type       = 0x16,
454
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
455
					   request_mem_enable),
456
	},
457
	{
458
		.data_type      = QMI_OPT_FLAG,
459
		.elem_len       = 1,
460
		.elem_size      = sizeof(u8),
461
		.array_type     = NO_ARRAY,
462
		.tlv_type       = 0x17,
463
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
464
					   mem_ready_enable_valid),
465
	},
466
	{
467
		.data_type      = QMI_UNSIGNED_1_BYTE,
468
		.elem_len       = 1,
469
		.elem_size      = sizeof(u8),
470
		.array_type     = NO_ARRAY,
471
		.tlv_type       = 0x17,
472
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
473
					   mem_ready_enable),
474
	},
475
	{
476
		.data_type      = QMI_OPT_FLAG,
477
		.elem_len       = 1,
478
		.elem_size      = sizeof(u8),
479
		.array_type     = NO_ARRAY,
480
		.tlv_type       = 0x18,
481
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
482
					   fw_init_done_enable_valid),
483
	},
484
	{
485
		.data_type      = QMI_UNSIGNED_1_BYTE,
486
		.elem_len       = 1,
487
		.elem_size      = sizeof(u8),
488
		.array_type     = NO_ARRAY,
489
		.tlv_type       = 0x18,
490
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
491
					   fw_init_done_enable),
492
	},
493
	{
494
		.data_type      = QMI_OPT_FLAG,
495
		.elem_len       = 1,
496
		.elem_size      = sizeof(u8),
497
		.array_type     = NO_ARRAY,
498
		.tlv_type       = 0x19,
499
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
500
					   rejuvenate_enable_valid),
501
	},
502
	{
503
		.data_type      = QMI_UNSIGNED_4_BYTE,
504
		.elem_len       = 1,
505
		.elem_size      = sizeof(u32),
506
		.array_type     = NO_ARRAY,
507
		.tlv_type       = 0x19,
508
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
509
					   rejuvenate_enable),
510
	},
511
	{
512
		.data_type      = QMI_OPT_FLAG,
513
		.elem_len       = 1,
514
		.elem_size      = sizeof(u8),
515
		.array_type     = NO_ARRAY,
516
		.tlv_type       = 0x1A,
517
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
518
					   xo_cal_enable_valid),
519
	},
520
	{
521
		.data_type      = QMI_UNSIGNED_1_BYTE,
522
		.elem_len       = 1,
523
		.elem_size      = sizeof(u8),
524
		.array_type     = NO_ARRAY,
525
		.tlv_type       = 0x1A,
526
		.offset         = offsetof(struct wlfw_ind_register_req_msg_v01,
527
					   xo_cal_enable),
528
	},
529
	{}
530
};
531

532
const struct qmi_elem_info wlfw_ind_register_resp_msg_v01_ei[] = {
533
	{
534
		.data_type      = QMI_STRUCT,
535
		.elem_len       = 1,
536
		.elem_size      = sizeof(struct qmi_response_type_v01),
537
		.array_type     = NO_ARRAY,
538
		.tlv_type       = 0x02,
539
		.offset         = offsetof(struct wlfw_ind_register_resp_msg_v01,
540
					   resp),
541
		.ei_array      = qmi_response_type_v01_ei,
542
	},
543
	{
544
		.data_type      = QMI_OPT_FLAG,
545
		.elem_len       = 1,
546
		.elem_size      = sizeof(u8),
547
		.array_type     = NO_ARRAY,
548
		.tlv_type       = 0x10,
549
		.offset         = offsetof(struct wlfw_ind_register_resp_msg_v01,
550
					   fw_status_valid),
551
	},
552
	{
553
		.data_type      = QMI_UNSIGNED_8_BYTE,
554
		.elem_len       = 1,
555
		.elem_size      = sizeof(u64),
556
		.array_type     = NO_ARRAY,
557
		.tlv_type       = 0x10,
558
		.offset         = offsetof(struct wlfw_ind_register_resp_msg_v01,
559
					   fw_status),
560
	},
561
	{}
562
};
563

564
const struct qmi_elem_info wlfw_fw_ready_ind_msg_v01_ei[] = {
565
	{}
566
};
567

568
const struct qmi_elem_info wlfw_msa_ready_ind_msg_v01_ei[] = {
569
	{}
570
};
571

572
const struct qmi_elem_info wlfw_pin_connect_result_ind_msg_v01_ei[] = {
573
	{
574
		.data_type      = QMI_OPT_FLAG,
575
		.elem_len       = 1,
576
		.elem_size      = sizeof(u8),
577
		.array_type     = NO_ARRAY,
578
		.tlv_type       = 0x10,
579
		.offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
580
					   pwr_pin_result_valid),
581
	},
582
	{
583
		.data_type      = QMI_UNSIGNED_4_BYTE,
584
		.elem_len       = 1,
585
		.elem_size      = sizeof(u32),
586
		.array_type     = NO_ARRAY,
587
		.tlv_type       = 0x10,
588
		.offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
589
					   pwr_pin_result),
590
	},
591
	{
592
		.data_type      = QMI_OPT_FLAG,
593
		.elem_len       = 1,
594
		.elem_size      = sizeof(u8),
595
		.array_type     = NO_ARRAY,
596
		.tlv_type       = 0x11,
597
		.offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
598
					   phy_io_pin_result_valid),
599
	},
600
	{
601
		.data_type      = QMI_UNSIGNED_4_BYTE,
602
		.elem_len       = 1,
603
		.elem_size      = sizeof(u32),
604
		.array_type     = NO_ARRAY,
605
		.tlv_type       = 0x11,
606
		.offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
607
					   phy_io_pin_result),
608
	},
609
	{
610
		.data_type      = QMI_OPT_FLAG,
611
		.elem_len       = 1,
612
		.elem_size      = sizeof(u8),
613
		.array_type     = NO_ARRAY,
614
		.tlv_type       = 0x12,
615
		.offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
616
					   rf_pin_result_valid),
617
	},
618
	{
619
		.data_type      = QMI_UNSIGNED_4_BYTE,
620
		.elem_len       = 1,
621
		.elem_size      = sizeof(u32),
622
		.array_type     = NO_ARRAY,
623
		.tlv_type       = 0x12,
624
		.offset         = offsetof(struct wlfw_pin_connect_result_ind_msg_v01,
625
					   rf_pin_result),
626
	},
627
	{}
628
};
629

630
const struct qmi_elem_info wlfw_wlan_mode_req_msg_v01_ei[] = {
631
	{
632
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
633
		.elem_len       = 1,
634
		.elem_size      = sizeof(enum wlfw_driver_mode_enum_v01),
635
		.array_type     = NO_ARRAY,
636
		.tlv_type       = 0x01,
637
		.offset         = offsetof(struct wlfw_wlan_mode_req_msg_v01,
638
					   mode),
639
	},
640
	{
641
		.data_type      = QMI_OPT_FLAG,
642
		.elem_len       = 1,
643
		.elem_size      = sizeof(u8),
644
		.array_type     = NO_ARRAY,
645
		.tlv_type       = 0x10,
646
		.offset         = offsetof(struct wlfw_wlan_mode_req_msg_v01,
647
					   hw_debug_valid),
648
	},
649
	{
650
		.data_type      = QMI_UNSIGNED_1_BYTE,
651
		.elem_len       = 1,
652
		.elem_size      = sizeof(u8),
653
		.array_type     = NO_ARRAY,
654
		.tlv_type       = 0x10,
655
		.offset         = offsetof(struct wlfw_wlan_mode_req_msg_v01,
656
					   hw_debug),
657
	},
658
	{}
659
};
660

661
const struct qmi_elem_info wlfw_wlan_mode_resp_msg_v01_ei[] = {
662
	{
663
		.data_type      = QMI_STRUCT,
664
		.elem_len       = 1,
665
		.elem_size      = sizeof(struct qmi_response_type_v01),
666
		.array_type     = NO_ARRAY,
667
		.tlv_type       = 0x02,
668
		.offset         = offsetof(struct wlfw_wlan_mode_resp_msg_v01,
669
					   resp),
670
		.ei_array      = qmi_response_type_v01_ei,
671
	},
672
	{}
673
};
674

675
const struct qmi_elem_info wlfw_wlan_cfg_req_msg_v01_ei[] = {
676
	{
677
		.data_type      = QMI_OPT_FLAG,
678
		.elem_len       = 1,
679
		.elem_size      = sizeof(u8),
680
		.array_type     = NO_ARRAY,
681
		.tlv_type       = 0x10,
682
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
683
					   host_version_valid),
684
	},
685
	{
686
		.data_type      = QMI_STRING,
687
		.elem_len       = QMI_WLFW_MAX_STR_LEN_V01 + 1,
688
		.elem_size      = sizeof(char),
689
		.array_type     = NO_ARRAY,
690
		.tlv_type       = 0x10,
691
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
692
					   host_version),
693
	},
694
	{
695
		.data_type      = QMI_OPT_FLAG,
696
		.elem_len       = 1,
697
		.elem_size      = sizeof(u8),
698
		.array_type     = NO_ARRAY,
699
		.tlv_type       = 0x11,
700
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
701
					   tgt_cfg_valid),
702
	},
703
	{
704
		.data_type      = QMI_DATA_LEN,
705
		.elem_len       = 1,
706
		.elem_size      = sizeof(u8),
707
		.array_type     = NO_ARRAY,
708
		.tlv_type       = 0x11,
709
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
710
					   tgt_cfg_len),
711
	},
712
	{
713
		.data_type      = QMI_STRUCT,
714
		.elem_len       = QMI_WLFW_MAX_NUM_CE_V01,
715
		.elem_size      = sizeof(struct wlfw_ce_tgt_pipe_cfg_s_v01),
716
		.array_type       = VAR_LEN_ARRAY,
717
		.tlv_type       = 0x11,
718
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
719
					   tgt_cfg),
720
		.ei_array      = wlfw_ce_tgt_pipe_cfg_s_v01_ei,
721
	},
722
	{
723
		.data_type      = QMI_OPT_FLAG,
724
		.elem_len       = 1,
725
		.elem_size      = sizeof(u8),
726
		.array_type     = NO_ARRAY,
727
		.tlv_type       = 0x12,
728
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
729
					   svc_cfg_valid),
730
	},
731
	{
732
		.data_type      = QMI_DATA_LEN,
733
		.elem_len       = 1,
734
		.elem_size      = sizeof(u8),
735
		.array_type     = NO_ARRAY,
736
		.tlv_type       = 0x12,
737
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
738
					   svc_cfg_len),
739
	},
740
	{
741
		.data_type      = QMI_STRUCT,
742
		.elem_len       = QMI_WLFW_MAX_NUM_SVC_V01,
743
		.elem_size      = sizeof(struct wlfw_ce_svc_pipe_cfg_s_v01),
744
		.array_type       = VAR_LEN_ARRAY,
745
		.tlv_type       = 0x12,
746
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
747
					   svc_cfg),
748
		.ei_array      = wlfw_ce_svc_pipe_cfg_s_v01_ei,
749
	},
750
	{
751
		.data_type      = QMI_OPT_FLAG,
752
		.elem_len       = 1,
753
		.elem_size      = sizeof(u8),
754
		.array_type     = NO_ARRAY,
755
		.tlv_type       = 0x13,
756
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
757
					   shadow_reg_valid),
758
	},
759
	{
760
		.data_type      = QMI_DATA_LEN,
761
		.elem_len       = 1,
762
		.elem_size      = sizeof(u8),
763
		.array_type     = NO_ARRAY,
764
		.tlv_type       = 0x13,
765
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
766
					   shadow_reg_len),
767
	},
768
	{
769
		.data_type      = QMI_STRUCT,
770
		.elem_len       = QMI_WLFW_MAX_NUM_SHADOW_REG_V01,
771
		.elem_size      = sizeof(struct wlfw_shadow_reg_cfg_s_v01),
772
		.array_type       = VAR_LEN_ARRAY,
773
		.tlv_type       = 0x13,
774
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
775
					   shadow_reg),
776
		.ei_array      = wlfw_shadow_reg_cfg_s_v01_ei,
777
	},
778
	{
779
		.data_type      = QMI_OPT_FLAG,
780
		.elem_len       = 1,
781
		.elem_size      = sizeof(u8),
782
		.array_type     = NO_ARRAY,
783
		.tlv_type       = 0x14,
784
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
785
					   shadow_reg_v2_valid),
786
	},
787
	{
788
		.data_type      = QMI_DATA_LEN,
789
		.elem_len       = 1,
790
		.elem_size      = sizeof(u8),
791
		.array_type     = NO_ARRAY,
792
		.tlv_type       = 0x14,
793
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
794
					   shadow_reg_v2_len),
795
	},
796
	{
797
		.data_type      = QMI_STRUCT,
798
		.elem_len       = QMI_WLFW_MAX_SHADOW_REG_V2,
799
		.elem_size      = sizeof(struct wlfw_shadow_reg_v2_cfg_s_v01),
800
		.array_type       = VAR_LEN_ARRAY,
801
		.tlv_type       = 0x14,
802
		.offset         = offsetof(struct wlfw_wlan_cfg_req_msg_v01,
803
					   shadow_reg_v2),
804
		.ei_array      = wlfw_shadow_reg_v2_cfg_s_v01_ei,
805
	},
806
	{}
807
};
808

809
const struct qmi_elem_info wlfw_wlan_cfg_resp_msg_v01_ei[] = {
810
	{
811
		.data_type      = QMI_STRUCT,
812
		.elem_len       = 1,
813
		.elem_size      = sizeof(struct qmi_response_type_v01),
814
		.array_type     = NO_ARRAY,
815
		.tlv_type       = 0x02,
816
		.offset         = offsetof(struct wlfw_wlan_cfg_resp_msg_v01,
817
					   resp),
818
		.ei_array      = qmi_response_type_v01_ei,
819
	},
820
	{}
821
};
822

823
const struct qmi_elem_info wlfw_cap_req_msg_v01_ei[] = {
824
	{}
825
};
826

827
const struct qmi_elem_info wlfw_cap_resp_msg_v01_ei[] = {
828
	{
829
		.data_type      = QMI_STRUCT,
830
		.elem_len       = 1,
831
		.elem_size      = sizeof(struct qmi_response_type_v01),
832
		.array_type     = NO_ARRAY,
833
		.tlv_type       = 0x02,
834
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
835
					   resp),
836
		.ei_array      = qmi_response_type_v01_ei,
837
	},
838
	{
839
		.data_type      = QMI_OPT_FLAG,
840
		.elem_len       = 1,
841
		.elem_size      = sizeof(u8),
842
		.array_type     = NO_ARRAY,
843
		.tlv_type       = 0x10,
844
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
845
					   chip_info_valid),
846
	},
847
	{
848
		.data_type      = QMI_STRUCT,
849
		.elem_len       = 1,
850
		.elem_size      = sizeof(struct wlfw_rf_chip_info_s_v01),
851
		.array_type     = NO_ARRAY,
852
		.tlv_type       = 0x10,
853
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
854
					   chip_info),
855
		.ei_array      = wlfw_rf_chip_info_s_v01_ei,
856
	},
857
	{
858
		.data_type      = QMI_OPT_FLAG,
859
		.elem_len       = 1,
860
		.elem_size      = sizeof(u8),
861
		.array_type     = NO_ARRAY,
862
		.tlv_type       = 0x11,
863
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
864
					   board_info_valid),
865
	},
866
	{
867
		.data_type      = QMI_STRUCT,
868
		.elem_len       = 1,
869
		.elem_size      = sizeof(struct wlfw_rf_board_info_s_v01),
870
		.array_type     = NO_ARRAY,
871
		.tlv_type       = 0x11,
872
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
873
					   board_info),
874
		.ei_array      = wlfw_rf_board_info_s_v01_ei,
875
	},
876
	{
877
		.data_type      = QMI_OPT_FLAG,
878
		.elem_len       = 1,
879
		.elem_size      = sizeof(u8),
880
		.array_type     = NO_ARRAY,
881
		.tlv_type       = 0x12,
882
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
883
					   soc_info_valid),
884
	},
885
	{
886
		.data_type      = QMI_STRUCT,
887
		.elem_len       = 1,
888
		.elem_size      = sizeof(struct wlfw_soc_info_s_v01),
889
		.array_type     = NO_ARRAY,
890
		.tlv_type       = 0x12,
891
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
892
					   soc_info),
893
		.ei_array      = wlfw_soc_info_s_v01_ei,
894
	},
895
	{
896
		.data_type      = QMI_OPT_FLAG,
897
		.elem_len       = 1,
898
		.elem_size      = sizeof(u8),
899
		.array_type     = NO_ARRAY,
900
		.tlv_type       = 0x13,
901
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
902
					   fw_version_info_valid),
903
	},
904
	{
905
		.data_type      = QMI_STRUCT,
906
		.elem_len       = 1,
907
		.elem_size      = sizeof(struct wlfw_fw_version_info_s_v01),
908
		.array_type     = NO_ARRAY,
909
		.tlv_type       = 0x13,
910
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
911
					   fw_version_info),
912
		.ei_array      = wlfw_fw_version_info_s_v01_ei,
913
	},
914
	{
915
		.data_type      = QMI_OPT_FLAG,
916
		.elem_len       = 1,
917
		.elem_size      = sizeof(u8),
918
		.array_type     = NO_ARRAY,
919
		.tlv_type       = 0x14,
920
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
921
					   fw_build_id_valid),
922
	},
923
	{
924
		.data_type      = QMI_STRING,
925
		.elem_len       = QMI_WLFW_MAX_BUILD_ID_LEN_V01 + 1,
926
		.elem_size      = sizeof(char),
927
		.array_type     = NO_ARRAY,
928
		.tlv_type       = 0x14,
929
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
930
					   fw_build_id),
931
	},
932
	{
933
		.data_type      = QMI_OPT_FLAG,
934
		.elem_len       = 1,
935
		.elem_size      = sizeof(u8),
936
		.array_type     = NO_ARRAY,
937
		.tlv_type       = 0x15,
938
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
939
					   num_macs_valid),
940
	},
941
	{
942
		.data_type      = QMI_UNSIGNED_1_BYTE,
943
		.elem_len       = 1,
944
		.elem_size      = sizeof(u8),
945
		.array_type     = NO_ARRAY,
946
		.tlv_type       = 0x15,
947
		.offset         = offsetof(struct wlfw_cap_resp_msg_v01,
948
					   num_macs),
949
	},
950
	{}
951
};
952

953
const struct qmi_elem_info wlfw_bdf_download_req_msg_v01_ei[] = {
954
	{
955
		.data_type      = QMI_UNSIGNED_1_BYTE,
956
		.elem_len       = 1,
957
		.elem_size      = sizeof(u8),
958
		.array_type     = NO_ARRAY,
959
		.tlv_type       = 0x01,
960
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
961
					   valid),
962
	},
963
	{
964
		.data_type      = QMI_OPT_FLAG,
965
		.elem_len       = 1,
966
		.elem_size      = sizeof(u8),
967
		.array_type     = NO_ARRAY,
968
		.tlv_type       = 0x10,
969
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
970
					   file_id_valid),
971
	},
972
	{
973
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
974
		.elem_len       = 1,
975
		.elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
976
		.array_type     = NO_ARRAY,
977
		.tlv_type       = 0x10,
978
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
979
					   file_id),
980
	},
981
	{
982
		.data_type      = QMI_OPT_FLAG,
983
		.elem_len       = 1,
984
		.elem_size      = sizeof(u8),
985
		.array_type     = NO_ARRAY,
986
		.tlv_type       = 0x11,
987
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
988
					   total_size_valid),
989
	},
990
	{
991
		.data_type      = QMI_UNSIGNED_4_BYTE,
992
		.elem_len       = 1,
993
		.elem_size      = sizeof(u32),
994
		.array_type     = NO_ARRAY,
995
		.tlv_type       = 0x11,
996
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
997
					   total_size),
998
	},
999
	{
1000
		.data_type      = QMI_OPT_FLAG,
1001
		.elem_len       = 1,
1002
		.elem_size      = sizeof(u8),
1003
		.array_type     = NO_ARRAY,
1004
		.tlv_type       = 0x12,
1005
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1006
					   seg_id_valid),
1007
	},
1008
	{
1009
		.data_type      = QMI_UNSIGNED_4_BYTE,
1010
		.elem_len       = 1,
1011
		.elem_size      = sizeof(u32),
1012
		.array_type     = NO_ARRAY,
1013
		.tlv_type       = 0x12,
1014
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1015
					   seg_id),
1016
	},
1017
	{
1018
		.data_type      = QMI_OPT_FLAG,
1019
		.elem_len       = 1,
1020
		.elem_size      = sizeof(u8),
1021
		.array_type     = NO_ARRAY,
1022
		.tlv_type       = 0x13,
1023
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1024
					   data_valid),
1025
	},
1026
	{
1027
		.data_type      = QMI_DATA_LEN,
1028
		.elem_len       = 1,
1029
		.elem_size      = sizeof(u16),
1030
		.array_type     = NO_ARRAY,
1031
		.tlv_type       = 0x13,
1032
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1033
					   data_len),
1034
	},
1035
	{
1036
		.data_type      = QMI_UNSIGNED_1_BYTE,
1037
		.elem_len       = QMI_WLFW_MAX_DATA_SIZE_V01,
1038
		.elem_size      = sizeof(u8),
1039
		.array_type       = VAR_LEN_ARRAY,
1040
		.tlv_type       = 0x13,
1041
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1042
					   data),
1043
	},
1044
	{
1045
		.data_type      = QMI_OPT_FLAG,
1046
		.elem_len       = 1,
1047
		.elem_size      = sizeof(u8),
1048
		.array_type     = NO_ARRAY,
1049
		.tlv_type       = 0x14,
1050
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1051
					   end_valid),
1052
	},
1053
	{
1054
		.data_type      = QMI_UNSIGNED_1_BYTE,
1055
		.elem_len       = 1,
1056
		.elem_size      = sizeof(u8),
1057
		.array_type     = NO_ARRAY,
1058
		.tlv_type       = 0x14,
1059
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1060
					   end),
1061
	},
1062
	{
1063
		.data_type      = QMI_OPT_FLAG,
1064
		.elem_len       = 1,
1065
		.elem_size      = sizeof(u8),
1066
		.array_type     = NO_ARRAY,
1067
		.tlv_type       = 0x15,
1068
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1069
					   bdf_type_valid),
1070
	},
1071
	{
1072
		.data_type      = QMI_UNSIGNED_1_BYTE,
1073
		.elem_len       = 1,
1074
		.elem_size      = sizeof(u8),
1075
		.array_type     = NO_ARRAY,
1076
		.tlv_type       = 0x15,
1077
		.offset         = offsetof(struct wlfw_bdf_download_req_msg_v01,
1078
					   bdf_type),
1079
	},
1080
	{}
1081
};
1082

1083
const struct qmi_elem_info wlfw_bdf_download_resp_msg_v01_ei[] = {
1084
	{
1085
		.data_type      = QMI_STRUCT,
1086
		.elem_len       = 1,
1087
		.elem_size      = sizeof(struct qmi_response_type_v01),
1088
		.array_type     = NO_ARRAY,
1089
		.tlv_type       = 0x02,
1090
		.offset         = offsetof(struct wlfw_bdf_download_resp_msg_v01,
1091
					   resp),
1092
		.ei_array      = qmi_response_type_v01_ei,
1093
	},
1094
	{}
1095
};
1096

1097
const struct qmi_elem_info wlfw_cal_report_req_msg_v01_ei[] = {
1098
	{
1099
		.data_type      = QMI_DATA_LEN,
1100
		.elem_len       = 1,
1101
		.elem_size      = sizeof(u8),
1102
		.array_type     = NO_ARRAY,
1103
		.tlv_type       = 0x01,
1104
		.offset         = offsetof(struct wlfw_cal_report_req_msg_v01,
1105
					   meta_data_len),
1106
	},
1107
	{
1108
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
1109
		.elem_len       = QMI_WLFW_MAX_NUM_CAL_V01,
1110
		.elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1111
		.array_type       = VAR_LEN_ARRAY,
1112
		.tlv_type       = 0x01,
1113
		.offset         = offsetof(struct wlfw_cal_report_req_msg_v01,
1114
					   meta_data),
1115
	},
1116
	{
1117
		.data_type      = QMI_OPT_FLAG,
1118
		.elem_len       = 1,
1119
		.elem_size      = sizeof(u8),
1120
		.array_type     = NO_ARRAY,
1121
		.tlv_type       = 0x10,
1122
		.offset         = offsetof(struct wlfw_cal_report_req_msg_v01,
1123
					   xo_cal_data_valid),
1124
	},
1125
	{
1126
		.data_type      = QMI_UNSIGNED_1_BYTE,
1127
		.elem_len       = 1,
1128
		.elem_size      = sizeof(u8),
1129
		.array_type     = NO_ARRAY,
1130
		.tlv_type       = 0x10,
1131
		.offset         = offsetof(struct wlfw_cal_report_req_msg_v01,
1132
					   xo_cal_data),
1133
	},
1134
	{}
1135
};
1136

1137
const struct qmi_elem_info wlfw_cal_report_resp_msg_v01_ei[] = {
1138
	{
1139
		.data_type      = QMI_STRUCT,
1140
		.elem_len       = 1,
1141
		.elem_size      = sizeof(struct qmi_response_type_v01),
1142
		.array_type     = NO_ARRAY,
1143
		.tlv_type       = 0x02,
1144
		.offset         = offsetof(struct wlfw_cal_report_resp_msg_v01,
1145
					   resp),
1146
		.ei_array      = qmi_response_type_v01_ei,
1147
	},
1148
	{}
1149
};
1150

1151
const struct qmi_elem_info wlfw_initiate_cal_download_ind_msg_v01_ei[] = {
1152
	{
1153
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
1154
		.elem_len       = 1,
1155
		.elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1156
		.array_type     = NO_ARRAY,
1157
		.tlv_type       = 0x01,
1158
		.offset         = offsetof(struct wlfw_initiate_cal_download_ind_msg_v01,
1159
					   cal_id),
1160
	},
1161
	{}
1162
};
1163

1164
const struct qmi_elem_info wlfw_cal_download_req_msg_v01_ei[] = {
1165
	{
1166
		.data_type      = QMI_UNSIGNED_1_BYTE,
1167
		.elem_len       = 1,
1168
		.elem_size      = sizeof(u8),
1169
		.array_type     = NO_ARRAY,
1170
		.tlv_type       = 0x01,
1171
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1172
					   valid),
1173
	},
1174
	{
1175
		.data_type      = QMI_OPT_FLAG,
1176
		.elem_len       = 1,
1177
		.elem_size      = sizeof(u8),
1178
		.array_type     = NO_ARRAY,
1179
		.tlv_type       = 0x10,
1180
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1181
					   file_id_valid),
1182
	},
1183
	{
1184
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
1185
		.elem_len       = 1,
1186
		.elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1187
		.array_type     = NO_ARRAY,
1188
		.tlv_type       = 0x10,
1189
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1190
					   file_id),
1191
	},
1192
	{
1193
		.data_type      = QMI_OPT_FLAG,
1194
		.elem_len       = 1,
1195
		.elem_size      = sizeof(u8),
1196
		.array_type     = NO_ARRAY,
1197
		.tlv_type       = 0x11,
1198
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1199
					   total_size_valid),
1200
	},
1201
	{
1202
		.data_type      = QMI_UNSIGNED_4_BYTE,
1203
		.elem_len       = 1,
1204
		.elem_size      = sizeof(u32),
1205
		.array_type     = NO_ARRAY,
1206
		.tlv_type       = 0x11,
1207
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1208
					   total_size),
1209
	},
1210
	{
1211
		.data_type      = QMI_OPT_FLAG,
1212
		.elem_len       = 1,
1213
		.elem_size      = sizeof(u8),
1214
		.array_type     = NO_ARRAY,
1215
		.tlv_type       = 0x12,
1216
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1217
					   seg_id_valid),
1218
	},
1219
	{
1220
		.data_type      = QMI_UNSIGNED_4_BYTE,
1221
		.elem_len       = 1,
1222
		.elem_size      = sizeof(u32),
1223
		.array_type     = NO_ARRAY,
1224
		.tlv_type       = 0x12,
1225
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1226
					   seg_id),
1227
	},
1228
	{
1229
		.data_type      = QMI_OPT_FLAG,
1230
		.elem_len       = 1,
1231
		.elem_size      = sizeof(u8),
1232
		.array_type     = NO_ARRAY,
1233
		.tlv_type       = 0x13,
1234
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1235
					   data_valid),
1236
	},
1237
	{
1238
		.data_type      = QMI_DATA_LEN,
1239
		.elem_len       = 1,
1240
		.elem_size      = sizeof(u16),
1241
		.array_type     = NO_ARRAY,
1242
		.tlv_type       = 0x13,
1243
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1244
					   data_len),
1245
	},
1246
	{
1247
		.data_type      = QMI_UNSIGNED_1_BYTE,
1248
		.elem_len       = QMI_WLFW_MAX_DATA_SIZE_V01,
1249
		.elem_size      = sizeof(u8),
1250
		.array_type       = VAR_LEN_ARRAY,
1251
		.tlv_type       = 0x13,
1252
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1253
					   data),
1254
	},
1255
	{
1256
		.data_type      = QMI_OPT_FLAG,
1257
		.elem_len       = 1,
1258
		.elem_size      = sizeof(u8),
1259
		.array_type     = NO_ARRAY,
1260
		.tlv_type       = 0x14,
1261
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1262
					   end_valid),
1263
	},
1264
	{
1265
		.data_type      = QMI_UNSIGNED_1_BYTE,
1266
		.elem_len       = 1,
1267
		.elem_size      = sizeof(u8),
1268
		.array_type     = NO_ARRAY,
1269
		.tlv_type       = 0x14,
1270
		.offset         = offsetof(struct wlfw_cal_download_req_msg_v01,
1271
					   end),
1272
	},
1273
	{}
1274
};
1275

1276
const struct qmi_elem_info wlfw_cal_download_resp_msg_v01_ei[] = {
1277
	{
1278
		.data_type      = QMI_STRUCT,
1279
		.elem_len       = 1,
1280
		.elem_size      = sizeof(struct qmi_response_type_v01),
1281
		.array_type     = NO_ARRAY,
1282
		.tlv_type       = 0x02,
1283
		.offset         = offsetof(struct wlfw_cal_download_resp_msg_v01,
1284
					   resp),
1285
		.ei_array      = qmi_response_type_v01_ei,
1286
	},
1287
	{}
1288
};
1289

1290
const struct qmi_elem_info wlfw_initiate_cal_update_ind_msg_v01_ei[] = {
1291
	{
1292
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
1293
		.elem_len       = 1,
1294
		.elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1295
		.array_type     = NO_ARRAY,
1296
		.tlv_type       = 0x01,
1297
		.offset         = offsetof(struct wlfw_initiate_cal_update_ind_msg_v01,
1298
					   cal_id),
1299
	},
1300
	{
1301
		.data_type      = QMI_UNSIGNED_4_BYTE,
1302
		.elem_len       = 1,
1303
		.elem_size      = sizeof(u32),
1304
		.array_type     = NO_ARRAY,
1305
		.tlv_type       = 0x02,
1306
		.offset         = offsetof(struct wlfw_initiate_cal_update_ind_msg_v01,
1307
					   total_size),
1308
	},
1309
	{}
1310
};
1311

1312
const struct qmi_elem_info wlfw_cal_update_req_msg_v01_ei[] = {
1313
	{
1314
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
1315
		.elem_len       = 1,
1316
		.elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1317
		.array_type     = NO_ARRAY,
1318
		.tlv_type       = 0x01,
1319
		.offset         = offsetof(struct wlfw_cal_update_req_msg_v01,
1320
					   cal_id),
1321
	},
1322
	{
1323
		.data_type      = QMI_UNSIGNED_4_BYTE,
1324
		.elem_len       = 1,
1325
		.elem_size      = sizeof(u32),
1326
		.array_type     = NO_ARRAY,
1327
		.tlv_type       = 0x02,
1328
		.offset         = offsetof(struct wlfw_cal_update_req_msg_v01,
1329
					   seg_id),
1330
	},
1331
	{}
1332
};
1333

1334
const struct qmi_elem_info wlfw_cal_update_resp_msg_v01_ei[] = {
1335
	{
1336
		.data_type      = QMI_STRUCT,
1337
		.elem_len       = 1,
1338
		.elem_size      = sizeof(struct qmi_response_type_v01),
1339
		.array_type     = NO_ARRAY,
1340
		.tlv_type       = 0x02,
1341
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1342
					   resp),
1343
		.ei_array      = qmi_response_type_v01_ei,
1344
	},
1345
	{
1346
		.data_type      = QMI_OPT_FLAG,
1347
		.elem_len       = 1,
1348
		.elem_size      = sizeof(u8),
1349
		.array_type     = NO_ARRAY,
1350
		.tlv_type       = 0x10,
1351
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1352
					   file_id_valid),
1353
	},
1354
	{
1355
		.data_type      = QMI_SIGNED_4_BYTE_ENUM,
1356
		.elem_len       = 1,
1357
		.elem_size      = sizeof(enum wlfw_cal_temp_id_enum_v01),
1358
		.array_type     = NO_ARRAY,
1359
		.tlv_type       = 0x10,
1360
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1361
					   file_id),
1362
	},
1363
	{
1364
		.data_type      = QMI_OPT_FLAG,
1365
		.elem_len       = 1,
1366
		.elem_size      = sizeof(u8),
1367
		.array_type     = NO_ARRAY,
1368
		.tlv_type       = 0x11,
1369
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1370
					   total_size_valid),
1371
	},
1372
	{
1373
		.data_type      = QMI_UNSIGNED_4_BYTE,
1374
		.elem_len       = 1,
1375
		.elem_size      = sizeof(u32),
1376
		.array_type     = NO_ARRAY,
1377
		.tlv_type       = 0x11,
1378
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1379
					   total_size),
1380
	},
1381
	{
1382
		.data_type      = QMI_OPT_FLAG,
1383
		.elem_len       = 1,
1384
		.elem_size      = sizeof(u8),
1385
		.array_type     = NO_ARRAY,
1386
		.tlv_type       = 0x12,
1387
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1388
					   seg_id_valid),
1389
	},
1390
	{
1391
		.data_type      = QMI_UNSIGNED_4_BYTE,
1392
		.elem_len       = 1,
1393
		.elem_size      = sizeof(u32),
1394
		.array_type     = NO_ARRAY,
1395
		.tlv_type       = 0x12,
1396
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1397
					   seg_id),
1398
	},
1399
	{
1400
		.data_type      = QMI_OPT_FLAG,
1401
		.elem_len       = 1,
1402
		.elem_size      = sizeof(u8),
1403
		.array_type     = NO_ARRAY,
1404
		.tlv_type       = 0x13,
1405
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1406
					   data_valid),
1407
	},
1408
	{
1409
		.data_type      = QMI_DATA_LEN,
1410
		.elem_len       = 1,
1411
		.elem_size      = sizeof(u16),
1412
		.array_type     = NO_ARRAY,
1413
		.tlv_type       = 0x13,
1414
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1415
					   data_len),
1416
	},
1417
	{
1418
		.data_type      = QMI_UNSIGNED_1_BYTE,
1419
		.elem_len       = QMI_WLFW_MAX_DATA_SIZE_V01,
1420
		.elem_size      = sizeof(u8),
1421
		.array_type       = VAR_LEN_ARRAY,
1422
		.tlv_type       = 0x13,
1423
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1424
					   data),
1425
	},
1426
	{
1427
		.data_type      = QMI_OPT_FLAG,
1428
		.elem_len       = 1,
1429
		.elem_size      = sizeof(u8),
1430
		.array_type     = NO_ARRAY,
1431
		.tlv_type       = 0x14,
1432
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1433
					   end_valid),
1434
	},
1435
	{
1436
		.data_type      = QMI_UNSIGNED_1_BYTE,
1437
		.elem_len       = 1,
1438
		.elem_size      = sizeof(u8),
1439
		.array_type     = NO_ARRAY,
1440
		.tlv_type       = 0x14,
1441
		.offset         = offsetof(struct wlfw_cal_update_resp_msg_v01,
1442
					   end),
1443
	},
1444
	{}
1445
};
1446

1447
const struct qmi_elem_info wlfw_msa_info_req_msg_v01_ei[] = {
1448
	{
1449
		.data_type      = QMI_UNSIGNED_8_BYTE,
1450
		.elem_len       = 1,
1451
		.elem_size      = sizeof(u64),
1452
		.array_type     = NO_ARRAY,
1453
		.tlv_type       = 0x01,
1454
		.offset         = offsetof(struct wlfw_msa_info_req_msg_v01,
1455
					   msa_addr),
1456
	},
1457
	{
1458
		.data_type      = QMI_UNSIGNED_4_BYTE,
1459
		.elem_len       = 1,
1460
		.elem_size      = sizeof(u32),
1461
		.array_type     = NO_ARRAY,
1462
		.tlv_type       = 0x02,
1463
		.offset         = offsetof(struct wlfw_msa_info_req_msg_v01,
1464
					   size),
1465
	},
1466
	{}
1467
};
1468

1469
const struct qmi_elem_info wlfw_msa_info_resp_msg_v01_ei[] = {
1470
	{
1471
		.data_type      = QMI_STRUCT,
1472
		.elem_len       = 1,
1473
		.elem_size      = sizeof(struct qmi_response_type_v01),
1474
		.array_type     = NO_ARRAY,
1475
		.tlv_type       = 0x02,
1476
		.offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
1477
					   resp),
1478
		.ei_array      = qmi_response_type_v01_ei,
1479
	},
1480
	{
1481
		.data_type      = QMI_DATA_LEN,
1482
		.elem_len       = 1,
1483
		.elem_size      = sizeof(u8),
1484
		.array_type     = NO_ARRAY,
1485
		.tlv_type       = 0x03,
1486
		.offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
1487
					   mem_region_info_len),
1488
	},
1489
	{
1490
		.data_type      = QMI_STRUCT,
1491
		.elem_len       = QMI_WLFW_MAX_MEM_REG_V01,
1492
		.elem_size      = sizeof(struct wlfw_memory_region_info_s_v01),
1493
		.array_type       = VAR_LEN_ARRAY,
1494
		.tlv_type       = 0x03,
1495
		.offset         = offsetof(struct wlfw_msa_info_resp_msg_v01,
1496
					   mem_region_info),
1497
		.ei_array      = wlfw_memory_region_info_s_v01_ei,
1498
	},
1499
	{}
1500
};
1501

1502
const struct qmi_elem_info wlfw_msa_ready_req_msg_v01_ei[] = {
1503
	{}
1504
};
1505

1506
const struct qmi_elem_info wlfw_msa_ready_resp_msg_v01_ei[] = {
1507
	{
1508
		.data_type      = QMI_STRUCT,
1509
		.elem_len       = 1,
1510
		.elem_size      = sizeof(struct qmi_response_type_v01),
1511
		.array_type     = NO_ARRAY,
1512
		.tlv_type       = 0x02,
1513
		.offset         = offsetof(struct wlfw_msa_ready_resp_msg_v01,
1514
					   resp),
1515
		.ei_array      = qmi_response_type_v01_ei,
1516
	},
1517
	{}
1518
};
1519

1520
const struct qmi_elem_info wlfw_ini_req_msg_v01_ei[] = {
1521
	{
1522
		.data_type      = QMI_OPT_FLAG,
1523
		.elem_len       = 1,
1524
		.elem_size      = sizeof(u8),
1525
		.array_type     = NO_ARRAY,
1526
		.tlv_type       = 0x10,
1527
		.offset         = offsetof(struct wlfw_ini_req_msg_v01,
1528
					   enablefwlog_valid),
1529
	},
1530
	{
1531
		.data_type      = QMI_UNSIGNED_1_BYTE,
1532
		.elem_len       = 1,
1533
		.elem_size      = sizeof(u8),
1534
		.array_type     = NO_ARRAY,
1535
		.tlv_type       = 0x10,
1536
		.offset         = offsetof(struct wlfw_ini_req_msg_v01,
1537
					   enablefwlog),
1538
	},
1539
	{}
1540
};
1541

1542
const struct qmi_elem_info wlfw_ini_resp_msg_v01_ei[] = {
1543
	{
1544
		.data_type      = QMI_STRUCT,
1545
		.elem_len       = 1,
1546
		.elem_size      = sizeof(struct qmi_response_type_v01),
1547
		.array_type     = NO_ARRAY,
1548
		.tlv_type       = 0x02,
1549
		.offset         = offsetof(struct wlfw_ini_resp_msg_v01,
1550
					   resp),
1551
		.ei_array      = qmi_response_type_v01_ei,
1552
	},
1553
	{}
1554
};
1555

1556
const struct qmi_elem_info wlfw_athdiag_read_req_msg_v01_ei[] = {
1557
	{
1558
		.data_type      = QMI_UNSIGNED_4_BYTE,
1559
		.elem_len       = 1,
1560
		.elem_size      = sizeof(u32),
1561
		.array_type     = NO_ARRAY,
1562
		.tlv_type       = 0x01,
1563
		.offset         = offsetof(struct wlfw_athdiag_read_req_msg_v01,
1564
					   offset),
1565
	},
1566
	{
1567
		.data_type      = QMI_UNSIGNED_4_BYTE,
1568
		.elem_len       = 1,
1569
		.elem_size      = sizeof(u32),
1570
		.array_type     = NO_ARRAY,
1571
		.tlv_type       = 0x02,
1572
		.offset         = offsetof(struct wlfw_athdiag_read_req_msg_v01,
1573
					   mem_type),
1574
	},
1575
	{
1576
		.data_type      = QMI_UNSIGNED_4_BYTE,
1577
		.elem_len       = 1,
1578
		.elem_size      = sizeof(u32),
1579
		.array_type     = NO_ARRAY,
1580
		.tlv_type       = 0x03,
1581
		.offset         = offsetof(struct wlfw_athdiag_read_req_msg_v01,
1582
					   data_len),
1583
	},
1584
	{}
1585
};
1586

1587
const struct qmi_elem_info wlfw_athdiag_read_resp_msg_v01_ei[] = {
1588
	{
1589
		.data_type      = QMI_STRUCT,
1590
		.elem_len       = 1,
1591
		.elem_size      = sizeof(struct qmi_response_type_v01),
1592
		.array_type     = NO_ARRAY,
1593
		.tlv_type       = 0x02,
1594
		.offset         = offsetof(struct wlfw_athdiag_read_resp_msg_v01,
1595
					   resp),
1596
		.ei_array      = qmi_response_type_v01_ei,
1597
	},
1598
	{
1599
		.data_type      = QMI_OPT_FLAG,
1600
		.elem_len       = 1,
1601
		.elem_size      = sizeof(u8),
1602
		.array_type     = NO_ARRAY,
1603
		.tlv_type       = 0x10,
1604
		.offset         = offsetof(struct wlfw_athdiag_read_resp_msg_v01,
1605
					   data_valid),
1606
	},
1607
	{
1608
		.data_type      = QMI_DATA_LEN,
1609
		.elem_len       = 1,
1610
		.elem_size      = sizeof(u16),
1611
		.array_type     = NO_ARRAY,
1612
		.tlv_type       = 0x10,
1613
		.offset         = offsetof(struct wlfw_athdiag_read_resp_msg_v01,
1614
					   data_len),
1615
	},
1616
	{
1617
		.data_type      = QMI_UNSIGNED_1_BYTE,
1618
		.elem_len       = QMI_WLFW_MAX_ATHDIAG_DATA_SIZE_V01,
1619
		.elem_size      = sizeof(u8),
1620
		.array_type       = VAR_LEN_ARRAY,
1621
		.tlv_type       = 0x10,
1622
		.offset         = offsetof(struct wlfw_athdiag_read_resp_msg_v01,
1623
					   data),
1624
	},
1625
	{}
1626
};
1627

1628
const struct qmi_elem_info wlfw_athdiag_write_req_msg_v01_ei[] = {
1629
	{
1630
		.data_type      = QMI_UNSIGNED_4_BYTE,
1631
		.elem_len       = 1,
1632
		.elem_size      = sizeof(u32),
1633
		.array_type     = NO_ARRAY,
1634
		.tlv_type       = 0x01,
1635
		.offset         = offsetof(struct wlfw_athdiag_write_req_msg_v01,
1636
					   offset),
1637
	},
1638
	{
1639
		.data_type      = QMI_UNSIGNED_4_BYTE,
1640
		.elem_len       = 1,
1641
		.elem_size      = sizeof(u32),
1642
		.array_type     = NO_ARRAY,
1643
		.tlv_type       = 0x02,
1644
		.offset         = offsetof(struct wlfw_athdiag_write_req_msg_v01,
1645
					   mem_type),
1646
	},
1647
	{
1648
		.data_type      = QMI_DATA_LEN,
1649
		.elem_len       = 1,
1650
		.elem_size      = sizeof(u16),
1651
		.array_type     = NO_ARRAY,
1652
		.tlv_type       = 0x03,
1653
		.offset         = offsetof(struct wlfw_athdiag_write_req_msg_v01,
1654
					   data_len),
1655
	},
1656
	{
1657
		.data_type      = QMI_UNSIGNED_1_BYTE,
1658
		.elem_len       = QMI_WLFW_MAX_ATHDIAG_DATA_SIZE_V01,
1659
		.elem_size      = sizeof(u8),
1660
		.array_type       = VAR_LEN_ARRAY,
1661
		.tlv_type       = 0x03,
1662
		.offset         = offsetof(struct wlfw_athdiag_write_req_msg_v01,
1663
					   data),
1664
	},
1665
	{}
1666
};
1667

1668
const struct qmi_elem_info wlfw_athdiag_write_resp_msg_v01_ei[] = {
1669
	{
1670
		.data_type      = QMI_STRUCT,
1671
		.elem_len       = 1,
1672
		.elem_size      = sizeof(struct qmi_response_type_v01),
1673
		.array_type     = NO_ARRAY,
1674
		.tlv_type       = 0x02,
1675
		.offset         = offsetof(struct wlfw_athdiag_write_resp_msg_v01,
1676
					   resp),
1677
		.ei_array      = qmi_response_type_v01_ei,
1678
	},
1679
	{}
1680
};
1681

1682
const struct qmi_elem_info wlfw_vbatt_req_msg_v01_ei[] = {
1683
	{
1684
		.data_type      = QMI_UNSIGNED_8_BYTE,
1685
		.elem_len       = 1,
1686
		.elem_size      = sizeof(u64),
1687
		.array_type     = NO_ARRAY,
1688
		.tlv_type       = 0x01,
1689
		.offset         = offsetof(struct wlfw_vbatt_req_msg_v01,
1690
					   voltage_uv),
1691
	},
1692
	{}
1693
};
1694

1695
const struct qmi_elem_info wlfw_vbatt_resp_msg_v01_ei[] = {
1696
	{
1697
		.data_type      = QMI_STRUCT,
1698
		.elem_len       = 1,
1699
		.elem_size      = sizeof(struct qmi_response_type_v01),
1700
		.array_type     = NO_ARRAY,
1701
		.tlv_type       = 0x02,
1702
		.offset         = offsetof(struct wlfw_vbatt_resp_msg_v01,
1703
					   resp),
1704
		.ei_array      = qmi_response_type_v01_ei,
1705
	},
1706
	{}
1707
};
1708

1709
const struct qmi_elem_info wlfw_mac_addr_req_msg_v01_ei[] = {
1710
	{
1711
		.data_type      = QMI_OPT_FLAG,
1712
		.elem_len       = 1,
1713
		.elem_size      = sizeof(u8),
1714
		.array_type     = NO_ARRAY,
1715
		.tlv_type       = 0x10,
1716
		.offset         = offsetof(struct wlfw_mac_addr_req_msg_v01,
1717
					   mac_addr_valid),
1718
	},
1719
	{
1720
		.data_type      = QMI_UNSIGNED_1_BYTE,
1721
		.elem_len       = QMI_WLFW_MAC_ADDR_SIZE_V01,
1722
		.elem_size      = sizeof(u8),
1723
		.array_type       = STATIC_ARRAY,
1724
		.tlv_type       = 0x10,
1725
		.offset         = offsetof(struct wlfw_mac_addr_req_msg_v01,
1726
					   mac_addr),
1727
	},
1728
	{}
1729
};
1730

1731
const struct qmi_elem_info wlfw_mac_addr_resp_msg_v01_ei[] = {
1732
	{
1733
		.data_type      = QMI_STRUCT,
1734
		.elem_len       = 1,
1735
		.elem_size      = sizeof(struct qmi_response_type_v01),
1736
		.array_type     = NO_ARRAY,
1737
		.tlv_type       = 0x02,
1738
		.offset         = offsetof(struct wlfw_mac_addr_resp_msg_v01,
1739
					   resp),
1740
		.ei_array      = qmi_response_type_v01_ei,
1741
	},
1742
	{}
1743
};
1744

1745
const struct qmi_elem_info wlfw_host_cap_req_msg_v01_ei[] = {
1746
	{
1747
		.data_type      = QMI_OPT_FLAG,
1748
		.elem_len       = 1,
1749
		.elem_size      = sizeof(u8),
1750
		.array_type     = NO_ARRAY,
1751
		.tlv_type       = 0x10,
1752
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1753
					   daemon_support_valid),
1754
	},
1755
	{
1756
		.data_type      = QMI_UNSIGNED_4_BYTE,
1757
		.elem_len       = 1,
1758
		.elem_size      = sizeof(u32),
1759
		.array_type     = NO_ARRAY,
1760
		.tlv_type       = 0x10,
1761
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1762
					   daemon_support),
1763
	},
1764
	{
1765
		.data_type      = QMI_OPT_FLAG,
1766
		.elem_len       = 1,
1767
		.elem_size      = sizeof(u8),
1768
		.array_type     = NO_ARRAY,
1769
		.tlv_type       = 0x11,
1770
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1771
					   wake_msi_valid),
1772
	},
1773
	{
1774
		.data_type      = QMI_UNSIGNED_4_BYTE,
1775
		.elem_len       = 1,
1776
		.elem_size      = sizeof(u32),
1777
		.array_type     = NO_ARRAY,
1778
		.tlv_type       = 0x11,
1779
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1780
					   wake_msi),
1781
	},
1782
	{
1783
		.data_type      = QMI_OPT_FLAG,
1784
		.elem_len       = 1,
1785
		.elem_size      = sizeof(u8),
1786
		.array_type     = NO_ARRAY,
1787
		.tlv_type       = 0x12,
1788
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1789
					   gpios_valid),
1790
	},
1791
	{
1792
		.data_type      = QMI_DATA_LEN,
1793
		.elem_len       = 1,
1794
		.elem_size      = sizeof(u32),
1795
		.array_type     = NO_ARRAY,
1796
		.tlv_type       = 0x12,
1797
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1798
					   gpios_len),
1799
	},
1800
	{
1801
		.data_type      = QMI_UNSIGNED_4_BYTE,
1802
		.elem_len       = QMI_WLFW_MAX_NUM_GPIO_V01,
1803
		.elem_size      = sizeof(u32),
1804
		.array_type     = VAR_LEN_ARRAY,
1805
		.tlv_type       = 0x12,
1806
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1807
					   gpios),
1808
	},
1809
	{
1810
		.data_type      = QMI_OPT_FLAG,
1811
		.elem_len       = 1,
1812
		.elem_size      = sizeof(u8),
1813
		.array_type     = NO_ARRAY,
1814
		.tlv_type       = 0x13,
1815
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1816
					   nm_modem_valid),
1817
	},
1818
	{
1819
		.data_type      = QMI_UNSIGNED_1_BYTE,
1820
		.elem_len       = 1,
1821
		.elem_size      = sizeof(u8),
1822
		.array_type     = NO_ARRAY,
1823
		.tlv_type       = 0x13,
1824
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1825
					   nm_modem),
1826
	},
1827
	{
1828
		.data_type      = QMI_OPT_FLAG,
1829
		.elem_len       = 1,
1830
		.elem_size      = sizeof(u8),
1831
		.array_type     = NO_ARRAY,
1832
		.tlv_type       = 0x14,
1833
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1834
					   bdf_support_valid),
1835
	},
1836
	{
1837
		.data_type      = QMI_UNSIGNED_1_BYTE,
1838
		.elem_len       = 1,
1839
		.elem_size      = sizeof(u8),
1840
		.array_type     = NO_ARRAY,
1841
		.tlv_type       = 0x14,
1842
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1843
					   bdf_support),
1844
	},
1845
	{
1846
		.data_type      = QMI_OPT_FLAG,
1847
		.elem_len       = 1,
1848
		.elem_size      = sizeof(u8),
1849
		.array_type     = NO_ARRAY,
1850
		.tlv_type       = 0x15,
1851
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1852
					   bdf_cache_support_valid),
1853
	},
1854
	{
1855
		.data_type      = QMI_UNSIGNED_1_BYTE,
1856
		.elem_len       = 1,
1857
		.elem_size      = sizeof(u8),
1858
		.array_type     = NO_ARRAY,
1859
		.tlv_type       = 0x15,
1860
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1861
					   bdf_cache_support),
1862
	},
1863
	{
1864
		.data_type      = QMI_OPT_FLAG,
1865
		.elem_len       = 1,
1866
		.elem_size      = sizeof(u8),
1867
		.array_type     = NO_ARRAY,
1868
		.tlv_type       = 0x16,
1869
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1870
					   m3_support_valid),
1871
	},
1872
	{
1873
		.data_type      = QMI_UNSIGNED_1_BYTE,
1874
		.elem_len       = 1,
1875
		.elem_size      = sizeof(u8),
1876
		.array_type     = NO_ARRAY,
1877
		.tlv_type       = 0x16,
1878
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1879
					   m3_support),
1880
	},
1881
	{
1882
		.data_type      = QMI_OPT_FLAG,
1883
		.elem_len       = 1,
1884
		.elem_size      = sizeof(u8),
1885
		.array_type     = NO_ARRAY,
1886
		.tlv_type       = 0x17,
1887
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1888
					   m3_cache_support_valid),
1889
	},
1890
	{
1891
		.data_type      = QMI_UNSIGNED_1_BYTE,
1892
		.elem_len       = 1,
1893
		.elem_size      = sizeof(u8),
1894
		.array_type     = NO_ARRAY,
1895
		.tlv_type       = 0x17,
1896
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1897
					   m3_cache_support),
1898
	},
1899
	{
1900
		.data_type      = QMI_OPT_FLAG,
1901
		.elem_len       = 1,
1902
		.elem_size      = sizeof(u8),
1903
		.array_type     = NO_ARRAY,
1904
		.tlv_type       = 0x18,
1905
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1906
					   cal_filesys_support_valid),
1907
	},
1908
	{
1909
		.data_type      = QMI_UNSIGNED_1_BYTE,
1910
		.elem_len       = 1,
1911
		.elem_size      = sizeof(u8),
1912
		.array_type     = NO_ARRAY,
1913
		.tlv_type       = 0x18,
1914
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1915
					   cal_filesys_support),
1916
	},
1917
	{
1918
		.data_type      = QMI_OPT_FLAG,
1919
		.elem_len       = 1,
1920
		.elem_size      = sizeof(u8),
1921
		.array_type     = NO_ARRAY,
1922
		.tlv_type       = 0x19,
1923
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1924
					   cal_cache_support_valid),
1925
	},
1926
	{
1927
		.data_type      = QMI_UNSIGNED_1_BYTE,
1928
		.elem_len       = 1,
1929
		.elem_size      = sizeof(u8),
1930
		.array_type     = NO_ARRAY,
1931
		.tlv_type       = 0x19,
1932
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1933
					   cal_cache_support),
1934
	},
1935
	{
1936
		.data_type      = QMI_OPT_FLAG,
1937
		.elem_len       = 1,
1938
		.elem_size      = sizeof(u8),
1939
		.array_type     = NO_ARRAY,
1940
		.tlv_type       = 0x1A,
1941
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1942
					   cal_done_valid),
1943
	},
1944
	{
1945
		.data_type      = QMI_UNSIGNED_1_BYTE,
1946
		.elem_len       = 1,
1947
		.elem_size      = sizeof(u8),
1948
		.array_type     = NO_ARRAY,
1949
		.tlv_type       = 0x1A,
1950
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1951
					   cal_done),
1952
	},
1953
	{
1954
		.data_type      = QMI_OPT_FLAG,
1955
		.elem_len       = 1,
1956
		.elem_size      = sizeof(u8),
1957
		.array_type     = NO_ARRAY,
1958
		.tlv_type       = 0x1B,
1959
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1960
					   mem_bucket_valid),
1961
	},
1962
	{
1963
		.data_type      = QMI_UNSIGNED_4_BYTE,
1964
		.elem_len       = 1,
1965
		.elem_size      = sizeof(u32),
1966
		.array_type     = NO_ARRAY,
1967
		.tlv_type       = 0x1B,
1968
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1969
					   mem_bucket),
1970
	},
1971
	{
1972
		.data_type      = QMI_OPT_FLAG,
1973
		.elem_len       = 1,
1974
		.elem_size      = sizeof(u8),
1975
		.array_type     = NO_ARRAY,
1976
		.tlv_type       = 0x1C,
1977
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1978
					   mem_cfg_mode_valid),
1979
	},
1980
	{
1981
		.data_type      = QMI_UNSIGNED_1_BYTE,
1982
		.elem_len       = 1,
1983
		.elem_size      = sizeof(u8),
1984
		.array_type     = NO_ARRAY,
1985
		.tlv_type       = 0x1C,
1986
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
1987
					   mem_cfg_mode),
1988
	},
1989
	{}
1990
};
1991

1992
const struct qmi_elem_info wlfw_host_cap_8bit_req_msg_v01_ei[] = {
1993
	{
1994
		.data_type      = QMI_OPT_FLAG,
1995
		.elem_len       = 1,
1996
		.elem_size      = sizeof(u8),
1997
		.array_type     = NO_ARRAY,
1998
		.tlv_type       = 0x10,
1999
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
2000
					   daemon_support_valid),
2001
	},
2002
	{
2003
		.data_type      = QMI_UNSIGNED_1_BYTE,
2004
		.elem_len       = 1,
2005
		.elem_size      = sizeof(u8),
2006
		.array_type     = NO_ARRAY,
2007
		.tlv_type       = 0x10,
2008
		.offset         = offsetof(struct wlfw_host_cap_req_msg_v01,
2009
					   daemon_support),
2010
	},
2011
	{}
2012
};
2013

2014
const struct qmi_elem_info wlfw_host_cap_resp_msg_v01_ei[] = {
2015
	{
2016
		.data_type      = QMI_STRUCT,
2017
		.elem_len       = 1,
2018
		.elem_size      = sizeof(struct qmi_response_type_v01),
2019
		.array_type     = NO_ARRAY,
2020
		.tlv_type       = 0x02,
2021
		.offset         = offsetof(struct wlfw_host_cap_resp_msg_v01,
2022
					   resp),
2023
		.ei_array      = qmi_response_type_v01_ei,
2024
	},
2025
	{}
2026
};
2027

2028
const struct qmi_elem_info wlfw_request_mem_ind_msg_v01_ei[] = {
2029
	{
2030
		.data_type      = QMI_DATA_LEN,
2031
		.elem_len       = 1,
2032
		.elem_size      = sizeof(u8),
2033
		.array_type     = NO_ARRAY,
2034
		.tlv_type       = 0x01,
2035
		.offset         = offsetof(struct wlfw_request_mem_ind_msg_v01,
2036
					   mem_seg_len),
2037
	},
2038
	{
2039
		.data_type      = QMI_STRUCT,
2040
		.elem_len       = QMI_WLFW_MAX_NUM_MEM_SEG_V01,
2041
		.elem_size      = sizeof(struct wlfw_mem_seg_s_v01),
2042
		.array_type       = VAR_LEN_ARRAY,
2043
		.tlv_type       = 0x01,
2044
		.offset         = offsetof(struct wlfw_request_mem_ind_msg_v01,
2045
					   mem_seg),
2046
		.ei_array      = wlfw_mem_seg_s_v01_ei,
2047
	},
2048
	{}
2049
};
2050

2051
const struct qmi_elem_info wlfw_respond_mem_req_msg_v01_ei[] = {
2052
	{
2053
		.data_type      = QMI_DATA_LEN,
2054
		.elem_len       = 1,
2055
		.elem_size      = sizeof(u8),
2056
		.array_type     = NO_ARRAY,
2057
		.tlv_type       = 0x01,
2058
		.offset         = offsetof(struct wlfw_respond_mem_req_msg_v01,
2059
					   mem_seg_len),
2060
	},
2061
	{
2062
		.data_type      = QMI_STRUCT,
2063
		.elem_len       = QMI_WLFW_MAX_NUM_MEM_SEG_V01,
2064
		.elem_size      = sizeof(struct wlfw_mem_seg_resp_s_v01),
2065
		.array_type       = VAR_LEN_ARRAY,
2066
		.tlv_type       = 0x01,
2067
		.offset         = offsetof(struct wlfw_respond_mem_req_msg_v01,
2068
					   mem_seg),
2069
		.ei_array      = wlfw_mem_seg_resp_s_v01_ei,
2070
	},
2071
	{}
2072
};
2073

2074
const struct qmi_elem_info wlfw_respond_mem_resp_msg_v01_ei[] = {
2075
	{
2076
		.data_type      = QMI_STRUCT,
2077
		.elem_len       = 1,
2078
		.elem_size      = sizeof(struct qmi_response_type_v01),
2079
		.array_type     = NO_ARRAY,
2080
		.tlv_type       = 0x02,
2081
		.offset         = offsetof(struct wlfw_respond_mem_resp_msg_v01,
2082
					   resp),
2083
		.ei_array      = qmi_response_type_v01_ei,
2084
	},
2085
	{}
2086
};
2087

2088
const struct qmi_elem_info wlfw_mem_ready_ind_msg_v01_ei[] = {
2089
	{}
2090
};
2091

2092
const struct qmi_elem_info wlfw_fw_init_done_ind_msg_v01_ei[] = {
2093
	{}
2094
};
2095

2096
const struct qmi_elem_info wlfw_rejuvenate_ind_msg_v01_ei[] = {
2097
	{
2098
		.data_type      = QMI_OPT_FLAG,
2099
		.elem_len       = 1,
2100
		.elem_size      = sizeof(u8),
2101
		.array_type     = NO_ARRAY,
2102
		.tlv_type       = 0x10,
2103
		.offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2104
					   cause_for_rejuvenation_valid),
2105
	},
2106
	{
2107
		.data_type      = QMI_UNSIGNED_1_BYTE,
2108
		.elem_len       = 1,
2109
		.elem_size      = sizeof(u8),
2110
		.array_type     = NO_ARRAY,
2111
		.tlv_type       = 0x10,
2112
		.offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2113
					   cause_for_rejuvenation),
2114
	},
2115
	{
2116
		.data_type      = QMI_OPT_FLAG,
2117
		.elem_len       = 1,
2118
		.elem_size      = sizeof(u8),
2119
		.array_type     = NO_ARRAY,
2120
		.tlv_type       = 0x11,
2121
		.offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2122
					   requesting_sub_system_valid),
2123
	},
2124
	{
2125
		.data_type      = QMI_UNSIGNED_1_BYTE,
2126
		.elem_len       = 1,
2127
		.elem_size      = sizeof(u8),
2128
		.array_type     = NO_ARRAY,
2129
		.tlv_type       = 0x11,
2130
		.offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2131
					   requesting_sub_system),
2132
	},
2133
	{
2134
		.data_type      = QMI_OPT_FLAG,
2135
		.elem_len       = 1,
2136
		.elem_size      = sizeof(u8),
2137
		.array_type     = NO_ARRAY,
2138
		.tlv_type       = 0x12,
2139
		.offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2140
					   line_number_valid),
2141
	},
2142
	{
2143
		.data_type      = QMI_UNSIGNED_2_BYTE,
2144
		.elem_len       = 1,
2145
		.elem_size      = sizeof(u16),
2146
		.array_type     = NO_ARRAY,
2147
		.tlv_type       = 0x12,
2148
		.offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2149
					   line_number),
2150
	},
2151
	{
2152
		.data_type      = QMI_OPT_FLAG,
2153
		.elem_len       = 1,
2154
		.elem_size      = sizeof(u8),
2155
		.array_type     = NO_ARRAY,
2156
		.tlv_type       = 0x13,
2157
		.offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2158
					   function_name_valid),
2159
	},
2160
	{
2161
		.data_type      = QMI_STRING,
2162
		.elem_len       = QMI_WLFW_FUNCTION_NAME_LEN_V01 + 1,
2163
		.elem_size      = sizeof(char),
2164
		.array_type     = NO_ARRAY,
2165
		.tlv_type       = 0x13,
2166
		.offset         = offsetof(struct wlfw_rejuvenate_ind_msg_v01,
2167
					   function_name),
2168
	},
2169
	{}
2170
};
2171

2172
const struct qmi_elem_info wlfw_rejuvenate_ack_req_msg_v01_ei[] = {
2173
	{}
2174
};
2175

2176
const struct qmi_elem_info wlfw_rejuvenate_ack_resp_msg_v01_ei[] = {
2177
	{
2178
		.data_type      = QMI_STRUCT,
2179
		.elem_len       = 1,
2180
		.elem_size      = sizeof(struct qmi_response_type_v01),
2181
		.array_type     = NO_ARRAY,
2182
		.tlv_type       = 0x02,
2183
		.offset         = offsetof(struct wlfw_rejuvenate_ack_resp_msg_v01,
2184
					   resp),
2185
		.ei_array      = qmi_response_type_v01_ei,
2186
	},
2187
	{}
2188
};
2189

2190
const struct qmi_elem_info wlfw_dynamic_feature_mask_req_msg_v01_ei[] = {
2191
	{
2192
		.data_type      = QMI_OPT_FLAG,
2193
		.elem_len       = 1,
2194
		.elem_size      = sizeof(u8),
2195
		.array_type     = NO_ARRAY,
2196
		.tlv_type       = 0x10,
2197
		.offset         = offsetof(struct wlfw_dynamic_feature_mask_req_msg_v01,
2198
					   mask_valid),
2199
	},
2200
	{
2201
		.data_type      = QMI_UNSIGNED_8_BYTE,
2202
		.elem_len       = 1,
2203
		.elem_size      = sizeof(u64),
2204
		.array_type     = NO_ARRAY,
2205
		.tlv_type       = 0x10,
2206
		.offset         = offsetof(struct wlfw_dynamic_feature_mask_req_msg_v01,
2207
					   mask),
2208
	},
2209
	{}
2210
};
2211

2212
const struct qmi_elem_info wlfw_dynamic_feature_mask_resp_msg_v01_ei[] = {
2213
	{
2214
		.data_type      = QMI_STRUCT,
2215
		.elem_len       = 1,
2216
		.elem_size      = sizeof(struct qmi_response_type_v01),
2217
		.array_type     = NO_ARRAY,
2218
		.tlv_type       = 0x02,
2219
		.offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2220
					   resp),
2221
		.ei_array      = qmi_response_type_v01_ei,
2222
	},
2223
	{
2224
		.data_type      = QMI_OPT_FLAG,
2225
		.elem_len       = 1,
2226
		.elem_size      = sizeof(u8),
2227
		.array_type     = NO_ARRAY,
2228
		.tlv_type       = 0x10,
2229
		.offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2230
					   prev_mask_valid),
2231
	},
2232
	{
2233
		.data_type      = QMI_UNSIGNED_8_BYTE,
2234
		.elem_len       = 1,
2235
		.elem_size      = sizeof(u64),
2236
		.array_type     = NO_ARRAY,
2237
		.tlv_type       = 0x10,
2238
		.offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2239
					   prev_mask),
2240
	},
2241
	{
2242
		.data_type      = QMI_OPT_FLAG,
2243
		.elem_len       = 1,
2244
		.elem_size      = sizeof(u8),
2245
		.array_type     = NO_ARRAY,
2246
		.tlv_type       = 0x11,
2247
		.offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2248
					   curr_mask_valid),
2249
	},
2250
	{
2251
		.data_type      = QMI_UNSIGNED_8_BYTE,
2252
		.elem_len       = 1,
2253
		.elem_size      = sizeof(u64),
2254
		.array_type     = NO_ARRAY,
2255
		.tlv_type       = 0x11,
2256
		.offset         = offsetof(struct wlfw_dynamic_feature_mask_resp_msg_v01,
2257
					   curr_mask),
2258
	},
2259
	{}
2260
};
2261

2262
const struct qmi_elem_info wlfw_m3_info_req_msg_v01_ei[] = {
2263
	{
2264
		.data_type      = QMI_UNSIGNED_8_BYTE,
2265
		.elem_len       = 1,
2266
		.elem_size      = sizeof(u64),
2267
		.array_type     = NO_ARRAY,
2268
		.tlv_type       = 0x01,
2269
		.offset         = offsetof(struct wlfw_m3_info_req_msg_v01,
2270
					   addr),
2271
	},
2272
	{
2273
		.data_type      = QMI_UNSIGNED_4_BYTE,
2274
		.elem_len       = 1,
2275
		.elem_size      = sizeof(u32),
2276
		.array_type     = NO_ARRAY,
2277
		.tlv_type       = 0x02,
2278
		.offset         = offsetof(struct wlfw_m3_info_req_msg_v01,
2279
					   size),
2280
	},
2281
	{}
2282
};
2283

2284
const struct qmi_elem_info wlfw_m3_info_resp_msg_v01_ei[] = {
2285
	{
2286
		.data_type      = QMI_STRUCT,
2287
		.elem_len       = 1,
2288
		.elem_size      = sizeof(struct qmi_response_type_v01),
2289
		.array_type     = NO_ARRAY,
2290
		.tlv_type       = 0x02,
2291
		.offset         = offsetof(struct wlfw_m3_info_resp_msg_v01,
2292
					   resp),
2293
		.ei_array      = qmi_response_type_v01_ei,
2294
	},
2295
	{}
2296
};
2297

2298
const struct qmi_elem_info wlfw_xo_cal_ind_msg_v01_ei[] = {
2299
	{
2300
		.data_type      = QMI_UNSIGNED_1_BYTE,
2301
		.elem_len       = 1,
2302
		.elem_size      = sizeof(u8),
2303
		.array_type     = NO_ARRAY,
2304
		.tlv_type       = 0x01,
2305
		.offset         = offsetof(struct wlfw_xo_cal_ind_msg_v01,
2306
					   xo_cal_data),
2307
	},
2308
	{}
2309
};
2310

2311
Product

Resources

Company
