1 /*
2 * Freescale Management Complex (MC) bus public interface
3 *
4 * Copyright (C) 2014-2016 Freescale Semiconductor, Inc.
5 * Author: German Rivera <German.Rivera@freescale.com>
6 *
7 * This file is licensed under the terms of the GNU General Public
8 * License version 2. This program is licensed "as is" without any
9 * warranty of any kind, whether express or implied.
10 */
11 #ifndef _FSL_MC_H_
12 #define _FSL_MC_H_
13
14 #include <linux/device.h>
15 #include <linux/mod_devicetable.h>
16 #include <linux/interrupt.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 *
36 * Generic DPAA device driver object for device drivers that are registered
37 * with a DPRC bus. This structure is to be embedded in each device-specific
38 * driver structure.
39 */
40 struct fsl_mc_driver {
41 struct device_driver driver;
42 const struct fsl_mc_device_id *match_id_table;
43 int (*probe)(struct fsl_mc_device *dev);
44 int (*remove)(struct fsl_mc_device *dev);
45 void (*shutdown)(struct fsl_mc_device *dev);
46 int (*suspend)(struct fsl_mc_device *dev, pm_message_t state);
47 int (*resume)(struct fsl_mc_device *dev);
48 };
49
50 #define to_fsl_mc_driver(_drv) \
51 container_of(_drv, struct fsl_mc_driver, driver)
52
53 /**
54 * enum fsl_mc_pool_type - Types of allocatable MC bus resources
55 *
56 * Entries in these enum are used as indices in the array of resource
57 * pools of an fsl_mc_bus object.
58 */
59 enum fsl_mc_pool_type {
60 FSL_MC_POOL_DPMCP = 0x0, /* corresponds to "dpmcp" in the MC */
61 FSL_MC_POOL_DPBP, /* corresponds to "dpbp" in the MC */
62 FSL_MC_POOL_DPCON, /* corresponds to "dpcon" in the MC */
63 FSL_MC_POOL_IRQ,
64
65 /*
66 * NOTE: New resource pool types must be added before this entry
67 */
68 FSL_MC_NUM_POOL_TYPES
69 };
70
71 /**
72 * struct fsl_mc_resource - MC generic resource
73 * @type: type of resource
74 * @id: unique MC resource Id within the resources of the same type
75 * @data: pointer to resource-specific data if the resource is currently
76 * allocated, or NULL if the resource is not currently allocated.
77 * @parent_pool: pointer to the parent resource pool from which this
78 * resource is allocated from.
79 * @node: Node in the free list of the corresponding resource pool
80 *
81 * NOTE: This structure is to be embedded as a field of specific
82 * MC resource structures.
83 */
84 struct fsl_mc_resource {
85 enum fsl_mc_pool_type type;
86 s32 id;
87 void *data;
88 struct fsl_mc_resource_pool *parent_pool;
89 struct list_head node;
90 };
91
92 /**
93 * struct fsl_mc_device_irq - MC object device message-based interrupt
94 * @msi_desc: pointer to MSI descriptor allocated by fsl_mc_msi_alloc_descs()
95 * @mc_dev: MC object device that owns this interrupt
96 * @dev_irq_index: device-relative IRQ index
97 * @resource: MC generic resource associated with the interrupt
98 */
99 struct fsl_mc_device_irq {
100 struct msi_desc *msi_desc;
101 struct fsl_mc_device *mc_dev;
102 u8 dev_irq_index;
103 struct fsl_mc_resource resource;
104 };
105
106 #define to_fsl_mc_irq(_mc_resource) \
107 container_of(_mc_resource, struct fsl_mc_device_irq, resource)
108
109 /* Opened state - Indicates that an object is open by at least one owner */
110 #define FSL_MC_OBJ_STATE_OPEN 0x00000001
111 /* Plugged state - Indicates that the object is plugged */
112 #define FSL_MC_OBJ_STATE_PLUGGED 0x00000002
113
114 /**
115 * Shareability flag - Object flag indicating no memory shareability.
116 * the object generates memory accesses that are non coherent with other
117 * masters;
118 * user is responsible for proper memory handling through IOMMU configuration.
119 */
120 #define FSL_MC_OBJ_FLAG_NO_MEM_SHAREABILITY 0x0001
121
122 /**
123 * struct fsl_mc_obj_desc - Object descriptor
124 * @type: Type of object: NULL terminated string
125 * @id: ID of logical object resource
126 * @vendor: Object vendor identifier
127 * @ver_major: Major version number
128 * @ver_minor: Minor version number
129 * @irq_count: Number of interrupts supported by the object
130 * @region_count: Number of mappable regions supported by the object
131 * @state: Object state: combination of FSL_MC_OBJ_STATE_ states
132 * @label: Object label: NULL terminated string
133 * @flags: Object's flags
134 */
135 struct fsl_mc_obj_desc {
136 char type[16];
137 int id;
138 u16 vendor;
139 u16 ver_major;
140 u16 ver_minor;
141 u8 irq_count;
142 u8 region_count;
143 u32 state;
144 char label[16];
145 u16 flags;
146 };
147
148 /**
149 * Bit masks for a MC object device (struct fsl_mc_device) flags
150 */
151 #define FSL_MC_IS_DPRC 0x0001
152
153 /**
154 * struct fsl_mc_device - MC object device object
155 * @dev: Linux driver model device object
156 * @dma_mask: Default DMA mask
157 * @flags: MC object device flags
158 * @icid: Isolation context ID for the device
159 * @mc_handle: MC handle for the corresponding MC object opened
160 * @mc_io: Pointer to MC IO object assigned to this device or
161 * NULL if none.
162 * @obj_desc: MC description of the DPAA device
163 * @regions: pointer to array of MMIO region entries
164 * @irqs: pointer to array of pointers to interrupts allocated to this device
165 * @resource: generic resource associated with this MC object device, if any.
166 *
167 * Generic device object for MC object devices that are "attached" to a
168 * MC bus.
169 *
170 * NOTES:
171 * - For a non-DPRC object its icid is the same as its parent DPRC's icid.
172 * - The SMMU notifier callback gets invoked after device_add() has been
173 * called for an MC object device, but before the device-specific probe
174 * callback gets called.
175 * - DP_OBJ_DPRC objects are the only MC objects that have built-in MC
176 * portals. For all other MC objects, their device drivers are responsible for
177 * allocating MC portals for them by calling fsl_mc_portal_allocate().
178 * - Some types of MC objects (e.g., DP_OBJ_DPBP, DP_OBJ_DPCON) are
179 * treated as resources that can be allocated/deallocated from the
180 * corresponding resource pool in the object's parent DPRC, using the
181 * fsl_mc_object_allocate()/fsl_mc_object_free() functions. These MC objects
182 * are known as "allocatable" objects. For them, the corresponding
183 * fsl_mc_device's 'resource' points to the associated resource object.
184 * For MC objects that are not allocatable (e.g., DP_OBJ_DPRC, DP_OBJ_DPNI),
185 * 'resource' is NULL.
186 */
187 struct fsl_mc_device {
188 struct device dev;
189 u64 dma_mask;
190 u16 flags;
191 u16 icid;
192 u16 mc_handle;
193 struct fsl_mc_io *mc_io;
194 struct fsl_mc_obj_desc obj_desc;
195 struct resource *regions;
196 struct fsl_mc_device_irq **irqs;
197 struct fsl_mc_resource *resource;
198 };
199
200 #define to_fsl_mc_device(_dev) \
201 container_of(_dev, struct fsl_mc_device, dev)
202
203 #define MC_CMD_NUM_OF_PARAMS 7
204
205 struct mc_cmd_header {
206 u8 src_id;
207 u8 flags_hw;
208 u8 status;
209 u8 flags_sw;
210 __le16 token;
211 __le16 cmd_id;
212 };
213
214 struct mc_command {
215 u64 header;
216 u64 params[MC_CMD_NUM_OF_PARAMS];
217 };
218
219 enum mc_cmd_status {
220 MC_CMD_STATUS_OK = 0x0, /* Completed successfully */
221 MC_CMD_STATUS_READY = 0x1, /* Ready to be processed */
222 MC_CMD_STATUS_AUTH_ERR = 0x3, /* Authentication error */
223 MC_CMD_STATUS_NO_PRIVILEGE = 0x4, /* No privilege */
224 MC_CMD_STATUS_DMA_ERR = 0x5, /* DMA or I/O error */
225 MC_CMD_STATUS_CONFIG_ERR = 0x6, /* Configuration error */
226 MC_CMD_STATUS_TIMEOUT = 0x7, /* Operation timed out */
227 MC_CMD_STATUS_NO_RESOURCE = 0x8, /* No resources */
228 MC_CMD_STATUS_NO_MEMORY = 0x9, /* No memory available */
229 MC_CMD_STATUS_BUSY = 0xA, /* Device is busy */
230 MC_CMD_STATUS_UNSUPPORTED_OP = 0xB, /* Unsupported operation */
231 MC_CMD_STATUS_INVALID_STATE = 0xC /* Invalid state */
232 };
233
234 /*
235 * MC command flags
236 */
237
238 /* High priority flag */
239 #define MC_CMD_FLAG_PRI 0x80
240 /* Command completion flag */
241 #define MC_CMD_FLAG_INTR_DIS 0x01
242
mc_encode_cmd_header(u16 cmd_id,u32 cmd_flags,u16 token)243 static inline u64 mc_encode_cmd_header(u16 cmd_id,
244 u32 cmd_flags,
245 u16 token)
246 {
247 u64 header = 0;
248 struct mc_cmd_header *hdr = (struct mc_cmd_header *)&header;
249
250 hdr->cmd_id = cpu_to_le16(cmd_id);
251 hdr->token = cpu_to_le16(token);
252 hdr->status = MC_CMD_STATUS_READY;
253 if (cmd_flags & MC_CMD_FLAG_PRI)
254 hdr->flags_hw = MC_CMD_FLAG_PRI;
255 if (cmd_flags & MC_CMD_FLAG_INTR_DIS)
256 hdr->flags_sw = MC_CMD_FLAG_INTR_DIS;
257
258 return header;
259 }
260
mc_cmd_hdr_read_token(struct mc_command * cmd)261 static inline u16 mc_cmd_hdr_read_token(struct mc_command *cmd)
262 {
263 struct mc_cmd_header *hdr = (struct mc_cmd_header *)&cmd->header;
264 u16 token = le16_to_cpu(hdr->token);
265
266 return token;
267 }
268
269 struct mc_rsp_create {
270 __le32 object_id;
271 };
272
273 struct mc_rsp_api_ver {
274 __le16 major_ver;
275 __le16 minor_ver;
276 };
277
mc_cmd_read_object_id(struct mc_command * cmd)278 static inline u32 mc_cmd_read_object_id(struct mc_command *cmd)
279 {
280 struct mc_rsp_create *rsp_params;
281
282 rsp_params = (struct mc_rsp_create *)cmd->params;
283 return le32_to_cpu(rsp_params->object_id);
284 }
285
mc_cmd_read_api_version(struct mc_command * cmd,u16 * major_ver,u16 * minor_ver)286 static inline void mc_cmd_read_api_version(struct mc_command *cmd,
287 u16 *major_ver,
288 u16 *minor_ver)
289 {
290 struct mc_rsp_api_ver *rsp_params;
291
292 rsp_params = (struct mc_rsp_api_ver *)cmd->params;
293 *major_ver = le16_to_cpu(rsp_params->major_ver);
294 *minor_ver = le16_to_cpu(rsp_params->minor_ver);
295 }
296
297 /**
298 * Bit masks for a MC I/O object (struct fsl_mc_io) flags
299 */
300 #define FSL_MC_IO_ATOMIC_CONTEXT_PORTAL 0x0001
301
302 /**
303 * struct fsl_mc_io - MC I/O object to be passed-in to mc_send_command()
304 * @dev: device associated with this Mc I/O object
305 * @flags: flags for mc_send_command()
306 * @portal_size: MC command portal size in bytes
307 * @portal_phys_addr: MC command portal physical address
308 * @portal_virt_addr: MC command portal virtual address
309 * @dpmcp_dev: pointer to the DPMCP device associated with the MC portal.
310 *
311 * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not
312 * set:
313 * @mutex: Mutex to serialize mc_send_command() calls that use the same MC
314 * portal, if the fsl_mc_io object was created with the
315 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag off. mc_send_command() calls for this
316 * fsl_mc_io object must be made only from non-atomic context.
317 *
318 * Fields are only meaningful if the FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is
319 * set:
320 * @spinlock: Spinlock to serialize mc_send_command() calls that use the same MC
321 * portal, if the fsl_mc_io object was created with the
322 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag on. mc_send_command() calls for this
323 * fsl_mc_io object can be made from atomic or non-atomic context.
324 */
325 struct fsl_mc_io {
326 struct device *dev;
327 u16 flags;
328 u16 portal_size;
329 phys_addr_t portal_phys_addr;
330 void __iomem *portal_virt_addr;
331 struct fsl_mc_device *dpmcp_dev;
332 union {
333 /*
334 * This field is only meaningful if the
335 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is not set
336 */
337 struct mutex mutex; /* serializes mc_send_command() */
338
339 /*
340 * This field is only meaningful if the
341 * FSL_MC_IO_ATOMIC_CONTEXT_PORTAL flag is set
342 */
343 spinlock_t spinlock; /* serializes mc_send_command() */
344 };
345 };
346
347 int mc_send_command(struct fsl_mc_io *mc_io, struct mc_command *cmd);
348
349 #ifdef CONFIG_FSL_MC_BUS
350 #define dev_is_fsl_mc(_dev) ((_dev)->bus == &fsl_mc_bus_type)
351 #else
352 /* If fsl-mc bus is not present device cannot belong to fsl-mc bus */
353 #define dev_is_fsl_mc(_dev) (0)
354 #endif
355
356 /*
357 * module_fsl_mc_driver() - Helper macro for drivers that don't do
358 * anything special in module init/exit. This eliminates a lot of
359 * boilerplate. Each module may only use this macro once, and
360 * calling it replaces module_init() and module_exit()
361 */
362 #define module_fsl_mc_driver(__fsl_mc_driver) \
363 module_driver(__fsl_mc_driver, fsl_mc_driver_register, \
364 fsl_mc_driver_unregister)
365
366 /*
367 * Macro to avoid include chaining to get THIS_MODULE
368 */
369 #define fsl_mc_driver_register(drv) \
370 __fsl_mc_driver_register(drv, THIS_MODULE)
371
372 int __must_check __fsl_mc_driver_register(struct fsl_mc_driver *fsl_mc_driver,
373 struct module *owner);
374
375 void fsl_mc_driver_unregister(struct fsl_mc_driver *driver);
376
377 int __must_check fsl_mc_portal_allocate(struct fsl_mc_device *mc_dev,
378 u16 mc_io_flags,
379 struct fsl_mc_io **new_mc_io);
380
381 void fsl_mc_portal_free(struct fsl_mc_io *mc_io);
382
383 int fsl_mc_portal_reset(struct fsl_mc_io *mc_io);
384
385 int __must_check fsl_mc_object_allocate(struct fsl_mc_device *mc_dev,
386 enum fsl_mc_pool_type pool_type,
387 struct fsl_mc_device **new_mc_adev);
388
389 void fsl_mc_object_free(struct fsl_mc_device *mc_adev);
390
391 struct irq_domain *fsl_mc_msi_create_irq_domain(struct fwnode_handle *fwnode,
392 struct msi_domain_info *info,
393 struct irq_domain *parent);
394
395 int __must_check fsl_mc_allocate_irqs(struct fsl_mc_device *mc_dev);
396
397 void fsl_mc_free_irqs(struct fsl_mc_device *mc_dev);
398
399 extern struct bus_type fsl_mc_bus_type;
400
401 #endif /* _FSL_MC_H_ */
402