1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
2 *
3 * Copyright 2010-2016 Freescale Semiconductor Inc.
4 * Copyright 2017-2020 NXP
5 *
6 */
7
8 #include <sys/types.h>
9 #include <sys/ioctl.h>
10 #include <ifaddrs.h>
11
12 /* This header declares the driver interface we implement */
13 #include <fman.h>
14 #include <dpaa_of.h>
15 #include <rte_malloc.h>
16 #include <rte_dpaa_logs.h>
17 #include <rte_string_fns.h>
18
19 #define QMI_PORT_REGS_OFFSET 0x400
20
21 /* CCSR map address to access ccsr based register */
22 void *fman_ccsr_map;
23 /* fman version info */
24 u16 fman_ip_rev;
25 static int get_once;
26 u32 fman_dealloc_bufs_mask_hi;
27 u32 fman_dealloc_bufs_mask_lo;
28
29 int fman_ccsr_map_fd = -1;
30 static COMPAT_LIST_HEAD(__ifs);
31
32 /* This is the (const) global variable that callers have read-only access to.
33 * Internally, we have read-write access directly to __ifs.
34 */
35 const struct list_head *fman_if_list = &__ifs;
36
37 static void
if_destructor(struct __fman_if * __if)38 if_destructor(struct __fman_if *__if)
39 {
40 struct fman_if_bpool *bp, *tmpbp;
41
42 if (!__if)
43 return;
44
45 if (__if->__if.mac_type == fman_offline)
46 goto cleanup;
47
48 list_for_each_entry_safe(bp, tmpbp, &__if->__if.bpool_list, node) {
49 list_del(&bp->node);
50 free(bp);
51 }
52 cleanup:
53 free(__if);
54 }
55
56 static int
fman_get_ip_rev(const struct device_node * fman_node)57 fman_get_ip_rev(const struct device_node *fman_node)
58 {
59 const uint32_t *fman_addr;
60 uint64_t phys_addr;
61 uint64_t regs_size;
62 uint32_t ip_rev_1;
63 int _errno;
64
65 fman_addr = of_get_address(fman_node, 0, ®s_size, NULL);
66 if (!fman_addr) {
67 pr_err("of_get_address cannot return fman address\n");
68 return -EINVAL;
69 }
70 phys_addr = of_translate_address(fman_node, fman_addr);
71 if (!phys_addr) {
72 pr_err("of_translate_address failed\n");
73 return -EINVAL;
74 }
75 fman_ccsr_map = mmap(NULL, regs_size, PROT_READ | PROT_WRITE,
76 MAP_SHARED, fman_ccsr_map_fd, phys_addr);
77 if (fman_ccsr_map == MAP_FAILED) {
78 pr_err("Can not map FMan ccsr base");
79 return -EINVAL;
80 }
81
82 ip_rev_1 = in_be32(fman_ccsr_map + FMAN_IP_REV_1);
83 fman_ip_rev = (ip_rev_1 & FMAN_IP_REV_1_MAJOR_MASK) >>
84 FMAN_IP_REV_1_MAJOR_SHIFT;
85
86 _errno = munmap(fman_ccsr_map, regs_size);
87 if (_errno)
88 pr_err("munmap() of FMan ccsr failed");
89
90 return 0;
91 }
92
93 static int
fman_get_mac_index(uint64_t regs_addr_host,uint8_t * mac_idx)94 fman_get_mac_index(uint64_t regs_addr_host, uint8_t *mac_idx)
95 {
96 int ret = 0;
97
98 /*
99 * MAC1 : E_0000h
100 * MAC2 : E_2000h
101 * MAC3 : E_4000h
102 * MAC4 : E_6000h
103 * MAC5 : E_8000h
104 * MAC6 : E_A000h
105 * MAC7 : E_C000h
106 * MAC8 : E_E000h
107 * MAC9 : F_0000h
108 * MAC10: F_2000h
109 */
110 switch (regs_addr_host) {
111 case 0xE0000:
112 *mac_idx = 1;
113 break;
114 case 0xE2000:
115 *mac_idx = 2;
116 break;
117 case 0xE4000:
118 *mac_idx = 3;
119 break;
120 case 0xE6000:
121 *mac_idx = 4;
122 break;
123 case 0xE8000:
124 *mac_idx = 5;
125 break;
126 case 0xEA000:
127 *mac_idx = 6;
128 break;
129 case 0xEC000:
130 *mac_idx = 7;
131 break;
132 case 0xEE000:
133 *mac_idx = 8;
134 break;
135 case 0xF0000:
136 *mac_idx = 9;
137 break;
138 case 0xF2000:
139 *mac_idx = 10;
140 break;
141 default:
142 ret = -EINVAL;
143 }
144
145 return ret;
146 }
147
fman_if_vsp_init(struct __fman_if * __if)148 static void fman_if_vsp_init(struct __fman_if *__if)
149 {
150 const phandle *prop;
151 int cell_index;
152 const struct device_node *dev;
153 size_t lenp;
154 const uint8_t mac_idx[] = {-1, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1};
155
156 if (__if->__if.mac_type == fman_mac_1g) {
157 for_each_compatible_node(dev, NULL,
158 "fsl,fman-port-1g-rx-extended-args") {
159 prop = of_get_property(dev, "cell-index", &lenp);
160 if (prop) {
161 cell_index = of_read_number(
162 &prop[0],
163 lenp / sizeof(phandle));
164 if (cell_index == mac_idx[__if->__if.mac_idx]) {
165 prop = of_get_property(
166 dev,
167 "vsp-window", &lenp);
168 if (prop) {
169 __if->__if.num_profiles =
170 of_read_number(
171 &prop[0], 1);
172 __if->__if.base_profile_id =
173 of_read_number(
174 &prop[1], 1);
175 }
176 }
177 }
178 }
179 } else if (__if->__if.mac_type == fman_mac_10g) {
180 for_each_compatible_node(dev, NULL,
181 "fsl,fman-port-10g-rx-extended-args") {
182 prop = of_get_property(dev, "cell-index", &lenp);
183 if (prop) {
184 cell_index = of_read_number(
185 &prop[0], lenp / sizeof(phandle));
186 if (cell_index == mac_idx[__if->__if.mac_idx]) {
187 prop = of_get_property(
188 dev, "vsp-window", &lenp);
189 if (prop) {
190 __if->__if.num_profiles =
191 of_read_number(
192 &prop[0], 1);
193 __if->__if.base_profile_id =
194 of_read_number(
195 &prop[1], 1);
196 }
197 }
198 }
199 }
200 }
201 }
202
203 static int
fman_if_init(const struct device_node * dpa_node)204 fman_if_init(const struct device_node *dpa_node)
205 {
206 const char *rprop, *mprop;
207 uint64_t phys_addr;
208 struct __fman_if *__if;
209 struct fman_if_bpool *bpool;
210
211 const phandle *mac_phandle, *ports_phandle, *pools_phandle;
212 const phandle *tx_channel_id = NULL, *mac_addr, *cell_idx;
213 const phandle *rx_phandle, *tx_phandle;
214 uint64_t tx_phandle_host[4] = {0};
215 uint64_t rx_phandle_host[4] = {0};
216 uint64_t regs_addr_host = 0;
217 uint64_t cell_idx_host = 0;
218
219 const struct device_node *mac_node = NULL, *tx_node;
220 const struct device_node *pool_node, *fman_node, *rx_node;
221 const uint32_t *regs_addr = NULL;
222 const char *mname, *fname;
223 const char *dname = dpa_node->full_name;
224 size_t lenp;
225 int _errno, is_shared = 0;
226 const char *char_prop;
227 uint32_t na;
228
229 if (of_device_is_available(dpa_node) == false)
230 return 0;
231
232 if (!of_device_is_compatible(dpa_node, "fsl,dpa-ethernet-init") &&
233 !of_device_is_compatible(dpa_node, "fsl,dpa-ethernet-shared")) {
234 return 0;
235 }
236
237 if (of_device_is_compatible(dpa_node, "fsl,dpa-ethernet-shared"))
238 is_shared = 1;
239
240 rprop = "fsl,qman-frame-queues-rx";
241 mprop = "fsl,fman-mac";
242
243 /* Allocate an object for this network interface */
244 __if = rte_malloc(NULL, sizeof(*__if), RTE_CACHE_LINE_SIZE);
245 if (!__if) {
246 FMAN_ERR(-ENOMEM, "malloc(%zu)\n", sizeof(*__if));
247 goto err;
248 }
249 memset(__if, 0, sizeof(*__if));
250 INIT_LIST_HEAD(&__if->__if.bpool_list);
251 strlcpy(__if->node_name, dpa_node->name, IF_NAME_MAX_LEN - 1);
252 __if->node_name[IF_NAME_MAX_LEN - 1] = '\0';
253 strlcpy(__if->node_path, dpa_node->full_name, PATH_MAX - 1);
254 __if->node_path[PATH_MAX - 1] = '\0';
255
256 /* Obtain the MAC node used by this interface except macless */
257 mac_phandle = of_get_property(dpa_node, mprop, &lenp);
258 if (!mac_phandle) {
259 FMAN_ERR(-EINVAL, "%s: no %s\n", dname, mprop);
260 goto err;
261 }
262 assert(lenp == sizeof(phandle));
263 mac_node = of_find_node_by_phandle(*mac_phandle);
264 if (!mac_node) {
265 FMAN_ERR(-ENXIO, "%s: bad 'fsl,fman-mac\n", dname);
266 goto err;
267 }
268 mname = mac_node->full_name;
269
270 /* Map the CCSR regs for the MAC node */
271 regs_addr = of_get_address(mac_node, 0, &__if->regs_size, NULL);
272 if (!regs_addr) {
273 FMAN_ERR(-EINVAL, "of_get_address(%s)\n", mname);
274 goto err;
275 }
276 phys_addr = of_translate_address(mac_node, regs_addr);
277 if (!phys_addr) {
278 FMAN_ERR(-EINVAL, "of_translate_address(%s, %p)\n",
279 mname, regs_addr);
280 goto err;
281 }
282 __if->ccsr_map = mmap(NULL, __if->regs_size,
283 PROT_READ | PROT_WRITE, MAP_SHARED,
284 fman_ccsr_map_fd, phys_addr);
285 if (__if->ccsr_map == MAP_FAILED) {
286 FMAN_ERR(-errno, "mmap(0x%"PRIx64")\n", phys_addr);
287 goto err;
288 }
289 na = of_n_addr_cells(mac_node);
290 /* Get rid of endianness (issues). Convert to host byte order */
291 regs_addr_host = of_read_number(regs_addr, na);
292
293
294 /* Get the index of the Fman this i/f belongs to */
295 fman_node = of_get_parent(mac_node);
296 na = of_n_addr_cells(mac_node);
297 if (!fman_node) {
298 FMAN_ERR(-ENXIO, "of_get_parent(%s)\n", mname);
299 goto err;
300 }
301 fname = fman_node->full_name;
302 cell_idx = of_get_property(fman_node, "cell-index", &lenp);
303 if (!cell_idx) {
304 FMAN_ERR(-ENXIO, "%s: no cell-index)\n", fname);
305 goto err;
306 }
307 assert(lenp == sizeof(*cell_idx));
308 cell_idx_host = of_read_number(cell_idx, lenp / sizeof(phandle));
309 __if->__if.fman_idx = cell_idx_host;
310 if (!get_once) {
311 _errno = fman_get_ip_rev(fman_node);
312 if (_errno) {
313 FMAN_ERR(-ENXIO, "%s: ip_rev is not available\n",
314 fname);
315 goto err;
316 }
317 }
318
319 if (fman_ip_rev >= FMAN_V3) {
320 /*
321 * Set A2V, OVOM, EBD bits in contextA to allow external
322 * buffer deallocation by fman.
323 */
324 fman_dealloc_bufs_mask_hi = FMAN_V3_CONTEXTA_EN_A2V |
325 FMAN_V3_CONTEXTA_EN_OVOM;
326 fman_dealloc_bufs_mask_lo = FMAN_V3_CONTEXTA_EN_EBD;
327 } else {
328 fman_dealloc_bufs_mask_hi = 0;
329 fman_dealloc_bufs_mask_lo = 0;
330 }
331 /* Is the MAC node 1G, 2.5G, 10G? */
332 __if->__if.is_memac = 0;
333
334 if (of_device_is_compatible(mac_node, "fsl,fman-1g-mac"))
335 __if->__if.mac_type = fman_mac_1g;
336 else if (of_device_is_compatible(mac_node, "fsl,fman-10g-mac"))
337 __if->__if.mac_type = fman_mac_10g;
338 else if (of_device_is_compatible(mac_node, "fsl,fman-memac")) {
339 __if->__if.is_memac = 1;
340 char_prop = of_get_property(mac_node, "phy-connection-type",
341 NULL);
342 if (!char_prop) {
343 printf("memac: unknown MII type assuming 1G\n");
344 /* Right now forcing memac to 1g in case of error*/
345 __if->__if.mac_type = fman_mac_1g;
346 } else {
347 if (strstr(char_prop, "sgmii-2500"))
348 __if->__if.mac_type = fman_mac_2_5g;
349 else if (strstr(char_prop, "sgmii"))
350 __if->__if.mac_type = fman_mac_1g;
351 else if (strstr(char_prop, "rgmii")) {
352 __if->__if.mac_type = fman_mac_1g;
353 __if->__if.is_rgmii = 1;
354 } else if (strstr(char_prop, "xgmii"))
355 __if->__if.mac_type = fman_mac_10g;
356 }
357 } else {
358 FMAN_ERR(-EINVAL, "%s: unknown MAC type\n", mname);
359 goto err;
360 }
361
362 /*
363 * For MAC ports, we cannot rely on cell-index. In
364 * T2080, two of the 10G ports on single FMAN have same
365 * duplicate cell-indexes as the other two 10G ports on
366 * same FMAN. Hence, we now rely upon addresses of the
367 * ports from device tree to deduce the index.
368 */
369
370 _errno = fman_get_mac_index(regs_addr_host, &__if->__if.mac_idx);
371 if (_errno) {
372 FMAN_ERR(-EINVAL, "Invalid register address: %" PRIx64,
373 regs_addr_host);
374 goto err;
375 }
376
377 /* Extract the MAC address for private and shared interfaces */
378 mac_addr = of_get_property(mac_node, "local-mac-address",
379 &lenp);
380 if (!mac_addr) {
381 FMAN_ERR(-EINVAL, "%s: no local-mac-address\n",
382 mname);
383 goto err;
384 }
385 memcpy(&__if->__if.mac_addr, mac_addr, ETHER_ADDR_LEN);
386
387 /* Extract the Tx port (it's the second of the two port handles)
388 * and get its channel ID
389 */
390 ports_phandle = of_get_property(mac_node, "fsl,port-handles",
391 &lenp);
392 if (!ports_phandle)
393 ports_phandle = of_get_property(mac_node, "fsl,fman-ports",
394 &lenp);
395 if (!ports_phandle) {
396 FMAN_ERR(-EINVAL, "%s: no fsl,port-handles\n",
397 mname);
398 goto err;
399 }
400 assert(lenp == (2 * sizeof(phandle)));
401 tx_node = of_find_node_by_phandle(ports_phandle[1]);
402 if (!tx_node) {
403 FMAN_ERR(-ENXIO, "%s: bad fsl,port-handle[1]\n", mname);
404 goto err;
405 }
406 /* Extract the channel ID (from tx-port-handle) */
407 tx_channel_id = of_get_property(tx_node, "fsl,qman-channel-id",
408 &lenp);
409 if (!tx_channel_id) {
410 FMAN_ERR(-EINVAL, "%s: no fsl-qman-channel-id\n",
411 tx_node->full_name);
412 goto err;
413 }
414
415 rx_node = of_find_node_by_phandle(ports_phandle[0]);
416 if (!rx_node) {
417 FMAN_ERR(-ENXIO, "%s: bad fsl,port-handle[0]\n", mname);
418 goto err;
419 }
420 regs_addr = of_get_address(rx_node, 0, &__if->regs_size, NULL);
421 if (!regs_addr) {
422 FMAN_ERR(-EINVAL, "of_get_address(%s)\n", mname);
423 goto err;
424 }
425 phys_addr = of_translate_address(rx_node, regs_addr);
426 if (!phys_addr) {
427 FMAN_ERR(-EINVAL, "of_translate_address(%s, %p)\n",
428 mname, regs_addr);
429 goto err;
430 }
431 __if->bmi_map = mmap(NULL, __if->regs_size,
432 PROT_READ | PROT_WRITE, MAP_SHARED,
433 fman_ccsr_map_fd, phys_addr);
434 if (__if->bmi_map == MAP_FAILED) {
435 FMAN_ERR(-errno, "mmap(0x%"PRIx64")\n", phys_addr);
436 goto err;
437 }
438
439 /* No channel ID for MAC-less */
440 assert(lenp == sizeof(*tx_channel_id));
441 na = of_n_addr_cells(mac_node);
442 __if->__if.tx_channel_id = of_read_number(tx_channel_id, na);
443
444 /* Extract the Rx FQIDs. (Note, the device representation is silly,
445 * there are "counts" that must always be 1.)
446 */
447 rx_phandle = of_get_property(dpa_node, rprop, &lenp);
448 if (!rx_phandle) {
449 FMAN_ERR(-EINVAL, "%s: no fsl,qman-frame-queues-rx\n", dname);
450 goto err;
451 }
452
453 assert(lenp >= (4 * sizeof(phandle)));
454
455 na = of_n_addr_cells(mac_node);
456 /* Get rid of endianness (issues). Convert to host byte order */
457 rx_phandle_host[0] = of_read_number(&rx_phandle[0], na);
458 rx_phandle_host[1] = of_read_number(&rx_phandle[1], na);
459 rx_phandle_host[2] = of_read_number(&rx_phandle[2], na);
460 rx_phandle_host[3] = of_read_number(&rx_phandle[3], na);
461
462 assert((rx_phandle_host[1] == 1) && (rx_phandle_host[3] == 1));
463 __if->__if.fqid_rx_err = rx_phandle_host[0];
464 __if->__if.fqid_rx_def = rx_phandle_host[2];
465
466 /* Extract the Tx FQIDs */
467 tx_phandle = of_get_property(dpa_node,
468 "fsl,qman-frame-queues-tx", &lenp);
469 if (!tx_phandle) {
470 FMAN_ERR(-EINVAL, "%s: no fsl,qman-frame-queues-tx\n", dname);
471 goto err;
472 }
473
474 assert(lenp >= (4 * sizeof(phandle)));
475 /*TODO: Fix for other cases also */
476 na = of_n_addr_cells(mac_node);
477 /* Get rid of endianness (issues). Convert to host byte order */
478 tx_phandle_host[0] = of_read_number(&tx_phandle[0], na);
479 tx_phandle_host[1] = of_read_number(&tx_phandle[1], na);
480 tx_phandle_host[2] = of_read_number(&tx_phandle[2], na);
481 tx_phandle_host[3] = of_read_number(&tx_phandle[3], na);
482 assert((tx_phandle_host[1] == 1) && (tx_phandle_host[3] == 1));
483 __if->__if.fqid_tx_err = tx_phandle_host[0];
484 __if->__if.fqid_tx_confirm = tx_phandle_host[2];
485
486 /* Obtain the buffer pool nodes used by this interface */
487 pools_phandle = of_get_property(dpa_node, "fsl,bman-buffer-pools",
488 &lenp);
489 if (!pools_phandle) {
490 FMAN_ERR(-EINVAL, "%s: no fsl,bman-buffer-pools\n", dname);
491 goto err;
492 }
493 /* For each pool, parse the corresponding node and add a pool object
494 * to the interface's "bpool_list"
495 */
496 assert(lenp && !(lenp % sizeof(phandle)));
497 while (lenp) {
498 size_t proplen;
499 const phandle *prop;
500 uint64_t bpid_host = 0;
501 uint64_t bpool_host[6] = {0};
502 const char *pname;
503 /* Allocate an object for the pool */
504 bpool = rte_malloc(NULL, sizeof(*bpool), RTE_CACHE_LINE_SIZE);
505 if (!bpool) {
506 FMAN_ERR(-ENOMEM, "malloc(%zu)\n", sizeof(*bpool));
507 goto err;
508 }
509 /* Find the pool node */
510 pool_node = of_find_node_by_phandle(*pools_phandle);
511 if (!pool_node) {
512 FMAN_ERR(-ENXIO, "%s: bad fsl,bman-buffer-pools\n",
513 dname);
514 rte_free(bpool);
515 goto err;
516 }
517 pname = pool_node->full_name;
518 /* Extract the BPID property */
519 prop = of_get_property(pool_node, "fsl,bpid", &proplen);
520 if (!prop) {
521 FMAN_ERR(-EINVAL, "%s: no fsl,bpid\n", pname);
522 rte_free(bpool);
523 goto err;
524 }
525 assert(proplen == sizeof(*prop));
526 na = of_n_addr_cells(mac_node);
527 /* Get rid of endianness (issues).
528 * Convert to host byte-order
529 */
530 bpid_host = of_read_number(prop, na);
531 bpool->bpid = bpid_host;
532 /* Extract the cfg property (count/size/addr). "fsl,bpool-cfg"
533 * indicates for the Bman driver to seed the pool.
534 * "fsl,bpool-ethernet-cfg" is used by the network driver. The
535 * two are mutually exclusive, so check for either of them.
536 */
537 prop = of_get_property(pool_node, "fsl,bpool-cfg",
538 &proplen);
539 if (!prop)
540 prop = of_get_property(pool_node,
541 "fsl,bpool-ethernet-cfg",
542 &proplen);
543 if (!prop) {
544 /* It's OK for there to be no bpool-cfg */
545 bpool->count = bpool->size = bpool->addr = 0;
546 } else {
547 assert(proplen == (6 * sizeof(*prop)));
548 na = of_n_addr_cells(mac_node);
549 /* Get rid of endianness (issues).
550 * Convert to host byte order
551 */
552 bpool_host[0] = of_read_number(&prop[0], na);
553 bpool_host[1] = of_read_number(&prop[1], na);
554 bpool_host[2] = of_read_number(&prop[2], na);
555 bpool_host[3] = of_read_number(&prop[3], na);
556 bpool_host[4] = of_read_number(&prop[4], na);
557 bpool_host[5] = of_read_number(&prop[5], na);
558
559 bpool->count = ((uint64_t)bpool_host[0] << 32) |
560 bpool_host[1];
561 bpool->size = ((uint64_t)bpool_host[2] << 32) |
562 bpool_host[3];
563 bpool->addr = ((uint64_t)bpool_host[4] << 32) |
564 bpool_host[5];
565 }
566 /* Parsing of the pool is complete, add it to the interface
567 * list.
568 */
569 list_add_tail(&bpool->node, &__if->__if.bpool_list);
570 lenp -= sizeof(phandle);
571 pools_phandle++;
572 }
573
574 if (is_shared)
575 __if->__if.is_shared_mac = 1;
576
577 fman_if_vsp_init(__if);
578
579 /* Parsing of the network interface is complete, add it to the list */
580 DPAA_BUS_LOG(DEBUG, "Found %s, Tx Channel = %x, FMAN = %x,"
581 "Port ID = %x",
582 dname, __if->__if.tx_channel_id, __if->__if.fman_idx,
583 __if->__if.mac_idx);
584
585 list_add_tail(&__if->__if.node, &__ifs);
586 return 0;
587 err:
588 if_destructor(__if);
589 return _errno;
590 }
591
592 int
fman_init(void)593 fman_init(void)
594 {
595 const struct device_node *dpa_node, *parent_node;
596 int _errno;
597
598 /* If multiple dependencies try to initialise the Fman driver, don't
599 * panic.
600 */
601 if (fman_ccsr_map_fd != -1)
602 return 0;
603
604 fman_ccsr_map_fd = open(FMAN_DEVICE_PATH, O_RDWR);
605 if (unlikely(fman_ccsr_map_fd < 0)) {
606 DPAA_BUS_LOG(ERR, "Unable to open (/dev/mem)");
607 return fman_ccsr_map_fd;
608 }
609
610 parent_node = of_find_compatible_node(NULL, NULL, "fsl,dpaa");
611 if (!parent_node) {
612 DPAA_BUS_LOG(ERR, "Unable to find fsl,dpaa node");
613 return -ENODEV;
614 }
615
616 for_each_child_node(parent_node, dpa_node) {
617 _errno = fman_if_init(dpa_node);
618 if (_errno) {
619 FMAN_ERR(_errno, "if_init(%s)\n", dpa_node->full_name);
620 goto err;
621 }
622 }
623
624 return 0;
625 err:
626 fman_finish();
627 return _errno;
628 }
629
630 void
fman_finish(void)631 fman_finish(void)
632 {
633 struct __fman_if *__if, *tmpif;
634
635 assert(fman_ccsr_map_fd != -1);
636
637 list_for_each_entry_safe(__if, tmpif, &__ifs, __if.node) {
638 int _errno;
639
640 /* disable Rx and Tx */
641 if ((__if->__if.mac_type == fman_mac_1g) &&
642 (!__if->__if.is_memac))
643 out_be32(__if->ccsr_map + 0x100,
644 in_be32(__if->ccsr_map + 0x100) & ~(u32)0x5);
645 else
646 out_be32(__if->ccsr_map + 8,
647 in_be32(__if->ccsr_map + 8) & ~(u32)3);
648 /* release the mapping */
649 _errno = munmap(__if->ccsr_map, __if->regs_size);
650 if (unlikely(_errno < 0))
651 fprintf(stderr, "%s:%d:%s(): munmap() = %d (%s)\n",
652 __FILE__, __LINE__, __func__,
653 -errno, strerror(errno));
654 printf("Tearing down %s\n", __if->node_path);
655 list_del(&__if->__if.node);
656 rte_free(__if);
657 }
658
659 close(fman_ccsr_map_fd);
660 fman_ccsr_map_fd = -1;
661 }
662