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