projects / openwrt / staging / mkresin.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
bcm63xx: ar-5315u: expose LEDs through controller
[openwrt/staging/mkresin.git] / target / linux / layerscape / patches-4.14 / 704-dpaa2-mac-phy-support-layerscape.patch
1 From dd0cc8d0739a72ee5d85039a9ba7812383e8f555 Mon Sep 17 00:00:00 2001
2 From: Biwen Li <biwen.li@nxp.com>
3 Date: Wed, 17 Apr 2019 18:58:30 +0800
4 Subject: [PATCH] dpaa2-mac-phy: support layerscape
5
6 This is an integrated patch of dpaa2-mac-phy for layerscape
7
8 Signed-off-by: Alex Marginean <alexandru.marginean@nxp.com>
9 Signed-off-by: Biwen Li <biwen.li@nxp.com>
10 Signed-off-by: Bogdan Hamciuc <bogdan.hamciuc@nxp.com>
11 Signed-off-by: Bogdan Purcareata <bogdan.purcareata@nxp.com>
12 Signed-off-by: Catalin Neacsu <valentin-catalin.neacsu@nxp.com>
13 Signed-off-by: Constantin Tudor <constantin.tudor@nxp.com>
14 Signed-off-by: Florin Chiculita <florinlaurentiu.chiculita@nxp.com>
15 Signed-off-by: Ioana Ciornei <ioana.ciornei@nxp.com>
16 Signed-off-by: Ioana Radulescu <ruxandra.radulescu@nxp.com>
17 Signed-off-by: Itai Katz <itai.katz@freescale.com>
18 Signed-off-by: J. German Rivera <German.Rivera@freescale.com>
19 Signed-off-by: Pankaj Bansal <pankaj.bansal@nxp.com>
20 Signed-off-by: Razvan Stefanescu <razvan.stefanescu@nxp.com>
21 Signed-off-by: Stuart Yoder <stuart.yoder@freescale.com>
22 Signed-off-by: Valentin Catalin Neacsu <valentin-catalin.neacsu@nxp.com>
23 ---
24 drivers/staging/fsl-dpaa2/mac/Kconfig | 23 +
25 drivers/staging/fsl-dpaa2/mac/Makefile | 10 +
26 drivers/staging/fsl-dpaa2/mac/dpmac-cmd.h | 196 ++++++
27 drivers/staging/fsl-dpaa2/mac/dpmac.c | 689 ++++++++++++++++++
28 drivers/staging/fsl-dpaa2/mac/dpmac.h | 374 ++++++++++
29 drivers/staging/fsl-dpaa2/mac/mac.c | 817 ++++++++++++++++++++++
30 6 files changed, 2109 insertions(+)
31 create mode 100644 drivers/staging/fsl-dpaa2/mac/Kconfig
32 create mode 100644 drivers/staging/fsl-dpaa2/mac/Makefile
33 create mode 100644 drivers/staging/fsl-dpaa2/mac/dpmac-cmd.h
34 create mode 100644 drivers/staging/fsl-dpaa2/mac/dpmac.c
35 create mode 100644 drivers/staging/fsl-dpaa2/mac/dpmac.h
36 create mode 100644 drivers/staging/fsl-dpaa2/mac/mac.c
37
38 --- /dev/null
39 +++ b/drivers/staging/fsl-dpaa2/mac/Kconfig
40 @@ -0,0 +1,23 @@
41 +config FSL_DPAA2_MAC
42 + tristate "DPAA2 MAC / PHY interface"
43 + depends on FSL_MC_BUS && FSL_DPAA2
44 + select MDIO_BUS_MUX_MMIOREG
45 + select FSL_XGMAC_MDIO
46 + select FIXED_PHY
47 + ---help---
48 + Prototype driver for DPAA2 MAC / PHY interface object.
49 + This driver works as a proxy between phylib including phy drivers and
50 + the MC firmware. It receives updates on link state changes from PHY
51 + lib and forwards them to MC and receives interrupt from MC whenever
52 + a request is made to change the link state.
53 +
54 +
55 +config FSL_DPAA2_MAC_NETDEVS
56 + bool "Expose net interfaces for PHYs"
57 + default n
58 + depends on FSL_DPAA2_MAC
59 + ---help---
60 + Exposes macX net interfaces which allow direct control over MACs and
61 + PHYs.
62 + .
63 + Leave disabled if unsure.
64 --- /dev/null
65 +++ b/drivers/staging/fsl-dpaa2/mac/Makefile
66 @@ -0,0 +1,10 @@
67 +
68 +obj-$(CONFIG_FSL_DPAA2_MAC) += dpaa2-mac.o
69 +
70 +dpaa2-mac-objs := mac.o dpmac.o
71 +
72 +all:
73 + make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
74 +
75 +clean:
76 + make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
77 --- /dev/null
78 +++ b/drivers/staging/fsl-dpaa2/mac/dpmac-cmd.h
79 @@ -0,0 +1,196 @@
80 +/* Copyright 2013-2016 Freescale Semiconductor Inc.
81 + *
82 + * Redistribution and use in source and binary forms, with or without
83 + * modification, are permitted provided that the following conditions are met:
84 + * * Redistributions of source code must retain the above copyright
85 + * notice, this list of conditions and the following disclaimer.
86 + * * Redistributions in binary form must reproduce the above copyright
87 + * notice, this list of conditions and the following disclaimer in the
88 + * documentation and/or other materials provided with the distribution.
89 + * * Neither the name of the above-listed copyright holders nor the
90 + * names of any contributors may be used to endorse or promote products
91 + * derived from this software without specific prior written permission.
92 + *
93 + *
94 + * ALTERNATIVELY, this software may be distributed under the terms of the
95 + * GNU General Public License ("GPL") as published by the Free Software
96 + * Foundation, either version 2 of that License or (at your option) any
97 + * later version.
98 + *
99 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
100 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
101 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
102 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
103 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
104 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
105 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
106 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
107 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
108 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
109 + * POSSIBILITY OF SUCH DAMAGE.
110 + */
111 +#ifndef _FSL_DPMAC_CMD_H
112 +#define _FSL_DPMAC_CMD_H
113 +
114 +/* DPMAC Version */
115 +#define DPMAC_VER_MAJOR 4
116 +#define DPMAC_VER_MINOR 2
117 +#define DPMAC_CMD_BASE_VERSION 1
118 +#define DPMAC_CMD_2ND_VERSION 2
119 +#define DPMAC_CMD_ID_OFFSET 4
120 +
121 +#define DPMAC_CMD(id) (((id) << DPMAC_CMD_ID_OFFSET) | DPMAC_CMD_BASE_VERSION)
122 +#define DPMAC_CMD_V2(id) (((id) << DPMAC_CMD_ID_OFFSET) | DPMAC_CMD_2ND_VERSION)
123 +
124 +/* Command IDs */
125 +#define DPMAC_CMDID_CLOSE DPMAC_CMD(0x800)
126 +#define DPMAC_CMDID_OPEN DPMAC_CMD(0x80c)
127 +#define DPMAC_CMDID_CREATE DPMAC_CMD(0x90c)
128 +#define DPMAC_CMDID_DESTROY DPMAC_CMD(0x98c)
129 +#define DPMAC_CMDID_GET_API_VERSION DPMAC_CMD(0xa0c)
130 +
131 +#define DPMAC_CMDID_GET_ATTR DPMAC_CMD(0x004)
132 +#define DPMAC_CMDID_RESET DPMAC_CMD(0x005)
133 +
134 +#define DPMAC_CMDID_SET_IRQ_ENABLE DPMAC_CMD(0x012)
135 +#define DPMAC_CMDID_GET_IRQ_ENABLE DPMAC_CMD(0x013)
136 +#define DPMAC_CMDID_SET_IRQ_MASK DPMAC_CMD(0x014)
137 +#define DPMAC_CMDID_GET_IRQ_MASK DPMAC_CMD(0x015)
138 +#define DPMAC_CMDID_GET_IRQ_STATUS DPMAC_CMD(0x016)
139 +#define DPMAC_CMDID_CLEAR_IRQ_STATUS DPMAC_CMD(0x017)
140 +
141 +#define DPMAC_CMDID_GET_LINK_CFG DPMAC_CMD(0x0c2)
142 +#define DPMAC_CMDID_GET_LINK_CFG_V2 DPMAC_CMD_V2(0x0c2)
143 +#define DPMAC_CMDID_SET_LINK_STATE DPMAC_CMD(0x0c3)
144 +#define DPMAC_CMDID_SET_LINK_STATE_V2 DPMAC_CMD_V2(0x0c3)
145 +#define DPMAC_CMDID_GET_COUNTER DPMAC_CMD(0x0c4)
146 +
147 +#define DPMAC_CMDID_SET_PORT_MAC_ADDR DPMAC_CMD(0x0c5)
148 +
149 +/* Macros for accessing command fields smaller than 1byte */
150 +#define DPMAC_MASK(field) \
151 + GENMASK(DPMAC_##field##_SHIFT + DPMAC_##field##_SIZE - 1, \
152 + DPMAC_##field##_SHIFT)
153 +#define dpmac_set_field(var, field, val) \
154 + ((var) |= (((val) << DPMAC_##field##_SHIFT) & DPMAC_MASK(field)))
155 +#define dpmac_get_field(var, field) \
156 + (((var) & DPMAC_MASK(field)) >> DPMAC_##field##_SHIFT)
157 +
158 +struct dpmac_cmd_open {
159 + u32 dpmac_id;
160 +};
161 +
162 +struct dpmac_cmd_create {
163 + u32 mac_id;
164 +};
165 +
166 +struct dpmac_cmd_destroy {
167 + u32 dpmac_id;
168 +};
169 +
170 +struct dpmac_cmd_set_irq_enable {
171 + u8 enable;
172 + u8 pad[3];
173 + u8 irq_index;
174 +};
175 +
176 +struct dpmac_cmd_get_irq_enable {
177 + u32 pad;
178 + u8 irq_index;
179 +};
180 +
181 +struct dpmac_rsp_get_irq_enable {
182 + u8 enabled;
183 +};
184 +
185 +struct dpmac_cmd_set_irq_mask {
186 + u32 mask;
187 + u8 irq_index;
188 +};
189 +
190 +struct dpmac_cmd_get_irq_mask {
191 + u32 pad;
192 + u8 irq_index;
193 +};
194 +
195 +struct dpmac_rsp_get_irq_mask {
196 + u32 mask;
197 +};
198 +
199 +struct dpmac_cmd_get_irq_status {
200 + u32 status;
201 + u8 irq_index;
202 +};
203 +
204 +struct dpmac_rsp_get_irq_status {
205 + u32 status;
206 +};
207 +
208 +struct dpmac_cmd_clear_irq_status {
209 + u32 status;
210 + u8 irq_index;
211 +};
212 +
213 +struct dpmac_rsp_get_attributes {
214 + u8 eth_if;
215 + u8 link_type;
216 + u16 id;
217 + u32 max_rate;
218 +};
219 +
220 +struct dpmac_rsp_get_link_cfg {
221 + u64 options;
222 + u32 rate;
223 +};
224 +
225 +struct dpmac_rsp_get_link_cfg_v2 {
226 + u64 options;
227 + u32 rate;
228 + u32 pad;
229 + u64 advertising;
230 +};
231 +
232 +#define DPMAC_STATE_SIZE 1
233 +#define DPMAC_STATE_SHIFT 0
234 +#define DPMAC_STATE_VALID_SIZE 1
235 +#define DPMAC_STATE_VALID_SHIFT 1
236 +
237 +struct dpmac_cmd_set_link_state {
238 + u64 options;
239 + u32 rate;
240 + u32 pad;
241 + /* only least significant bit is valid */
242 + u8 up;
243 +};
244 +
245 +struct dpmac_cmd_set_link_state_v2 {
246 + u64 options;
247 + u32 rate;
248 + u32 pad0;
249 + /* from lsb: up:1, state_valid:1 */
250 + u8 state;
251 + u8 pad1[7];
252 + u64 supported;
253 + u64 advertising;
254 +};
255 +
256 +struct dpmac_cmd_get_counter {
257 + u8 type;
258 +};
259 +
260 +struct dpmac_rsp_get_counter {
261 + u64 pad;
262 + u64 counter;
263 +};
264 +
265 +struct dpmac_rsp_get_api_version {
266 + u16 major;
267 + u16 minor;
268 +};
269 +
270 +struct dpmac_cmd_set_port_mac_addr {
271 + u8 pad[2];
272 + u8 addr[6];
273 +};
274 +
275 +#endif /* _FSL_DPMAC_CMD_H */
276 --- /dev/null
277 +++ b/drivers/staging/fsl-dpaa2/mac/dpmac.c
278 @@ -0,0 +1,689 @@
279 +/* Copyright 2013-2016 Freescale Semiconductor Inc.
280 + *
281 + * Redistribution and use in source and binary forms, with or without
282 + * modification, are permitted provided that the following conditions are met:
283 + * * Redistributions of source code must retain the above copyright
284 + * notice, this list of conditions and the following disclaimer.
285 + * * Redistributions in binary form must reproduce the above copyright
286 + * notice, this list of conditions and the following disclaimer in the
287 + * documentation and/or other materials provided with the distribution.
288 + * * Neither the name of the above-listed copyright holders nor the
289 + * names of any contributors may be used to endorse or promote products
290 + * derived from this software without specific prior written permission.
291 + *
292 + *
293 + * ALTERNATIVELY, this software may be distributed under the terms of the
294 + * GNU General Public License ("GPL") as published by the Free Software
295 + * Foundation, either version 2 of that License or (at your option) any
296 + * later version.
297 + *
298 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
299 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
300 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
301 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
302 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
303 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
304 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
305 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
306 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
307 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
308 + * POSSIBILITY OF SUCH DAMAGE.
309 + */
310 +#include <linux/fsl/mc.h>
311 +#include "dpmac.h"
312 +#include "dpmac-cmd.h"
313 +
314 +/**
315 + * dpmac_open() - Open a control session for the specified object.
316 + * @mc_io: Pointer to MC portal's I/O object
317 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
318 + * @dpmac_id: DPMAC unique ID
319 + * @token: Returned token; use in subsequent API calls
320 + *
321 + * This function can be used to open a control session for an
322 + * already created object; an object may have been declared in
323 + * the DPL or by calling the dpmac_create function.
324 + * This function returns a unique authentication token,
325 + * associated with the specific object ID and the specific MC
326 + * portal; this token must be used in all subsequent commands for
327 + * this specific object
328 + *
329 + * Return: '0' on Success; Error code otherwise.
330 + */
331 +int dpmac_open(struct fsl_mc_io *mc_io,
332 + u32 cmd_flags,
333 + int dpmac_id,
334 + u16 *token)
335 +{
336 + struct dpmac_cmd_open *cmd_params;
337 + struct fsl_mc_command cmd = { 0 };
338 + int err;
339 +
340 + /* prepare command */
341 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_OPEN,
342 + cmd_flags,
343 + 0);
344 + cmd_params = (struct dpmac_cmd_open *)cmd.params;
345 + cmd_params->dpmac_id = cpu_to_le32(dpmac_id);
346 +
347 + /* send command to mc*/
348 + err = mc_send_command(mc_io, &cmd);
349 + if (err)
350 + return err;
351 +
352 + /* retrieve response parameters */
353 + *token = mc_cmd_hdr_read_token(&cmd);
354 +
355 + return err;
356 +}
357 +
358 +/**
359 + * dpmac_close() - Close the control session of the object
360 + * @mc_io: Pointer to MC portal's I/O object
361 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
362 + * @token: Token of DPMAC object
363 + *
364 + * After this function is called, no further operations are
365 + * allowed on the object without opening a new control session.
366 + *
367 + * Return: '0' on Success; Error code otherwise.
368 + */
369 +int dpmac_close(struct fsl_mc_io *mc_io,
370 + u32 cmd_flags,
371 + u16 token)
372 +{
373 + struct fsl_mc_command cmd = { 0 };
374 +
375 + /* prepare command */
376 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CLOSE, cmd_flags,
377 + token);
378 +
379 + /* send command to mc*/
380 + return mc_send_command(mc_io, &cmd);
381 +}
382 +
383 +/**
384 + * dpmac_create() - Create the DPMAC object.
385 + * @mc_io: Pointer to MC portal's I/O object
386 + * @dprc_token: Parent container token; '0' for default container
387 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
388 + * @cfg: Configuration structure
389 + * @obj_id: Returned object id
390 + *
391 + * Create the DPMAC object, allocate required resources and
392 + * perform required initialization.
393 + *
394 + * The function accepts an authentication token of a parent
395 + * container that this object should be assigned to. The token
396 + * can be '0' so the object will be assigned to the default container.
397 + * The newly created object can be opened with the returned
398 + * object id and using the container's associated tokens and MC portals.
399 + *
400 + * Return: '0' on Success; Error code otherwise.
401 + */
402 +int dpmac_create(struct fsl_mc_io *mc_io,
403 + u16 dprc_token,
404 + u32 cmd_flags,
405 + const struct dpmac_cfg *cfg,
406 + u32 *obj_id)
407 +{
408 + struct dpmac_cmd_create *cmd_params;
409 + struct fsl_mc_command cmd = { 0 };
410 + int err;
411 +
412 + /* prepare command */
413 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CREATE,
414 + cmd_flags,
415 + dprc_token);
416 + cmd_params = (struct dpmac_cmd_create *)cmd.params;
417 + cmd_params->mac_id = cpu_to_le32(cfg->mac_id);
418 +
419 + /* send command to mc*/
420 + err = mc_send_command(mc_io, &cmd);
421 + if (err)
422 + return err;
423 +
424 + /* retrieve response parameters */
425 + *obj_id = mc_cmd_read_object_id(&cmd);
426 +
427 + return 0;
428 +}
429 +
430 +/**
431 + * dpmac_destroy() - Destroy the DPMAC object and release all its resources.
432 + * @mc_io: Pointer to MC portal's I/O object
433 + * @dprc_token: Parent container token; '0' for default container
434 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
435 + * @object_id: The object id; it must be a valid id within the container that
436 + * created this object;
437 + *
438 + * The function accepts the authentication token of the parent container that
439 + * created the object (not the one that currently owns the object). The object
440 + * is searched within parent using the provided 'object_id'.
441 + * All tokens to the object must be closed before calling destroy.
442 + *
443 + * Return: '0' on Success; error code otherwise.
444 + */
445 +int dpmac_destroy(struct fsl_mc_io *mc_io,
446 + u16 dprc_token,
447 + u32 cmd_flags,
448 + u32 object_id)
449 +{
450 + struct dpmac_cmd_destroy *cmd_params;
451 + struct fsl_mc_command cmd = { 0 };
452 +
453 + /* prepare command */
454 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_DESTROY,
455 + cmd_flags,
456 + dprc_token);
457 + cmd_params = (struct dpmac_cmd_destroy *)cmd.params;
458 + cmd_params->dpmac_id = cpu_to_le32(object_id);
459 +
460 + /* send command to mc*/
461 + return mc_send_command(mc_io, &cmd);
462 +}
463 +
464 +/**
465 + * dpmac_set_irq_enable() - Set overall interrupt state.
466 + * @mc_io: Pointer to MC portal's I/O object
467 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
468 + * @token: Token of DPMAC object
469 + * @irq_index: The interrupt index to configure
470 + * @en: Interrupt state - enable = 1, disable = 0
471 + *
472 + * Allows GPP software to control when interrupts are generated.
473 + * Each interrupt can have up to 32 causes. The enable/disable control's the
474 + * overall interrupt state. if the interrupt is disabled no causes will cause
475 + * an interrupt.
476 + *
477 + * Return: '0' on Success; Error code otherwise.
478 + */
479 +int dpmac_set_irq_enable(struct fsl_mc_io *mc_io,
480 + u32 cmd_flags,
481 + u16 token,
482 + u8 irq_index,
483 + u8 en)
484 +{
485 + struct dpmac_cmd_set_irq_enable *cmd_params;
486 + struct fsl_mc_command cmd = { 0 };
487 +
488 + /* prepare command */
489 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_SET_IRQ_ENABLE,
490 + cmd_flags,
491 + token);
492 + cmd_params = (struct dpmac_cmd_set_irq_enable *)cmd.params;
493 + cmd_params->irq_index = irq_index;
494 + cmd_params->enable = en;
495 +
496 + /* send command to mc*/
497 + return mc_send_command(mc_io, &cmd);
498 +}
499 +
500 +/**
501 + * dpmac_get_irq_enable() - Get overall interrupt state
502 + * @mc_io: Pointer to MC portal's I/O object
503 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
504 + * @token: Token of DPMAC object
505 + * @irq_index: The interrupt index to configure
506 + * @en: Returned interrupt state - enable = 1, disable = 0
507 + *
508 + * Return: '0' on Success; Error code otherwise.
509 + */
510 +int dpmac_get_irq_enable(struct fsl_mc_io *mc_io,
511 + u32 cmd_flags,
512 + u16 token,
513 + u8 irq_index,
514 + u8 *en)
515 +{
516 + struct dpmac_cmd_get_irq_enable *cmd_params;
517 + struct dpmac_rsp_get_irq_enable *rsp_params;
518 + struct fsl_mc_command cmd = { 0 };
519 + int err;
520 +
521 + /* prepare command */
522 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_IRQ_ENABLE,
523 + cmd_flags,
524 + token);
525 + cmd_params = (struct dpmac_cmd_get_irq_enable *)cmd.params;
526 + cmd_params->irq_index = irq_index;
527 +
528 + /* send command to mc*/
529 + err = mc_send_command(mc_io, &cmd);
530 + if (err)
531 + return err;
532 +
533 + /* retrieve response parameters */
534 + rsp_params = (struct dpmac_rsp_get_irq_enable *)cmd.params;
535 + *en = rsp_params->enabled;
536 +
537 + return 0;
538 +}
539 +
540 +/**
541 + * dpmac_set_irq_mask() - Set interrupt mask.
542 + * @mc_io: Pointer to MC portal's I/O object
543 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
544 + * @token: Token of DPMAC object
545 + * @irq_index: The interrupt index to configure
546 + * @mask: Event mask to trigger interrupt;
547 + * each bit:
548 + * 0 = ignore event
549 + * 1 = consider event for asserting IRQ
550 + *
551 + * Every interrupt can have up to 32 causes and the interrupt model supports
552 + * masking/unmasking each cause independently
553 + *
554 + * Return: '0' on Success; Error code otherwise.
555 + */
556 +int dpmac_set_irq_mask(struct fsl_mc_io *mc_io,
557 + u32 cmd_flags,
558 + u16 token,
559 + u8 irq_index,
560 + u32 mask)
561 +{
562 + struct dpmac_cmd_set_irq_mask *cmd_params;
563 + struct fsl_mc_command cmd = { 0 };
564 +
565 + /* prepare command */
566 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_SET_IRQ_MASK,
567 + cmd_flags,
568 + token);
569 + cmd_params = (struct dpmac_cmd_set_irq_mask *)cmd.params;
570 + cmd_params->mask = cpu_to_le32(mask);
571 + cmd_params->irq_index = irq_index;
572 +
573 + /* send command to mc*/
574 + return mc_send_command(mc_io, &cmd);
575 +}
576 +
577 +/**
578 + * dpmac_get_irq_mask() - Get interrupt mask.
579 + * @mc_io: Pointer to MC portal's I/O object
580 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
581 + * @token: Token of DPMAC object
582 + * @irq_index: The interrupt index to configure
583 + * @mask: Returned event mask to trigger interrupt
584 + *
585 + * Every interrupt can have up to 32 causes and the interrupt model supports
586 + * masking/unmasking each cause independently
587 + *
588 + * Return: '0' on Success; Error code otherwise.
589 + */
590 +int dpmac_get_irq_mask(struct fsl_mc_io *mc_io,
591 + u32 cmd_flags,
592 + u16 token,
593 + u8 irq_index,
594 + u32 *mask)
595 +{
596 + struct dpmac_cmd_get_irq_mask *cmd_params;
597 + struct dpmac_rsp_get_irq_mask *rsp_params;
598 + struct fsl_mc_command cmd = { 0 };
599 + int err;
600 +
601 + /* prepare command */
602 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_IRQ_MASK,
603 + cmd_flags,
604 + token);
605 + cmd_params = (struct dpmac_cmd_get_irq_mask *)cmd.params;
606 + cmd_params->irq_index = irq_index;
607 +
608 + /* send command to mc*/
609 + err = mc_send_command(mc_io, &cmd);
610 + if (err)
611 + return err;
612 +
613 + /* retrieve response parameters */
614 + rsp_params = (struct dpmac_rsp_get_irq_mask *)cmd.params;
615 + *mask = le32_to_cpu(rsp_params->mask);
616 +
617 + return 0;
618 +}
619 +
620 +/**
621 + * dpmac_get_irq_status() - Get the current status of any pending interrupts.
622 + *
623 + * @mc_io: Pointer to MC portal's I/O object
624 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
625 + * @token: Token of DPMAC object
626 + * @irq_index: The interrupt index to configure
627 + * @status: Returned interrupts status - one bit per cause:
628 + * 0 = no interrupt pending
629 + * 1 = interrupt pending
630 + *
631 + * Return: '0' on Success; Error code otherwise.
632 + */
633 +int dpmac_get_irq_status(struct fsl_mc_io *mc_io,
634 + u32 cmd_flags,
635 + u16 token,
636 + u8 irq_index,
637 + u32 *status)
638 +{
639 + struct dpmac_cmd_get_irq_status *cmd_params;
640 + struct dpmac_rsp_get_irq_status *rsp_params;
641 + struct fsl_mc_command cmd = { 0 };
642 + int err;
643 +
644 + /* prepare command */
645 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_IRQ_STATUS,
646 + cmd_flags,
647 + token);
648 + cmd_params = (struct dpmac_cmd_get_irq_status *)cmd.params;
649 + cmd_params->status = cpu_to_le32(*status);
650 + cmd_params->irq_index = irq_index;
651 +
652 + /* send command to mc*/
653 + err = mc_send_command(mc_io, &cmd);
654 + if (err)
655 + return err;
656 +
657 + /* retrieve response parameters */
658 + rsp_params = (struct dpmac_rsp_get_irq_status *)cmd.params;
659 + *status = le32_to_cpu(rsp_params->status);
660 +
661 + return 0;
662 +}
663 +
664 +/**
665 + * dpmac_clear_irq_status() - Clear a pending interrupt's status
666 + *
667 + * @mc_io: Pointer to MC portal's I/O object
668 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
669 + * @token: Token of DPMAC object
670 + * @irq_index: The interrupt index to configure
671 + * @status: Bits to clear (W1C) - one bit per cause:
672 + * 0 = don't change
673 + * 1 = clear status bit
674 + *
675 + * Return: '0' on Success; Error code otherwise.
676 + */
677 +int dpmac_clear_irq_status(struct fsl_mc_io *mc_io,
678 + u32 cmd_flags,
679 + u16 token,
680 + u8 irq_index,
681 + u32 status)
682 +{
683 + struct dpmac_cmd_clear_irq_status *cmd_params;
684 + struct fsl_mc_command cmd = { 0 };
685 +
686 + /* prepare command */
687 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_CLEAR_IRQ_STATUS,
688 + cmd_flags,
689 + token);
690 + cmd_params = (struct dpmac_cmd_clear_irq_status *)cmd.params;
691 + cmd_params->status = cpu_to_le32(status);
692 + cmd_params->irq_index = irq_index;
693 +
694 + /* send command to mc*/
695 + return mc_send_command(mc_io, &cmd);
696 +}
697 +
698 +/**
699 + * dpmac_get_attributes - Retrieve DPMAC attributes.
700 + *
701 + * @mc_io: Pointer to MC portal's I/O object
702 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
703 + * @token: Token of DPMAC object
704 + * @attr: Returned object's attributes
705 + *
706 + * Return: '0' on Success; Error code otherwise.
707 + */
708 +int dpmac_get_attributes(struct fsl_mc_io *mc_io,
709 + u32 cmd_flags,
710 + u16 token,
711 + struct dpmac_attr *attr)
712 +{
713 + struct dpmac_rsp_get_attributes *rsp_params;
714 + struct fsl_mc_command cmd = { 0 };
715 + int err;
716 +
717 + /* prepare command */
718 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_ATTR,
719 + cmd_flags,
720 + token);
721 +
722 + /* send command to mc*/
723 + err = mc_send_command(mc_io, &cmd);
724 + if (err)
725 + return err;
726 +
727 + /* retrieve response parameters */
728 + rsp_params = (struct dpmac_rsp_get_attributes *)cmd.params;
729 + attr->eth_if = rsp_params->eth_if;
730 + attr->link_type = rsp_params->link_type;
731 + attr->id = le16_to_cpu(rsp_params->id);
732 + attr->max_rate = le32_to_cpu(rsp_params->max_rate);
733 +
734 + return 0;
735 +}
736 +
737 +/**
738 + * dpmac_get_link_cfg() - Get Ethernet link configuration
739 + * @mc_io: Pointer to opaque I/O object
740 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
741 + * @token: Token of DPMAC object
742 + * @cfg: Returned structure with the link configuration
743 + *
744 + * Return: '0' on Success; Error code otherwise.
745 + */
746 +int dpmac_get_link_cfg(struct fsl_mc_io *mc_io,
747 + u32 cmd_flags,
748 + u16 token,
749 + struct dpmac_link_cfg *cfg)
750 +{
751 + struct dpmac_rsp_get_link_cfg *rsp_params;
752 + struct fsl_mc_command cmd = { 0 };
753 + int err = 0;
754 +
755 + /* prepare command */
756 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_LINK_CFG,
757 + cmd_flags,
758 + token);
759 +
760 + /* send command to mc*/
761 + err = mc_send_command(mc_io, &cmd);
762 + if (err)
763 + return err;
764 +
765 + rsp_params = (struct dpmac_rsp_get_link_cfg *)cmd.params;
766 + cfg->options = le64_to_cpu(rsp_params->options);
767 + cfg->rate = le32_to_cpu(rsp_params->rate);
768 +
769 + return 0;
770 +}
771 +
772 +/**
773 + * dpmac_get_link_cfg_v2() - Get Ethernet link configuration
774 + * @mc_io: Pointer to opaque I/O object
775 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
776 + * @token: Token of DPMAC object
777 + * @cfg: Returned structure with the link configuration
778 + *
779 + * Return: '0' on Success; Error code otherwise.
780 + */
781 +int dpmac_get_link_cfg_v2(struct fsl_mc_io *mc_io,
782 + u32 cmd_flags,
783 + u16 token,
784 + struct dpmac_link_cfg *cfg)
785 +{
786 + struct dpmac_rsp_get_link_cfg_v2 *rsp_params;
787 + struct fsl_mc_command cmd = { 0 };
788 + int err = 0;
789 +
790 + /* prepare command */
791 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_LINK_CFG_V2,
792 + cmd_flags,
793 + token);
794 +
795 + /* send command to mc*/
796 + err = mc_send_command(mc_io, &cmd);
797 + if (err)
798 + return err;
799 +
800 + rsp_params = (struct dpmac_rsp_get_link_cfg_v2 *)cmd.params;
801 + cfg->options = le64_to_cpu(rsp_params->options);
802 + cfg->rate = le32_to_cpu(rsp_params->rate);
803 + cfg->advertising = le64_to_cpu(rsp_params->advertising);
804 +
805 + return 0;
806 +}
807 +
808 +/**
809 + * dpmac_set_link_state() - Set the Ethernet link status
810 + * @mc_io: Pointer to opaque I/O object
811 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
812 + * @token: Token of DPMAC object
813 + * @link_state: Link state configuration
814 + *
815 + * Return: '0' on Success; Error code otherwise.
816 + */
817 +int dpmac_set_link_state(struct fsl_mc_io *mc_io,
818 + u32 cmd_flags,
819 + u16 token,
820 + struct dpmac_link_state *link_state)
821 +{
822 + struct dpmac_cmd_set_link_state *cmd_params;
823 + struct fsl_mc_command cmd = { 0 };
824 +
825 + /* prepare command */
826 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_SET_LINK_STATE,
827 + cmd_flags,
828 + token);
829 + cmd_params = (struct dpmac_cmd_set_link_state *)cmd.params;
830 + cmd_params->options = cpu_to_le64(link_state->options);
831 + cmd_params->rate = cpu_to_le32(link_state->rate);
832 + dpmac_set_field(cmd_params->up, STATE, link_state->up);
833 +
834 + /* send command to mc*/
835 + return mc_send_command(mc_io, &cmd);
836 +}
837 +
838 +/**
839 + * dpmac_set_link_state_v2() - Set the Ethernet link status
840 + * @mc_io: Pointer to opaque I/O object
841 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
842 + * @token: Token of DPMAC object
843 + * @link_state: Link state configuration
844 + *
845 + * Return: '0' on Success; Error code otherwise.
846 + */
847 +int dpmac_set_link_state_v2(struct fsl_mc_io *mc_io,
848 + u32 cmd_flags,
849 + u16 token,
850 + struct dpmac_link_state *link_state)
851 +{
852 + struct dpmac_cmd_set_link_state_v2 *cmd_params;
853 + struct fsl_mc_command cmd = { 0 };
854 +
855 + /* prepare command */
856 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_SET_LINK_STATE_V2,
857 + cmd_flags,
858 + token);
859 + cmd_params = (struct dpmac_cmd_set_link_state_v2 *)cmd.params;
860 + cmd_params->options = cpu_to_le64(link_state->options);
861 + cmd_params->rate = cpu_to_le32(link_state->rate);
862 + dpmac_set_field(cmd_params->state, STATE, link_state->up);
863 + dpmac_set_field(cmd_params->state, STATE_VALID,
864 + link_state->state_valid);
865 + cmd_params->supported = cpu_to_le64(link_state->supported);
866 + cmd_params->advertising = cpu_to_le64(link_state->advertising);
867 +
868 + /* send command to mc*/
869 + return mc_send_command(mc_io, &cmd);
870 +}
871 +
872 +/**
873 + * dpmac_get_counter() - Read a specific DPMAC counter
874 + * @mc_io: Pointer to opaque I/O object
875 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
876 + * @token: Token of DPMAC object
877 + * @type: The requested counter
878 + * @counter: Returned counter value
879 + *
880 + * Return: The requested counter; '0' otherwise.
881 + */
882 +int dpmac_get_counter(struct fsl_mc_io *mc_io,
883 + u32 cmd_flags,
884 + u16 token,
885 + enum dpmac_counter type,
886 + u64 *counter)
887 +{
888 + struct dpmac_cmd_get_counter *dpmac_cmd;
889 + struct dpmac_rsp_get_counter *dpmac_rsp;
890 + struct fsl_mc_command cmd = { 0 };
891 + int err = 0;
892 +
893 + /* prepare command */
894 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_COUNTER,
895 + cmd_flags,
896 + token);
897 + dpmac_cmd = (struct dpmac_cmd_get_counter *)cmd.params;
898 + dpmac_cmd->type = type;
899 +
900 + /* send command to mc*/
901 + err = mc_send_command(mc_io, &cmd);
902 + if (err)
903 + return err;
904 +
905 + dpmac_rsp = (struct dpmac_rsp_get_counter *)cmd.params;
906 + *counter = le64_to_cpu(dpmac_rsp->counter);
907 +
908 + return 0;
909 +}
910 +
911 +/* untested */
912 +int dpmac_set_port_mac_addr(struct fsl_mc_io *mc_io,
913 + u32 cmd_flags,
914 + u16 token,
915 + const u8 addr[6])
916 +{
917 + struct dpmac_cmd_set_port_mac_addr *dpmac_cmd;
918 + struct fsl_mc_command cmd = { 0 };
919 +
920 + /* prepare command */
921 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_SET_PORT_MAC_ADDR,
922 + cmd_flags,
923 + token);
924 + dpmac_cmd = (struct dpmac_cmd_set_port_mac_addr *)cmd.params;
925 + dpmac_cmd->addr[0] = addr[5];
926 + dpmac_cmd->addr[1] = addr[4];
927 + dpmac_cmd->addr[2] = addr[3];
928 + dpmac_cmd->addr[3] = addr[2];
929 + dpmac_cmd->addr[4] = addr[1];
930 + dpmac_cmd->addr[5] = addr[0];
931 +
932 + /* send command to mc*/
933 + return mc_send_command(mc_io, &cmd);
934 +}
935 +
936 +/**
937 + * dpmac_get_api_version() - Get Data Path MAC version
938 + * @mc_io: Pointer to MC portal's I/O object
939 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
940 + * @major_ver: Major version of data path mac API
941 + * @minor_ver: Minor version of data path mac API
942 + *
943 + * Return: '0' on Success; Error code otherwise.
944 + */
945 +int dpmac_get_api_version(struct fsl_mc_io *mc_io,
946 + u32 cmd_flags,
947 + u16 *major_ver,
948 + u16 *minor_ver)
949 +{
950 + struct dpmac_rsp_get_api_version *rsp_params;
951 + struct fsl_mc_command cmd = { 0 };
952 + int err;
953 +
954 + cmd.header = mc_encode_cmd_header(DPMAC_CMDID_GET_API_VERSION,
955 + cmd_flags,
956 + 0);
957 +
958 + err = mc_send_command(mc_io, &cmd);
959 + if (err)
960 + return err;
961 +
962 + rsp_params = (struct dpmac_rsp_get_api_version *)cmd.params;
963 + *major_ver = le16_to_cpu(rsp_params->major);
964 + *minor_ver = le16_to_cpu(rsp_params->minor);
965 +
966 + return 0;
967 +}
968 --- /dev/null
969 +++ b/drivers/staging/fsl-dpaa2/mac/dpmac.h
970 @@ -0,0 +1,374 @@
971 +/* Copyright 2013-2016 Freescale Semiconductor Inc.
972 + *
973 + * Redistribution and use in source and binary forms, with or without
974 + * modification, are permitted provided that the following conditions are met:
975 + * * Redistributions of source code must retain the above copyright
976 + * notice, this list of conditions and the following disclaimer.
977 + * * Redistributions in binary form must reproduce the above copyright
978 + * notice, this list of conditions and the following disclaimer in the
979 + * documentation and/or other materials provided with the distribution.
980 + * * Neither the name of the above-listed copyright holders nor the
981 + * names of any contributors may be used to endorse or promote products
982 + * derived from this software without specific prior written permission.
983 + *
984 + *
985 + * ALTERNATIVELY, this software may be distributed under the terms of the
986 + * GNU General Public License ("GPL") as published by the Free Software
987 + * Foundation, either version 2 of that License or (at your option) any
988 + * later version.
989 + *
990 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
991 + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
992 + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
993 + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
994 + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
995 + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
996 + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
997 + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
998 + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
999 + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
1000 + * POSSIBILITY OF SUCH DAMAGE.
1001 + */
1002 +#ifndef __FSL_DPMAC_H
1003 +#define __FSL_DPMAC_H
1004 +
1005 +/* Data Path MAC API
1006 + * Contains initialization APIs and runtime control APIs for DPMAC
1007 + */
1008 +
1009 +struct fsl_mc_io;
1010 +
1011 +int dpmac_open(struct fsl_mc_io *mc_io,
1012 + u32 cmd_flags,
1013 + int dpmac_id,
1014 + u16 *token);
1015 +
1016 +int dpmac_close(struct fsl_mc_io *mc_io,
1017 + u32 cmd_flags,
1018 + u16 token);
1019 +
1020 +/**
1021 + * enum dpmac_link_type - DPMAC link type
1022 + * @DPMAC_LINK_TYPE_NONE: No link
1023 + * @DPMAC_LINK_TYPE_FIXED: Link is fixed type
1024 + * @DPMAC_LINK_TYPE_PHY: Link by PHY ID
1025 + * @DPMAC_LINK_TYPE_BACKPLANE: Backplane link type
1026 + */
1027 +enum dpmac_link_type {
1028 + DPMAC_LINK_TYPE_NONE,
1029 + DPMAC_LINK_TYPE_FIXED,
1030 + DPMAC_LINK_TYPE_PHY,
1031 + DPMAC_LINK_TYPE_BACKPLANE
1032 +};
1033 +
1034 +/**
1035 + * enum dpmac_eth_if - DPMAC Ethrnet interface
1036 + * @DPMAC_ETH_IF_MII: MII interface
1037 + * @DPMAC_ETH_IF_RMII: RMII interface
1038 + * @DPMAC_ETH_IF_SMII: SMII interface
1039 + * @DPMAC_ETH_IF_GMII: GMII interface
1040 + * @DPMAC_ETH_IF_RGMII: RGMII interface
1041 + * @DPMAC_ETH_IF_SGMII: SGMII interface
1042 + * @DPMAC_ETH_IF_QSGMII: QSGMII interface
1043 + * @DPMAC_ETH_IF_XAUI: XAUI interface
1044 + * @DPMAC_ETH_IF_XFI: XFI interface
1045 + */
1046 +enum dpmac_eth_if {
1047 + DPMAC_ETH_IF_MII,
1048 + DPMAC_ETH_IF_RMII,
1049 + DPMAC_ETH_IF_SMII,
1050 + DPMAC_ETH_IF_GMII,
1051 + DPMAC_ETH_IF_RGMII,
1052 + DPMAC_ETH_IF_SGMII,
1053 + DPMAC_ETH_IF_QSGMII,
1054 + DPMAC_ETH_IF_XAUI,
1055 + DPMAC_ETH_IF_XFI
1056 +};
1057 +
1058 +/**
1059 + * struct dpmac_cfg - Structure representing DPMAC configuration
1060 + * @mac_id: Represents the Hardware MAC ID; in case of multiple WRIOP,
1061 + * the MAC IDs are continuous.
1062 + * For example: 2 WRIOPs, 16 MACs in each:
1063 + * MAC IDs for the 1st WRIOP: 1-16,
1064 + * MAC IDs for the 2nd WRIOP: 17-32.
1065 + */
1066 +struct dpmac_cfg {
1067 + u16 mac_id;
1068 +};
1069 +
1070 +int dpmac_create(struct fsl_mc_io *mc_io,
1071 + u16 dprc_token,
1072 + u32 cmd_flags,
1073 + const struct dpmac_cfg *cfg,
1074 + u32 *obj_id);
1075 +
1076 +int dpmac_destroy(struct fsl_mc_io *mc_io,
1077 + u16 dprc_token,
1078 + u32 cmd_flags,
1079 + u32 object_id);
1080 +
1081 +/**
1082 + * DPMAC IRQ Index and Events
1083 + */
1084 +
1085 +/**
1086 + * IRQ index
1087 + */
1088 +#define DPMAC_IRQ_INDEX 0
1089 +/**
1090 + * IRQ event - indicates a change in link state
1091 + */
1092 +#define DPMAC_IRQ_EVENT_LINK_CFG_REQ 0x00000001
1093 +/**
1094 + * IRQ event - Indicates that the link state changed
1095 + */
1096 +#define DPMAC_IRQ_EVENT_LINK_CHANGED 0x00000002
1097 +
1098 +int dpmac_set_irq_enable(struct fsl_mc_io *mc_io,
1099 + u32 cmd_flags,
1100 + u16 token,
1101 + u8 irq_index,
1102 + u8 en);
1103 +
1104 +int dpmac_get_irq_enable(struct fsl_mc_io *mc_io,
1105 + u32 cmd_flags,
1106 + u16 token,
1107 + u8 irq_index,
1108 + u8 *en);
1109 +
1110 +int dpmac_set_irq_mask(struct fsl_mc_io *mc_io,
1111 + u32 cmd_flags,
1112 + u16 token,
1113 + u8 irq_index,
1114 + u32 mask);
1115 +
1116 +int dpmac_get_irq_mask(struct fsl_mc_io *mc_io,
1117 + u32 cmd_flags,
1118 + u16 token,
1119 + u8 irq_index,
1120 + u32 *mask);
1121 +
1122 +int dpmac_get_irq_status(struct fsl_mc_io *mc_io,
1123 + u32 cmd_flags,
1124 + u16 token,
1125 + u8 irq_index,
1126 + u32 *status);
1127 +
1128 +int dpmac_clear_irq_status(struct fsl_mc_io *mc_io,
1129 + u32 cmd_flags,
1130 + u16 token,
1131 + u8 irq_index,
1132 + u32 status);
1133 +
1134 +/**
1135 + * struct dpmac_attr - Structure representing DPMAC attributes
1136 + * @id: DPMAC object ID
1137 + * @max_rate: Maximum supported rate - in Mbps
1138 + * @eth_if: Ethernet interface
1139 + * @link_type: link type
1140 + */
1141 +struct dpmac_attr {
1142 + u16 id;
1143 + u32 max_rate;
1144 + enum dpmac_eth_if eth_if;
1145 + enum dpmac_link_type link_type;
1146 +};
1147 +
1148 +int dpmac_get_attributes(struct fsl_mc_io *mc_io,
1149 + u32 cmd_flags,
1150 + u16 token,
1151 + struct dpmac_attr *attr);
1152 +
1153 +/**
1154 + * DPMAC link configuration/state options
1155 + */
1156 +
1157 +/**
1158 + * Enable auto-negotiation
1159 + */
1160 +#define DPMAC_LINK_OPT_AUTONEG 0x0000000000000001ULL
1161 +/**
1162 + * Enable half-duplex mode
1163 + */
1164 +#define DPMAC_LINK_OPT_HALF_DUPLEX 0x0000000000000002ULL
1165 +/**
1166 + * Enable pause frames
1167 + */
1168 +#define DPMAC_LINK_OPT_PAUSE 0x0000000000000004ULL
1169 +/**
1170 + * Enable a-symmetric pause frames
1171 + */
1172 +#define DPMAC_LINK_OPT_ASYM_PAUSE 0x0000000000000008ULL
1173 +
1174 +/**
1175 + * Advertised link speeds
1176 + */
1177 +#define DPMAC_ADVERTISED_10BASET_FULL 0x0000000000000001ULL
1178 +#define DPMAC_ADVERTISED_100BASET_FULL 0x0000000000000002ULL
1179 +#define DPMAC_ADVERTISED_1000BASET_FULL 0x0000000000000004ULL
1180 +#define DPMAC_ADVERTISED_10000BASET_FULL 0x0000000000000010ULL
1181 +#define DPMAC_ADVERTISED_2500BASEX_FULL 0x0000000000000020ULL
1182 +
1183 +/**
1184 + * Advertise auto-negotiation enable
1185 + */
1186 +#define DPMAC_ADVERTISED_AUTONEG 0x0000000000000008ULL
1187 +
1188 +/**
1189 + * struct dpmac_link_cfg - Structure representing DPMAC link configuration
1190 + * @rate: Link's rate - in Mbps
1191 + * @options: Enable/Disable DPMAC link cfg features (bitmap)
1192 + * @advertising: Speeds that are advertised for autoneg (bitmap)
1193 + */
1194 +struct dpmac_link_cfg {
1195 + u32 rate;
1196 + u64 options;
1197 + u64 advertising;
1198 +};
1199 +
1200 +int dpmac_get_link_cfg(struct fsl_mc_io *mc_io,
1201 + u32 cmd_flags,
1202 + u16 token,
1203 + struct dpmac_link_cfg *cfg);
1204 +
1205 +int dpmac_get_link_cfg_v2(struct fsl_mc_io *mc_io,
1206 + u32 cmd_flags,
1207 + u16 token,
1208 + struct dpmac_link_cfg *cfg);
1209 +
1210 +/**
1211 + * struct dpmac_link_state - DPMAC link configuration request
1212 + * @rate: Rate in Mbps
1213 + * @options: Enable/Disable DPMAC link cfg features (bitmap)
1214 + * @up: Link state
1215 + * @state_valid: Ignore/Update the state of the link
1216 + * @supported: Speeds capability of the phy (bitmap)
1217 + * @advertising: Speeds that are advertised for autoneg (bitmap)
1218 + */
1219 +struct dpmac_link_state {
1220 + u32 rate;
1221 + u64 options;
1222 + int up;
1223 + int state_valid;
1224 + u64 supported;
1225 + u64 advertising;
1226 +};
1227 +
1228 +int dpmac_set_link_state(struct fsl_mc_io *mc_io,
1229 + u32 cmd_flags,
1230 + u16 token,
1231 + struct dpmac_link_state *link_state);
1232 +
1233 +int dpmac_set_link_state_v2(struct fsl_mc_io *mc_io,
1234 + u32 cmd_flags,
1235 + u16 token,
1236 + struct dpmac_link_state *link_state);
1237 +
1238 +/**
1239 + * enum dpmac_counter - DPMAC counter types
1240 + * @DPMAC_CNT_ING_FRAME_64: counts 64-bytes frames, good or bad.
1241 + * @DPMAC_CNT_ING_FRAME_127: counts 65- to 127-bytes frames, good or bad.
1242 + * @DPMAC_CNT_ING_FRAME_255: counts 128- to 255-bytes frames, good or bad.
1243 + * @DPMAC_CNT_ING_FRAME_511: counts 256- to 511-bytes frames, good or bad.
1244 + * @DPMAC_CNT_ING_FRAME_1023: counts 512- to 1023-bytes frames, good or bad.
1245 + * @DPMAC_CNT_ING_FRAME_1518: counts 1024- to 1518-bytes frames, good or bad.
1246 + * @DPMAC_CNT_ING_FRAME_1519_MAX: counts 1519-bytes frames and larger
1247 + * (up to max frame length specified),
1248 + * good or bad.
1249 + * @DPMAC_CNT_ING_FRAG: counts frames which are shorter than 64 bytes received
1250 + * with a wrong CRC
1251 + * @DPMAC_CNT_ING_JABBER: counts frames longer than the maximum frame length
1252 + * specified, with a bad frame check sequence.
1253 + * @DPMAC_CNT_ING_FRAME_DISCARD: counts dropped frames due to internal errors.
1254 + * Occurs when a receive FIFO overflows.
1255 + * Includes also frames truncated as a result of
1256 + * the receive FIFO overflow.
1257 + * @DPMAC_CNT_ING_ALIGN_ERR: counts frames with an alignment error
1258 + * (optional used for wrong SFD).
1259 + * @DPMAC_CNT_EGR_UNDERSIZED: counts frames transmitted that was less than 64
1260 + * bytes long with a good CRC.
1261 + * @DPMAC_CNT_ING_OVERSIZED: counts frames longer than the maximum frame length
1262 + * specified, with a good frame check sequence.
1263 + * @DPMAC_CNT_ING_VALID_PAUSE_FRAME: counts valid pause frames (regular and PFC)
1264 + * @DPMAC_CNT_EGR_VALID_PAUSE_FRAME: counts valid pause frames transmitted
1265 + * (regular and PFC).
1266 + * @DPMAC_CNT_ING_BYTE: counts bytes received except preamble for all valid
1267 + * frames and valid pause frames.
1268 + * @DPMAC_CNT_ING_MCAST_FRAME: counts received multicast frames.
1269 + * @DPMAC_CNT_ING_BCAST_FRAME: counts received broadcast frames.
1270 + * @DPMAC_CNT_ING_ALL_FRAME: counts each good or bad frames received.
1271 + * @DPMAC_CNT_ING_UCAST_FRAME: counts received unicast frames.
1272 + * @DPMAC_CNT_ING_ERR_FRAME: counts frames received with an error
1273 + * (except for undersized/fragment frame).
1274 + * @DPMAC_CNT_EGR_BYTE: counts bytes transmitted except preamble for all valid
1275 + * frames and valid pause frames transmitted.
1276 + * @DPMAC_CNT_EGR_MCAST_FRAME: counts transmitted multicast frames.
1277 + * @DPMAC_CNT_EGR_BCAST_FRAME: counts transmitted broadcast frames.
1278 + * @DPMAC_CNT_EGR_UCAST_FRAME: counts transmitted unicast frames.
1279 + * @DPMAC_CNT_EGR_ERR_FRAME: counts frames transmitted with an error.
1280 + * @DPMAC_CNT_ING_GOOD_FRAME: counts frames received without error, including
1281 + * pause frames.
1282 + * @DPMAC_CNT_ENG_GOOD_FRAME: counts frames transmitted without error, including
1283 + * pause frames.
1284 + */
1285 +enum dpmac_counter {
1286 + DPMAC_CNT_ING_FRAME_64,
1287 + DPMAC_CNT_ING_FRAME_127,
1288 + DPMAC_CNT_ING_FRAME_255,
1289 + DPMAC_CNT_ING_FRAME_511,
1290 + DPMAC_CNT_ING_FRAME_1023,
1291 + DPMAC_CNT_ING_FRAME_1518,
1292 + DPMAC_CNT_ING_FRAME_1519_MAX,
1293 + DPMAC_CNT_ING_FRAG,
1294 + DPMAC_CNT_ING_JABBER,
1295 + DPMAC_CNT_ING_FRAME_DISCARD,
1296 + DPMAC_CNT_ING_ALIGN_ERR,
1297 + DPMAC_CNT_EGR_UNDERSIZED,
1298 + DPMAC_CNT_ING_OVERSIZED,
1299 + DPMAC_CNT_ING_VALID_PAUSE_FRAME,
1300 + DPMAC_CNT_EGR_VALID_PAUSE_FRAME,
1301 + DPMAC_CNT_ING_BYTE,
1302 + DPMAC_CNT_ING_MCAST_FRAME,
1303 + DPMAC_CNT_ING_BCAST_FRAME,
1304 + DPMAC_CNT_ING_ALL_FRAME,
1305 + DPMAC_CNT_ING_UCAST_FRAME,
1306 + DPMAC_CNT_ING_ERR_FRAME,
1307 + DPMAC_CNT_EGR_BYTE,
1308 + DPMAC_CNT_EGR_MCAST_FRAME,
1309 + DPMAC_CNT_EGR_BCAST_FRAME,
1310 + DPMAC_CNT_EGR_UCAST_FRAME,
1311 + DPMAC_CNT_EGR_ERR_FRAME,
1312 + DPMAC_CNT_ING_GOOD_FRAME,
1313 + DPMAC_CNT_ENG_GOOD_FRAME
1314 +};
1315 +
1316 +int dpmac_get_counter(struct fsl_mc_io *mc_io,
1317 + u32 cmd_flags,
1318 + u16 token,
1319 + enum dpmac_counter type,
1320 + u64 *counter);
1321 +
1322 +/**
1323 + * dpmac_set_port_mac_addr() - Set a MAC address associated with the physical
1324 + * port. This is not used for filtering, MAC is always in
1325 + * promiscuous mode, it is passed to DPNIs through DPNI API for
1326 + * application used.
1327 + * @mc_io: Pointer to opaque I/O object
1328 + * @cmd_flags: Command flags; one or more of 'MC_CMD_FLAG_'
1329 + * @token: Token of DPMAC object
1330 + * @addr: MAC address to set
1331 + *
1332 + * Return: The requested counter; '0' otherwise.
1333 + */
1334 +int dpmac_set_port_mac_addr(struct fsl_mc_io *mc_io,
1335 + u32 cmd_flags,
1336 + u16 token,
1337 + const u8 addr[6]);
1338 +
1339 +int dpmac_get_api_version(struct fsl_mc_io *mc_io,
1340 + u32 cmd_flags,
1341 + u16 *major_ver,
1342 + u16 *minor_ver);
1343 +
1344 +#endif /* __FSL_DPMAC_H */
1345 --- /dev/null
1346 +++ b/drivers/staging/fsl-dpaa2/mac/mac.c
1347 @@ -0,0 +1,817 @@
1348 +/* Copyright 2015 Freescale Semiconductor Inc.
1349 + * Copyright 2018 NXP
1350 + *
1351 + * Redistribution and use in source and binary forms, with or without
1352 + * modification, are permitted provided that the following conditions are met:
1353 + * * Redistributions of source code must retain the above copyright
1354 + * notice, this list of conditions and the following disclaimer.
1355 + * * Redistributions in binary form must reproduce the above copyright
1356 + * notice, this list of conditions and the following disclaimer in the
1357 + * documentation and/or other materials provided with the distribution.
1358 + * * Neither the name of Freescale Semiconductor nor the
1359 + * names of its contributors may be used to endorse or promote products
1360 + * derived from this software without specific prior written permission.
1361 + *
1362 + *
1363 + * ALTERNATIVELY, this software may be distributed under the terms of the
1364 + * GNU General Public License ("GPL") as published by the Free Software
1365 + * Foundation, either version 2 of that License or (at your option) any
1366 + * later version.
1367 + *
1368 + * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
1369 + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1370 + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
1371 + * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
1372 + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
1373 + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
1374 + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
1375 + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
1376 + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
1377 + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1378 + */
1379 +
1380 +#include <linux/module.h>
1381 +
1382 +#include <linux/netdevice.h>
1383 +#include <linux/etherdevice.h>
1384 +#include <linux/msi.h>
1385 +#include <linux/rtnetlink.h>
1386 +#include <linux/if_vlan.h>
1387 +
1388 +#include <uapi/linux/if_bridge.h>
1389 +#include <net/netlink.h>
1390 +
1391 +#include <linux/of.h>
1392 +#include <linux/of_mdio.h>
1393 +#include <linux/of_net.h>
1394 +#include <linux/phy.h>
1395 +#include <linux/phy_fixed.h>
1396 +
1397 +#include <linux/fsl/mc.h>
1398 +
1399 +#include "dpmac.h"
1400 +#include "dpmac-cmd.h"
1401 +
1402 +struct dpaa2_mac_priv {
1403 + struct net_device *netdev;
1404 + struct fsl_mc_device *mc_dev;
1405 + struct dpmac_attr attr;
1406 + struct dpmac_link_state old_state;
1407 + u16 dpmac_ver_major;
1408 + u16 dpmac_ver_minor;
1409 +};
1410 +
1411 +/* TODO: fix the 10G modes, mapping can't be right:
1412 + * XGMII is paralel
1413 + * XAUI is serial, using 8b/10b encoding
1414 + * XFI is also serial but using 64b/66b encoding
1415 + * they can't all map to XGMII...
1416 + *
1417 + * This must be kept in sync with enum dpmac_eth_if.
1418 + */
1419 +static phy_interface_t dpaa2_mac_iface_mode[] = {
1420 + PHY_INTERFACE_MODE_MII, /* DPMAC_ETH_IF_MII */
1421 + PHY_INTERFACE_MODE_RMII, /* DPMAC_ETH_IF_RMII */
1422 + PHY_INTERFACE_MODE_SMII, /* DPMAC_ETH_IF_SMII */
1423 + PHY_INTERFACE_MODE_GMII, /* DPMAC_ETH_IF_GMII */
1424 + PHY_INTERFACE_MODE_RGMII, /* DPMAC_ETH_IF_RGMII */
1425 + PHY_INTERFACE_MODE_SGMII, /* DPMAC_ETH_IF_SGMII */
1426 + PHY_INTERFACE_MODE_QSGMII, /* DPMAC_ETH_IF_QSGMII */
1427 + PHY_INTERFACE_MODE_XGMII, /* DPMAC_ETH_IF_XAUI */
1428 + PHY_INTERFACE_MODE_XGMII, /* DPMAC_ETH_IF_XFI */
1429 + PHY_INTERFACE_MODE_XGMII, /* DPMAC_ETH_IF_CAUI */
1430 + PHY_INTERFACE_MODE_XGMII, /* DPMAC_ETH_IF_1000BASEX */
1431 + PHY_INTERFACE_MODE_XGMII, /* DPMAC_ETH_IF_USXGMII */
1432 +};
1433 +
1434 +static int cmp_dpmac_ver(struct dpaa2_mac_priv *priv,
1435 + u16 ver_major, u16 ver_minor)
1436 +{
1437 + if (priv->dpmac_ver_major == ver_major)
1438 + return priv->dpmac_ver_minor - ver_minor;
1439 + return priv->dpmac_ver_major - ver_major;
1440 +}
1441 +
1442 +#define DPMAC_LINK_AUTONEG_VER_MAJOR 4
1443 +#define DPMAC_LINK_AUTONEG_VER_MINOR 3
1444 +
1445 +struct dpaa2_mac_link_mode_map {
1446 + u64 dpmac_lm;
1447 + u64 ethtool_lm;
1448 +};
1449 +
1450 +static const struct dpaa2_mac_link_mode_map dpaa2_mac_lm_map[] = {
1451 + {DPMAC_ADVERTISED_10BASET_FULL, ETHTOOL_LINK_MODE_10baseT_Full_BIT},
1452 + {DPMAC_ADVERTISED_100BASET_FULL, ETHTOOL_LINK_MODE_100baseT_Full_BIT},
1453 + {DPMAC_ADVERTISED_1000BASET_FULL, ETHTOOL_LINK_MODE_1000baseT_Full_BIT},
1454 + {DPMAC_ADVERTISED_10000BASET_FULL, ETHTOOL_LINK_MODE_10000baseT_Full_BIT},
1455 + {DPMAC_ADVERTISED_2500BASEX_FULL, ETHTOOL_LINK_MODE_2500baseX_Full_BIT},
1456 + {DPMAC_ADVERTISED_AUTONEG, ETHTOOL_LINK_MODE_Autoneg_BIT},
1457 +};
1458 +
1459 +static void link_mode_dpmac2phydev(u64 dpmac_lm, u32 *phydev_lm)
1460 +{
1461 + __ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
1462 + int i;
1463 +
1464 + for (i = 0; i < ARRAY_SIZE(dpaa2_mac_lm_map); i++) {
1465 + if (dpmac_lm & dpaa2_mac_lm_map[i].dpmac_lm)
1466 + __set_bit(dpaa2_mac_lm_map[i].ethtool_lm, mask);
1467 + }
1468 +
1469 + ethtool_convert_link_mode_to_legacy_u32(phydev_lm, mask);
1470 +}
1471 +
1472 +static void link_mode_phydev2dpmac(u32 phydev_lm, u64 *dpni_lm)
1473 +{
1474 + unsigned long lm;
1475 + int i;
1476 +
1477 + ethtool_convert_legacy_u32_to_link_mode(&lm, phydev_lm);
1478 +
1479 + for (i = 0; i < ARRAY_SIZE(dpaa2_mac_lm_map); i++) {
1480 + if (test_bit(dpaa2_mac_lm_map[i].ethtool_lm, &lm))
1481 + *dpni_lm |= dpaa2_mac_lm_map[i].dpmac_lm;
1482 + }
1483 +}
1484 +
1485 +static void dpaa2_mac_link_changed(struct net_device *netdev)
1486 +{
1487 + struct phy_device *phydev;
1488 + struct dpmac_link_state state = { 0 };
1489 + struct dpaa2_mac_priv *priv = netdev_priv(netdev);
1490 + int err;
1491 +
1492 + /* the PHY just notified us of link state change */
1493 + phydev = netdev->phydev;
1494 +
1495 + state.up = !!phydev->link;
1496 + if (phydev->link) {
1497 + state.rate = phydev->speed;
1498 +
1499 + if (!phydev->duplex)
1500 + state.options |= DPMAC_LINK_OPT_HALF_DUPLEX;
1501 + if (phydev->autoneg)
1502 + state.options |= DPMAC_LINK_OPT_AUTONEG;
1503 +
1504 + if (phydev->pause && (phydev->advertising & ADVERTISED_Pause))
1505 + state.options |= DPMAC_LINK_OPT_PAUSE;
1506 + if (phydev->pause &&
1507 + (phydev->advertising & ADVERTISED_Asym_Pause))
1508 + state.options |= DPMAC_LINK_OPT_ASYM_PAUSE;
1509 +
1510 + netif_carrier_on(netdev);
1511 + } else {
1512 + netif_carrier_off(netdev);
1513 + }
1514 +
1515 + if (priv->old_state.up != state.up ||
1516 + priv->old_state.rate != state.rate ||
1517 + priv->old_state.options != state.options) {
1518 + priv->old_state = state;
1519 + phy_print_status(phydev);
1520 + }
1521 +
1522 + if (cmp_dpmac_ver(priv, DPMAC_LINK_AUTONEG_VER_MAJOR,
1523 + DPMAC_LINK_AUTONEG_VER_MINOR) < 0) {
1524 + err = dpmac_set_link_state(priv->mc_dev->mc_io, 0,
1525 + priv->mc_dev->mc_handle, &state);
1526 + } else {
1527 + link_mode_phydev2dpmac(phydev->supported, &state.supported);
1528 + link_mode_phydev2dpmac(phydev->advertising, &state.advertising);
1529 + state.state_valid = 1;
1530 +
1531 + err = dpmac_set_link_state_v2(priv->mc_dev->mc_io, 0,
1532 + priv->mc_dev->mc_handle, &state);
1533 + }
1534 + if (unlikely(err))
1535 + dev_err(&priv->mc_dev->dev, "dpmac_set_link_state: %d\n", err);
1536 +}
1537 +
1538 +static int dpaa2_mac_open(struct net_device *netdev)
1539 +{
1540 + /* start PHY state machine */
1541 + phy_start(netdev->phydev);
1542 +
1543 + return 0;
1544 +}
1545 +
1546 +static int dpaa2_mac_stop(struct net_device *netdev)
1547 +{
1548 + if (!netdev->phydev)
1549 + goto done;
1550 +
1551 + /* stop PHY state machine */
1552 + phy_stop(netdev->phydev);
1553 +
1554 + /* signal link down to firmware */
1555 + netdev->phydev->link = 0;
1556 + dpaa2_mac_link_changed(netdev);
1557 +
1558 +done:
1559 + return 0;
1560 +}
1561 +
1562 +#ifdef CONFIG_FSL_DPAA2_MAC_NETDEVS
1563 +static netdev_tx_t dpaa2_mac_drop_frame(struct sk_buff *skb,
1564 + struct net_device *dev)
1565 +{
1566 + /* we don't support I/O for now, drop the frame */
1567 + dev_kfree_skb_any(skb);
1568 + return NETDEV_TX_OK;
1569 +}
1570 +
1571 +static void dpaa2_mac_get_drvinfo(struct net_device *net_dev,
1572 + struct ethtool_drvinfo *drvinfo)
1573 +{
1574 + struct dpaa2_mac_priv *priv = netdev_priv(net_dev);
1575 +
1576 + strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver));
1577 + snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1578 + "%u.%u", priv->dpmac_ver_major, priv->dpmac_ver_minor);
1579 + strlcpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent),
1580 + sizeof(drvinfo->bus_info));
1581 +}
1582 +
1583 +static int dpaa2_mac_get_link_ksettings(struct net_device *netdev,
1584 + struct ethtool_link_ksettings *ks)
1585 +{
1586 + phy_ethtool_ksettings_get(netdev->phydev, ks);
1587 +
1588 + return 0;
1589 +}
1590 +
1591 +static int dpaa2_mac_set_link_ksettings(struct net_device *netdev,
1592 + const struct ethtool_link_ksettings *ks)
1593 +{
1594 + return phy_ethtool_ksettings_set(netdev->phydev, ks);
1595 +}
1596 +
1597 +static void dpaa2_mac_get_stats(struct net_device *netdev,
1598 + struct rtnl_link_stats64 *storage)
1599 +{
1600 + struct dpaa2_mac_priv *priv = netdev_priv(netdev);
1601 + u64 tmp;
1602 + int err;
1603 +
1604 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1605 + DPMAC_CNT_EGR_MCAST_FRAME,
1606 + &storage->tx_packets);
1607 + if (err)
1608 + goto error;
1609 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1610 + DPMAC_CNT_EGR_BCAST_FRAME, &tmp);
1611 + if (err)
1612 + goto error;
1613 + storage->tx_packets += tmp;
1614 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1615 + DPMAC_CNT_EGR_UCAST_FRAME, &tmp);
1616 + if (err)
1617 + goto error;
1618 + storage->tx_packets += tmp;
1619 +
1620 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1621 + DPMAC_CNT_EGR_UNDERSIZED, &storage->tx_dropped);
1622 + if (err)
1623 + goto error;
1624 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1625 + DPMAC_CNT_EGR_BYTE, &storage->tx_bytes);
1626 + if (err)
1627 + goto error;
1628 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1629 + DPMAC_CNT_EGR_ERR_FRAME, &storage->tx_errors);
1630 + if (err)
1631 + goto error;
1632 +
1633 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1634 + DPMAC_CNT_ING_ALL_FRAME, &storage->rx_packets);
1635 + if (err)
1636 + goto error;
1637 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1638 + DPMAC_CNT_ING_MCAST_FRAME, &storage->multicast);
1639 + if (err)
1640 + goto error;
1641 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1642 + DPMAC_CNT_ING_FRAME_DISCARD,
1643 + &storage->rx_dropped);
1644 + if (err)
1645 + goto error;
1646 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1647 + DPMAC_CNT_ING_ALIGN_ERR, &storage->rx_errors);
1648 + if (err)
1649 + goto error;
1650 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1651 + DPMAC_CNT_ING_OVERSIZED, &tmp);
1652 + if (err)
1653 + goto error;
1654 + storage->rx_errors += tmp;
1655 + err = dpmac_get_counter(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle,
1656 + DPMAC_CNT_ING_BYTE, &storage->rx_bytes);
1657 + if (err)
1658 + goto error;
1659 +
1660 + return;
1661 +error:
1662 + netdev_err(netdev, "dpmac_get_counter err %d\n", err);
1663 +}
1664 +
1665 +static struct {
1666 + enum dpmac_counter id;
1667 + char name[ETH_GSTRING_LEN];
1668 +} dpaa2_mac_counters[] = {
1669 + {DPMAC_CNT_ING_ALL_FRAME, "rx all frames"},
1670 + {DPMAC_CNT_ING_GOOD_FRAME, "rx frames ok"},
1671 + {DPMAC_CNT_ING_ERR_FRAME, "rx frame errors"},
1672 + {DPMAC_CNT_ING_FRAME_DISCARD, "rx frame discards"},
1673 + {DPMAC_CNT_ING_UCAST_FRAME, "rx u-cast"},
1674 + {DPMAC_CNT_ING_BCAST_FRAME, "rx b-cast"},
1675 + {DPMAC_CNT_ING_MCAST_FRAME, "rx m-cast"},
1676 + {DPMAC_CNT_ING_FRAME_64, "rx 64 bytes"},
1677 + {DPMAC_CNT_ING_FRAME_127, "rx 65-127 bytes"},
1678 + {DPMAC_CNT_ING_FRAME_255, "rx 128-255 bytes"},
1679 + {DPMAC_CNT_ING_FRAME_511, "rx 256-511 bytes"},
1680 + {DPMAC_CNT_ING_FRAME_1023, "rx 512-1023 bytes"},
1681 + {DPMAC_CNT_ING_FRAME_1518, "rx 1024-1518 bytes"},
1682 + {DPMAC_CNT_ING_FRAME_1519_MAX, "rx 1519-max bytes"},
1683 + {DPMAC_CNT_ING_FRAG, "rx frags"},
1684 + {DPMAC_CNT_ING_JABBER, "rx jabber"},
1685 + {DPMAC_CNT_ING_ALIGN_ERR, "rx align errors"},
1686 + {DPMAC_CNT_ING_OVERSIZED, "rx oversized"},
1687 + {DPMAC_CNT_ING_VALID_PAUSE_FRAME, "rx pause"},
1688 + {DPMAC_CNT_ING_BYTE, "rx bytes"},
1689 + {DPMAC_CNT_ENG_GOOD_FRAME, "tx frames ok"},
1690 + {DPMAC_CNT_EGR_UCAST_FRAME, "tx u-cast"},
1691 + {DPMAC_CNT_EGR_MCAST_FRAME, "tx m-cast"},
1692 + {DPMAC_CNT_EGR_BCAST_FRAME, "tx b-cast"},
1693 + {DPMAC_CNT_EGR_ERR_FRAME, "tx frame errors"},
1694 + {DPMAC_CNT_EGR_UNDERSIZED, "tx undersized"},
1695 + {DPMAC_CNT_EGR_VALID_PAUSE_FRAME, "tx b-pause"},
1696 + {DPMAC_CNT_EGR_BYTE, "tx bytes"},
1697 +
1698 +};
1699 +
1700 +static void dpaa2_mac_get_strings(struct net_device *netdev,
1701 + u32 stringset, u8 *data)
1702 +{
1703 + int i;
1704 +
1705 + switch (stringset) {
1706 + case ETH_SS_STATS:
1707 + for (i = 0; i < ARRAY_SIZE(dpaa2_mac_counters); i++)
1708 + memcpy(data + i * ETH_GSTRING_LEN,
1709 + dpaa2_mac_counters[i].name,
1710 + ETH_GSTRING_LEN);
1711 + break;
1712 + }
1713 +}
1714 +
1715 +static void dpaa2_mac_get_ethtool_stats(struct net_device *netdev,
1716 + struct ethtool_stats *stats,
1717 + u64 *data)
1718 +{
1719 + struct dpaa2_mac_priv *priv = netdev_priv(netdev);
1720 + int i;
1721 + int err;
1722 +
1723 + for (i = 0; i < ARRAY_SIZE(dpaa2_mac_counters); i++) {
1724 + err = dpmac_get_counter(priv->mc_dev->mc_io,
1725 + 0,
1726 + priv->mc_dev->mc_handle,
1727 + dpaa2_mac_counters[i].id, &data[i]);
1728 + if (err)
1729 + netdev_err(netdev, "dpmac_get_counter[%s] err %d\n",
1730 + dpaa2_mac_counters[i].name, err);
1731 + }
1732 +}
1733 +
1734 +static int dpaa2_mac_get_sset_count(struct net_device *dev, int sset)
1735 +{
1736 + switch (sset) {
1737 + case ETH_SS_STATS:
1738 + return ARRAY_SIZE(dpaa2_mac_counters);
1739 + default:
1740 + return -EOPNOTSUPP;
1741 + }
1742 +}
1743 +
1744 +static const struct net_device_ops dpaa2_mac_ndo_ops = {
1745 + .ndo_open = &dpaa2_mac_open,
1746 + .ndo_stop = &dpaa2_mac_stop,
1747 + .ndo_start_xmit = &dpaa2_mac_drop_frame,
1748 + .ndo_get_stats64 = &dpaa2_mac_get_stats,
1749 +};
1750 +
1751 +static const struct ethtool_ops dpaa2_mac_ethtool_ops = {
1752 + .get_drvinfo = &dpaa2_mac_get_drvinfo,
1753 + .get_link_ksettings = &dpaa2_mac_get_link_ksettings,
1754 + .set_link_ksettings = &dpaa2_mac_set_link_ksettings,
1755 + .get_strings = &dpaa2_mac_get_strings,
1756 + .get_ethtool_stats = &dpaa2_mac_get_ethtool_stats,
1757 + .get_sset_count = &dpaa2_mac_get_sset_count,
1758 +};
1759 +#endif /* CONFIG_FSL_DPAA2_MAC_NETDEVS */
1760 +
1761 +static void configure_link(struct dpaa2_mac_priv *priv,
1762 + struct dpmac_link_cfg *cfg)
1763 +{
1764 + struct phy_device *phydev = priv->netdev->phydev;
1765 +
1766 + if (unlikely(!phydev))
1767 + return;
1768 +
1769 + phydev->speed = cfg->rate;
1770 + phydev->duplex = !!(cfg->options & DPMAC_LINK_OPT_HALF_DUPLEX);
1771 +
1772 + if (cfg->advertising != 0) {
1773 + phydev->advertising = 0;
1774 + link_mode_dpmac2phydev(cfg->advertising, &phydev->advertising);
1775 + }
1776 +
1777 + if (phydev->supported & SUPPORTED_Pause) {
1778 + if (cfg->options & DPMAC_LINK_OPT_PAUSE)
1779 + phydev->advertising |= ADVERTISED_Pause;
1780 + else
1781 + phydev->advertising &= ~ADVERTISED_Pause;
1782 + }
1783 +
1784 + if (phydev->supported & SUPPORTED_Asym_Pause) {
1785 + if (cfg->options & DPMAC_LINK_OPT_ASYM_PAUSE)
1786 + phydev->advertising |= ADVERTISED_Asym_Pause;
1787 + else
1788 + phydev->advertising &= ~ADVERTISED_Asym_Pause;
1789 + }
1790 +
1791 + if (cfg->options & DPMAC_LINK_OPT_AUTONEG) {
1792 + phydev->autoneg = AUTONEG_ENABLE;
1793 + phydev->advertising |= ADVERTISED_Autoneg;
1794 + } else {
1795 + phydev->autoneg = AUTONEG_DISABLE;
1796 + phydev->advertising &= ~ADVERTISED_Autoneg;
1797 + }
1798 +
1799 + phy_start_aneg(phydev);
1800 +}
1801 +
1802 +static irqreturn_t dpaa2_mac_irq_handler(int irq_num, void *arg)
1803 +{
1804 + struct device *dev = (struct device *)arg;
1805 + struct fsl_mc_device *mc_dev = to_fsl_mc_device(dev);
1806 + struct dpaa2_mac_priv *priv = dev_get_drvdata(dev);
1807 + struct dpmac_link_cfg link_cfg = { 0 };
1808 + u32 status;
1809 + int err;
1810 +
1811 + err = dpmac_get_irq_status(mc_dev->mc_io, 0, mc_dev->mc_handle,
1812 + DPMAC_IRQ_INDEX, &status);
1813 + if (unlikely(err || !status))
1814 + return IRQ_NONE;
1815 +
1816 + /* DPNI-initiated link configuration; 'ifconfig up' also calls this */
1817 + if (status & DPMAC_IRQ_EVENT_LINK_CFG_REQ) {
1818 + if (cmp_dpmac_ver(priv, DPMAC_LINK_AUTONEG_VER_MAJOR,
1819 + DPMAC_LINK_AUTONEG_VER_MINOR) < 0)
1820 + err = dpmac_get_link_cfg(mc_dev->mc_io, 0,
1821 + mc_dev->mc_handle, &link_cfg);
1822 + else
1823 + err = dpmac_get_link_cfg_v2(mc_dev->mc_io, 0,
1824 + mc_dev->mc_handle,
1825 + &link_cfg);
1826 + if (unlikely(err))
1827 + goto out;
1828 +
1829 + configure_link(priv, &link_cfg);
1830 + }
1831 +
1832 +out:
1833 + dpmac_clear_irq_status(mc_dev->mc_io, 0, mc_dev->mc_handle,
1834 + DPMAC_IRQ_INDEX, status);
1835 +
1836 + return IRQ_HANDLED;
1837 +}
1838 +
1839 +static int setup_irqs(struct fsl_mc_device *mc_dev)
1840 +{
1841 + int err = 0;
1842 + struct fsl_mc_device_irq *irq;
1843 +
1844 + err = fsl_mc_allocate_irqs(mc_dev);
1845 + if (err) {
1846 + dev_err(&mc_dev->dev, "fsl_mc_allocate_irqs err %d\n", err);
1847 + return err;
1848 + }
1849 +
1850 + irq = mc_dev->irqs[0];
1851 + err = devm_request_threaded_irq(&mc_dev->dev, irq->msi_desc->irq,
1852 + NULL, &dpaa2_mac_irq_handler,
1853 + IRQF_NO_SUSPEND | IRQF_ONESHOT,
1854 + dev_name(&mc_dev->dev), &mc_dev->dev);
1855 + if (err) {
1856 + dev_err(&mc_dev->dev, "devm_request_threaded_irq err %d\n",
1857 + err);
1858 + goto free_irq;
1859 + }
1860 +
1861 + err = dpmac_set_irq_mask(mc_dev->mc_io, 0, mc_dev->mc_handle,
1862 + DPMAC_IRQ_INDEX, DPMAC_IRQ_EVENT_LINK_CFG_REQ);
1863 + if (err) {
1864 + dev_err(&mc_dev->dev, "dpmac_set_irq_mask err %d\n", err);
1865 + goto free_irq;
1866 + }
1867 + err = dpmac_set_irq_enable(mc_dev->mc_io, 0, mc_dev->mc_handle,
1868 + DPMAC_IRQ_INDEX, 1);
1869 + if (err) {
1870 + dev_err(&mc_dev->dev, "dpmac_set_irq_enable err %d\n", err);
1871 + goto free_irq;
1872 + }
1873 +
1874 + return 0;
1875 +
1876 +free_irq:
1877 + fsl_mc_free_irqs(mc_dev);
1878 +
1879 + return err;
1880 +}
1881 +
1882 +static void teardown_irqs(struct fsl_mc_device *mc_dev)
1883 +{
1884 + int err;
1885 +
1886 + err = dpmac_set_irq_enable(mc_dev->mc_io, 0, mc_dev->mc_handle,
1887 + DPMAC_IRQ_INDEX, 0);
1888 + if (err)
1889 + dev_err(&mc_dev->dev, "dpmac_set_irq_enable err %d\n", err);
1890 +
1891 + fsl_mc_free_irqs(mc_dev);
1892 +}
1893 +
1894 +static struct device_node *find_dpmac_node(struct device *dev, u16 dpmac_id)
1895 +{
1896 + struct device_node *dpmacs, *dpmac = NULL;
1897 + struct device_node *mc_node = dev->of_node;
1898 + u32 id;
1899 + int err;
1900 +
1901 + dpmacs = of_find_node_by_name(mc_node, "dpmacs");
1902 + if (!dpmacs) {
1903 + dev_err(dev, "No dpmacs subnode in device-tree\n");
1904 + return NULL;
1905 + }
1906 +
1907 + while ((dpmac = of_get_next_child(dpmacs, dpmac))) {
1908 + err = of_property_read_u32(dpmac, "reg", &id);
1909 + if (err)
1910 + continue;
1911 + if (id == dpmac_id)
1912 + return dpmac;
1913 + }
1914 +
1915 + return NULL;
1916 +}
1917 +
1918 +static int dpaa2_mac_probe(struct fsl_mc_device *mc_dev)
1919 +{
1920 + struct device *dev;
1921 + struct dpaa2_mac_priv *priv = NULL;
1922 + struct device_node *phy_node, *dpmac_node;
1923 + struct net_device *netdev;
1924 + int if_mode;
1925 + int err = 0;
1926 +
1927 + dev = &mc_dev->dev;
1928 +
1929 + /* prepare a net_dev structure to make the phy lib API happy */
1930 + netdev = alloc_etherdev(sizeof(*priv));
1931 + if (!netdev) {
1932 + dev_err(dev, "alloc_etherdev error\n");
1933 + err = -ENOMEM;
1934 + goto err_exit;
1935 + }
1936 + priv = netdev_priv(netdev);
1937 + priv->mc_dev = mc_dev;
1938 + priv->netdev = netdev;
1939 +
1940 + SET_NETDEV_DEV(netdev, dev);
1941 +
1942 +#ifdef CONFIG_FSL_DPAA2_MAC_NETDEVS
1943 + snprintf(netdev->name, IFNAMSIZ, "mac%d", mc_dev->obj_desc.id);
1944 +#endif
1945 +
1946 + dev_set_drvdata(dev, priv);
1947 +
1948 + /* We may need to issue MC commands while in atomic context */
1949 + err = fsl_mc_portal_allocate(mc_dev, FSL_MC_IO_ATOMIC_CONTEXT_PORTAL,
1950 + &mc_dev->mc_io);
1951 + if (err || !mc_dev->mc_io) {
1952 + dev_dbg(dev, "fsl_mc_portal_allocate error: %d\n", err);
1953 + err = -EPROBE_DEFER;
1954 + goto err_free_netdev;
1955 + }
1956 +
1957 + err = dpmac_open(mc_dev->mc_io, 0, mc_dev->obj_desc.id,
1958 + &mc_dev->mc_handle);
1959 + if (err || !mc_dev->mc_handle) {
1960 + dev_err(dev, "dpmac_open error: %d\n", err);
1961 + err = -ENODEV;
1962 + goto err_free_mcp;
1963 + }
1964 +
1965 + err = dpmac_get_api_version(mc_dev->mc_io, 0, &priv->dpmac_ver_major,
1966 + &priv->dpmac_ver_minor);
1967 + if (err) {
1968 + dev_err(dev, "dpmac_get_api_version failed\n");
1969 + goto err_version;
1970 + }
1971 +
1972 + if (cmp_dpmac_ver(priv, DPMAC_VER_MAJOR, DPMAC_VER_MINOR) < 0) {
1973 + dev_err(dev, "DPMAC version %u.%u lower than supported %u.%u\n",
1974 + priv->dpmac_ver_major, priv->dpmac_ver_minor,
1975 + DPMAC_VER_MAJOR, DPMAC_VER_MINOR);
1976 + err = -ENOTSUPP;
1977 + goto err_version;
1978 + }
1979 +
1980 + err = dpmac_get_attributes(mc_dev->mc_io, 0,
1981 + mc_dev->mc_handle, &priv->attr);
1982 + if (err) {
1983 + dev_err(dev, "dpmac_get_attributes err %d\n", err);
1984 + err = -EINVAL;
1985 + goto err_close;
1986 + }
1987 +
1988 + /* Look up the DPMAC node in the device-tree. */
1989 + dpmac_node = find_dpmac_node(dev, priv->attr.id);
1990 + if (!dpmac_node) {
1991 + dev_err(dev, "No dpmac@%d subnode found.\n", priv->attr.id);
1992 + err = -ENODEV;
1993 + goto err_close;
1994 + }
1995 +
1996 + err = setup_irqs(mc_dev);
1997 + if (err) {
1998 + err = -EFAULT;
1999 + goto err_close;
2000 + }
2001 +
2002 +#ifdef CONFIG_FSL_DPAA2_MAC_NETDEVS
2003 + /* OPTIONAL, register netdev just to make it visible to the user */
2004 + netdev->netdev_ops = &dpaa2_mac_ndo_ops;
2005 + netdev->ethtool_ops = &dpaa2_mac_ethtool_ops;
2006 +
2007 + /* phy starts up enabled so netdev should be up too */
2008 + netdev->flags |= IFF_UP;
2009 +
2010 + err = register_netdev(priv->netdev);
2011 + if (err < 0) {
2012 + dev_err(dev, "register_netdev error %d\n", err);
2013 + err = -ENODEV;
2014 + goto err_free_irq;
2015 + }
2016 +#endif /* CONFIG_FSL_DPAA2_MAC_NETDEVS */
2017 +
2018 + /* get the interface mode from the dpmac of node or from the MC attributes */
2019 + if_mode = of_get_phy_mode(dpmac_node);
2020 + if (if_mode >= 0) {
2021 + dev_dbg(dev, "\tusing if mode %s for eth_if %d\n",
2022 + phy_modes(if_mode), priv->attr.eth_if);
2023 + goto link_type;
2024 + }
2025 +
2026 + if (priv->attr.eth_if < ARRAY_SIZE(dpaa2_mac_iface_mode)) {
2027 + if_mode = dpaa2_mac_iface_mode[priv->attr.eth_if];
2028 + dev_dbg(dev, "\tusing if mode %s for eth_if %d\n",
2029 + phy_modes(if_mode), priv->attr.eth_if);
2030 + } else {
2031 + dev_err(dev, "Unexpected interface mode %d\n",
2032 + priv->attr.eth_if);
2033 + err = -EINVAL;
2034 + goto err_no_if_mode;
2035 + }
2036 +
2037 +link_type:
2038 + /* probe the PHY as fixed-link if the DPMAC attribute indicates so */
2039 + if (priv->attr.link_type == DPMAC_LINK_TYPE_FIXED)
2040 + goto probe_fixed_link;
2041 +
2042 + /* or if there's no phy-handle defined in the device tree */
2043 + phy_node = of_parse_phandle(dpmac_node, "phy-handle", 0);
2044 + if (!phy_node) {
2045 + goto probe_fixed_link;
2046 + }
2047 +
2048 + /* try to connect to the PHY */
2049 + netdev->phydev = of_phy_connect(netdev, phy_node,
2050 + &dpaa2_mac_link_changed, 0, if_mode);
2051 + if (!netdev->phydev) {
2052 + /* No need for dev_err(); the kernel's loud enough as it is. */
2053 + dev_dbg(dev, "Can't of_phy_connect() now.\n");
2054 + /* We might be waiting for the MDIO MUX to probe, so defer
2055 + * our own probing.
2056 + */
2057 + err = -EPROBE_DEFER;
2058 + goto err_defer;
2059 + }
2060 + dev_info(dev, "Connected to %s PHY.\n", phy_modes(if_mode));
2061 +
2062 +probe_fixed_link:
2063 + if (!netdev->phydev) {
2064 + struct fixed_phy_status status = {
2065 + .link = 1,
2066 + /* fixed-phys don't support 10Gbps speed for now */
2067 + .speed = 1000,
2068 + .duplex = 1,
2069 + };
2070 +
2071 + /* try to register a fixed link phy */
2072 + netdev->phydev = fixed_phy_register(PHY_POLL, &status, -1,
2073 + NULL);
2074 + if (!netdev->phydev || IS_ERR(netdev->phydev)) {
2075 + dev_err(dev, "error trying to register fixed PHY\n");
2076 + /* So we don't crash unregister_netdev() later on */
2077 + netdev->phydev = NULL;
2078 + err = -EFAULT;
2079 + goto err_no_phy;
2080 + }
2081 +
2082 + err = phy_connect_direct(netdev, netdev->phydev,
2083 + &dpaa2_mac_link_changed, if_mode);
2084 + if (err) {
2085 + dev_err(dev, "error trying to connect to PHY\n");
2086 + goto err_no_phy;
2087 + }
2088 +
2089 + dev_info(dev, "Registered fixed PHY.\n");
2090 + }
2091 +
2092 + dpaa2_mac_open(netdev);
2093 +
2094 + return 0;
2095 +
2096 +err_no_if_mode:
2097 +err_defer:
2098 +err_no_phy:
2099 +#ifdef CONFIG_FSL_DPAA2_MAC_NETDEVS
2100 + unregister_netdev(netdev);
2101 +err_free_irq:
2102 +#endif
2103 + teardown_irqs(mc_dev);
2104 +err_version:
2105 +err_close:
2106 + dpmac_close(mc_dev->mc_io, 0, mc_dev->mc_handle);
2107 +err_free_mcp:
2108 + fsl_mc_portal_free(mc_dev->mc_io);
2109 +err_free_netdev:
2110 + free_netdev(netdev);
2111 +err_exit:
2112 + return err;
2113 +}
2114 +
2115 +static int dpaa2_mac_remove(struct fsl_mc_device *mc_dev)
2116 +{
2117 + struct device *dev = &mc_dev->dev;
2118 + struct dpaa2_mac_priv *priv = dev_get_drvdata(dev);
2119 + struct net_device *netdev = priv->netdev;
2120 +
2121 + dpaa2_mac_stop(netdev);
2122 +
2123 + if (phy_is_pseudo_fixed_link(netdev->phydev))
2124 + fixed_phy_unregister(netdev->phydev);
2125 + else
2126 + phy_disconnect(netdev->phydev);
2127 + netdev->phydev = NULL;
2128 +
2129 +#ifdef CONFIG_FSL_DPAA2_MAC_NETDEVS
2130 + unregister_netdev(priv->netdev);
2131 +#endif
2132 + teardown_irqs(priv->mc_dev);
2133 + dpmac_close(priv->mc_dev->mc_io, 0, priv->mc_dev->mc_handle);
2134 + fsl_mc_portal_free(priv->mc_dev->mc_io);
2135 + free_netdev(priv->netdev);
2136 +
2137 + dev_set_drvdata(dev, NULL);
2138 +
2139 + return 0;
2140 +}
2141 +
2142 +static const struct fsl_mc_device_id dpaa2_mac_match_id_table[] = {
2143 + {
2144 + .vendor = FSL_MC_VENDOR_FREESCALE,
2145 + .obj_type = "dpmac",
2146 + },
2147 + { .vendor = 0x0 }
2148 +};
2149 +MODULE_DEVICE_TABLE(fslmc, dpaa2_mac_match_id_table);
2150 +
2151 +static struct fsl_mc_driver dpaa2_mac_drv = {
2152 + .driver = {
2153 + .name = KBUILD_MODNAME,
2154 + .owner = THIS_MODULE,
2155 + },
2156 + .probe = dpaa2_mac_probe,
2157 + .remove = dpaa2_mac_remove,
2158 + .match_id_table = dpaa2_mac_match_id_table,
2159 +};
2160 +
2161 +module_fsl_mc_driver(dpaa2_mac_drv);
2162 +
2163 +MODULE_LICENSE("GPL");
2164 +MODULE_DESCRIPTION("DPAA2 PHY proxy interface driver");
Staging tree of Mathias Kresin