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
 */
5

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2310
Product

Resources

Company
