1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright 2013-2016 Freescale Semiconductor Inc. |
4 | * Copyright 2016-2018 NXP |
5 | */ |
6 | |
7 | #include <linux/fsl/mc.h> |
8 | |
9 | #include "dprtc.h" |
10 | #include "dprtc-cmd.h" |
11 | |
12 | /** |
13 | * dprtc_open() - Open a control session for the specified object. |
14 | * @mc_io: Pointer to MC portal's I/O object |
15 | * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' |
16 | * @dprtc_id: DPRTC unique ID |
17 | * @token: Returned token; use in subsequent API calls |
18 | * |
19 | * This function can be used to open a control session for an |
20 | * already created object; an object may have been declared in |
21 | * the DPL or by calling the dprtc_create function. |
22 | * This function returns a unique authentication token, |
23 | * associated with the specific object ID and the specific MC |
24 | * portal; this token must be used in all subsequent commands for |
25 | * this specific object |
26 | * |
27 | * Return: '0' on Success; Error code otherwise. |
28 | */ |
29 | int dprtc_open(struct fsl_mc_io *mc_io, |
30 | u32 cmd_flags, |
31 | int dprtc_id, |
32 | u16 *token) |
33 | { |
34 | struct dprtc_cmd_open *cmd_params; |
35 | struct fsl_mc_command cmd = { 0 }; |
36 | int err; |
37 | |
38 | cmd.header = mc_encode_cmd_header(DPRTC_CMDID_OPEN, |
39 | cmd_flags, |
40 | token: 0); |
41 | cmd_params = (struct dprtc_cmd_open *)cmd.params; |
42 | cmd_params->dprtc_id = cpu_to_le32(dprtc_id); |
43 | |
44 | err = mc_send_command(mc_io, cmd: &cmd); |
45 | if (err) |
46 | return err; |
47 | |
48 | *token = mc_cmd_hdr_read_token(cmd: &cmd); |
49 | |
50 | return 0; |
51 | } |
52 | |
53 | /** |
54 | * dprtc_close() - Close the control session of the object |
55 | * @mc_io: Pointer to MC portal's I/O object |
56 | * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' |
57 | * @token: Token of DPRTC object |
58 | * |
59 | * After this function is called, no further operations are |
60 | * allowed on the object without opening a new control session. |
61 | * |
62 | * Return: '0' on Success; Error code otherwise. |
63 | */ |
64 | int dprtc_close(struct fsl_mc_io *mc_io, |
65 | u32 cmd_flags, |
66 | u16 token) |
67 | { |
68 | struct fsl_mc_command cmd = { 0 }; |
69 | |
70 | cmd.header = mc_encode_cmd_header(DPRTC_CMDID_CLOSE, cmd_flags, |
71 | token); |
72 | |
73 | return mc_send_command(mc_io, cmd: &cmd); |
74 | } |
75 | |
76 | /** |
77 | * dprtc_set_irq_enable() - Set overall interrupt state. |
78 | * @mc_io: Pointer to MC portal's I/O object |
79 | * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' |
80 | * @token: Token of DPRTC object |
81 | * @irq_index: The interrupt index to configure |
82 | * @en: Interrupt state - enable = 1, disable = 0 |
83 | * |
84 | * Allows GPP software to control when interrupts are generated. |
85 | * Each interrupt can have up to 32 causes. The enable/disable control's the |
86 | * overall interrupt state. if the interrupt is disabled no causes will cause |
87 | * an interrupt. |
88 | * |
89 | * Return: '0' on Success; Error code otherwise. |
90 | */ |
91 | int dprtc_set_irq_enable(struct fsl_mc_io *mc_io, |
92 | u32 cmd_flags, |
93 | u16 token, |
94 | u8 irq_index, |
95 | u8 en) |
96 | { |
97 | struct dprtc_cmd_set_irq_enable *cmd_params; |
98 | struct fsl_mc_command cmd = { 0 }; |
99 | |
100 | cmd.header = mc_encode_cmd_header(DPRTC_CMDID_SET_IRQ_ENABLE, |
101 | cmd_flags, |
102 | token); |
103 | cmd_params = (struct dprtc_cmd_set_irq_enable *)cmd.params; |
104 | cmd_params->irq_index = irq_index; |
105 | cmd_params->en = en; |
106 | |
107 | return mc_send_command(mc_io, cmd: &cmd); |
108 | } |
109 | |
110 | /** |
111 | * dprtc_get_irq_enable() - Get overall interrupt state |
112 | * @mc_io: Pointer to MC portal's I/O object |
113 | * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' |
114 | * @token: Token of DPRTC object |
115 | * @irq_index: The interrupt index to configure |
116 | * @en: Returned interrupt state - enable = 1, disable = 0 |
117 | * |
118 | * Return: '0' on Success; Error code otherwise. |
119 | */ |
120 | int dprtc_get_irq_enable(struct fsl_mc_io *mc_io, |
121 | u32 cmd_flags, |
122 | u16 token, |
123 | u8 irq_index, |
124 | u8 *en) |
125 | { |
126 | struct dprtc_rsp_get_irq_enable *rsp_params; |
127 | struct dprtc_cmd_get_irq *cmd_params; |
128 | struct fsl_mc_command cmd = { 0 }; |
129 | int err; |
130 | |
131 | cmd.header = mc_encode_cmd_header(DPRTC_CMDID_GET_IRQ_ENABLE, |
132 | cmd_flags, |
133 | token); |
134 | cmd_params = (struct dprtc_cmd_get_irq *)cmd.params; |
135 | cmd_params->irq_index = irq_index; |
136 | |
137 | err = mc_send_command(mc_io, cmd: &cmd); |
138 | if (err) |
139 | return err; |
140 | |
141 | rsp_params = (struct dprtc_rsp_get_irq_enable *)cmd.params; |
142 | *en = rsp_params->en; |
143 | |
144 | return 0; |
145 | } |
146 | |
147 | /** |
148 | * dprtc_set_irq_mask() - Set interrupt mask. |
149 | * @mc_io: Pointer to MC portal's I/O object |
150 | * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' |
151 | * @token: Token of DPRTC object |
152 | * @irq_index: The interrupt index to configure |
153 | * @mask: Event mask to trigger interrupt; |
154 | * each bit: |
155 | * 0 = ignore event |
156 | * 1 = consider event for asserting IRQ |
157 | * |
158 | * Every interrupt can have up to 32 causes and the interrupt model supports |
159 | * masking/unmasking each cause independently |
160 | * |
161 | * Return: '0' on Success; Error code otherwise. |
162 | */ |
163 | int dprtc_set_irq_mask(struct fsl_mc_io *mc_io, |
164 | u32 cmd_flags, |
165 | u16 token, |
166 | u8 irq_index, |
167 | u32 mask) |
168 | { |
169 | struct dprtc_cmd_set_irq_mask *cmd_params; |
170 | struct fsl_mc_command cmd = { 0 }; |
171 | |
172 | cmd.header = mc_encode_cmd_header(DPRTC_CMDID_SET_IRQ_MASK, |
173 | cmd_flags, |
174 | token); |
175 | cmd_params = (struct dprtc_cmd_set_irq_mask *)cmd.params; |
176 | cmd_params->mask = cpu_to_le32(mask); |
177 | cmd_params->irq_index = irq_index; |
178 | |
179 | return mc_send_command(mc_io, cmd: &cmd); |
180 | } |
181 | |
182 | /** |
183 | * dprtc_get_irq_mask() - Get interrupt mask. |
184 | * @mc_io: Pointer to MC portal's I/O object |
185 | * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' |
186 | * @token: Token of DPRTC object |
187 | * @irq_index: The interrupt index to configure |
188 | * @mask: Returned event mask to trigger interrupt |
189 | * |
190 | * Every interrupt can have up to 32 causes and the interrupt model supports |
191 | * masking/unmasking each cause independently |
192 | * |
193 | * Return: '0' on Success; Error code otherwise. |
194 | */ |
195 | int dprtc_get_irq_mask(struct fsl_mc_io *mc_io, |
196 | u32 cmd_flags, |
197 | u16 token, |
198 | u8 irq_index, |
199 | u32 *mask) |
200 | { |
201 | struct dprtc_rsp_get_irq_mask *rsp_params; |
202 | struct dprtc_cmd_get_irq *cmd_params; |
203 | struct fsl_mc_command cmd = { 0 }; |
204 | int err; |
205 | |
206 | cmd.header = mc_encode_cmd_header(DPRTC_CMDID_GET_IRQ_MASK, |
207 | cmd_flags, |
208 | token); |
209 | cmd_params = (struct dprtc_cmd_get_irq *)cmd.params; |
210 | cmd_params->irq_index = irq_index; |
211 | |
212 | err = mc_send_command(mc_io, cmd: &cmd); |
213 | if (err) |
214 | return err; |
215 | |
216 | rsp_params = (struct dprtc_rsp_get_irq_mask *)cmd.params; |
217 | *mask = le32_to_cpu(rsp_params->mask); |
218 | |
219 | return 0; |
220 | } |
221 | |
222 | /** |
223 | * dprtc_get_irq_status() - Get the current status of any pending interrupts. |
224 | * |
225 | * @mc_io: Pointer to MC portal's I/O object |
226 | * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' |
227 | * @token: Token of DPRTC object |
228 | * @irq_index: The interrupt index to configure |
229 | * @status: Returned interrupts status - one bit per cause: |
230 | * 0 = no interrupt pending |
231 | * 1 = interrupt pending |
232 | * |
233 | * Return: '0' on Success; Error code otherwise. |
234 | */ |
235 | int dprtc_get_irq_status(struct fsl_mc_io *mc_io, |
236 | u32 cmd_flags, |
237 | u16 token, |
238 | u8 irq_index, |
239 | u32 *status) |
240 | { |
241 | struct dprtc_cmd_get_irq_status *cmd_params; |
242 | struct dprtc_rsp_get_irq_status *rsp_params; |
243 | struct fsl_mc_command cmd = { 0 }; |
244 | int err; |
245 | |
246 | cmd.header = mc_encode_cmd_header(DPRTC_CMDID_GET_IRQ_STATUS, |
247 | cmd_flags, |
248 | token); |
249 | cmd_params = (struct dprtc_cmd_get_irq_status *)cmd.params; |
250 | cmd_params->status = cpu_to_le32(*status); |
251 | cmd_params->irq_index = irq_index; |
252 | |
253 | err = mc_send_command(mc_io, cmd: &cmd); |
254 | if (err) |
255 | return err; |
256 | |
257 | rsp_params = (struct dprtc_rsp_get_irq_status *)cmd.params; |
258 | *status = le32_to_cpu(rsp_params->status); |
259 | |
260 | return 0; |
261 | } |
262 | |
263 | /** |
264 | * dprtc_clear_irq_status() - Clear a pending interrupt's status |
265 | * |
266 | * @mc_io: Pointer to MC portal's I/O object |
267 | * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_' |
268 | * @token: Token of DPRTC object |
269 | * @irq_index: The interrupt index to configure |
270 | * @status: Bits to clear (W1C) - one bit per cause: |
271 | * 0 = don't change |
272 | * 1 = clear status bit |
273 | * |
274 | * Return: '0' on Success; Error code otherwise. |
275 | */ |
276 | int dprtc_clear_irq_status(struct fsl_mc_io *mc_io, |
277 | u32 cmd_flags, |
278 | u16 token, |
279 | u8 irq_index, |
280 | u32 status) |
281 | { |
282 | struct dprtc_cmd_clear_irq_status *cmd_params; |
283 | struct fsl_mc_command cmd = { 0 }; |
284 | |
285 | cmd.header = mc_encode_cmd_header(DPRTC_CMDID_CLEAR_IRQ_STATUS, |
286 | cmd_flags, |
287 | token); |
288 | cmd_params = (struct dprtc_cmd_clear_irq_status *)cmd.params; |
289 | cmd_params->irq_index = irq_index; |
290 | cmd_params->status = cpu_to_le32(status); |
291 | |
292 | return mc_send_command(mc_io, cmd: &cmd); |
293 | } |
294 | |