1
2
3
4
5
6
7#include <linux/kernel.h>
8#include <linux/fsl/mc.h>
9
10#include "fsl-mc-private.h"
11
12
13
14
15
16static u16 dprc_major_ver;
17static u16 dprc_minor_ver;
18
19
20
21
22
23
24
25
26
27
28
29
30int dprc_open(struct fsl_mc_io *mc_io,
31 u32 cmd_flags,
32 int container_id,
33 u16 *token)
34{
35 struct fsl_mc_command cmd = { 0 };
36 struct dprc_cmd_open *cmd_params;
37 int err;
38
39
40 cmd.header = mc_encode_cmd_header(DPRC_CMDID_OPEN, cmd_flags,
41 0);
42 cmd_params = (struct dprc_cmd_open *)cmd.params;
43 cmd_params->container_id = cpu_to_le32(container_id);
44
45
46 err = mc_send_command(mc_io, &cmd);
47 if (err)
48 return err;
49
50
51 *token = mc_cmd_hdr_read_token(&cmd);
52
53 return 0;
54}
55EXPORT_SYMBOL_GPL(dprc_open);
56
57
58
59
60
61
62
63
64
65
66
67
68int dprc_close(struct fsl_mc_io *mc_io,
69 u32 cmd_flags,
70 u16 token)
71{
72 struct fsl_mc_command cmd = { 0 };
73
74
75 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLOSE, cmd_flags,
76 token);
77
78
79 return mc_send_command(mc_io, &cmd);
80}
81EXPORT_SYMBOL_GPL(dprc_close);
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112int dprc_reset_container(struct fsl_mc_io *mc_io,
113 u32 cmd_flags,
114 u16 token,
115 int child_container_id,
116 u32 options)
117{
118 struct fsl_mc_command cmd = { 0 };
119 struct dprc_cmd_reset_container *cmd_params;
120 u32 cmdid = DPRC_CMDID_RESET_CONT;
121 int err;
122
123
124
125
126
127 if (!dprc_major_ver && !dprc_minor_ver) {
128 err = dprc_get_api_version(mc_io, 0,
129 &dprc_major_ver,
130 &dprc_minor_ver);
131 if (err)
132 return err;
133 }
134
135
136
137
138
139
140 if (dprc_major_ver > 6 || (dprc_major_ver == 6 && dprc_minor_ver >= 5))
141 cmdid = DPRC_CMDID_RESET_CONT_V2;
142
143
144 cmd.header = mc_encode_cmd_header(cmdid, cmd_flags, token);
145 cmd_params = (struct dprc_cmd_reset_container *)cmd.params;
146 cmd_params->child_container_id = cpu_to_le32(child_container_id);
147 cmd_params->options = cpu_to_le32(options);
148
149
150 return mc_send_command(mc_io, &cmd);
151}
152EXPORT_SYMBOL_GPL(dprc_reset_container);
153
154
155
156
157
158
159
160
161
162
163
164int dprc_set_irq(struct fsl_mc_io *mc_io,
165 u32 cmd_flags,
166 u16 token,
167 u8 irq_index,
168 struct dprc_irq_cfg *irq_cfg)
169{
170 struct fsl_mc_command cmd = { 0 };
171 struct dprc_cmd_set_irq *cmd_params;
172
173
174 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ,
175 cmd_flags,
176 token);
177 cmd_params = (struct dprc_cmd_set_irq *)cmd.params;
178 cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
179 cmd_params->irq_index = irq_index;
180 cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
181 cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
182
183
184 return mc_send_command(mc_io, &cmd);
185}
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202int dprc_set_irq_enable(struct fsl_mc_io *mc_io,
203 u32 cmd_flags,
204 u16 token,
205 u8 irq_index,
206 u8 en)
207{
208 struct fsl_mc_command cmd = { 0 };
209 struct dprc_cmd_set_irq_enable *cmd_params;
210
211
212 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_ENABLE,
213 cmd_flags, token);
214 cmd_params = (struct dprc_cmd_set_irq_enable *)cmd.params;
215 cmd_params->enable = en & DPRC_ENABLE;
216 cmd_params->irq_index = irq_index;
217
218
219 return mc_send_command(mc_io, &cmd);
220}
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238int dprc_set_irq_mask(struct fsl_mc_io *mc_io,
239 u32 cmd_flags,
240 u16 token,
241 u8 irq_index,
242 u32 mask)
243{
244 struct fsl_mc_command cmd = { 0 };
245 struct dprc_cmd_set_irq_mask *cmd_params;
246
247
248 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_IRQ_MASK,
249 cmd_flags, token);
250 cmd_params = (struct dprc_cmd_set_irq_mask *)cmd.params;
251 cmd_params->mask = cpu_to_le32(mask);
252 cmd_params->irq_index = irq_index;
253
254
255 return mc_send_command(mc_io, &cmd);
256}
257
258
259
260
261
262
263
264
265
266
267
268
269
270int dprc_get_irq_status(struct fsl_mc_io *mc_io,
271 u32 cmd_flags,
272 u16 token,
273 u8 irq_index,
274 u32 *status)
275{
276 struct fsl_mc_command cmd = { 0 };
277 struct dprc_cmd_get_irq_status *cmd_params;
278 struct dprc_rsp_get_irq_status *rsp_params;
279 int err;
280
281
282 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_IRQ_STATUS,
283 cmd_flags, token);
284 cmd_params = (struct dprc_cmd_get_irq_status *)cmd.params;
285 cmd_params->status = cpu_to_le32(*status);
286 cmd_params->irq_index = irq_index;
287
288
289 err = mc_send_command(mc_io, &cmd);
290 if (err)
291 return err;
292
293
294 rsp_params = (struct dprc_rsp_get_irq_status *)cmd.params;
295 *status = le32_to_cpu(rsp_params->status);
296
297 return 0;
298}
299
300
301
302
303
304
305
306
307
308
309
310
311
312int dprc_clear_irq_status(struct fsl_mc_io *mc_io,
313 u32 cmd_flags,
314 u16 token,
315 u8 irq_index,
316 u32 status)
317{
318 struct fsl_mc_command cmd = { 0 };
319 struct dprc_cmd_clear_irq_status *cmd_params;
320
321
322 cmd.header = mc_encode_cmd_header(DPRC_CMDID_CLEAR_IRQ_STATUS,
323 cmd_flags, token);
324 cmd_params = (struct dprc_cmd_clear_irq_status *)cmd.params;
325 cmd_params->status = cpu_to_le32(status);
326 cmd_params->irq_index = irq_index;
327
328
329 return mc_send_command(mc_io, &cmd);
330}
331
332
333
334
335
336
337
338
339
340
341int dprc_get_attributes(struct fsl_mc_io *mc_io,
342 u32 cmd_flags,
343 u16 token,
344 struct dprc_attributes *attr)
345{
346 struct fsl_mc_command cmd = { 0 };
347 struct dprc_rsp_get_attributes *rsp_params;
348 int err;
349
350
351 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_ATTR,
352 cmd_flags,
353 token);
354
355
356 err = mc_send_command(mc_io, &cmd);
357 if (err)
358 return err;
359
360
361 rsp_params = (struct dprc_rsp_get_attributes *)cmd.params;
362 attr->container_id = le32_to_cpu(rsp_params->container_id);
363 attr->icid = le32_to_cpu(rsp_params->icid);
364 attr->options = le32_to_cpu(rsp_params->options);
365 attr->portal_id = le32_to_cpu(rsp_params->portal_id);
366
367 return 0;
368}
369
370
371
372
373
374
375
376
377
378
379int dprc_get_obj_count(struct fsl_mc_io *mc_io,
380 u32 cmd_flags,
381 u16 token,
382 int *obj_count)
383{
384 struct fsl_mc_command cmd = { 0 };
385 struct dprc_rsp_get_obj_count *rsp_params;
386 int err;
387
388
389 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_COUNT,
390 cmd_flags, token);
391
392
393 err = mc_send_command(mc_io, &cmd);
394 if (err)
395 return err;
396
397
398 rsp_params = (struct dprc_rsp_get_obj_count *)cmd.params;
399 *obj_count = le32_to_cpu(rsp_params->obj_count);
400
401 return 0;
402}
403EXPORT_SYMBOL_GPL(dprc_get_obj_count);
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420int dprc_get_obj(struct fsl_mc_io *mc_io,
421 u32 cmd_flags,
422 u16 token,
423 int obj_index,
424 struct fsl_mc_obj_desc *obj_desc)
425{
426 struct fsl_mc_command cmd = { 0 };
427 struct dprc_cmd_get_obj *cmd_params;
428 struct dprc_rsp_get_obj *rsp_params;
429 int err;
430
431
432 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ,
433 cmd_flags,
434 token);
435 cmd_params = (struct dprc_cmd_get_obj *)cmd.params;
436 cmd_params->obj_index = cpu_to_le32(obj_index);
437
438
439 err = mc_send_command(mc_io, &cmd);
440 if (err)
441 return err;
442
443
444 rsp_params = (struct dprc_rsp_get_obj *)cmd.params;
445 obj_desc->id = le32_to_cpu(rsp_params->id);
446 obj_desc->vendor = le16_to_cpu(rsp_params->vendor);
447 obj_desc->irq_count = rsp_params->irq_count;
448 obj_desc->region_count = rsp_params->region_count;
449 obj_desc->state = le32_to_cpu(rsp_params->state);
450 obj_desc->ver_major = le16_to_cpu(rsp_params->version_major);
451 obj_desc->ver_minor = le16_to_cpu(rsp_params->version_minor);
452 obj_desc->flags = le16_to_cpu(rsp_params->flags);
453 strncpy(obj_desc->type, rsp_params->type, 16);
454 obj_desc->type[15] = '\0';
455 strncpy(obj_desc->label, rsp_params->label, 16);
456 obj_desc->label[15] = '\0';
457 return 0;
458}
459EXPORT_SYMBOL_GPL(dprc_get_obj);
460
461
462
463
464
465
466
467
468
469
470
471
472
473int dprc_set_obj_irq(struct fsl_mc_io *mc_io,
474 u32 cmd_flags,
475 u16 token,
476 char *obj_type,
477 int obj_id,
478 u8 irq_index,
479 struct dprc_irq_cfg *irq_cfg)
480{
481 struct fsl_mc_command cmd = { 0 };
482 struct dprc_cmd_set_obj_irq *cmd_params;
483
484
485 cmd.header = mc_encode_cmd_header(DPRC_CMDID_SET_OBJ_IRQ,
486 cmd_flags,
487 token);
488 cmd_params = (struct dprc_cmd_set_obj_irq *)cmd.params;
489 cmd_params->irq_val = cpu_to_le32(irq_cfg->val);
490 cmd_params->irq_index = irq_index;
491 cmd_params->irq_addr = cpu_to_le64(irq_cfg->paddr);
492 cmd_params->irq_num = cpu_to_le32(irq_cfg->irq_num);
493 cmd_params->obj_id = cpu_to_le32(obj_id);
494 strncpy(cmd_params->obj_type, obj_type, 16);
495 cmd_params->obj_type[15] = '\0';
496
497
498 return mc_send_command(mc_io, &cmd);
499}
500EXPORT_SYMBOL_GPL(dprc_set_obj_irq);
501
502
503
504
505
506
507
508
509
510
511
512
513
514int dprc_get_obj_region(struct fsl_mc_io *mc_io,
515 u32 cmd_flags,
516 u16 token,
517 char *obj_type,
518 int obj_id,
519 u8 region_index,
520 struct dprc_region_desc *region_desc)
521{
522 struct fsl_mc_command cmd = { 0 };
523 struct dprc_cmd_get_obj_region *cmd_params;
524 struct dprc_rsp_get_obj_region *rsp_params;
525 int err;
526
527
528
529
530
531 if (!dprc_major_ver && !dprc_minor_ver) {
532 err = dprc_get_api_version(mc_io, 0,
533 &dprc_major_ver,
534 &dprc_minor_ver);
535 if (err)
536 return err;
537 }
538
539 if (dprc_major_ver > 6 || (dprc_major_ver == 6 && dprc_minor_ver >= 6)) {
540
541
542
543
544
545
546
547 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG_V3,
548 cmd_flags, token);
549
550 } else if (dprc_major_ver == 6 && dprc_minor_ver >= 3) {
551
552
553
554
555
556
557 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG_V2,
558 cmd_flags, token);
559 } else {
560 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_OBJ_REG,
561 cmd_flags, token);
562 }
563
564 cmd_params = (struct dprc_cmd_get_obj_region *)cmd.params;
565 cmd_params->obj_id = cpu_to_le32(obj_id);
566 cmd_params->region_index = region_index;
567 strncpy(cmd_params->obj_type, obj_type, 16);
568 cmd_params->obj_type[15] = '\0';
569
570
571 err = mc_send_command(mc_io, &cmd);
572 if (err)
573 return err;
574
575
576 rsp_params = (struct dprc_rsp_get_obj_region *)cmd.params;
577 region_desc->base_offset = le64_to_cpu(rsp_params->base_offset);
578 region_desc->size = le32_to_cpu(rsp_params->size);
579 region_desc->type = rsp_params->type;
580 region_desc->flags = le32_to_cpu(rsp_params->flags);
581 if (dprc_major_ver > 6 || (dprc_major_ver == 6 && dprc_minor_ver >= 3))
582 region_desc->base_address = le64_to_cpu(rsp_params->base_addr);
583 else
584 region_desc->base_address = 0;
585
586 return 0;
587}
588EXPORT_SYMBOL_GPL(dprc_get_obj_region);
589
590
591
592
593
594
595
596
597
598
599int dprc_get_api_version(struct fsl_mc_io *mc_io,
600 u32 cmd_flags,
601 u16 *major_ver,
602 u16 *minor_ver)
603{
604 struct fsl_mc_command cmd = { 0 };
605 int err;
606
607
608 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_API_VERSION,
609 cmd_flags, 0);
610
611
612 err = mc_send_command(mc_io, &cmd);
613 if (err)
614 return err;
615
616
617 mc_cmd_read_api_version(&cmd, major_ver, minor_ver);
618
619 return 0;
620}
621
622
623
624
625
626
627
628
629
630int dprc_get_container_id(struct fsl_mc_io *mc_io,
631 u32 cmd_flags,
632 int *container_id)
633{
634 struct fsl_mc_command cmd = { 0 };
635 int err;
636
637
638 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONT_ID,
639 cmd_flags,
640 0);
641
642
643 err = mc_send_command(mc_io, &cmd);
644 if (err)
645 return err;
646
647
648 *container_id = (int)mc_cmd_read_object_id(&cmd);
649
650 return 0;
651}
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668int dprc_get_connection(struct fsl_mc_io *mc_io,
669 u32 cmd_flags,
670 u16 token,
671 const struct dprc_endpoint *endpoint1,
672 struct dprc_endpoint *endpoint2,
673 int *state)
674{
675 struct dprc_cmd_get_connection *cmd_params;
676 struct dprc_rsp_get_connection *rsp_params;
677 struct fsl_mc_command cmd = { 0 };
678 int err, i;
679
680
681 cmd.header = mc_encode_cmd_header(DPRC_CMDID_GET_CONNECTION,
682 cmd_flags,
683 token);
684 cmd_params = (struct dprc_cmd_get_connection *)cmd.params;
685 cmd_params->ep1_id = cpu_to_le32(endpoint1->id);
686 cmd_params->ep1_interface_id = cpu_to_le16(endpoint1->if_id);
687 for (i = 0; i < 16; i++)
688 cmd_params->ep1_type[i] = endpoint1->type[i];
689
690
691 err = mc_send_command(mc_io, &cmd);
692 if (err)
693 return -ENOTCONN;
694
695
696 rsp_params = (struct dprc_rsp_get_connection *)cmd.params;
697 endpoint2->id = le32_to_cpu(rsp_params->ep2_id);
698 endpoint2->if_id = le16_to_cpu(rsp_params->ep2_interface_id);
699 *state = le32_to_cpu(rsp_params->state);
700 for (i = 0; i < 16; i++)
701 endpoint2->type[i] = rsp_params->ep2_type[i];
702
703 return 0;
704}
705