1 /* SPDX-License-Identifier: (BSD-3-Clause OR GPL-2.0)
3 * Copyright 2010-2016 Freescale Semiconductor Inc.
12 /* This header declares the driver interface we implement */
15 #include <rte_malloc.h>
16 #include <rte_dpaa_logs.h>
17 #include <rte_string_fns.h>
19 #define QMI_PORT_REGS_OFFSET 0x400
21 /* CCSR map address to access ccsr based register */
23 /* fman version info */
26 u32 fman_dealloc_bufs_mask_hi
;
27 u32 fman_dealloc_bufs_mask_lo
;
29 int fman_ccsr_map_fd
= -1;
30 static COMPAT_LIST_HEAD(__ifs
);
32 /* This is the (const) global variable that callers have read-only access to.
33 * Internally, we have read-write access directly to __ifs.
35 const struct list_head
*fman_if_list
= &__ifs
;
38 if_destructor(struct __fman_if
*__if
)
40 struct fman_if_bpool
*bp
, *tmpbp
;
45 if (__if
->__if
.mac_type
== fman_offline
)
48 list_for_each_entry_safe(bp
, tmpbp
, &__if
->__if
.bpool_list
, node
) {
57 fman_get_ip_rev(const struct device_node
*fman_node
)
59 const uint32_t *fman_addr
;
65 fman_addr
= of_get_address(fman_node
, 0, ®s_size
, NULL
);
67 pr_err("of_get_address cannot return fman address\n");
70 phys_addr
= of_translate_address(fman_node
, fman_addr
);
72 pr_err("of_translate_address failed\n");
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");
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
;
86 _errno
= munmap(fman_ccsr_map
, regs_size
);
88 pr_err("munmap() of FMan ccsr failed");
94 fman_get_mac_index(uint64_t regs_addr_host
, uint8_t *mac_idx
)
110 switch (regs_addr_host
) {
149 fman_if_init(const struct device_node
*dpa_node
)
151 const char *rprop
, *mprop
;
153 struct __fman_if
*__if
;
154 struct fman_if_bpool
*bpool
;
156 const phandle
*mac_phandle
, *ports_phandle
, *pools_phandle
;
157 const phandle
*tx_channel_id
= NULL
, *mac_addr
, *cell_idx
;
158 const phandle
*rx_phandle
, *tx_phandle
;
159 uint64_t tx_phandle_host
[4] = {0};
160 uint64_t rx_phandle_host
[4] = {0};
161 uint64_t regs_addr_host
= 0;
162 uint64_t cell_idx_host
= 0;
164 const struct device_node
*mac_node
= NULL
, *tx_node
;
165 const struct device_node
*pool_node
, *fman_node
, *rx_node
;
166 const uint32_t *regs_addr
= NULL
;
167 const char *mname
, *fname
;
168 const char *dname
= dpa_node
->full_name
;
171 const char *char_prop
;
174 if (of_device_is_available(dpa_node
) == false)
177 rprop
= "fsl,qman-frame-queues-rx";
178 mprop
= "fsl,fman-mac";
180 /* Allocate an object for this network interface */
181 __if
= rte_malloc(NULL
, sizeof(*__if
), RTE_CACHE_LINE_SIZE
);
183 FMAN_ERR(-ENOMEM
, "malloc(%zu)\n", sizeof(*__if
));
186 memset(__if
, 0, sizeof(*__if
));
187 INIT_LIST_HEAD(&__if
->__if
.bpool_list
);
188 strlcpy(__if
->node_path
, dpa_node
->full_name
, PATH_MAX
- 1);
189 __if
->node_path
[PATH_MAX
- 1] = '\0';
191 /* Obtain the MAC node used by this interface except macless */
192 mac_phandle
= of_get_property(dpa_node
, mprop
, &lenp
);
194 FMAN_ERR(-EINVAL
, "%s: no %s\n", dname
, mprop
);
197 assert(lenp
== sizeof(phandle
));
198 mac_node
= of_find_node_by_phandle(*mac_phandle
);
200 FMAN_ERR(-ENXIO
, "%s: bad 'fsl,fman-mac\n", dname
);
203 mname
= mac_node
->full_name
;
205 /* Map the CCSR regs for the MAC node */
206 regs_addr
= of_get_address(mac_node
, 0, &__if
->regs_size
, NULL
);
208 FMAN_ERR(-EINVAL
, "of_get_address(%s)\n", mname
);
211 phys_addr
= of_translate_address(mac_node
, regs_addr
);
213 FMAN_ERR(-EINVAL
, "of_translate_address(%s, %p)\n",
217 __if
->ccsr_map
= mmap(NULL
, __if
->regs_size
,
218 PROT_READ
| PROT_WRITE
, MAP_SHARED
,
219 fman_ccsr_map_fd
, phys_addr
);
220 if (__if
->ccsr_map
== MAP_FAILED
) {
221 FMAN_ERR(-errno
, "mmap(0x%"PRIx64
")\n", phys_addr
);
224 na
= of_n_addr_cells(mac_node
);
225 /* Get rid of endianness (issues). Convert to host byte order */
226 regs_addr_host
= of_read_number(regs_addr
, na
);
229 /* Get the index of the Fman this i/f belongs to */
230 fman_node
= of_get_parent(mac_node
);
231 na
= of_n_addr_cells(mac_node
);
233 FMAN_ERR(-ENXIO
, "of_get_parent(%s)\n", mname
);
236 fname
= fman_node
->full_name
;
237 cell_idx
= of_get_property(fman_node
, "cell-index", &lenp
);
239 FMAN_ERR(-ENXIO
, "%s: no cell-index)\n", fname
);
242 assert(lenp
== sizeof(*cell_idx
));
243 cell_idx_host
= of_read_number(cell_idx
, lenp
/ sizeof(phandle
));
244 __if
->__if
.fman_idx
= cell_idx_host
;
246 _errno
= fman_get_ip_rev(fman_node
);
248 FMAN_ERR(-ENXIO
, "%s: ip_rev is not available\n",
254 if (fman_ip_rev
>= FMAN_V3
) {
256 * Set A2V, OVOM, EBD bits in contextA to allow external
257 * buffer deallocation by fman.
259 fman_dealloc_bufs_mask_hi
= FMAN_V3_CONTEXTA_EN_A2V
|
260 FMAN_V3_CONTEXTA_EN_OVOM
;
261 fman_dealloc_bufs_mask_lo
= FMAN_V3_CONTEXTA_EN_EBD
;
263 fman_dealloc_bufs_mask_hi
= 0;
264 fman_dealloc_bufs_mask_lo
= 0;
266 /* Is the MAC node 1G, 10G? */
267 __if
->__if
.is_memac
= 0;
269 if (of_device_is_compatible(mac_node
, "fsl,fman-1g-mac"))
270 __if
->__if
.mac_type
= fman_mac_1g
;
271 else if (of_device_is_compatible(mac_node
, "fsl,fman-10g-mac"))
272 __if
->__if
.mac_type
= fman_mac_10g
;
273 else if (of_device_is_compatible(mac_node
, "fsl,fman-memac")) {
274 __if
->__if
.is_memac
= 1;
275 char_prop
= of_get_property(mac_node
, "phy-connection-type",
278 printf("memac: unknown MII type assuming 1G\n");
279 /* Right now forcing memac to 1g in case of error*/
280 __if
->__if
.mac_type
= fman_mac_1g
;
282 if (strstr(char_prop
, "sgmii"))
283 __if
->__if
.mac_type
= fman_mac_1g
;
284 else if (strstr(char_prop
, "rgmii")) {
285 __if
->__if
.mac_type
= fman_mac_1g
;
286 __if
->__if
.is_rgmii
= 1;
287 } else if (strstr(char_prop
, "xgmii"))
288 __if
->__if
.mac_type
= fman_mac_10g
;
291 FMAN_ERR(-EINVAL
, "%s: unknown MAC type\n", mname
);
296 * For MAC ports, we cannot rely on cell-index. In
297 * T2080, two of the 10G ports on single FMAN have same
298 * duplicate cell-indexes as the other two 10G ports on
299 * same FMAN. Hence, we now rely upon addresses of the
300 * ports from device tree to deduce the index.
303 _errno
= fman_get_mac_index(regs_addr_host
, &__if
->__if
.mac_idx
);
305 FMAN_ERR(-EINVAL
, "Invalid register address: %" PRIx64
,
310 /* Extract the MAC address for private and shared interfaces */
311 mac_addr
= of_get_property(mac_node
, "local-mac-address",
314 FMAN_ERR(-EINVAL
, "%s: no local-mac-address\n",
318 memcpy(&__if
->__if
.mac_addr
, mac_addr
, ETHER_ADDR_LEN
);
320 /* Extract the Tx port (it's the second of the two port handles)
321 * and get its channel ID
323 ports_phandle
= of_get_property(mac_node
, "fsl,port-handles",
326 ports_phandle
= of_get_property(mac_node
, "fsl,fman-ports",
328 if (!ports_phandle
) {
329 FMAN_ERR(-EINVAL
, "%s: no fsl,port-handles\n",
333 assert(lenp
== (2 * sizeof(phandle
)));
334 tx_node
= of_find_node_by_phandle(ports_phandle
[1]);
336 FMAN_ERR(-ENXIO
, "%s: bad fsl,port-handle[1]\n", mname
);
339 /* Extract the channel ID (from tx-port-handle) */
340 tx_channel_id
= of_get_property(tx_node
, "fsl,qman-channel-id",
342 if (!tx_channel_id
) {
343 FMAN_ERR(-EINVAL
, "%s: no fsl-qman-channel-id\n",
348 rx_node
= of_find_node_by_phandle(ports_phandle
[0]);
350 FMAN_ERR(-ENXIO
, "%s: bad fsl,port-handle[0]\n", mname
);
353 regs_addr
= of_get_address(rx_node
, 0, &__if
->regs_size
, NULL
);
355 FMAN_ERR(-EINVAL
, "of_get_address(%s)\n", mname
);
358 phys_addr
= of_translate_address(rx_node
, regs_addr
);
360 FMAN_ERR(-EINVAL
, "of_translate_address(%s, %p)\n",
364 __if
->bmi_map
= mmap(NULL
, __if
->regs_size
,
365 PROT_READ
| PROT_WRITE
, MAP_SHARED
,
366 fman_ccsr_map_fd
, phys_addr
);
367 if (__if
->bmi_map
== MAP_FAILED
) {
368 FMAN_ERR(-errno
, "mmap(0x%"PRIx64
")\n", phys_addr
);
372 /* No channel ID for MAC-less */
373 assert(lenp
== sizeof(*tx_channel_id
));
374 na
= of_n_addr_cells(mac_node
);
375 __if
->__if
.tx_channel_id
= of_read_number(tx_channel_id
, na
);
377 /* Extract the Rx FQIDs. (Note, the device representation is silly,
378 * there are "counts" that must always be 1.)
380 rx_phandle
= of_get_property(dpa_node
, rprop
, &lenp
);
382 FMAN_ERR(-EINVAL
, "%s: no fsl,qman-frame-queues-rx\n", dname
);
386 assert(lenp
== (4 * sizeof(phandle
)));
388 na
= of_n_addr_cells(mac_node
);
389 /* Get rid of endianness (issues). Convert to host byte order */
390 rx_phandle_host
[0] = of_read_number(&rx_phandle
[0], na
);
391 rx_phandle_host
[1] = of_read_number(&rx_phandle
[1], na
);
392 rx_phandle_host
[2] = of_read_number(&rx_phandle
[2], na
);
393 rx_phandle_host
[3] = of_read_number(&rx_phandle
[3], na
);
395 assert((rx_phandle_host
[1] == 1) && (rx_phandle_host
[3] == 1));
396 __if
->__if
.fqid_rx_err
= rx_phandle_host
[0];
397 __if
->__if
.fqid_rx_def
= rx_phandle_host
[2];
399 /* Extract the Tx FQIDs */
400 tx_phandle
= of_get_property(dpa_node
,
401 "fsl,qman-frame-queues-tx", &lenp
);
403 FMAN_ERR(-EINVAL
, "%s: no fsl,qman-frame-queues-tx\n", dname
);
407 assert(lenp
== (4 * sizeof(phandle
)));
408 /*TODO: Fix for other cases also */
409 na
= of_n_addr_cells(mac_node
);
410 /* Get rid of endianness (issues). Convert to host byte order */
411 tx_phandle_host
[0] = of_read_number(&tx_phandle
[0], na
);
412 tx_phandle_host
[1] = of_read_number(&tx_phandle
[1], na
);
413 tx_phandle_host
[2] = of_read_number(&tx_phandle
[2], na
);
414 tx_phandle_host
[3] = of_read_number(&tx_phandle
[3], na
);
415 assert((tx_phandle_host
[1] == 1) && (tx_phandle_host
[3] == 1));
416 __if
->__if
.fqid_tx_err
= tx_phandle_host
[0];
417 __if
->__if
.fqid_tx_confirm
= tx_phandle_host
[2];
419 /* Obtain the buffer pool nodes used by this interface */
420 pools_phandle
= of_get_property(dpa_node
, "fsl,bman-buffer-pools",
422 if (!pools_phandle
) {
423 FMAN_ERR(-EINVAL
, "%s: no fsl,bman-buffer-pools\n", dname
);
426 /* For each pool, parse the corresponding node and add a pool object
427 * to the interface's "bpool_list"
429 assert(lenp
&& !(lenp
% sizeof(phandle
)));
433 uint64_t bpid_host
= 0;
434 uint64_t bpool_host
[6] = {0};
436 /* Allocate an object for the pool */
437 bpool
= rte_malloc(NULL
, sizeof(*bpool
), RTE_CACHE_LINE_SIZE
);
439 FMAN_ERR(-ENOMEM
, "malloc(%zu)\n", sizeof(*bpool
));
442 /* Find the pool node */
443 pool_node
= of_find_node_by_phandle(*pools_phandle
);
445 FMAN_ERR(-ENXIO
, "%s: bad fsl,bman-buffer-pools\n",
450 pname
= pool_node
->full_name
;
451 /* Extract the BPID property */
452 prop
= of_get_property(pool_node
, "fsl,bpid", &proplen
);
454 FMAN_ERR(-EINVAL
, "%s: no fsl,bpid\n", pname
);
458 assert(proplen
== sizeof(*prop
));
459 na
= of_n_addr_cells(mac_node
);
460 /* Get rid of endianness (issues).
461 * Convert to host byte-order
463 bpid_host
= of_read_number(prop
, na
);
464 bpool
->bpid
= bpid_host
;
465 /* Extract the cfg property (count/size/addr). "fsl,bpool-cfg"
466 * indicates for the Bman driver to seed the pool.
467 * "fsl,bpool-ethernet-cfg" is used by the network driver. The
468 * two are mutually exclusive, so check for either of them.
470 prop
= of_get_property(pool_node
, "fsl,bpool-cfg",
473 prop
= of_get_property(pool_node
,
474 "fsl,bpool-ethernet-cfg",
477 /* It's OK for there to be no bpool-cfg */
478 bpool
->count
= bpool
->size
= bpool
->addr
= 0;
480 assert(proplen
== (6 * sizeof(*prop
)));
481 na
= of_n_addr_cells(mac_node
);
482 /* Get rid of endianness (issues).
483 * Convert to host byte order
485 bpool_host
[0] = of_read_number(&prop
[0], na
);
486 bpool_host
[1] = of_read_number(&prop
[1], na
);
487 bpool_host
[2] = of_read_number(&prop
[2], na
);
488 bpool_host
[3] = of_read_number(&prop
[3], na
);
489 bpool_host
[4] = of_read_number(&prop
[4], na
);
490 bpool_host
[5] = of_read_number(&prop
[5], na
);
492 bpool
->count
= ((uint64_t)bpool_host
[0] << 32) |
494 bpool
->size
= ((uint64_t)bpool_host
[2] << 32) |
496 bpool
->addr
= ((uint64_t)bpool_host
[4] << 32) |
499 /* Parsing of the pool is complete, add it to the interface
502 list_add_tail(&bpool
->node
, &__if
->__if
.bpool_list
);
503 lenp
-= sizeof(phandle
);
507 /* Parsing of the network interface is complete, add it to the list */
508 DPAA_BUS_LOG(DEBUG
, "Found %s, Tx Channel = %x, FMAN = %x,"
510 dname
, __if
->__if
.tx_channel_id
, __if
->__if
.fman_idx
,
513 list_add_tail(&__if
->__if
.node
, &__ifs
);
523 const struct device_node
*dpa_node
;
526 /* If multiple dependencies try to initialise the Fman driver, don't
529 if (fman_ccsr_map_fd
!= -1)
532 fman_ccsr_map_fd
= open(FMAN_DEVICE_PATH
, O_RDWR
);
533 if (unlikely(fman_ccsr_map_fd
< 0)) {
534 DPAA_BUS_LOG(ERR
, "Unable to open (/dev/mem)");
535 return fman_ccsr_map_fd
;
538 for_each_compatible_node(dpa_node
, NULL
, "fsl,dpa-ethernet-init") {
539 _errno
= fman_if_init(dpa_node
);
541 FMAN_ERR(_errno
, "if_init(%s)\n", dpa_node
->full_name
);
555 struct __fman_if
*__if
, *tmpif
;
557 assert(fman_ccsr_map_fd
!= -1);
559 list_for_each_entry_safe(__if
, tmpif
, &__ifs
, __if
.node
) {
562 /* disable Rx and Tx */
563 if ((__if
->__if
.mac_type
== fman_mac_1g
) &&
564 (!__if
->__if
.is_memac
))
565 out_be32(__if
->ccsr_map
+ 0x100,
566 in_be32(__if
->ccsr_map
+ 0x100) & ~(u32
)0x5);
568 out_be32(__if
->ccsr_map
+ 8,
569 in_be32(__if
->ccsr_map
+ 8) & ~(u32
)3);
570 /* release the mapping */
571 _errno
= munmap(__if
->ccsr_map
, __if
->regs_size
);
572 if (unlikely(_errno
< 0))
573 fprintf(stderr
, "%s:%d:%s(): munmap() = %d (%s)\n",
574 __FILE__
, __LINE__
, __func__
,
575 -errno
, strerror(errno
));
576 printf("Tearing down %s\n", __if
->node_path
);
577 list_del(&__if
->__if
.node
);
581 close(fman_ccsr_map_fd
);
582 fman_ccsr_map_fd
= -1;