1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | /* |
3 | * Freescale Management Complex (MC) bus public interface |
4 | * |
5 | * Copyright (C) 2014-2016 Freescale Semiconductor, Inc. |
6 | * Copyright 2019-2020 NXP |
7 | * Author: German Rivera <German.Rivera@freescale.com> |
8 | * |
9 | */ |
10 | #ifndef _FSL_MC_H_ |
11 | #define _FSL_MC_H_ |
12 | |
13 | #include <linux/device.h> |
14 | #include <linux/mod_devicetable.h> |
15 | #include <linux/interrupt.h> |
16 | #include <uapi/linux/fsl_mc.h> |
17 | |
18 | #define FSL_MC_VENDOR_FREESCALE 0x1957 |
19 | |
20 | struct irq_domain; |
21 | struct msi_domain_info; |
22 | |
23 | struct fsl_mc_device; |
24 | struct fsl_mc_io; |
25 | |
26 | /** |
27 | * struct fsl_mc_driver - MC object device driver object |
28 | * @driver: Generic device driver |
29 | * @match_id_table: table of supported device matching Ids |
30 | * @probe: Function called when a device is added |
31 | * @remove: Function called when a device is removed |
32 | * @shutdown: Function called at shutdown time to quiesce the device |
33 | * @suspend: Function called when a device is stopped |
34 | * @resume: Function called when a device is resumed |
35 | * @driver_managed_dma: Device driver doesn't use kernel DMA API for DMA. |
36 | * For most device drivers, no need to care about this flag |
37 | * as long as all DMAs are handled through the kernel DMA API. |
38 | * For some special ones, for example VFIO drivers, they know |
39 | * how to manage the DMA themselves and set this flag so that |
40 | * the IOMMU layer will allow them to setup and manage their |
41 | * own I/O address space. |
42 | * |
43 | * Generic DPAA device driver object for device drivers that are registered |
44 | * with a DPRC bus. This structure is to be embedded in each device-specific |
45 | * driver structure. |
46 | */ |
47 | struct fsl_mc_driver { |
48 | struct device_driver driver; |
49 | const struct fsl_mc_device_id *match_id_table; |
50 | int (*probe)(struct fsl_mc_device *dev); |
51 | void (*remove)(struct fsl_mc_device *dev); |
52 | void (*shutdown)(struct fsl_mc_device *dev); |
53 | int (*suspend)(struct fsl_mc_device *dev, pm_message_t state); |
54 | int (*resume)(struct fsl_mc_device *dev); |
55 | bool driver_managed_dma; |
56 | }; |
57 | |
58 | #define to_fsl_mc_driver(_drv) \ |
59 | container_of(_drv, struct fsl_mc_driver, driver) |
60 | |
61 | /** |
62 | * enum fsl_mc_pool_type - Types of allocatable MC bus resources |
63 | * |
64 | * Entries in these enum are used as indices in the array of resource |
65 | * pools of an fsl_mc_bus object. |
66 | */ |
67 | enum fsl_mc_pool_type { |
68 | FSL_MC_POOL_DPMCP = 0x0, /* corresponds to "dpmcp" in the MC */ |
69 | FSL_MC_POOL_DPBP, /* corresponds to "dpbp" in the MC */ |
70 | FSL_MC_POOL_DPCON, /* corresponds to "dpcon" in the MC */ |
71 | FSL_MC_POOL_IRQ, |
72 | |
73 | /* |
74 | * NOTE: New resource pool types must be added before this entry |
75 | */ |
76 | FSL_MC_NUM_POOL_TYPES |
77 | }; |
78 | |
79 | /** |
80 | * struct fsl_mc_resource - MC generic resource |
81 | * @type: type of resource |
82 | * @id: unique MC resource Id within the resources of the same type |
83 | * @data: pointer to resource-specific data if the resource is currently |
84 | * allocated, or NULL if the resource is not currently allocated. |
85 | * @parent_pool: pointer to the parent resource pool from which this |
86 | * resource is allocated from. |
87 | * @node: Node in the free list of the corresponding resource pool |
88 | * |
89 | * NOTE: This structure is to be embedded as a field of specific |
90 | * MC resource structures. |
91 | */ |
92 | struct fsl_mc_resource { |
93 | enum fsl_mc_pool_type type; |
94 | s32 id; |
95 | void *data; |
96 | struct fsl_mc_resource_pool *parent_pool; |
97 | struct list_head node; |
98 | }; |
99 | |
100 | /** |
101 | * struct fsl_mc_device_irq - MC object device message-based interrupt |
102 | * @virq: Linux virtual interrupt number |
103 | * @mc_dev: MC object device that owns this interrupt |
104 | * @dev_irq_index: device-relative IRQ index |
105 | * @resource: MC generic resource associated with the interrupt |
106 | */ |
107 | struct fsl_mc_device_irq { |
108 | unsigned int virq; |
109 | struct fsl_mc_device *mc_dev; |
110 | u8 dev_irq_index; |
111 | struct fsl_mc_resource resource; |
112 | }; |
113 | |
114 | #define to_fsl_mc_irq(_mc_resource) \ |
115 | container_of(_mc_resource, struct fsl_mc_device_irq, resource) |
116 | |
117 | /* Opened state - Indicates that an object is open by at least one owner */ |
118 | #define FSL_MC_OBJ_STATE_OPEN 0x00000001 |
119 | /* Plugged state - Indicates that the object is plugged */ |
120 | #define FSL_MC_OBJ_STATE_PLUGGED 0x00000002 |
121 | |
122 | /** |
123 | * Shareability flag - Object flag indicating no memory shareability. |
124 | * the object generates memory accesses that are non coherent with other |
125 | * masters; |
126 | * user is responsible for proper memory handling through IOMMU configuration. |
127 | */ |
128 | #define FSL_MC_OBJ_FLAG_NO_MEM_SHAREABILITY 0x0001 |
129 | |
130 | /** |
131 | * struct fsl_mc_obj_desc - Object descriptor |
132 | * @type: Type of object: NULL terminated string |
133 | * @id: ID of logical object resource |
134 | * @vendor: Object vendor identifier |
135 | * @ver_major: Major version number |
136 | * @ver_minor: Minor version number |
137 | * @irq_count: Number of interrupts supported by the object |
138 | * @region_count: Number of mappable regions supported by the object |
139 | * @state: Object state: combination of FSL_MC_OBJ_STATE_ states |
140 | * @label: Object label: NULL terminated string |
141 | * @flags: Object's flags |
142 | */ |
143 | struct fsl_mc_obj_desc { |
144 | char type[16]; |
145 | int id; |
146 | u16 vendor; |
147 | u16 ver_major; |
148 | u16 ver_minor; |
149 | u8 irq_count; |
150 | u8 region_count; |
151 | u32 state; |
152 | char label[16]; |
153 | u16 flags; |
154 | }; |
155 | |
156 | /** |
157 | * Bit masks for a MC object device (struct fsl_mc_device) flags |
158 | */ |
159 | #define FSL_MC_IS_DPRC 0x0001 |
160 | |
161 | /* Region flags */ |
162 | /* Indicates that region can be mapped as cacheable */ |
163 | #define FSL_MC_REGION_CACHEABLE 0x00000001 |
164 | |
165 | /* Indicates that region can be mapped as shareable */ |
166 | #define FSL_MC_REGION_SHAREABLE 0x00000002 |
167 | |
168 | /** |
169 | * struct fsl_mc_device - MC object device object |
170 | * @dev: Linux driver model device object |
171 | * @dma_mask: Default DMA mask |
172 | * @flags: MC object device flags |
173 | * @icid: Isolation context ID for the device |
174 | * @mc_handle: MC handle for the corresponding MC object opened |
175 | * @mc_io: Pointer to MC IO object assigned to this device or |
176 | * NULL if none. |
177 | * @obj_desc: MC description of the DPAA device |
178 | * @regions: pointer to array of MMIO region entries |
179 | * @irqs: pointer to array of pointers to interrupts allocated to this device |
180 | * @resource: generic resource associated with this MC object device, if any. |
181 | * @driver_override: driver name to force a match; do not set directly, |
182 | * because core frees it; use driver_set_override() to |
183 | * set or clear it. |
184 | * |
185 | * Generic device object for MC object devices that are "attached" to a |
186 | * MC bus. |
187 | * |
188 | * NOTES: |
189 | * - For a non-DPRC object its icid is the same as its parent DPRC's icid. |
190 | * - The SMMU notifier callback gets invoked after device_add() has been |
191 | * called for an MC object device, but before the device-specific probe |
192 | * callback gets called. |
193 | * - DP_OBJ_DPRC objects are the only MC objects that have built-in MC |
194 | * portals. For all other MC objects, their device drivers are responsible for |
195 | * allocating MC portals for them by calling fsl_mc_portal_allocate(). |
196 | * - Some types of MC objects (e.g., DP_OBJ_DPBP, DP_OBJ_DPCON) are |
197 | * treated as resources that can be allocated/deallocated from the |
198 | * corresponding resource pool in the object's parent DPRC, using the |
199 | * fsl_mc_object_allocate()/fsl_mc_object_free() functions. These MC objects |
200 | * are known as "allocatable" objects. For them, the corresponding |
201 | * fsl_mc_device's 'resource' points to the associated resource object. |
202 | * For MC objects that are not allocatable (e.g., DP_OBJ_DPRC, DP_OBJ_DPNI), |
203 | * 'resource' is NULL. |
204 | */ |
205 | struct fsl_mc_device { |
206 | struct device dev; |
207 | u64 dma_mask; |
208 | u16 flags; |
209 | u32 icid; |
210 | u16 mc_handle; |
211 | struct fsl_mc_io *mc_io; |
212 | struct fsl_mc_obj_desc obj_desc; |
213 | struct resource *regions; |
214 | struct fsl_mc_device_irq **irqs; |
215 | struct fsl_mc_resource *resource; |
216 | struct device_link *consumer_link; |
217 | const char *driver_override; |
218 | }; |
219 | |
220 | #define to_fsl_mc_device(_dev) \ |
221 | container_of(_dev, struct fsl_mc_device, dev) |
222 | |
223 | struct { |
224 | u8 ; |
225 | u8 ; |
226 | u8 ; |
227 | u8 ; |
228 | __le16 ; |
229 | __le16 ; |
230 | }; |
231 | |
232 | enum mc_cmd_status { |
233 | MC_CMD_STATUS_OK = 0x0, /* Completed successfully */ |
234 | MC_CMD_STATUS_READY = 0x1, /* Ready to be processed */ |
235 | MC_CMD_STATUS_AUTH_ERR = 0x3, /* Authentication error */ |
236 | MC_CMD_STATUS_NO_PRIVILEGE = 0x4, /* No privilege */ |
237 | MC_CMD_STATUS_DMA_ERR = 0x5, /* DMA or I/O error */ |
238 | MC_CMD_STATUS_CONFIG_ERR = 0x6, /* Configuration error */ |
239 | MC_CMD_STATUS_TIMEOUT = 0x7, /* Operation timed out */ |
240 | MC_CMD_STATUS_NO_RESOURCE = 0x8, /* No resources */ |
241 | MC_CMD_STATUS_NO_MEMORY = 0x9, /* No memory available */ |
242 | MC_CMD_STATUS_BUSY = 0xA, /* Device is busy */ |
243 | MC_CMD_STATUS_UNSUPPORTED_OP = 0xB, /* Unsupported operation */ |
244 | MC_CMD_STATUS_INVALID_STATE = 0xC /* Invalid state */ |
245 | }; |
246 | |
247 | /* |
248 | * MC command flags |
249 | */ |
250 | |
251 | /* High priority flag */ |
252 | #define MC_CMD_FLAG_PRI 0x80 |
253 | /* Command completion flag */ |
254 | #define MC_CMD_FLAG_INTR_DIS 0x01 |
255 | |
256 | static inline __le64 (u16 cmd_id, |
257 | u32 cmd_flags, |
258 | u16 token) |
259 | { |
260 | __le64 = 0; |
261 | struct mc_cmd_header *hdr = (struct mc_cmd_header *)&header; |
262 | |
263 | hdr->cmd_id = cpu_to_le16(cmd_id); |
264 | hdr->token = cpu_to_le16(token); |
265 | hdr->status = MC_CMD_STATUS_READY; |
266 | if (cmd_flags & MC_CMD_FLAG_PRI) |
267 | hdr->flags_hw = MC_CMD_FLAG_PRI; |
268 | if (cmd_flags & MC_CMD_FLAG_INTR_DIS) |
269 | hdr->flags_sw = MC_CMD_FLAG_INTR_DIS; |
270 | |
271 | return header; |
272 | } |
273 | |
274 | static inline u16 mc_cmd_hdr_read_token(struct fsl_mc_command *cmd) |
275 | { |
276 | struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header; |
277 | u16 token = le16_to_cpu(hdr->token); |
278 | |
279 | return token; |
280 | } |
281 | |
282 | struct mc_rsp_create { |
283 | __le32 object_id; |
284 | }; |
285 | |
286 | struct mc_rsp_api_ver { |
287 | __le16 major_ver; |
288 | __le16 minor_ver; |
289 | }; |
290 | |
291 | static inline u32 mc_cmd_read_object_id(struct fsl_mc_command *cmd) |
292 | { |
293 | struct mc_rsp_create *rsp_params; |
294 | |
295 | rsp_params = (struct mc_rsp_create *)cmd->params; |
296 | return le32_to_cpu(rsp_params->object_id); |
297 | } |
298 | |
299 | static inline void mc_cmd_read_api_version(struct fsl_mc_command *cmd, |
300 | u16 *major_ver, |
301 | u16 *minor_ver) |
302 | { |
303 | struct mc_rsp_api_ver *rsp_params; |
304 | |
305 | rsp_params = (struct mc_rsp_api_ver *)cmd->params; |
306 | *major_ver = le16_to_cpu(rsp_params->major_ver); |
307 | *minor_ver = le16_to_cpu(rsp_params->minor_ver); |
308 | } |
309 | |
310 | /** |
311 | * Bit masks for a MC I/O object (struct fsl_mc_io) flags |
312 | */ |
313 | #define FSL_MC_IO_ATOMIC_CONTEXT_PORTAL 0x0001 |
314 | |
315 | /** |
316 | * struct fsl_mc_io - MC I/O object to be passed-in to mc_send_command() |
317 | * @dev: device associated with this Mc I/O object |
318 | * @flags: flags for mc_send_command() |
319 | * @portal_size: MC command portal size in bytes |
320 | * @portal_phys_addr: MC command portal physical address |
321 | * @portal_virt_addr: MC command portal virtual address |
322 | * @dpmcp_dev: pointer to the DPMCP device associated with the MC portal. |
323 | * |
324 | * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not |
325 | * set: |
326 | * @mutex: Mutex to serialize mc_send_command() calls that use the same MC |
327 | * portal, if the fsl_mc_io object was created with the |
328 | * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag off. mc_send_command() calls for this |
329 | * fsl_mc_io object must be made only from non-atomic context. |
330 | * |
331 | * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is |
332 | * set: |
333 | * @spinlock: Spinlock to serialize mc_send_command() calls that use the same MC |
334 | * portal, if the fsl_mc_io object was created with the |
335 | * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag on. mc_send_command() calls for this |
336 | * fsl_mc_io object can be made from atomic or non-atomic context. |
337 | */ |
338 | struct fsl_mc_io { |
339 | struct device *dev; |
340 | u16 flags; |
341 | u32 portal_size; |
342 | phys_addr_t portal_phys_addr; |
343 | void __iomem *portal_virt_addr; |
344 | struct fsl_mc_device *dpmcp_dev; |
345 | union { |
346 | /* |
347 | * This field is only meaningful if the |
348 | * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not set |
349 | */ |
350 | struct mutex mutex; /* serializes mc_send_command() */ |
351 | |
352 | /* |
353 | * This field is only meaningful if the |
354 | * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is set |
355 | */ |
356 | raw_spinlock_t spinlock; /* serializes mc_send_command() */ |
357 | }; |
358 | }; |
359 | |
360 | int mc_send_command(struct fsl_mc_io *mc_io, struct fsl_mc_command *cmd); |
361 | |
362 | #ifdef CONFIG_FSL_MC_BUS |
363 | #define dev_is_fsl_mc(_dev) ((_dev)->bus == &fsl_mc_bus_type) |
364 | #else |
365 | /* If fsl-mc bus is not present device cannot belong to fsl-mc bus */ |
366 | #define dev_is_fsl_mc(_dev) (0) |
367 | #endif |
368 | |
369 | /* Macro to check if a device is a container device */ |
370 | #define fsl_mc_is_cont_dev(_dev) (to_fsl_mc_device(_dev)->flags & \ |
371 | FSL_MC_IS_DPRC) |
372 | |
373 | /* Macro to get the container device of a MC device */ |
374 | #define fsl_mc_cont_dev(_dev) (fsl_mc_is_cont_dev(_dev) ? \ |
375 | (_dev) : (_dev)->parent) |
376 | |
377 | /* |
378 | * module_fsl_mc_driver() - Helper macro for drivers that don't do |
379 | * anything special in module init/exit. This eliminates a lot of |
380 | * boilerplate. Each module may only use this macro once, and |
381 | * calling it replaces module_init() and module_exit() |
382 | */ |
383 | #define module_fsl_mc_driver(__fsl_mc_driver) \ |
384 | module_driver(__fsl_mc_driver, fsl_mc_driver_register, \ |
385 | fsl_mc_driver_unregister) |
386 | |
387 | /* |
388 | * Macro to avoid include chaining to get THIS_MODULE |
389 | */ |
390 | #define fsl_mc_driver_register(drv) \ |
391 | __fsl_mc_driver_register(drv, THIS_MODULE) |
392 | |
393 | int __must_check __fsl_mc_driver_register(struct fsl_mc_driver *fsl_mc_driver, |
394 | struct module *owner); |
395 | |
396 | void fsl_mc_driver_unregister(struct fsl_mc_driver *driver); |
397 | |
398 | /** |
399 | * struct fsl_mc_version |
400 | * @major: Major version number: incremented on API compatibility changes |
401 | * @minor: Minor version number: incremented on API additions (that are |
402 | * backward compatible); reset when major version is incremented |
403 | * @revision: Internal revision number: incremented on implementation changes |
404 | * and/or bug fixes that have no impact on API |
405 | */ |
406 | struct fsl_mc_version { |
407 | u32 major; |
408 | u32 minor; |
409 | u32 revision; |
410 | }; |
411 | |
412 | struct fsl_mc_version *fsl_mc_get_version(void); |
413 | |
414 | int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev, |
415 | u16 mc_io_flags, |
416 | struct fsl_mc_io **new_mc_io); |
417 | |
418 | void fsl_mc_portal_free(struct fsl_mc_io *mc_io); |
419 | |
420 | int fsl_mc_portal_reset(struct fsl_mc_io *mc_io); |
421 | |
422 | int __must_check fsl_mc_object_allocate(struct fsl_mc_device *mc_dev, |
423 | enum fsl_mc_pool_type pool_type, |
424 | struct fsl_mc_device **new_mc_adev); |
425 | |
426 | void fsl_mc_object_free(struct fsl_mc_device *mc_adev); |
427 | |
428 | struct irq_domain *fsl_mc_msi_create_irq_domain(struct fwnode_handle *fwnode, |
429 | struct msi_domain_info *info, |
430 | struct irq_domain *parent); |
431 | |
432 | int __must_check fsl_mc_allocate_irqs(struct fsl_mc_device *mc_dev); |
433 | |
434 | void fsl_mc_free_irqs(struct fsl_mc_device *mc_dev); |
435 | |
436 | struct fsl_mc_device *fsl_mc_get_endpoint(struct fsl_mc_device *mc_dev, |
437 | u16 if_id); |
438 | |
439 | extern struct bus_type fsl_mc_bus_type; |
440 | |
441 | extern struct device_type fsl_mc_bus_dprc_type; |
442 | extern struct device_type fsl_mc_bus_dpni_type; |
443 | extern struct device_type fsl_mc_bus_dpio_type; |
444 | extern struct device_type fsl_mc_bus_dpsw_type; |
445 | extern struct device_type fsl_mc_bus_dpbp_type; |
446 | extern struct device_type fsl_mc_bus_dpcon_type; |
447 | extern struct device_type fsl_mc_bus_dpmcp_type; |
448 | extern struct device_type fsl_mc_bus_dpmac_type; |
449 | extern struct device_type fsl_mc_bus_dprtc_type; |
450 | extern struct device_type fsl_mc_bus_dpseci_type; |
451 | extern struct device_type fsl_mc_bus_dpdmux_type; |
452 | extern struct device_type fsl_mc_bus_dpdcei_type; |
453 | extern struct device_type fsl_mc_bus_dpaiop_type; |
454 | extern struct device_type fsl_mc_bus_dpci_type; |
455 | extern struct device_type fsl_mc_bus_dpdmai_type; |
456 | |
457 | static inline bool is_fsl_mc_bus_dprc(const struct fsl_mc_device *mc_dev) |
458 | { |
459 | return mc_dev->dev.type == &fsl_mc_bus_dprc_type; |
460 | } |
461 | |
462 | static inline bool is_fsl_mc_bus_dpni(const struct fsl_mc_device *mc_dev) |
463 | { |
464 | return mc_dev->dev.type == &fsl_mc_bus_dpni_type; |
465 | } |
466 | |
467 | static inline bool is_fsl_mc_bus_dpio(const struct fsl_mc_device *mc_dev) |
468 | { |
469 | return mc_dev->dev.type == &fsl_mc_bus_dpio_type; |
470 | } |
471 | |
472 | static inline bool is_fsl_mc_bus_dpsw(const struct fsl_mc_device *mc_dev) |
473 | { |
474 | return mc_dev->dev.type == &fsl_mc_bus_dpsw_type; |
475 | } |
476 | |
477 | static inline bool is_fsl_mc_bus_dpdmux(const struct fsl_mc_device *mc_dev) |
478 | { |
479 | return mc_dev->dev.type == &fsl_mc_bus_dpdmux_type; |
480 | } |
481 | |
482 | static inline bool is_fsl_mc_bus_dpbp(const struct fsl_mc_device *mc_dev) |
483 | { |
484 | return mc_dev->dev.type == &fsl_mc_bus_dpbp_type; |
485 | } |
486 | |
487 | static inline bool is_fsl_mc_bus_dpcon(const struct fsl_mc_device *mc_dev) |
488 | { |
489 | return mc_dev->dev.type == &fsl_mc_bus_dpcon_type; |
490 | } |
491 | |
492 | static inline bool is_fsl_mc_bus_dpmcp(const struct fsl_mc_device *mc_dev) |
493 | { |
494 | return mc_dev->dev.type == &fsl_mc_bus_dpmcp_type; |
495 | } |
496 | |
497 | static inline bool is_fsl_mc_bus_dpmac(const struct fsl_mc_device *mc_dev) |
498 | { |
499 | return mc_dev->dev.type == &fsl_mc_bus_dpmac_type; |
500 | } |
501 | |
502 | static inline bool is_fsl_mc_bus_dprtc(const struct fsl_mc_device *mc_dev) |
503 | { |
504 | return mc_dev->dev.type == &fsl_mc_bus_dprtc_type; |
505 | } |
506 | |
507 | static inline bool is_fsl_mc_bus_dpseci(const struct fsl_mc_device *mc_dev) |
508 | { |
509 | return mc_dev->dev.type == &fsl_mc_bus_dpseci_type; |
510 | } |
511 | |
512 | static inline bool is_fsl_mc_bus_dpdcei(const struct fsl_mc_device *mc_dev) |
513 | { |
514 | return mc_dev->dev.type == &fsl_mc_bus_dpdcei_type; |
515 | } |
516 | |
517 | static inline bool is_fsl_mc_bus_dpaiop(const struct fsl_mc_device *mc_dev) |
518 | { |
519 | return mc_dev->dev.type == &fsl_mc_bus_dpaiop_type; |
520 | } |
521 | |
522 | static inline bool is_fsl_mc_bus_dpci(const struct fsl_mc_device *mc_dev) |
523 | { |
524 | return mc_dev->dev.type == &fsl_mc_bus_dpci_type; |
525 | } |
526 | |
527 | static inline bool is_fsl_mc_bus_dpdmai(const struct fsl_mc_device *mc_dev) |
528 | { |
529 | return mc_dev->dev.type == &fsl_mc_bus_dpdmai_type; |
530 | } |
531 | |
532 | #define DPRC_RESET_OPTION_NON_RECURSIVE 0x00000001 |
533 | int dprc_reset_container(struct fsl_mc_io *mc_io, |
534 | u32 cmd_flags, |
535 | u16 token, |
536 | int child_container_id, |
537 | u32 options); |
538 | |
539 | int dprc_scan_container(struct fsl_mc_device *mc_bus_dev, |
540 | bool alloc_interrupts); |
541 | |
542 | void dprc_remove_devices(struct fsl_mc_device *mc_bus_dev, |
543 | struct fsl_mc_obj_desc *obj_desc_array, |
544 | int num_child_objects_in_mc); |
545 | |
546 | int dprc_cleanup(struct fsl_mc_device *mc_dev); |
547 | |
548 | int dprc_setup(struct fsl_mc_device *mc_dev); |
549 | |
550 | /** |
551 | * Maximum number of total IRQs that can be pre-allocated for an MC bus' |
552 | * IRQ pool |
553 | */ |
554 | #define FSL_MC_IRQ_POOL_MAX_TOTAL_IRQS 256 |
555 | |
556 | int fsl_mc_populate_irq_pool(struct fsl_mc_device *mc_bus_dev, |
557 | unsigned int irq_count); |
558 | |
559 | void fsl_mc_cleanup_irq_pool(struct fsl_mc_device *mc_bus_dev); |
560 | |
561 | /* |
562 | * Data Path Buffer Pool (DPBP) API |
563 | * Contains initialization APIs and runtime control APIs for DPBP |
564 | */ |
565 | |
566 | int dpbp_open(struct fsl_mc_io *mc_io, |
567 | u32 cmd_flags, |
568 | int dpbp_id, |
569 | u16 *token); |
570 | |
571 | int dpbp_close(struct fsl_mc_io *mc_io, |
572 | u32 cmd_flags, |
573 | u16 token); |
574 | |
575 | int dpbp_enable(struct fsl_mc_io *mc_io, |
576 | u32 cmd_flags, |
577 | u16 token); |
578 | |
579 | int dpbp_disable(struct fsl_mc_io *mc_io, |
580 | u32 cmd_flags, |
581 | u16 token); |
582 | |
583 | int dpbp_reset(struct fsl_mc_io *mc_io, |
584 | u32 cmd_flags, |
585 | u16 token); |
586 | |
587 | /** |
588 | * struct dpbp_attr - Structure representing DPBP attributes |
589 | * @id: DPBP object ID |
590 | * @bpid: Hardware buffer pool ID; should be used as an argument in |
591 | * acquire/release operations on buffers |
592 | */ |
593 | struct dpbp_attr { |
594 | int id; |
595 | u16 bpid; |
596 | }; |
597 | |
598 | int dpbp_get_attributes(struct fsl_mc_io *mc_io, |
599 | u32 cmd_flags, |
600 | u16 token, |
601 | struct dpbp_attr *attr); |
602 | |
603 | /* Data Path Concentrator (DPCON) API |
604 | * Contains initialization APIs and runtime control APIs for DPCON |
605 | */ |
606 | |
607 | /** |
608 | * Use it to disable notifications; see dpcon_set_notification() |
609 | */ |
610 | #define DPCON_INVALID_DPIO_ID (int)(-1) |
611 | |
612 | int dpcon_open(struct fsl_mc_io *mc_io, |
613 | u32 cmd_flags, |
614 | int dpcon_id, |
615 | u16 *token); |
616 | |
617 | int dpcon_close(struct fsl_mc_io *mc_io, |
618 | u32 cmd_flags, |
619 | u16 token); |
620 | |
621 | int dpcon_enable(struct fsl_mc_io *mc_io, |
622 | u32 cmd_flags, |
623 | u16 token); |
624 | |
625 | int dpcon_disable(struct fsl_mc_io *mc_io, |
626 | u32 cmd_flags, |
627 | u16 token); |
628 | |
629 | int dpcon_reset(struct fsl_mc_io *mc_io, |
630 | u32 cmd_flags, |
631 | u16 token); |
632 | |
633 | int fsl_mc_obj_open(struct fsl_mc_io *mc_io, |
634 | u32 cmd_flags, |
635 | int obj_id, |
636 | char *obj_type, |
637 | u16 *token); |
638 | |
639 | int fsl_mc_obj_close(struct fsl_mc_io *mc_io, |
640 | u32 cmd_flags, |
641 | u16 token); |
642 | |
643 | int fsl_mc_obj_reset(struct fsl_mc_io *mc_io, |
644 | u32 cmd_flags, |
645 | u16 token); |
646 | |
647 | /** |
648 | * struct dpcon_attr - Structure representing DPCON attributes |
649 | * @id: DPCON object ID |
650 | * @qbman_ch_id: Channel ID to be used by dequeue operation |
651 | * @num_priorities: Number of priorities for the DPCON channel (1-8) |
652 | */ |
653 | struct dpcon_attr { |
654 | int id; |
655 | u16 qbman_ch_id; |
656 | u8 num_priorities; |
657 | }; |
658 | |
659 | int dpcon_get_attributes(struct fsl_mc_io *mc_io, |
660 | u32 cmd_flags, |
661 | u16 token, |
662 | struct dpcon_attr *attr); |
663 | |
664 | /** |
665 | * struct dpcon_notification_cfg - Structure representing notification params |
666 | * @dpio_id: DPIO object ID; must be configured with a notification channel; |
667 | * to disable notifications set it to 'DPCON_INVALID_DPIO_ID'; |
668 | * @priority: Priority selection within the DPIO channel; valid values |
669 | * are 0-7, depending on the number of priorities in that channel |
670 | * @user_ctx: User context value provided with each CDAN message |
671 | */ |
672 | struct dpcon_notification_cfg { |
673 | int dpio_id; |
674 | u8 priority; |
675 | u64 user_ctx; |
676 | }; |
677 | |
678 | int dpcon_set_notification(struct fsl_mc_io *mc_io, |
679 | u32 cmd_flags, |
680 | u16 token, |
681 | struct dpcon_notification_cfg *cfg); |
682 | |
683 | #endif /* _FSL_MC_H_ */ |
684 | |