source: rtems-libbsd/linux/drivers/net/ethernet/freescale/fman/fman.c @ cd089b9

55-freebsd-126-freebsd-12
Last change on this file since cd089b9 was cd089b9, checked in by Sebastian Huber <sebastian.huber@…>, on 05/05/17 at 06:47:39

Linux update to 4.11-rc5

Linux baseline a71c9a1c779f2499fb2afc0553e543f18aff6edf (4.11-rc5).

  • Property mode set to 100644
File size: 89.2 KB
Line 
1#include <machine/rtems-bsd-kernel-space.h>
2
3#include <rtems/bsd/local/opt_dpaa.h>
4
5/*
6 * Copyright 2008-2015 Freescale Semiconductor Inc.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 *     * Redistributions of source code must retain the above copyright
11 *       notice, this list of conditions and the following disclaimer.
12 *     * Redistributions in binary form must reproduce the above copyright
13 *       notice, this list of conditions and the following disclaimer in the
14 *       documentation and/or other materials provided with the distribution.
15 *     * Neither the name of Freescale Semiconductor nor the
16 *       names of its contributors may be used to endorse or promote products
17 *       derived from this software without specific prior written permission.
18 *
19 *
20 * ALTERNATIVELY, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") as published by the Free Software
22 * Foundation, either version 2 of that License or (at your option) any
23 * later version.
24 *
25 * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
26 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
27 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28 * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
29 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
30 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
31 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
32 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 */
36
37#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
38
39#include "fman.h"
40#include "fman_muram.h"
41
42#include <linux/fsl/guts.h>
43#include <linux/slab.h>
44#include <linux/delay.h>
45#include <linux/module.h>
46#include <linux/of_platform.h>
47#include <linux/clk.h>
48#include <linux/of_address.h>
49#include <linux/of_irq.h>
50#include <linux/interrupt.h>
51#include <linux/libfdt_env.h>
52#ifdef __rtems__
53#include <bsp/fdt.h>
54#include <bsp/qoriq.h>
55#endif /* __rtems__ */
56
57/* General defines */
58#define FMAN_LIODN_TBL                  64      /* size of LIODN table */
59#define MAX_NUM_OF_MACS                 10
60#define FM_NUM_OF_FMAN_CTRL_EVENT_REGS  4
61#define BASE_RX_PORTID                  0x08
62#define BASE_TX_PORTID                  0x28
63
64/* Modules registers offsets */
65#define BMI_OFFSET              0x00080000
66#define QMI_OFFSET              0x00080400
67#define DMA_OFFSET              0x000C2000
68#define FPM_OFFSET              0x000C3000
69#define IMEM_OFFSET             0x000C4000
70#define CGP_OFFSET              0x000DB000
71
72/* Exceptions bit map */
73#define EX_DMA_BUS_ERROR                0x80000000
74#define EX_DMA_READ_ECC                 0x40000000
75#define EX_DMA_SYSTEM_WRITE_ECC 0x20000000
76#define EX_DMA_FM_WRITE_ECC             0x10000000
77#define EX_FPM_STALL_ON_TASKS           0x08000000
78#define EX_FPM_SINGLE_ECC               0x04000000
79#define EX_FPM_DOUBLE_ECC               0x02000000
80#define EX_QMI_SINGLE_ECC               0x01000000
81#define EX_QMI_DEQ_FROM_UNKNOWN_PORTID  0x00800000
82#define EX_QMI_DOUBLE_ECC               0x00400000
83#define EX_BMI_LIST_RAM_ECC             0x00200000
84#define EX_BMI_STORAGE_PROFILE_ECC      0x00100000
85#define EX_BMI_STATISTICS_RAM_ECC       0x00080000
86#define EX_IRAM_ECC                     0x00040000
87#define EX_MURAM_ECC                    0x00020000
88#define EX_BMI_DISPATCH_RAM_ECC 0x00010000
89#define EX_DMA_SINGLE_PORT_ECC          0x00008000
90
91/* DMA defines */
92/* masks */
93#define DMA_MODE_BER                    0x00200000
94#define DMA_MODE_ECC                    0x00000020
95#define DMA_MODE_SECURE_PROT            0x00000800
96#define DMA_MODE_AXI_DBG_MASK           0x0F000000
97
98#define DMA_TRANSFER_PORTID_MASK        0xFF000000
99#define DMA_TRANSFER_TNUM_MASK          0x00FF0000
100#define DMA_TRANSFER_LIODN_MASK 0x00000FFF
101
102#define DMA_STATUS_BUS_ERR              0x08000000
103#define DMA_STATUS_READ_ECC             0x04000000
104#define DMA_STATUS_SYSTEM_WRITE_ECC     0x02000000
105#define DMA_STATUS_FM_WRITE_ECC 0x01000000
106#define DMA_STATUS_FM_SPDAT_ECC 0x00080000
107
108#define DMA_MODE_CACHE_OR_SHIFT         30
109#define DMA_MODE_AXI_DBG_SHIFT                  24
110#define DMA_MODE_CEN_SHIFT                      13
111#define DMA_MODE_CEN_MASK                       0x00000007
112#define DMA_MODE_DBG_SHIFT                      7
113#define DMA_MODE_AID_MODE_SHIFT         4
114
115#define DMA_THRESH_COMMQ_SHIFT                  24
116#define DMA_THRESH_READ_INT_BUF_SHIFT           16
117#define DMA_THRESH_READ_INT_BUF_MASK            0x0000003f
118#define DMA_THRESH_WRITE_INT_BUF_MASK           0x0000003f
119
120#define DMA_TRANSFER_PORTID_SHIFT               24
121#define DMA_TRANSFER_TNUM_SHIFT         16
122
123#define DMA_CAM_SIZEOF_ENTRY                    0x40
124#define DMA_CAM_UNITS                           8
125
126#define DMA_LIODN_SHIFT         16
127#define DMA_LIODN_BASE_MASK     0x00000FFF
128
129/* FPM defines */
130#define FPM_EV_MASK_DOUBLE_ECC          0x80000000
131#define FPM_EV_MASK_STALL               0x40000000
132#define FPM_EV_MASK_SINGLE_ECC          0x20000000
133#define FPM_EV_MASK_RELEASE_FM          0x00010000
134#define FPM_EV_MASK_DOUBLE_ECC_EN       0x00008000
135#define FPM_EV_MASK_STALL_EN            0x00004000
136#define FPM_EV_MASK_SINGLE_ECC_EN       0x00002000
137#define FPM_EV_MASK_EXTERNAL_HALT       0x00000008
138#define FPM_EV_MASK_ECC_ERR_HALT        0x00000004
139
140#define FPM_RAM_MURAM_ECC               0x00008000
141#define FPM_RAM_IRAM_ECC                0x00004000
142#define FPM_IRAM_ECC_ERR_EX_EN          0x00020000
143#define FPM_MURAM_ECC_ERR_EX_EN 0x00040000
144#define FPM_RAM_IRAM_ECC_EN             0x40000000
145#define FPM_RAM_RAMS_ECC_EN             0x80000000
146#define FPM_RAM_RAMS_ECC_EN_SRC_SEL     0x08000000
147
148#define FPM_REV1_MAJOR_MASK             0x0000FF00
149#define FPM_REV1_MINOR_MASK             0x000000FF
150
151#define FPM_DISP_LIMIT_SHIFT            24
152
153#define FPM_PRT_FM_CTL1                 0x00000001
154#define FPM_PRT_FM_CTL2                 0x00000002
155#define FPM_PORT_FM_CTL_PORTID_SHIFT    24
156#define FPM_PRC_ORA_FM_CTL_SEL_SHIFT    16
157
158#define FPM_THR1_PRS_SHIFT              24
159#define FPM_THR1_KG_SHIFT               16
160#define FPM_THR1_PLCR_SHIFT             8
161#define FPM_THR1_BMI_SHIFT              0
162
163#define FPM_THR2_QMI_ENQ_SHIFT          24
164#define FPM_THR2_QMI_DEQ_SHIFT          0
165#define FPM_THR2_FM_CTL1_SHIFT          16
166#define FPM_THR2_FM_CTL2_SHIFT          8
167
168#define FPM_EV_MASK_CAT_ERR_SHIFT       1
169#define FPM_EV_MASK_DMA_ERR_SHIFT       0
170
171#define FPM_REV1_MAJOR_SHIFT            8
172
173#define FPM_RSTC_FM_RESET               0x80000000
174#define FPM_RSTC_MAC0_RESET             0x40000000
175#define FPM_RSTC_MAC1_RESET             0x20000000
176#define FPM_RSTC_MAC2_RESET             0x10000000
177#define FPM_RSTC_MAC3_RESET             0x08000000
178#define FPM_RSTC_MAC8_RESET             0x04000000
179#define FPM_RSTC_MAC4_RESET             0x02000000
180#define FPM_RSTC_MAC5_RESET             0x01000000
181#define FPM_RSTC_MAC6_RESET             0x00800000
182#define FPM_RSTC_MAC7_RESET             0x00400000
183#define FPM_RSTC_MAC9_RESET             0x00200000
184
185#define FPM_TS_INT_SHIFT                16
186#define FPM_TS_CTL_EN                   0x80000000
187
188/* BMI defines */
189#define BMI_INIT_START                          0x80000000
190#define BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC     0x80000000
191#define BMI_ERR_INTR_EN_LIST_RAM_ECC            0x40000000
192#define BMI_ERR_INTR_EN_STATISTICS_RAM_ECC      0x20000000
193#define BMI_ERR_INTR_EN_DISPATCH_RAM_ECC        0x10000000
194#define BMI_NUM_OF_TASKS_MASK                   0x3F000000
195#define BMI_NUM_OF_EXTRA_TASKS_MASK             0x000F0000
196#define BMI_NUM_OF_DMAS_MASK                    0x00000F00
197#define BMI_NUM_OF_EXTRA_DMAS_MASK              0x0000000F
198#define BMI_FIFO_SIZE_MASK                      0x000003FF
199#define BMI_EXTRA_FIFO_SIZE_MASK                0x03FF0000
200#define BMI_CFG2_DMAS_MASK                      0x0000003F
201#define BMI_CFG2_TASKS_MASK                     0x0000003F
202
203#define BMI_CFG2_TASKS_SHIFT            16
204#define BMI_CFG2_DMAS_SHIFT             0
205#define BMI_CFG1_FIFO_SIZE_SHIFT        16
206#define BMI_NUM_OF_TASKS_SHIFT          24
207#define BMI_EXTRA_NUM_OF_TASKS_SHIFT    16
208#define BMI_NUM_OF_DMAS_SHIFT           8
209#define BMI_EXTRA_NUM_OF_DMAS_SHIFT     0
210
211#define BMI_FIFO_ALIGN                  0x100
212
213#define BMI_EXTRA_FIFO_SIZE_SHIFT       16
214
215/* QMI defines */
216#define QMI_CFG_ENQ_EN                  0x80000000
217#define QMI_CFG_DEQ_EN                  0x40000000
218#define QMI_CFG_EN_COUNTERS             0x10000000
219#define QMI_CFG_DEQ_MASK                0x0000003F
220#define QMI_CFG_ENQ_MASK                0x00003F00
221#define QMI_CFG_ENQ_SHIFT               8
222
223#define QMI_ERR_INTR_EN_DOUBLE_ECC      0x80000000
224#define QMI_ERR_INTR_EN_DEQ_FROM_DEF    0x40000000
225#define QMI_INTR_EN_SINGLE_ECC          0x80000000
226
227#define QMI_GS_HALT_NOT_BUSY            0x00000002
228
229/* IRAM defines */
230#define IRAM_IADD_AIE                   0x80000000
231#define IRAM_READY                      0x80000000
232
233/* Default values */
234#define DEFAULT_CATASTROPHIC_ERR                0
235#define DEFAULT_DMA_ERR                         0
236#define DEFAULT_AID_MODE                        FMAN_DMA_AID_OUT_TNUM
237#define DEFAULT_DMA_COMM_Q_LOW                  0x2A
238#define DEFAULT_DMA_COMM_Q_HIGH         0x3F
239#define DEFAULT_CACHE_OVERRIDE                  0
240#define DEFAULT_DMA_CAM_NUM_OF_ENTRIES          64
241#define DEFAULT_DMA_DBG_CNT_MODE                0
242#define DEFAULT_DMA_SOS_EMERGENCY               0
243#define DEFAULT_DMA_WATCHDOG                    0
244#define DEFAULT_DISP_LIMIT                      0
245#define DEFAULT_PRS_DISP_TH                     16
246#define DEFAULT_PLCR_DISP_TH                    16
247#define DEFAULT_KG_DISP_TH                      16
248#define DEFAULT_BMI_DISP_TH                     16
249#define DEFAULT_QMI_ENQ_DISP_TH         16
250#define DEFAULT_QMI_DEQ_DISP_TH         16
251#define DEFAULT_FM_CTL1_DISP_TH         16
252#define DEFAULT_FM_CTL2_DISP_TH         16
253
254#define DFLT_AXI_DBG_NUM_OF_BEATS               1
255
256#define DFLT_DMA_READ_INT_BUF_LOW(dma_thresh_max_buf)   \
257        ((dma_thresh_max_buf + 1) / 2)
258#define DFLT_DMA_READ_INT_BUF_HIGH(dma_thresh_max_buf)  \
259        ((dma_thresh_max_buf + 1) * 3 / 4)
260#define DFLT_DMA_WRITE_INT_BUF_LOW(dma_thresh_max_buf)  \
261        ((dma_thresh_max_buf + 1) / 2)
262#define DFLT_DMA_WRITE_INT_BUF_HIGH(dma_thresh_max_buf)\
263        ((dma_thresh_max_buf + 1) * 3 / 4)
264
265#define DMA_COMM_Q_LOW_FMAN_V3          0x2A
266#define DMA_COMM_Q_LOW_FMAN_V2(dma_thresh_max_commq)            \
267        ((dma_thresh_max_commq + 1) / 2)
268#define DFLT_DMA_COMM_Q_LOW(major, dma_thresh_max_commq)        \
269        ((major == 6) ? DMA_COMM_Q_LOW_FMAN_V3 :                \
270        DMA_COMM_Q_LOW_FMAN_V2(dma_thresh_max_commq))
271
272#define DMA_COMM_Q_HIGH_FMAN_V3 0x3f
273#define DMA_COMM_Q_HIGH_FMAN_V2(dma_thresh_max_commq)           \
274        ((dma_thresh_max_commq + 1) * 3 / 4)
275#define DFLT_DMA_COMM_Q_HIGH(major, dma_thresh_max_commq)       \
276        ((major == 6) ? DMA_COMM_Q_HIGH_FMAN_V3 :               \
277        DMA_COMM_Q_HIGH_FMAN_V2(dma_thresh_max_commq))
278
279#define TOTAL_NUM_OF_TASKS_FMAN_V3L     59
280#define TOTAL_NUM_OF_TASKS_FMAN_V3H     124
281#define DFLT_TOTAL_NUM_OF_TASKS(major, minor, bmi_max_num_of_tasks)     \
282        ((major == 6) ? ((minor == 1 || minor == 4) ?                   \
283        TOTAL_NUM_OF_TASKS_FMAN_V3L : TOTAL_NUM_OF_TASKS_FMAN_V3H) :    \
284        bmi_max_num_of_tasks)
285
286#define DMA_CAM_NUM_OF_ENTRIES_FMAN_V3          64
287#define DMA_CAM_NUM_OF_ENTRIES_FMAN_V2          32
288#define DFLT_DMA_CAM_NUM_OF_ENTRIES(major)                      \
289        (major == 6 ? DMA_CAM_NUM_OF_ENTRIES_FMAN_V3 :          \
290        DMA_CAM_NUM_OF_ENTRIES_FMAN_V2)
291
292#define FM_TIMESTAMP_1_USEC_BIT             8
293
294/* Defines used for enabling/disabling FMan interrupts */
295#define ERR_INTR_EN_DMA         0x00010000
296#define ERR_INTR_EN_FPM         0x80000000
297#define ERR_INTR_EN_BMI         0x00800000
298#define ERR_INTR_EN_QMI         0x00400000
299#define ERR_INTR_EN_MURAM       0x00040000
300#define ERR_INTR_EN_MAC0        0x00004000
301#define ERR_INTR_EN_MAC1        0x00002000
302#define ERR_INTR_EN_MAC2        0x00001000
303#define ERR_INTR_EN_MAC3        0x00000800
304#define ERR_INTR_EN_MAC4        0x00000400
305#define ERR_INTR_EN_MAC5        0x00000200
306#define ERR_INTR_EN_MAC6        0x00000100
307#define ERR_INTR_EN_MAC7        0x00000080
308#define ERR_INTR_EN_MAC8        0x00008000
309#define ERR_INTR_EN_MAC9        0x00000040
310
311#define INTR_EN_QMI             0x40000000
312#define INTR_EN_MAC0            0x00080000
313#define INTR_EN_MAC1            0x00040000
314#define INTR_EN_MAC2            0x00020000
315#define INTR_EN_MAC3            0x00010000
316#define INTR_EN_MAC4            0x00000040
317#define INTR_EN_MAC5            0x00000020
318#define INTR_EN_MAC6            0x00000008
319#define INTR_EN_MAC7            0x00000002
320#define INTR_EN_MAC8            0x00200000
321#define INTR_EN_MAC9            0x00100000
322#define INTR_EN_REV0            0x00008000
323#define INTR_EN_REV1            0x00004000
324#define INTR_EN_REV2            0x00002000
325#define INTR_EN_REV3            0x00001000
326#define INTR_EN_TMR             0x01000000
327
328enum fman_dma_aid_mode {
329        FMAN_DMA_AID_OUT_PORT_ID = 0,             /* 4 LSB of PORT_ID */
330        FMAN_DMA_AID_OUT_TNUM                     /* 4 LSB of TNUM */
331};
332
333struct fman_iram_regs {
334        u32 iadd;       /* FM IRAM instruction address register */
335        u32 idata;      /* FM IRAM instruction data register */
336        u32 itcfg;      /* FM IRAM timing config register */
337        u32 iready;     /* FM IRAM ready register */
338};
339
340struct fman_fpm_regs {
341        u32 fmfp_tnc;           /* FPM TNUM Control 0x00 */
342        u32 fmfp_prc;           /* FPM Port_ID FmCtl Association 0x04 */
343        u32 fmfp_brkc;          /* FPM Breakpoint Control 0x08 */
344        u32 fmfp_mxd;           /* FPM Flush Control 0x0c */
345        u32 fmfp_dist1;         /* FPM Dispatch Thresholds1 0x10 */
346        u32 fmfp_dist2;         /* FPM Dispatch Thresholds2 0x14 */
347        u32 fm_epi;             /* FM Error Pending Interrupts 0x18 */
348        u32 fm_rie;             /* FM Error Interrupt Enable 0x1c */
349        u32 fmfp_fcev[4];       /* FPM FMan-Controller Event 1-4 0x20-0x2f */
350        u32 res0030[4];         /* res 0x30 - 0x3f */
351        u32 fmfp_cee[4];        /* PM FMan-Controller Event 1-4 0x40-0x4f */
352        u32 res0050[4];         /* res 0x50-0x5f */
353        u32 fmfp_tsc1;          /* FPM TimeStamp Control1 0x60 */
354        u32 fmfp_tsc2;          /* FPM TimeStamp Control2 0x64 */
355        u32 fmfp_tsp;           /* FPM Time Stamp 0x68 */
356        u32 fmfp_tsf;           /* FPM Time Stamp Fraction 0x6c */
357        u32 fm_rcr;             /* FM Rams Control 0x70 */
358        u32 fmfp_extc;          /* FPM External Requests Control 0x74 */
359        u32 fmfp_ext1;          /* FPM External Requests Config1 0x78 */
360        u32 fmfp_ext2;          /* FPM External Requests Config2 0x7c */
361        u32 fmfp_drd[16];       /* FPM Data_Ram Data 0-15 0x80 - 0xbf */
362        u32 fmfp_dra;           /* FPM Data Ram Access 0xc0 */
363        u32 fm_ip_rev_1;        /* FM IP Block Revision 1 0xc4 */
364        u32 fm_ip_rev_2;        /* FM IP Block Revision 2 0xc8 */
365        u32 fm_rstc;            /* FM Reset Command 0xcc */
366        u32 fm_cld;             /* FM Classifier Debug 0xd0 */
367        u32 fm_npi;             /* FM Normal Pending Interrupts 0xd4 */
368        u32 fmfp_exte;          /* FPM External Requests Enable 0xd8 */
369        u32 fmfp_ee;            /* FPM Event&Mask 0xdc */
370        u32 fmfp_cev[4];        /* FPM CPU Event 1-4 0xe0-0xef */
371        u32 res00f0[4];         /* res 0xf0-0xff */
372        u32 fmfp_ps[50];        /* FPM Port Status 0x100-0x1c7 */
373        u32 res01c8[14];        /* res 0x1c8-0x1ff */
374        u32 fmfp_clfabc;        /* FPM CLFABC 0x200 */
375        u32 fmfp_clfcc;         /* FPM CLFCC 0x204 */
376        u32 fmfp_clfaval;       /* FPM CLFAVAL 0x208 */
377        u32 fmfp_clfbval;       /* FPM CLFBVAL 0x20c */
378        u32 fmfp_clfcval;       /* FPM CLFCVAL 0x210 */
379        u32 fmfp_clfamsk;       /* FPM CLFAMSK 0x214 */
380        u32 fmfp_clfbmsk;       /* FPM CLFBMSK 0x218 */
381        u32 fmfp_clfcmsk;       /* FPM CLFCMSK 0x21c */
382        u32 fmfp_clfamc;        /* FPM CLFAMC 0x220 */
383        u32 fmfp_clfbmc;        /* FPM CLFBMC 0x224 */
384        u32 fmfp_clfcmc;        /* FPM CLFCMC 0x228 */
385        u32 fmfp_decceh;        /* FPM DECCEH 0x22c */
386        u32 res0230[116];       /* res 0x230 - 0x3ff */
387        u32 fmfp_ts[128];       /* 0x400: FPM Task Status 0x400 - 0x5ff */
388        u32 res0600[0x400 - 384];
389};
390
391struct fman_bmi_regs {
392        u32 fmbm_init;          /* BMI Initialization 0x00 */
393        u32 fmbm_cfg1;          /* BMI Configuration 1 0x04 */
394        u32 fmbm_cfg2;          /* BMI Configuration 2 0x08 */
395        u32 res000c[5];         /* 0x0c - 0x1f */
396        u32 fmbm_ievr;          /* Interrupt Event Register 0x20 */
397        u32 fmbm_ier;           /* Interrupt Enable Register 0x24 */
398        u32 fmbm_ifr;           /* Interrupt Force Register 0x28 */
399        u32 res002c[5];         /* 0x2c - 0x3f */
400        u32 fmbm_arb[8];        /* BMI Arbitration 0x40 - 0x5f */
401        u32 res0060[12];        /* 0x60 - 0x8f */
402        u32 fmbm_dtc[3];        /* Debug Trap Counter 0x90 - 0x9b */
403        u32 res009c;            /* 0x9c */
404        u32 fmbm_dcv[3][4];     /* Debug Compare val 0xa0-0xcf */
405        u32 fmbm_dcm[3][4];     /* Debug Compare Mask 0xd0-0xff */
406        u32 fmbm_gde;           /* BMI Global Debug Enable 0x100 */
407        u32 fmbm_pp[63];        /* BMI Port Parameters 0x104 - 0x1ff */
408        u32 res0200;            /* 0x200 */
409        u32 fmbm_pfs[63];       /* BMI Port FIFO Size 0x204 - 0x2ff */
410        u32 res0300;            /* 0x300 */
411        u32 fmbm_spliodn[63];   /* Port Partition ID 0x304 - 0x3ff */
412};
413
414struct fman_qmi_regs {
415        u32 fmqm_gc;            /* General Configuration Register 0x00 */
416        u32 res0004;            /* 0x04 */
417        u32 fmqm_eie;           /* Error Interrupt Event Register 0x08 */
418        u32 fmqm_eien;          /* Error Interrupt Enable Register 0x0c */
419        u32 fmqm_eif;           /* Error Interrupt Force Register 0x10 */
420        u32 fmqm_ie;            /* Interrupt Event Register 0x14 */
421        u32 fmqm_ien;           /* Interrupt Enable Register 0x18 */
422        u32 fmqm_if;            /* Interrupt Force Register 0x1c */
423        u32 fmqm_gs;            /* Global Status Register 0x20 */
424        u32 fmqm_ts;            /* Task Status Register 0x24 */
425        u32 fmqm_etfc;          /* Enqueue Total Frame Counter 0x28 */
426        u32 fmqm_dtfc;          /* Dequeue Total Frame Counter 0x2c */
427        u32 fmqm_dc0;           /* Dequeue Counter 0 0x30 */
428        u32 fmqm_dc1;           /* Dequeue Counter 1 0x34 */
429        u32 fmqm_dc2;           /* Dequeue Counter 2 0x38 */
430        u32 fmqm_dc3;           /* Dequeue Counter 3 0x3c */
431        u32 fmqm_dfdc;          /* Dequeue FQID from Default Counter 0x40 */
432        u32 fmqm_dfcc;          /* Dequeue FQID from Context Counter 0x44 */
433        u32 fmqm_dffc;          /* Dequeue FQID from FD Counter 0x48 */
434        u32 fmqm_dcc;           /* Dequeue Confirm Counter 0x4c */
435        u32 res0050[7];         /* 0x50 - 0x6b */
436        u32 fmqm_tapc;          /* Tnum Aging Period Control 0x6c */
437        u32 fmqm_dmcvc;         /* Dequeue MAC Command Valid Counter 0x70 */
438        u32 fmqm_difdcc;        /* Dequeue Invalid FD Command Counter 0x74 */
439        u32 fmqm_da1v;          /* Dequeue A1 Valid Counter 0x78 */
440        u32 res007c;            /* 0x7c */
441        u32 fmqm_dtc;           /* 0x80 Debug Trap Counter 0x80 */
442        u32 fmqm_efddd;         /* 0x84 Enqueue Frame desc Dynamic dbg 0x84 */
443        u32 res0088[2];         /* 0x88 - 0x8f */
444        struct {
445                u32 fmqm_dtcfg1;        /* 0x90 dbg trap cfg 1 Register 0x00 */
446                u32 fmqm_dtval1;        /* Debug Trap Value 1 Register 0x04 */
447                u32 fmqm_dtm1;          /* Debug Trap Mask 1 Register 0x08 */
448                u32 fmqm_dtc1;          /* Debug Trap Counter 1 Register 0x0c */
449                u32 fmqm_dtcfg2;        /* dbg Trap cfg 2 Register 0x10 */
450                u32 fmqm_dtval2;        /* Debug Trap Value 2 Register 0x14 */
451                u32 fmqm_dtm2;          /* Debug Trap Mask 2 Register 0x18 */
452                u32 res001c;            /* 0x1c */
453        } dbg_traps[3];                 /* 0x90 - 0xef */
454        u8 res00f0[0x400 - 0xf0];       /* 0xf0 - 0x3ff */
455};
456
457struct fman_dma_regs {
458        u32 fmdmsr;     /* FM DMA status register 0x00 */
459        u32 fmdmmr;     /* FM DMA mode register 0x04 */
460        u32 fmdmtr;     /* FM DMA bus threshold register 0x08 */
461        u32 fmdmhy;     /* FM DMA bus hysteresis register 0x0c */
462        u32 fmdmsetr;   /* FM DMA SOS emergency Threshold Register 0x10 */
463        u32 fmdmtah;    /* FM DMA transfer bus address high reg 0x14 */
464        u32 fmdmtal;    /* FM DMA transfer bus address low reg 0x18 */
465        u32 fmdmtcid;   /* FM DMA transfer bus communication ID reg 0x1c */
466        u32 fmdmra;     /* FM DMA bus internal ram address register 0x20 */
467        u32 fmdmrd;     /* FM DMA bus internal ram data register 0x24 */
468        u32 fmdmwcr;    /* FM DMA CAM watchdog counter value 0x28 */
469        u32 fmdmebcr;   /* FM DMA CAM base in MURAM register 0x2c */
470        u32 fmdmccqdr;  /* FM DMA CAM and CMD Queue Debug reg 0x30 */
471        u32 fmdmccqvr1; /* FM DMA CAM and CMD Queue Value reg #1 0x34 */
472        u32 fmdmccqvr2; /* FM DMA CAM and CMD Queue Value reg #2 0x38 */
473        u32 fmdmcqvr3;  /* FM DMA CMD Queue Value register #3 0x3c */
474        u32 fmdmcqvr4;  /* FM DMA CMD Queue Value register #4 0x40 */
475        u32 fmdmcqvr5;  /* FM DMA CMD Queue Value register #5 0x44 */
476        u32 fmdmsefrc;  /* FM DMA Semaphore Entry Full Reject Cntr 0x48 */
477        u32 fmdmsqfrc;  /* FM DMA Semaphore Queue Full Reject Cntr 0x4c */
478        u32 fmdmssrc;   /* FM DMA Semaphore SYNC Reject Counter 0x50 */
479        u32 fmdmdcr;    /* FM DMA Debug Counter 0x54 */
480        u32 fmdmemsr;   /* FM DMA Emergency Smoother Register 0x58 */
481        u32 res005c;    /* 0x5c */
482        u32 fmdmplr[FMAN_LIODN_TBL / 2];        /* DMA LIODN regs 0x60-0xdf */
483        u32 res00e0[0x400 - 56];
484};
485
486/* Structure that holds current FMan state.
487 * Used for saving run time information.
488 */
489struct fman_state_struct {
490        u8 fm_id;
491        u16 fm_clk_freq;
492        struct fman_rev_info rev_info;
493        bool enabled_time_stamp;
494        u8 count1_micro_bit;
495        u8 total_num_of_tasks;
496        u8 accumulated_num_of_tasks;
497        u32 accumulated_fifo_size;
498        u8 accumulated_num_of_open_dmas;
499        u8 accumulated_num_of_deq_tnums;
500        u32 exceptions;
501        u32 extra_fifo_pool_size;
502        u8 extra_tasks_pool_size;
503        u8 extra_open_dmas_pool_size;
504        u16 port_mfl[MAX_NUM_OF_MACS];
505        u16 mac_mfl[MAX_NUM_OF_MACS];
506
507        /* SOC specific */
508        u32 fm_iram_size;
509        /* DMA */
510        u32 dma_thresh_max_commq;
511        u32 dma_thresh_max_buf;
512        u32 max_num_of_open_dmas;
513        /* QMI */
514        u32 qmi_max_num_of_tnums;
515        u32 qmi_def_tnums_thresh;
516        /* BMI */
517        u32 bmi_max_num_of_tasks;
518        u32 bmi_max_fifo_size;
519        /* General */
520        u32 fm_port_num_of_cg;
521        u32 num_of_rx_ports;
522        u32 total_fifo_size;
523
524        u32 qman_channel_base;
525        u32 num_of_qman_channels;
526
527        struct resource *res;
528};
529
530/* Structure that holds FMan initial configuration */
531struct fman_cfg {
532        u8 disp_limit_tsh;
533        u8 prs_disp_tsh;
534        u8 plcr_disp_tsh;
535        u8 kg_disp_tsh;
536        u8 bmi_disp_tsh;
537        u8 qmi_enq_disp_tsh;
538        u8 qmi_deq_disp_tsh;
539        u8 fm_ctl1_disp_tsh;
540        u8 fm_ctl2_disp_tsh;
541        int dma_cache_override;
542        enum fman_dma_aid_mode dma_aid_mode;
543        u32 dma_axi_dbg_num_of_beats;
544        u32 dma_cam_num_of_entries;
545        u32 dma_watchdog;
546        u8 dma_comm_qtsh_asrt_emer;
547        u32 dma_write_buf_tsh_asrt_emer;
548        u32 dma_read_buf_tsh_asrt_emer;
549        u8 dma_comm_qtsh_clr_emer;
550        u32 dma_write_buf_tsh_clr_emer;
551        u32 dma_read_buf_tsh_clr_emer;
552        u32 dma_sos_emergency;
553        int dma_dbg_cnt_mode;
554        int catastrophic_err;
555        int dma_err;
556        u32 exceptions;
557        u16 clk_freq;
558        u32 cam_base_addr;
559        u32 fifo_base_addr;
560        u32 total_fifo_size;
561        u32 total_num_of_tasks;
562        u32 qmi_def_tnums_thresh;
563};
564
565/* Structure that holds information received from device tree */
566struct fman_dts_params {
567        void __iomem *base_addr;                /* FMan virtual address */
568#ifndef __rtems__
569        struct resource *res;                   /* FMan memory resource */
570#endif /* __rtems__ */
571        u8 id;                                  /* FMan ID */
572
573        int err_irq;                            /* FMan Error IRQ */
574
575        u16 clk_freq;                           /* FMan clock freq (In Mhz) */
576
577        u32 qman_channel_base;                  /* QMan channels base */
578        u32 num_of_qman_channels;               /* Number of QMan channels */
579
580        struct resource muram_res;              /* MURAM resource */
581};
582
583/** fman_exceptions_cb
584 * fman         - Pointer to FMan
585 * exception    - The exception.
586 *
587 * Exceptions user callback routine, will be called upon an exception
588 * passing the exception identification.
589 *
590 * Return: irq status
591 */
592typedef irqreturn_t (fman_exceptions_cb)(struct fman *fman,
593                                         enum fman_exceptions exception);
594
595/** fman_bus_error_cb
596 * fman         - Pointer to FMan
597 * port_id      - Port id
598 * addr         - Address that caused the error
599 * tnum         - Owner of error
600 * liodn        - Logical IO device number
601 *
602 * Bus error user callback routine, will be called upon bus error,
603 * passing parameters describing the errors and the owner.
604 *
605 * Return: IRQ status
606 */
607typedef irqreturn_t (fman_bus_error_cb)(struct fman *fman, u8 port_id,
608                                        u64 addr, u8 tnum, u16 liodn);
609
610struct fman {
611        struct device *dev;
612        void __iomem *base_addr;
613        struct fman_intr_src intr_mng[FMAN_EV_CNT];
614
615        struct fman_fpm_regs __iomem *fpm_regs;
616        struct fman_bmi_regs __iomem *bmi_regs;
617        struct fman_qmi_regs __iomem *qmi_regs;
618        struct fman_dma_regs __iomem *dma_regs;
619        fman_exceptions_cb *exception_cb;
620        fman_bus_error_cb *bus_error_cb;
621        /* Spinlock for FMan use */
622        spinlock_t spinlock;
623        struct fman_state_struct *state;
624
625        struct fman_cfg *cfg;
626        struct muram_info *muram;
627        /* cam section in muram */
628        unsigned long cam_offset;
629        size_t cam_size;
630        /* Fifo in MURAM */
631        unsigned long fifo_offset;
632        size_t fifo_size;
633
634        u32 liodn_base[64];
635        u32 liodn_offset[64];
636
637        struct fman_dts_params dts_params;
638};
639
640static irqreturn_t fman_exceptions(struct fman *fman,
641                                   enum fman_exceptions exception)
642{
643        dev_dbg(fman->dev, "%s: FMan[%d] exception %d\n",
644                __func__, fman->state->fm_id, exception);
645
646        return IRQ_HANDLED;
647}
648
649static irqreturn_t fman_bus_error(struct fman *fman, u8 __maybe_unused port_id,
650                                  u64 __maybe_unused addr,
651                                  u8 __maybe_unused tnum,
652                                  u16 __maybe_unused liodn)
653{
654        dev_dbg(fman->dev, "%s: FMan[%d] bus error: port_id[%d]\n",
655                __func__, fman->state->fm_id, port_id);
656
657        return IRQ_HANDLED;
658}
659
660static inline irqreturn_t call_mac_isr(struct fman *fman, u8 id)
661{
662        if (fman->intr_mng[id].isr_cb) {
663                fman->intr_mng[id].isr_cb(fman->intr_mng[id].src_handle);
664
665                return IRQ_HANDLED;
666        }
667
668        return IRQ_NONE;
669}
670
671static inline u8 hw_port_id_to_sw_port_id(u8 major, u8 hw_port_id)
672{
673        u8 sw_port_id = 0;
674
675        if (hw_port_id >= BASE_TX_PORTID)
676                sw_port_id = hw_port_id - BASE_TX_PORTID;
677        else if (hw_port_id >= BASE_RX_PORTID)
678                sw_port_id = hw_port_id - BASE_RX_PORTID;
679        else
680                sw_port_id = 0;
681
682        return sw_port_id;
683}
684
685static void set_port_order_restoration(struct fman_fpm_regs __iomem *fpm_rg,
686                                       u8 port_id)
687{
688        u32 tmp = 0;
689
690        tmp = port_id << FPM_PORT_FM_CTL_PORTID_SHIFT;
691
692        tmp |= FPM_PRT_FM_CTL2 | FPM_PRT_FM_CTL1;
693
694        /* order restoration */
695        if (port_id % 2)
696                tmp |= FPM_PRT_FM_CTL1 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT;
697        else
698                tmp |= FPM_PRT_FM_CTL2 << FPM_PRC_ORA_FM_CTL_SEL_SHIFT;
699
700        iowrite32be(tmp, &fpm_rg->fmfp_prc);
701}
702
703static void set_port_liodn(struct fman *fman, u8 port_id,
704                           u32 liodn_base, u32 liodn_ofst)
705{
706        u32 tmp;
707
708        /* set LIODN base for this port */
709        tmp = ioread32be(&fman->dma_regs->fmdmplr[port_id / 2]);
710        if (port_id % 2) {
711                tmp &= ~DMA_LIODN_BASE_MASK;
712                tmp |= liodn_base;
713        } else {
714                tmp &= ~(DMA_LIODN_BASE_MASK << DMA_LIODN_SHIFT);
715                tmp |= liodn_base << DMA_LIODN_SHIFT;
716        }
717        iowrite32be(tmp, &fman->dma_regs->fmdmplr[port_id / 2]);
718        iowrite32be(liodn_ofst, &fman->bmi_regs->fmbm_spliodn[port_id - 1]);
719}
720
721static void enable_rams_ecc(struct fman_fpm_regs __iomem *fpm_rg)
722{
723        u32 tmp;
724
725        tmp = ioread32be(&fpm_rg->fm_rcr);
726        if (tmp & FPM_RAM_RAMS_ECC_EN_SRC_SEL)
727                iowrite32be(tmp | FPM_RAM_IRAM_ECC_EN, &fpm_rg->fm_rcr);
728        else
729                iowrite32be(tmp | FPM_RAM_RAMS_ECC_EN |
730                            FPM_RAM_IRAM_ECC_EN, &fpm_rg->fm_rcr);
731}
732
733static void disable_rams_ecc(struct fman_fpm_regs __iomem *fpm_rg)
734{
735        u32 tmp;
736
737        tmp = ioread32be(&fpm_rg->fm_rcr);
738        if (tmp & FPM_RAM_RAMS_ECC_EN_SRC_SEL)
739                iowrite32be(tmp & ~FPM_RAM_IRAM_ECC_EN, &fpm_rg->fm_rcr);
740        else
741                iowrite32be(tmp & ~(FPM_RAM_RAMS_ECC_EN | FPM_RAM_IRAM_ECC_EN),
742                            &fpm_rg->fm_rcr);
743}
744
745static void fman_defconfig(struct fman_cfg *cfg)
746{
747        memset(cfg, 0, sizeof(struct fman_cfg));
748
749        cfg->catastrophic_err = DEFAULT_CATASTROPHIC_ERR;
750        cfg->dma_err = DEFAULT_DMA_ERR;
751        cfg->dma_aid_mode = DEFAULT_AID_MODE;
752        cfg->dma_comm_qtsh_clr_emer = DEFAULT_DMA_COMM_Q_LOW;
753        cfg->dma_comm_qtsh_asrt_emer = DEFAULT_DMA_COMM_Q_HIGH;
754        cfg->dma_cache_override = DEFAULT_CACHE_OVERRIDE;
755        cfg->dma_cam_num_of_entries = DEFAULT_DMA_CAM_NUM_OF_ENTRIES;
756        cfg->dma_dbg_cnt_mode = DEFAULT_DMA_DBG_CNT_MODE;
757        cfg->dma_sos_emergency = DEFAULT_DMA_SOS_EMERGENCY;
758        cfg->dma_watchdog = DEFAULT_DMA_WATCHDOG;
759        cfg->disp_limit_tsh = DEFAULT_DISP_LIMIT;
760        cfg->prs_disp_tsh = DEFAULT_PRS_DISP_TH;
761        cfg->plcr_disp_tsh = DEFAULT_PLCR_DISP_TH;
762        cfg->kg_disp_tsh = DEFAULT_KG_DISP_TH;
763        cfg->bmi_disp_tsh = DEFAULT_BMI_DISP_TH;
764        cfg->qmi_enq_disp_tsh = DEFAULT_QMI_ENQ_DISP_TH;
765        cfg->qmi_deq_disp_tsh = DEFAULT_QMI_DEQ_DISP_TH;
766        cfg->fm_ctl1_disp_tsh = DEFAULT_FM_CTL1_DISP_TH;
767        cfg->fm_ctl2_disp_tsh = DEFAULT_FM_CTL2_DISP_TH;
768}
769
770static int dma_init(struct fman *fman)
771{
772        struct fman_dma_regs __iomem *dma_rg = fman->dma_regs;
773        struct fman_cfg *cfg = fman->cfg;
774        u32 tmp_reg;
775
776        /* Init DMA Registers */
777
778        /* clear status reg events */
779        tmp_reg = (DMA_STATUS_BUS_ERR | DMA_STATUS_READ_ECC |
780                   DMA_STATUS_SYSTEM_WRITE_ECC | DMA_STATUS_FM_WRITE_ECC);
781        iowrite32be(ioread32be(&dma_rg->fmdmsr) | tmp_reg, &dma_rg->fmdmsr);
782
783        /* configure mode register */
784        tmp_reg = 0;
785        tmp_reg |= cfg->dma_cache_override << DMA_MODE_CACHE_OR_SHIFT;
786        if (cfg->exceptions & EX_DMA_BUS_ERROR)
787                tmp_reg |= DMA_MODE_BER;
788        if ((cfg->exceptions & EX_DMA_SYSTEM_WRITE_ECC) |
789            (cfg->exceptions & EX_DMA_READ_ECC) |
790            (cfg->exceptions & EX_DMA_FM_WRITE_ECC))
791                tmp_reg |= DMA_MODE_ECC;
792        if (cfg->dma_axi_dbg_num_of_beats)
793                tmp_reg |= (DMA_MODE_AXI_DBG_MASK &
794                        ((cfg->dma_axi_dbg_num_of_beats - 1)
795                        << DMA_MODE_AXI_DBG_SHIFT));
796
797        tmp_reg |= (((cfg->dma_cam_num_of_entries / DMA_CAM_UNITS) - 1) &
798                DMA_MODE_CEN_MASK) << DMA_MODE_CEN_SHIFT;
799        tmp_reg |= DMA_MODE_SECURE_PROT;
800        tmp_reg |= cfg->dma_dbg_cnt_mode << DMA_MODE_DBG_SHIFT;
801        tmp_reg |= cfg->dma_aid_mode << DMA_MODE_AID_MODE_SHIFT;
802
803        iowrite32be(tmp_reg, &dma_rg->fmdmmr);
804
805        /* configure thresholds register */
806        tmp_reg = ((u32)cfg->dma_comm_qtsh_asrt_emer <<
807                DMA_THRESH_COMMQ_SHIFT);
808        tmp_reg |= (cfg->dma_read_buf_tsh_asrt_emer &
809                DMA_THRESH_READ_INT_BUF_MASK) << DMA_THRESH_READ_INT_BUF_SHIFT;
810        tmp_reg |= cfg->dma_write_buf_tsh_asrt_emer &
811                DMA_THRESH_WRITE_INT_BUF_MASK;
812
813        iowrite32be(tmp_reg, &dma_rg->fmdmtr);
814
815        /* configure hysteresis register */
816        tmp_reg = ((u32)cfg->dma_comm_qtsh_clr_emer <<
817                DMA_THRESH_COMMQ_SHIFT);
818        tmp_reg |= (cfg->dma_read_buf_tsh_clr_emer &
819                DMA_THRESH_READ_INT_BUF_MASK) << DMA_THRESH_READ_INT_BUF_SHIFT;
820        tmp_reg |= cfg->dma_write_buf_tsh_clr_emer &
821                DMA_THRESH_WRITE_INT_BUF_MASK;
822
823        iowrite32be(tmp_reg, &dma_rg->fmdmhy);
824
825        /* configure emergency threshold */
826        iowrite32be(cfg->dma_sos_emergency, &dma_rg->fmdmsetr);
827
828        /* configure Watchdog */
829        iowrite32be((cfg->dma_watchdog * cfg->clk_freq), &dma_rg->fmdmwcr);
830
831        iowrite32be(cfg->cam_base_addr, &dma_rg->fmdmebcr);
832
833        /* Allocate MURAM for CAM */
834        fman->cam_size =
835                (u32)(fman->cfg->dma_cam_num_of_entries * DMA_CAM_SIZEOF_ENTRY);
836        fman->cam_offset = fman_muram_alloc(fman->muram, fman->cam_size);
837        if (IS_ERR_VALUE(fman->cam_offset)) {
838                dev_err(fman->dev, "%s: MURAM alloc for DMA CAM failed\n",
839                        __func__);
840                return -ENOMEM;
841        }
842
843        if (fman->state->rev_info.major == 2) {
844                u32 __iomem *cam_base_addr;
845
846                fman_muram_free_mem(fman->muram, fman->cam_offset,
847                                    fman->cam_size);
848
849                fman->cam_size = fman->cfg->dma_cam_num_of_entries * 72 + 128;
850                fman->cam_offset = fman_muram_alloc(fman->muram,
851                                                    fman->cam_size);
852                if (IS_ERR_VALUE(fman->cam_offset)) {
853                        dev_err(fman->dev, "%s: MURAM alloc for DMA CAM failed\n",
854                                __func__);
855                        return -ENOMEM;
856                }
857
858                if (fman->cfg->dma_cam_num_of_entries % 8 ||
859                    fman->cfg->dma_cam_num_of_entries > 32) {
860                        dev_err(fman->dev, "%s: wrong dma_cam_num_of_entries\n",
861                                __func__);
862                        return -EINVAL;
863                }
864
865                cam_base_addr = (u32 __iomem *)
866                        fman_muram_offset_to_vbase(fman->muram,
867                                                   fman->cam_offset);
868                iowrite32be(~((1 <<
869                            (32 - fman->cfg->dma_cam_num_of_entries)) - 1),
870                            cam_base_addr);
871        }
872
873        fman->cfg->cam_base_addr = fman->cam_offset;
874
875        return 0;
876}
877
878static void fpm_init(struct fman_fpm_regs __iomem *fpm_rg, struct fman_cfg *cfg)
879{
880        u32 tmp_reg;
881        int i;
882
883        /* Init FPM Registers */
884
885        tmp_reg = (u32)(cfg->disp_limit_tsh << FPM_DISP_LIMIT_SHIFT);
886        iowrite32be(tmp_reg, &fpm_rg->fmfp_mxd);
887
888        tmp_reg = (((u32)cfg->prs_disp_tsh << FPM_THR1_PRS_SHIFT) |
889                   ((u32)cfg->kg_disp_tsh << FPM_THR1_KG_SHIFT) |
890                   ((u32)cfg->plcr_disp_tsh << FPM_THR1_PLCR_SHIFT) |
891                   ((u32)cfg->bmi_disp_tsh << FPM_THR1_BMI_SHIFT));
892        iowrite32be(tmp_reg, &fpm_rg->fmfp_dist1);
893
894        tmp_reg =
895                (((u32)cfg->qmi_enq_disp_tsh << FPM_THR2_QMI_ENQ_SHIFT) |
896                 ((u32)cfg->qmi_deq_disp_tsh << FPM_THR2_QMI_DEQ_SHIFT) |
897                 ((u32)cfg->fm_ctl1_disp_tsh << FPM_THR2_FM_CTL1_SHIFT) |
898                 ((u32)cfg->fm_ctl2_disp_tsh << FPM_THR2_FM_CTL2_SHIFT));
899        iowrite32be(tmp_reg, &fpm_rg->fmfp_dist2);
900
901        /* define exceptions and error behavior */
902        tmp_reg = 0;
903        /* Clear events */
904        tmp_reg |= (FPM_EV_MASK_STALL | FPM_EV_MASK_DOUBLE_ECC |
905                    FPM_EV_MASK_SINGLE_ECC);
906        /* enable interrupts */
907        if (cfg->exceptions & EX_FPM_STALL_ON_TASKS)
908                tmp_reg |= FPM_EV_MASK_STALL_EN;
909        if (cfg->exceptions & EX_FPM_SINGLE_ECC)
910                tmp_reg |= FPM_EV_MASK_SINGLE_ECC_EN;
911        if (cfg->exceptions & EX_FPM_DOUBLE_ECC)
912                tmp_reg |= FPM_EV_MASK_DOUBLE_ECC_EN;
913        tmp_reg |= (cfg->catastrophic_err << FPM_EV_MASK_CAT_ERR_SHIFT);
914        tmp_reg |= (cfg->dma_err << FPM_EV_MASK_DMA_ERR_SHIFT);
915        /* FMan is not halted upon external halt activation */
916        tmp_reg |= FPM_EV_MASK_EXTERNAL_HALT;
917        /* Man is not halted upon  Unrecoverable ECC error behavior */
918        tmp_reg |= FPM_EV_MASK_ECC_ERR_HALT;
919        iowrite32be(tmp_reg, &fpm_rg->fmfp_ee);
920
921        /* clear all fmCtls event registers */
922        for (i = 0; i < FM_NUM_OF_FMAN_CTRL_EVENT_REGS; i++)
923                iowrite32be(0xFFFFFFFF, &fpm_rg->fmfp_cev[i]);
924
925        /* RAM ECC -  enable and clear events */
926        /* first we need to clear all parser memory,
927         * as it is uninitialized and may cause ECC errors
928         */
929        /* event bits */
930        tmp_reg = (FPM_RAM_MURAM_ECC | FPM_RAM_IRAM_ECC);
931
932        iowrite32be(tmp_reg, &fpm_rg->fm_rcr);
933
934        tmp_reg = 0;
935        if (cfg->exceptions & EX_IRAM_ECC) {
936                tmp_reg |= FPM_IRAM_ECC_ERR_EX_EN;
937                enable_rams_ecc(fpm_rg);
938        }
939        if (cfg->exceptions & EX_MURAM_ECC) {
940                tmp_reg |= FPM_MURAM_ECC_ERR_EX_EN;
941                enable_rams_ecc(fpm_rg);
942        }
943        iowrite32be(tmp_reg, &fpm_rg->fm_rie);
944}
945
946static void bmi_init(struct fman_bmi_regs __iomem *bmi_rg,
947                     struct fman_cfg *cfg)
948{
949        u32 tmp_reg;
950
951        /* Init BMI Registers */
952
953        /* define common resources */
954        tmp_reg = cfg->fifo_base_addr;
955        tmp_reg = tmp_reg / BMI_FIFO_ALIGN;
956
957        tmp_reg |= ((cfg->total_fifo_size / FMAN_BMI_FIFO_UNITS - 1) <<
958                    BMI_CFG1_FIFO_SIZE_SHIFT);
959        iowrite32be(tmp_reg, &bmi_rg->fmbm_cfg1);
960
961        tmp_reg = ((cfg->total_num_of_tasks - 1) & BMI_CFG2_TASKS_MASK) <<
962                   BMI_CFG2_TASKS_SHIFT;
963        /* num of DMA's will be dynamically updated when each port is set */
964        iowrite32be(tmp_reg, &bmi_rg->fmbm_cfg2);
965
966        /* define unmaskable exceptions, enable and clear events */
967        tmp_reg = 0;
968        iowrite32be(BMI_ERR_INTR_EN_LIST_RAM_ECC |
969                    BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC |
970                    BMI_ERR_INTR_EN_STATISTICS_RAM_ECC |
971                    BMI_ERR_INTR_EN_DISPATCH_RAM_ECC, &bmi_rg->fmbm_ievr);
972
973        if (cfg->exceptions & EX_BMI_LIST_RAM_ECC)
974                tmp_reg |= BMI_ERR_INTR_EN_LIST_RAM_ECC;
975        if (cfg->exceptions & EX_BMI_STORAGE_PROFILE_ECC)
976                tmp_reg |= BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC;
977        if (cfg->exceptions & EX_BMI_STATISTICS_RAM_ECC)
978                tmp_reg |= BMI_ERR_INTR_EN_STATISTICS_RAM_ECC;
979        if (cfg->exceptions & EX_BMI_DISPATCH_RAM_ECC)
980                tmp_reg |= BMI_ERR_INTR_EN_DISPATCH_RAM_ECC;
981        iowrite32be(tmp_reg, &bmi_rg->fmbm_ier);
982}
983
984static void qmi_init(struct fman_qmi_regs __iomem *qmi_rg,
985                     struct fman_cfg *cfg)
986{
987        u32 tmp_reg;
988
989        /* Init QMI Registers */
990
991        /* Clear error interrupt events */
992
993        iowrite32be(QMI_ERR_INTR_EN_DOUBLE_ECC | QMI_ERR_INTR_EN_DEQ_FROM_DEF,
994                    &qmi_rg->fmqm_eie);
995        tmp_reg = 0;
996        if (cfg->exceptions & EX_QMI_DEQ_FROM_UNKNOWN_PORTID)
997                tmp_reg |= QMI_ERR_INTR_EN_DEQ_FROM_DEF;
998        if (cfg->exceptions & EX_QMI_DOUBLE_ECC)
999                tmp_reg |= QMI_ERR_INTR_EN_DOUBLE_ECC;
1000        /* enable events */
1001        iowrite32be(tmp_reg, &qmi_rg->fmqm_eien);
1002
1003        tmp_reg = 0;
1004        /* Clear interrupt events */
1005        iowrite32be(QMI_INTR_EN_SINGLE_ECC, &qmi_rg->fmqm_ie);
1006        if (cfg->exceptions & EX_QMI_SINGLE_ECC)
1007                tmp_reg |= QMI_INTR_EN_SINGLE_ECC;
1008        /* enable events */
1009        iowrite32be(tmp_reg, &qmi_rg->fmqm_ien);
1010}
1011
1012static int enable(struct fman *fman, struct fman_cfg *cfg)
1013{
1014        u32 cfg_reg = 0;
1015
1016        /* Enable all modules */
1017
1018        /* clear&enable global counters - calculate reg and save for later,
1019         * because it's the same reg for QMI enable
1020         */
1021        cfg_reg = QMI_CFG_EN_COUNTERS;
1022
1023        /* Set enqueue and dequeue thresholds */
1024        cfg_reg |= (cfg->qmi_def_tnums_thresh << 8) | cfg->qmi_def_tnums_thresh;
1025
1026        iowrite32be(BMI_INIT_START, &fman->bmi_regs->fmbm_init);
1027        iowrite32be(cfg_reg | QMI_CFG_ENQ_EN | QMI_CFG_DEQ_EN,
1028                    &fman->qmi_regs->fmqm_gc);
1029
1030        return 0;
1031}
1032
1033static int set_exception(struct fman *fman,
1034                         enum fman_exceptions exception, bool enable)
1035{
1036        u32 tmp;
1037
1038        switch (exception) {
1039        case FMAN_EX_DMA_BUS_ERROR:
1040                tmp = ioread32be(&fman->dma_regs->fmdmmr);
1041                if (enable)
1042                        tmp |= DMA_MODE_BER;
1043                else
1044                        tmp &= ~DMA_MODE_BER;
1045                /* disable bus error */
1046                iowrite32be(tmp, &fman->dma_regs->fmdmmr);
1047                break;
1048        case FMAN_EX_DMA_READ_ECC:
1049        case FMAN_EX_DMA_SYSTEM_WRITE_ECC:
1050        case FMAN_EX_DMA_FM_WRITE_ECC:
1051                tmp = ioread32be(&fman->dma_regs->fmdmmr);
1052                if (enable)
1053                        tmp |= DMA_MODE_ECC;
1054                else
1055                        tmp &= ~DMA_MODE_ECC;
1056                iowrite32be(tmp, &fman->dma_regs->fmdmmr);
1057                break;
1058        case FMAN_EX_FPM_STALL_ON_TASKS:
1059                tmp = ioread32be(&fman->fpm_regs->fmfp_ee);
1060                if (enable)
1061                        tmp |= FPM_EV_MASK_STALL_EN;
1062                else
1063                        tmp &= ~FPM_EV_MASK_STALL_EN;
1064                iowrite32be(tmp, &fman->fpm_regs->fmfp_ee);
1065                break;
1066        case FMAN_EX_FPM_SINGLE_ECC:
1067                tmp = ioread32be(&fman->fpm_regs->fmfp_ee);
1068                if (enable)
1069                        tmp |= FPM_EV_MASK_SINGLE_ECC_EN;
1070                else
1071                        tmp &= ~FPM_EV_MASK_SINGLE_ECC_EN;
1072                iowrite32be(tmp, &fman->fpm_regs->fmfp_ee);
1073                break;
1074        case FMAN_EX_FPM_DOUBLE_ECC:
1075                tmp = ioread32be(&fman->fpm_regs->fmfp_ee);
1076                if (enable)
1077                        tmp |= FPM_EV_MASK_DOUBLE_ECC_EN;
1078                else
1079                        tmp &= ~FPM_EV_MASK_DOUBLE_ECC_EN;
1080                iowrite32be(tmp, &fman->fpm_regs->fmfp_ee);
1081                break;
1082        case FMAN_EX_QMI_SINGLE_ECC:
1083                tmp = ioread32be(&fman->qmi_regs->fmqm_ien);
1084                if (enable)
1085                        tmp |= QMI_INTR_EN_SINGLE_ECC;
1086                else
1087                        tmp &= ~QMI_INTR_EN_SINGLE_ECC;
1088                iowrite32be(tmp, &fman->qmi_regs->fmqm_ien);
1089                break;
1090        case FMAN_EX_QMI_DOUBLE_ECC:
1091                tmp = ioread32be(&fman->qmi_regs->fmqm_eien);
1092                if (enable)
1093                        tmp |= QMI_ERR_INTR_EN_DOUBLE_ECC;
1094                else
1095                        tmp &= ~QMI_ERR_INTR_EN_DOUBLE_ECC;
1096                iowrite32be(tmp, &fman->qmi_regs->fmqm_eien);
1097                break;
1098        case FMAN_EX_QMI_DEQ_FROM_UNKNOWN_PORTID:
1099                tmp = ioread32be(&fman->qmi_regs->fmqm_eien);
1100                if (enable)
1101                        tmp |= QMI_ERR_INTR_EN_DEQ_FROM_DEF;
1102                else
1103                        tmp &= ~QMI_ERR_INTR_EN_DEQ_FROM_DEF;
1104                iowrite32be(tmp, &fman->qmi_regs->fmqm_eien);
1105                break;
1106        case FMAN_EX_BMI_LIST_RAM_ECC:
1107                tmp = ioread32be(&fman->bmi_regs->fmbm_ier);
1108                if (enable)
1109                        tmp |= BMI_ERR_INTR_EN_LIST_RAM_ECC;
1110                else
1111                        tmp &= ~BMI_ERR_INTR_EN_LIST_RAM_ECC;
1112                iowrite32be(tmp, &fman->bmi_regs->fmbm_ier);
1113                break;
1114        case FMAN_EX_BMI_STORAGE_PROFILE_ECC:
1115                tmp = ioread32be(&fman->bmi_regs->fmbm_ier);
1116                if (enable)
1117                        tmp |= BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC;
1118                else
1119                        tmp &= ~BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC;
1120                iowrite32be(tmp, &fman->bmi_regs->fmbm_ier);
1121                break;
1122        case FMAN_EX_BMI_STATISTICS_RAM_ECC:
1123                tmp = ioread32be(&fman->bmi_regs->fmbm_ier);
1124                if (enable)
1125                        tmp |= BMI_ERR_INTR_EN_STATISTICS_RAM_ECC;
1126                else
1127                        tmp &= ~BMI_ERR_INTR_EN_STATISTICS_RAM_ECC;
1128                iowrite32be(tmp, &fman->bmi_regs->fmbm_ier);
1129                break;
1130        case FMAN_EX_BMI_DISPATCH_RAM_ECC:
1131                tmp = ioread32be(&fman->bmi_regs->fmbm_ier);
1132                if (enable)
1133                        tmp |= BMI_ERR_INTR_EN_DISPATCH_RAM_ECC;
1134                else
1135                        tmp &= ~BMI_ERR_INTR_EN_DISPATCH_RAM_ECC;
1136                iowrite32be(tmp, &fman->bmi_regs->fmbm_ier);
1137                break;
1138        case FMAN_EX_IRAM_ECC:
1139                tmp = ioread32be(&fman->fpm_regs->fm_rie);
1140                if (enable) {
1141                        /* enable ECC if not enabled */
1142                        enable_rams_ecc(fman->fpm_regs);
1143                        /* enable ECC interrupts */
1144                        tmp |= FPM_IRAM_ECC_ERR_EX_EN;
1145                } else {
1146                        /* ECC mechanism may be disabled,
1147                         * depending on driver status
1148                         */
1149                        disable_rams_ecc(fman->fpm_regs);
1150                        tmp &= ~FPM_IRAM_ECC_ERR_EX_EN;
1151                }
1152                iowrite32be(tmp, &fman->fpm_regs->fm_rie);
1153                break;
1154        case FMAN_EX_MURAM_ECC:
1155                tmp = ioread32be(&fman->fpm_regs->fm_rie);
1156                if (enable) {
1157                        /* enable ECC if not enabled */
1158                        enable_rams_ecc(fman->fpm_regs);
1159                        /* enable ECC interrupts */
1160                        tmp |= FPM_MURAM_ECC_ERR_EX_EN;
1161                } else {
1162                        /* ECC mechanism may be disabled,
1163                         * depending on driver status
1164                         */
1165                        disable_rams_ecc(fman->fpm_regs);
1166                        tmp &= ~FPM_MURAM_ECC_ERR_EX_EN;
1167                }
1168                iowrite32be(tmp, &fman->fpm_regs->fm_rie);
1169                break;
1170        default:
1171                return -EINVAL;
1172        }
1173        return 0;
1174}
1175
1176static void resume(struct fman_fpm_regs __iomem *fpm_rg)
1177{
1178        u32 tmp;
1179
1180        tmp = ioread32be(&fpm_rg->fmfp_ee);
1181        /* clear tmp_reg event bits in order not to clear standing events */
1182        tmp &= ~(FPM_EV_MASK_DOUBLE_ECC |
1183                 FPM_EV_MASK_STALL | FPM_EV_MASK_SINGLE_ECC);
1184        tmp |= FPM_EV_MASK_RELEASE_FM;
1185
1186        iowrite32be(tmp, &fpm_rg->fmfp_ee);
1187}
1188
1189static int fill_soc_specific_params(struct fman_state_struct *state)
1190{
1191        u8 minor = state->rev_info.minor;
1192        /* P4080 - Major 2
1193         * P2041/P3041/P5020/P5040 - Major 3
1194         * Tx/Bx - Major 6
1195         */
1196        switch (state->rev_info.major) {
1197        case 3:
1198                state->bmi_max_fifo_size        = 160 * 1024;
1199                state->fm_iram_size             = 64 * 1024;
1200                state->dma_thresh_max_commq     = 31;
1201                state->dma_thresh_max_buf       = 127;
1202                state->qmi_max_num_of_tnums     = 64;
1203                state->qmi_def_tnums_thresh     = 48;
1204                state->bmi_max_num_of_tasks     = 128;
1205                state->max_num_of_open_dmas     = 32;
1206                state->fm_port_num_of_cg        = 256;
1207                state->num_of_rx_ports  = 6;
1208                state->total_fifo_size  = 122 * 1024;
1209                break;
1210
1211        case 2:
1212                state->bmi_max_fifo_size        = 160 * 1024;
1213                state->fm_iram_size             = 64 * 1024;
1214                state->dma_thresh_max_commq     = 31;
1215                state->dma_thresh_max_buf       = 127;
1216                state->qmi_max_num_of_tnums     = 64;
1217                state->qmi_def_tnums_thresh     = 48;
1218                state->bmi_max_num_of_tasks     = 128;
1219                state->max_num_of_open_dmas     = 32;
1220                state->fm_port_num_of_cg        = 256;
1221                state->num_of_rx_ports  = 5;
1222                state->total_fifo_size  = 100 * 1024;
1223                break;
1224
1225        case 6:
1226                state->dma_thresh_max_commq     = 83;
1227                state->dma_thresh_max_buf       = 127;
1228                state->qmi_max_num_of_tnums     = 64;
1229                state->qmi_def_tnums_thresh     = 32;
1230                state->fm_port_num_of_cg        = 256;
1231
1232                /* FManV3L */
1233                if (minor == 1 || minor == 4) {
1234                        state->bmi_max_fifo_size        = 192 * 1024;
1235                        state->bmi_max_num_of_tasks     = 64;
1236                        state->max_num_of_open_dmas     = 32;
1237                        state->num_of_rx_ports          = 5;
1238                        if (minor == 1)
1239                                state->fm_iram_size     = 32 * 1024;
1240                        else
1241                                state->fm_iram_size     = 64 * 1024;
1242                        state->total_fifo_size          = 156 * 1024;
1243                }
1244                /* FManV3H */
1245                else if (minor == 0 || minor == 2 || minor == 3) {
1246                        state->bmi_max_fifo_size        = 384 * 1024;
1247                        state->fm_iram_size             = 64 * 1024;
1248                        state->bmi_max_num_of_tasks     = 128;
1249                        state->max_num_of_open_dmas     = 84;
1250                        state->num_of_rx_ports          = 8;
1251                        state->total_fifo_size          = 295 * 1024;
1252                } else {
1253                        pr_err("Unsupported FManv3 version\n");
1254                        return -EINVAL;
1255                }
1256
1257                break;
1258        default:
1259                pr_err("Unsupported FMan version\n");
1260                return -EINVAL;
1261        }
1262
1263        return 0;
1264}
1265
1266static bool is_init_done(struct fman_cfg *cfg)
1267{
1268        /* Checks if FMan driver parameters were initialized */
1269        if (!cfg)
1270                return true;
1271
1272        return false;
1273}
1274
1275static void free_init_resources(struct fman *fman)
1276{
1277        if (fman->cam_offset)
1278                fman_muram_free_mem(fman->muram, fman->cam_offset,
1279                                    fman->cam_size);
1280        if (fman->fifo_offset)
1281                fman_muram_free_mem(fman->muram, fman->fifo_offset,
1282                                    fman->fifo_size);
1283}
1284
1285static irqreturn_t bmi_err_event(struct fman *fman)
1286{
1287        u32 event, mask, force;
1288        struct fman_bmi_regs __iomem *bmi_rg = fman->bmi_regs;
1289        irqreturn_t ret = IRQ_NONE;
1290
1291        event = ioread32be(&bmi_rg->fmbm_ievr);
1292        mask = ioread32be(&bmi_rg->fmbm_ier);
1293        event &= mask;
1294        /* clear the forced events */
1295        force = ioread32be(&bmi_rg->fmbm_ifr);
1296        if (force & event)
1297                iowrite32be(force & ~event, &bmi_rg->fmbm_ifr);
1298        /* clear the acknowledged events */
1299        iowrite32be(event, &bmi_rg->fmbm_ievr);
1300
1301        if (event & BMI_ERR_INTR_EN_STORAGE_PROFILE_ECC)
1302                ret = fman->exception_cb(fman, FMAN_EX_BMI_STORAGE_PROFILE_ECC);
1303        if (event & BMI_ERR_INTR_EN_LIST_RAM_ECC)
1304                ret = fman->exception_cb(fman, FMAN_EX_BMI_LIST_RAM_ECC);
1305        if (event & BMI_ERR_INTR_EN_STATISTICS_RAM_ECC)
1306                ret = fman->exception_cb(fman, FMAN_EX_BMI_STATISTICS_RAM_ECC);
1307        if (event & BMI_ERR_INTR_EN_DISPATCH_RAM_ECC)
1308                ret = fman->exception_cb(fman, FMAN_EX_BMI_DISPATCH_RAM_ECC);
1309
1310        return ret;
1311}
1312
1313static irqreturn_t qmi_err_event(struct fman *fman)
1314{
1315        u32 event, mask, force;
1316        struct fman_qmi_regs __iomem *qmi_rg = fman->qmi_regs;
1317        irqreturn_t ret = IRQ_NONE;
1318
1319        event = ioread32be(&qmi_rg->fmqm_eie);
1320        mask = ioread32be(&qmi_rg->fmqm_eien);
1321        event &= mask;
1322
1323        /* clear the forced events */
1324        force = ioread32be(&qmi_rg->fmqm_eif);
1325        if (force & event)
1326                iowrite32be(force & ~event, &qmi_rg->fmqm_eif);
1327        /* clear the acknowledged events */
1328        iowrite32be(event, &qmi_rg->fmqm_eie);
1329
1330        if (event & QMI_ERR_INTR_EN_DOUBLE_ECC)
1331                ret = fman->exception_cb(fman, FMAN_EX_QMI_DOUBLE_ECC);
1332        if (event & QMI_ERR_INTR_EN_DEQ_FROM_DEF)
1333                ret = fman->exception_cb(fman,
1334                                         FMAN_EX_QMI_DEQ_FROM_UNKNOWN_PORTID);
1335
1336        return ret;
1337}
1338
1339static irqreturn_t dma_err_event(struct fman *fman)
1340{
1341        u32 status, mask, com_id;
1342        u8 tnum, port_id, relative_port_id;
1343        u16 liodn;
1344        struct fman_dma_regs __iomem *dma_rg = fman->dma_regs;
1345        irqreturn_t ret = IRQ_NONE;
1346
1347        status = ioread32be(&dma_rg->fmdmsr);
1348        mask = ioread32be(&dma_rg->fmdmmr);
1349
1350        /* clear DMA_STATUS_BUS_ERR if mask has no DMA_MODE_BER */
1351        if ((mask & DMA_MODE_BER) != DMA_MODE_BER)
1352                status &= ~DMA_STATUS_BUS_ERR;
1353
1354        /* clear relevant bits if mask has no DMA_MODE_ECC */
1355        if ((mask & DMA_MODE_ECC) != DMA_MODE_ECC)
1356                status &= ~(DMA_STATUS_FM_SPDAT_ECC |
1357                            DMA_STATUS_READ_ECC |
1358                            DMA_STATUS_SYSTEM_WRITE_ECC |
1359                            DMA_STATUS_FM_WRITE_ECC);
1360
1361        /* clear set events */
1362        iowrite32be(status, &dma_rg->fmdmsr);
1363
1364        if (status & DMA_STATUS_BUS_ERR) {
1365                u64 addr;
1366
1367                addr = (u64)ioread32be(&dma_rg->fmdmtal);
1368                addr |= ((u64)(ioread32be(&dma_rg->fmdmtah)) << 32);
1369
1370                com_id = ioread32be(&dma_rg->fmdmtcid);
1371                port_id = (u8)(((com_id & DMA_TRANSFER_PORTID_MASK) >>
1372                               DMA_TRANSFER_PORTID_SHIFT));
1373                relative_port_id =
1374                hw_port_id_to_sw_port_id(fman->state->rev_info.major, port_id);
1375                tnum = (u8)((com_id & DMA_TRANSFER_TNUM_MASK) >>
1376                            DMA_TRANSFER_TNUM_SHIFT);
1377                liodn = (u16)(com_id & DMA_TRANSFER_LIODN_MASK);
1378                ret = fman->bus_error_cb(fman, relative_port_id, addr, tnum,
1379                                         liodn);
1380        }
1381        if (status & DMA_STATUS_FM_SPDAT_ECC)
1382                ret = fman->exception_cb(fman, FMAN_EX_DMA_SINGLE_PORT_ECC);
1383        if (status & DMA_STATUS_READ_ECC)
1384                ret = fman->exception_cb(fman, FMAN_EX_DMA_READ_ECC);
1385        if (status & DMA_STATUS_SYSTEM_WRITE_ECC)
1386                ret = fman->exception_cb(fman, FMAN_EX_DMA_SYSTEM_WRITE_ECC);
1387        if (status & DMA_STATUS_FM_WRITE_ECC)
1388                ret = fman->exception_cb(fman, FMAN_EX_DMA_FM_WRITE_ECC);
1389
1390        return ret;
1391}
1392
1393static irqreturn_t fpm_err_event(struct fman *fman)
1394{
1395        u32 event;
1396        struct fman_fpm_regs __iomem *fpm_rg = fman->fpm_regs;
1397        irqreturn_t ret = IRQ_NONE;
1398
1399        event = ioread32be(&fpm_rg->fmfp_ee);
1400        /* clear the all occurred events */
1401        iowrite32be(event, &fpm_rg->fmfp_ee);
1402
1403        if ((event & FPM_EV_MASK_DOUBLE_ECC) &&
1404            (event & FPM_EV_MASK_DOUBLE_ECC_EN))
1405                ret = fman->exception_cb(fman, FMAN_EX_FPM_DOUBLE_ECC);
1406        if ((event & FPM_EV_MASK_STALL) && (event & FPM_EV_MASK_STALL_EN))
1407                ret = fman->exception_cb(fman, FMAN_EX_FPM_STALL_ON_TASKS);
1408        if ((event & FPM_EV_MASK_SINGLE_ECC) &&
1409            (event & FPM_EV_MASK_SINGLE_ECC_EN))
1410                ret = fman->exception_cb(fman, FMAN_EX_FPM_SINGLE_ECC);
1411
1412        return ret;
1413}
1414
1415static irqreturn_t muram_err_intr(struct fman *fman)
1416{
1417        u32 event, mask;
1418        struct fman_fpm_regs __iomem *fpm_rg = fman->fpm_regs;
1419        irqreturn_t ret = IRQ_NONE;
1420
1421        event = ioread32be(&fpm_rg->fm_rcr);
1422        mask = ioread32be(&fpm_rg->fm_rie);
1423
1424        /* clear MURAM event bit (do not clear IRAM event) */
1425        iowrite32be(event & ~FPM_RAM_IRAM_ECC, &fpm_rg->fm_rcr);
1426
1427        if ((mask & FPM_MURAM_ECC_ERR_EX_EN) && (event & FPM_RAM_MURAM_ECC))
1428                ret = fman->exception_cb(fman, FMAN_EX_MURAM_ECC);
1429
1430        return ret;
1431}
1432
1433static irqreturn_t qmi_event(struct fman *fman)
1434{
1435        u32 event, mask, force;
1436        struct fman_qmi_regs __iomem *qmi_rg = fman->qmi_regs;
1437        irqreturn_t ret = IRQ_NONE;
1438
1439        event = ioread32be(&qmi_rg->fmqm_ie);
1440        mask = ioread32be(&qmi_rg->fmqm_ien);
1441        event &= mask;
1442        /* clear the forced events */
1443        force = ioread32be(&qmi_rg->fmqm_if);
1444        if (force & event)
1445                iowrite32be(force & ~event, &qmi_rg->fmqm_if);
1446        /* clear the acknowledged events */
1447        iowrite32be(event, &qmi_rg->fmqm_ie);
1448
1449        if (event & QMI_INTR_EN_SINGLE_ECC)
1450                ret = fman->exception_cb(fman, FMAN_EX_QMI_SINGLE_ECC);
1451
1452        return ret;
1453}
1454
1455static void enable_time_stamp(struct fman *fman)
1456{
1457        struct fman_fpm_regs __iomem *fpm_rg = fman->fpm_regs;
1458        u16 fm_clk_freq = fman->state->fm_clk_freq;
1459        u32 tmp, intgr, ts_freq;
1460        u64 frac;
1461
1462        ts_freq = (u32)(1 << fman->state->count1_micro_bit);
1463        /* configure timestamp so that bit 8 will count 1 microsecond
1464         * Find effective count rate at TIMESTAMP least significant bits:
1465         * Effective_Count_Rate = 1MHz x 2^8 = 256MHz
1466         * Find frequency ratio between effective count rate and the clock:
1467         * Effective_Count_Rate / CLK e.g. for 600 MHz clock:
1468         * 256/600 = 0.4266666...
1469         */
1470
1471        intgr = ts_freq / fm_clk_freq;
1472        /* we multiply by 2^16 to keep the fraction of the division
1473         * we do not div back, since we write this value as a fraction
1474         * see spec
1475         */
1476
1477        frac = ((ts_freq << 16) - (intgr << 16) * fm_clk_freq) / fm_clk_freq;
1478        /* we check remainder of the division in order to round up if not int */
1479        if (((ts_freq << 16) - (intgr << 16) * fm_clk_freq) % fm_clk_freq)
1480                frac++;
1481
1482        tmp = (intgr << FPM_TS_INT_SHIFT) | (u16)frac;
1483        iowrite32be(tmp, &fpm_rg->fmfp_tsc2);
1484
1485        /* enable timestamp with original clock */
1486        iowrite32be(FPM_TS_CTL_EN, &fpm_rg->fmfp_tsc1);
1487        fman->state->enabled_time_stamp = true;
1488}
1489
1490static int clear_iram(struct fman *fman)
1491{
1492        struct fman_iram_regs __iomem *iram;
1493        int i, count;
1494
1495        iram = fman->base_addr + IMEM_OFFSET;
1496
1497        /* Enable the auto-increment */
1498        iowrite32be(IRAM_IADD_AIE, &iram->iadd);
1499        count = 100;
1500        do {
1501                udelay(1);
1502        } while ((ioread32be(&iram->iadd) != IRAM_IADD_AIE) && --count);
1503        if (count == 0)
1504                return -EBUSY;
1505
1506        for (i = 0; i < (fman->state->fm_iram_size / 4); i++)
1507                iowrite32be(0xffffffff, &iram->idata);
1508
1509        iowrite32be(fman->state->fm_iram_size - 4, &iram->iadd);
1510        count = 100;
1511        do {
1512                udelay(1);
1513        } while ((ioread32be(&iram->idata) != 0xffffffff) && --count);
1514        if (count == 0)
1515                return -EBUSY;
1516
1517        return 0;
1518}
1519
1520static u32 get_exception_flag(enum fman_exceptions exception)
1521{
1522        u32 bit_mask;
1523
1524        switch (exception) {
1525        case FMAN_EX_DMA_BUS_ERROR:
1526                bit_mask = EX_DMA_BUS_ERROR;
1527                break;
1528        case FMAN_EX_DMA_SINGLE_PORT_ECC:
1529                bit_mask = EX_DMA_SINGLE_PORT_ECC;
1530                break;
1531        case FMAN_EX_DMA_READ_ECC:
1532                bit_mask = EX_DMA_READ_ECC;
1533                break;
1534        case FMAN_EX_DMA_SYSTEM_WRITE_ECC:
1535                bit_mask = EX_DMA_SYSTEM_WRITE_ECC;
1536                break;
1537        case FMAN_EX_DMA_FM_WRITE_ECC:
1538                bit_mask = EX_DMA_FM_WRITE_ECC;
1539                break;
1540        case FMAN_EX_FPM_STALL_ON_TASKS:
1541                bit_mask = EX_FPM_STALL_ON_TASKS;
1542                break;
1543        case FMAN_EX_FPM_SINGLE_ECC:
1544                bit_mask = EX_FPM_SINGLE_ECC;
1545                break;
1546        case FMAN_EX_FPM_DOUBLE_ECC:
1547                bit_mask = EX_FPM_DOUBLE_ECC;
1548                break;
1549        case FMAN_EX_QMI_SINGLE_ECC:
1550                bit_mask = EX_QMI_SINGLE_ECC;
1551                break;
1552        case FMAN_EX_QMI_DOUBLE_ECC:
1553                bit_mask = EX_QMI_DOUBLE_ECC;
1554                break;
1555        case FMAN_EX_QMI_DEQ_FROM_UNKNOWN_PORTID:
1556                bit_mask = EX_QMI_DEQ_FROM_UNKNOWN_PORTID;
1557                break;
1558        case FMAN_EX_BMI_LIST_RAM_ECC:
1559                bit_mask = EX_BMI_LIST_RAM_ECC;
1560                break;
1561        case FMAN_EX_BMI_STORAGE_PROFILE_ECC:
1562                bit_mask = EX_BMI_STORAGE_PROFILE_ECC;
1563                break;
1564        case FMAN_EX_BMI_STATISTICS_RAM_ECC:
1565                bit_mask = EX_BMI_STATISTICS_RAM_ECC;
1566                break;
1567        case FMAN_EX_BMI_DISPATCH_RAM_ECC:
1568                bit_mask = EX_BMI_DISPATCH_RAM_ECC;
1569                break;
1570        case FMAN_EX_MURAM_ECC:
1571                bit_mask = EX_MURAM_ECC;
1572                break;
1573        default:
1574                bit_mask = 0;
1575                break;
1576        }
1577
1578        return bit_mask;
1579}
1580
1581static int get_module_event(enum fman_event_modules module, u8 mod_id,
1582                            enum fman_intr_type intr_type)
1583{
1584        int event;
1585
1586        switch (module) {
1587        case FMAN_MOD_MAC:
1588                if (intr_type == FMAN_INTR_TYPE_ERR)
1589                        event = FMAN_EV_ERR_MAC0 + mod_id;
1590                else
1591                        event = FMAN_EV_MAC0 + mod_id;
1592                break;
1593        case FMAN_MOD_FMAN_CTRL:
1594                if (intr_type == FMAN_INTR_TYPE_ERR)
1595                        event = FMAN_EV_CNT;
1596                else
1597                        event = (FMAN_EV_FMAN_CTRL_0 + mod_id);
1598                break;
1599        case FMAN_MOD_DUMMY_LAST:
1600                event = FMAN_EV_CNT;
1601                break;
1602        default:
1603                event = FMAN_EV_CNT;
1604                break;
1605        }
1606
1607        return event;
1608}
1609
1610static int set_size_of_fifo(struct fman *fman, u8 port_id, u32 *size_of_fifo,
1611                            u32 *extra_size_of_fifo)
1612{
1613        struct fman_bmi_regs __iomem *bmi_rg = fman->bmi_regs;
1614        u32 fifo = *size_of_fifo;
1615        u32 extra_fifo = *extra_size_of_fifo;
1616        u32 tmp;
1617
1618        /* if this is the first time a port requires extra_fifo_pool_size,
1619         * the total extra_fifo_pool_size must be initialized to 1 buffer per
1620         * port
1621         */
1622        if (extra_fifo && !fman->state->extra_fifo_pool_size)
1623                fman->state->extra_fifo_pool_size =
1624                        fman->state->num_of_rx_ports * FMAN_BMI_FIFO_UNITS;
1625
1626        fman->state->extra_fifo_pool_size =
1627                max(fman->state->extra_fifo_pool_size, extra_fifo);
1628
1629        /* check that there are enough uncommitted fifo size */
1630        if ((fman->state->accumulated_fifo_size + fifo) >
1631            (fman->state->total_fifo_size -
1632            fman->state->extra_fifo_pool_size)) {
1633                dev_err(fman->dev, "%s: Requested fifo size and extra size exceed total FIFO size.\n",
1634                        __func__);
1635                return -EAGAIN;
1636        }
1637
1638        /* Read, modify and write to HW */
1639        tmp = (fifo / FMAN_BMI_FIFO_UNITS - 1) |
1640               ((extra_fifo / FMAN_BMI_FIFO_UNITS) <<
1641               BMI_EXTRA_FIFO_SIZE_SHIFT);
1642        iowrite32be(tmp, &bmi_rg->fmbm_pfs[port_id - 1]);
1643
1644        /* update accumulated */
1645        fman->state->accumulated_fifo_size += fifo;
1646
1647        return 0;
1648}
1649
1650static int set_num_of_tasks(struct fman *fman, u8 port_id, u8 *num_of_tasks,
1651                            u8 *num_of_extra_tasks)
1652{
1653        struct fman_bmi_regs __iomem *bmi_rg = fman->bmi_regs;
1654        u8 tasks = *num_of_tasks;
1655        u8 extra_tasks = *num_of_extra_tasks;
1656        u32 tmp;
1657
1658        if (extra_tasks)
1659                fman->state->extra_tasks_pool_size =
1660                max(fman->state->extra_tasks_pool_size, extra_tasks);
1661
1662        /* check that there are enough uncommitted tasks */
1663        if ((fman->state->accumulated_num_of_tasks + tasks) >
1664            (fman->state->total_num_of_tasks -
1665             fman->state->extra_tasks_pool_size)) {
1666                dev_err(fman->dev, "%s: Requested num_of_tasks and extra tasks pool for fm%d exceed total num_of_tasks.\n",
1667                        __func__, fman->state->fm_id);
1668                return -EAGAIN;
1669        }
1670        /* update accumulated */
1671        fman->state->accumulated_num_of_tasks += tasks;
1672
1673        /* Write to HW */
1674        tmp = ioread32be(&bmi_rg->fmbm_pp[port_id - 1]) &
1675            ~(BMI_NUM_OF_TASKS_MASK | BMI_NUM_OF_EXTRA_TASKS_MASK);
1676        tmp |= ((u32)((tasks - 1) << BMI_NUM_OF_TASKS_SHIFT) |
1677                (u32)(extra_tasks << BMI_EXTRA_NUM_OF_TASKS_SHIFT));
1678        iowrite32be(tmp, &bmi_rg->fmbm_pp[port_id - 1]);
1679
1680        return 0;
1681}
1682
1683static int set_num_of_open_dmas(struct fman *fman, u8 port_id,
1684                                u8 *num_of_open_dmas,
1685                                u8 *num_of_extra_open_dmas)
1686{
1687        struct fman_bmi_regs __iomem *bmi_rg = fman->bmi_regs;
1688        u8 open_dmas = *num_of_open_dmas;
1689        u8 extra_open_dmas = *num_of_extra_open_dmas;
1690        u8 total_num_dmas = 0, current_val = 0, current_extra_val = 0;
1691        u32 tmp;
1692
1693        if (!open_dmas) {
1694                /* Configuration according to values in the HW.
1695                 * read the current number of open Dma's
1696                 */
1697                tmp = ioread32be(&bmi_rg->fmbm_pp[port_id - 1]);
1698                current_extra_val = (u8)((tmp & BMI_NUM_OF_EXTRA_DMAS_MASK) >>
1699                                         BMI_EXTRA_NUM_OF_DMAS_SHIFT);
1700
1701                tmp = ioread32be(&bmi_rg->fmbm_pp[port_id - 1]);
1702                current_val = (u8)(((tmp & BMI_NUM_OF_DMAS_MASK) >>
1703                                   BMI_NUM_OF_DMAS_SHIFT) + 1);
1704
1705                /* This is the first configuration and user did not
1706                 * specify value (!open_dmas), reset values will be used
1707                 * and we just save these values for resource management
1708                 */
1709                fman->state->extra_open_dmas_pool_size =
1710                        (u8)max(fman->state->extra_open_dmas_pool_size,
1711                                current_extra_val);
1712                fman->state->accumulated_num_of_open_dmas += current_val;
1713                *num_of_open_dmas = current_val;
1714                *num_of_extra_open_dmas = current_extra_val;
1715                return 0;
1716        }
1717
1718        if (extra_open_dmas > current_extra_val)
1719                fman->state->extra_open_dmas_pool_size =
1720                    (u8)max(fman->state->extra_open_dmas_pool_size,
1721                            extra_open_dmas);
1722
1723        if ((fman->state->rev_info.major < 6) &&
1724            (fman->state->accumulated_num_of_open_dmas - current_val +
1725             open_dmas > fman->state->max_num_of_open_dmas)) {
1726                dev_err(fman->dev, "%s: Requested num_of_open_dmas for fm%d exceeds total num_of_open_dmas.\n",
1727                        __func__, fman->state->fm_id);
1728                return -EAGAIN;
1729        } else if ((fman->state->rev_info.major >= 6) &&
1730                   !((fman->state->rev_info.major == 6) &&
1731                   (fman->state->rev_info.minor == 0)) &&
1732                   (fman->state->accumulated_num_of_open_dmas -
1733                   current_val + open_dmas >
1734                   fman->state->dma_thresh_max_commq + 1)) {
1735                dev_err(fman->dev, "%s: Requested num_of_open_dmas for fm%d exceeds DMA Command queue (%d)\n",
1736                        __func__, fman->state->fm_id,
1737                       fman->state->dma_thresh_max_commq + 1);
1738                return -EAGAIN;
1739        }
1740
1741        WARN_ON(fman->state->accumulated_num_of_open_dmas < current_val);
1742        /* update acummulated */
1743        fman->state->accumulated_num_of_open_dmas -= current_val;
1744        fman->state->accumulated_num_of_open_dmas += open_dmas;
1745
1746        if (fman->state->rev_info.major < 6)
1747                total_num_dmas =
1748                    (u8)(fman->state->accumulated_num_of_open_dmas +
1749                    fman->state->extra_open_dmas_pool_size);
1750
1751        /* calculate reg */
1752        tmp = ioread32be(&bmi_rg->fmbm_pp[port_id - 1]) &
1753            ~(BMI_NUM_OF_DMAS_MASK | BMI_NUM_OF_EXTRA_DMAS_MASK);
1754        tmp |= (u32)(((open_dmas - 1) << BMI_NUM_OF_DMAS_SHIFT) |
1755                           (extra_open_dmas << BMI_EXTRA_NUM_OF_DMAS_SHIFT));
1756        iowrite32be(tmp, &bmi_rg->fmbm_pp[port_id - 1]);
1757
1758        /* update total num of DMA's with committed number of open DMAS,
1759         * and max uncommitted pool.
1760         */
1761        if (total_num_dmas) {
1762                tmp = ioread32be(&bmi_rg->fmbm_cfg2) & ~BMI_CFG2_DMAS_MASK;
1763                tmp |= (u32)(total_num_dmas - 1) << BMI_CFG2_DMAS_SHIFT;
1764                iowrite32be(tmp, &bmi_rg->fmbm_cfg2);
1765        }
1766
1767        return 0;
1768}
1769
1770static int fman_config(struct fman *fman)
1771{
1772        void __iomem *base_addr;
1773        int err;
1774
1775        base_addr = fman->dts_params.base_addr;
1776
1777        fman->state = kzalloc(sizeof(*fman->state), GFP_KERNEL);
1778        if (!fman->state)
1779                goto err_fm_state;
1780
1781        /* Allocate the FM driver's parameters structure */
1782        fman->cfg = kzalloc(sizeof(*fman->cfg), GFP_KERNEL);
1783        if (!fman->cfg)
1784                goto err_fm_drv;
1785
1786        /* Initialize MURAM block */
1787        fman->muram =
1788                fman_muram_init(fman->dts_params.muram_res.start,
1789                                resource_size(&fman->dts_params.muram_res));
1790        if (!fman->muram)
1791                goto err_fm_soc_specific;
1792
1793        /* Initialize FM parameters which will be kept by the driver */
1794        fman->state->fm_id = fman->dts_params.id;
1795        fman->state->fm_clk_freq = fman->dts_params.clk_freq;
1796        fman->state->qman_channel_base = fman->dts_params.qman_channel_base;
1797        fman->state->num_of_qman_channels =
1798                fman->dts_params.num_of_qman_channels;
1799#ifndef __rtems__
1800        fman->state->res = fman->dts_params.res;
1801#endif /* __rtems__ */
1802        fman->exception_cb = fman_exceptions;
1803        fman->bus_error_cb = fman_bus_error;
1804        fman->fpm_regs = base_addr + FPM_OFFSET;
1805        fman->bmi_regs = base_addr + BMI_OFFSET;
1806        fman->qmi_regs = base_addr + QMI_OFFSET;
1807        fman->dma_regs = base_addr + DMA_OFFSET;
1808        fman->base_addr = base_addr;
1809
1810        spin_lock_init(&fman->spinlock);
1811        fman_defconfig(fman->cfg);
1812
1813        fman->state->extra_fifo_pool_size = 0;
1814        fman->state->exceptions = (EX_DMA_BUS_ERROR                 |
1815                                        EX_DMA_READ_ECC              |
1816                                        EX_DMA_SYSTEM_WRITE_ECC      |
1817                                        EX_DMA_FM_WRITE_ECC          |
1818                                        EX_FPM_STALL_ON_TASKS        |
1819                                        EX_FPM_SINGLE_ECC            |
1820                                        EX_FPM_DOUBLE_ECC            |
1821                                        EX_QMI_DEQ_FROM_UNKNOWN_PORTID |
1822                                        EX_BMI_LIST_RAM_ECC          |
1823                                        EX_BMI_STORAGE_PROFILE_ECC   |
1824                                        EX_BMI_STATISTICS_RAM_ECC    |
1825                                        EX_MURAM_ECC                 |
1826                                        EX_BMI_DISPATCH_RAM_ECC      |
1827                                        EX_QMI_DOUBLE_ECC            |
1828                                        EX_QMI_SINGLE_ECC);
1829
1830        /* Read FMan revision for future use*/
1831        fman_get_revision(fman, &fman->state->rev_info);
1832
1833        err = fill_soc_specific_params(fman->state);
1834        if (err)
1835                goto err_fm_soc_specific;
1836
1837        /* FM_AID_MODE_NO_TNUM_SW005 Errata workaround */
1838        if (fman->state->rev_info.major >= 6)
1839                fman->cfg->dma_aid_mode = FMAN_DMA_AID_OUT_PORT_ID;
1840
1841        fman->cfg->qmi_def_tnums_thresh = fman->state->qmi_def_tnums_thresh;
1842
1843        fman->state->total_num_of_tasks =
1844        (u8)DFLT_TOTAL_NUM_OF_TASKS(fman->state->rev_info.major,
1845                                    fman->state->rev_info.minor,
1846                                    fman->state->bmi_max_num_of_tasks);
1847
1848        if (fman->state->rev_info.major < 6) {
1849                fman->cfg->dma_comm_qtsh_clr_emer =
1850                (u8)DFLT_DMA_COMM_Q_LOW(fman->state->rev_info.major,
1851                                        fman->state->dma_thresh_max_commq);
1852
1853                fman->cfg->dma_comm_qtsh_asrt_emer =
1854                (u8)DFLT_DMA_COMM_Q_HIGH(fman->state->rev_info.major,
1855                                         fman->state->dma_thresh_max_commq);
1856
1857                fman->cfg->dma_cam_num_of_entries =
1858                DFLT_DMA_CAM_NUM_OF_ENTRIES(fman->state->rev_info.major);
1859
1860                fman->cfg->dma_read_buf_tsh_clr_emer =
1861                DFLT_DMA_READ_INT_BUF_LOW(fman->state->dma_thresh_max_buf);
1862
1863                fman->cfg->dma_read_buf_tsh_asrt_emer =
1864                DFLT_DMA_READ_INT_BUF_HIGH(fman->state->dma_thresh_max_buf);
1865
1866                fman->cfg->dma_write_buf_tsh_clr_emer =
1867                DFLT_DMA_WRITE_INT_BUF_LOW(fman->state->dma_thresh_max_buf);
1868
1869                fman->cfg->dma_write_buf_tsh_asrt_emer =
1870                DFLT_DMA_WRITE_INT_BUF_HIGH(fman->state->dma_thresh_max_buf);
1871
1872                fman->cfg->dma_axi_dbg_num_of_beats =
1873                DFLT_AXI_DBG_NUM_OF_BEATS;
1874        }
1875
1876        return 0;
1877
1878err_fm_soc_specific:
1879        kfree(fman->cfg);
1880err_fm_drv:
1881        kfree(fman->state);
1882err_fm_state:
1883        kfree(fman);
1884        return -EINVAL;
1885}
1886
1887#ifndef __rtems__
1888static int fman_reset(struct fman *fman)
1889{
1890        u32 count;
1891        int err = 0;
1892
1893        if (fman->state->rev_info.major < 6) {
1894                iowrite32be(FPM_RSTC_FM_RESET, &fman->fpm_regs->fm_rstc);
1895                /* Wait for reset completion */
1896                count = 100;
1897                do {
1898                        udelay(1);
1899                } while (((ioread32be(&fman->fpm_regs->fm_rstc)) &
1900                         FPM_RSTC_FM_RESET) && --count);
1901                if (count == 0)
1902                        err = -EBUSY;
1903
1904                goto _return;
1905        } else {
1906#ifdef CONFIG_PPC
1907                struct device_node *guts_node;
1908                struct ccsr_guts __iomem *guts_regs;
1909                u32 devdisr2, reg;
1910
1911                /* Errata A007273 */
1912                guts_node =
1913                        of_find_compatible_node(NULL, NULL,
1914                                                "fsl,qoriq-device-config-2.0");
1915                if (!guts_node) {
1916                        dev_err(fman->dev, "%s: Couldn't find guts node\n",
1917                                __func__);
1918                        goto guts_node;
1919                }
1920
1921                guts_regs = of_iomap(guts_node, 0);
1922                if (!guts_regs) {
1923                        dev_err(fman->dev, "%s: Couldn't map %s regs\n",
1924                                __func__, guts_node->full_name);
1925                        goto guts_regs;
1926                }
1927#define FMAN1_ALL_MACS_MASK     0xFCC00000
1928#define FMAN2_ALL_MACS_MASK     0x000FCC00
1929                /* Read current state */
1930                devdisr2 = ioread32be(&guts_regs->devdisr2);
1931                if (fman->dts_params.id == 0)
1932                        reg = devdisr2 & ~FMAN1_ALL_MACS_MASK;
1933                else
1934                        reg = devdisr2 & ~FMAN2_ALL_MACS_MASK;
1935
1936                /* Enable all MACs */
1937                iowrite32be(reg, &guts_regs->devdisr2);
1938#endif
1939
1940                /* Perform FMan reset */
1941                iowrite32be(FPM_RSTC_FM_RESET, &fman->fpm_regs->fm_rstc);
1942
1943                /* Wait for reset completion */
1944                count = 100;
1945                do {
1946                        udelay(1);
1947                } while (((ioread32be(&fman->fpm_regs->fm_rstc)) &
1948                         FPM_RSTC_FM_RESET) && --count);
1949                if (count == 0) {
1950#ifdef CONFIG_PPC
1951                        iounmap(guts_regs);
1952                        of_node_put(guts_node);
1953#endif
1954                        err = -EBUSY;
1955                        goto _return;
1956                }
1957#ifdef CONFIG_PPC
1958
1959                /* Restore devdisr2 value */
1960                iowrite32be(devdisr2, &guts_regs->devdisr2);
1961
1962                iounmap(guts_regs);
1963                of_node_put(guts_node);
1964#endif
1965
1966                goto _return;
1967
1968#ifdef CONFIG_PPC
1969guts_regs:
1970                of_node_put(guts_node);
1971guts_node:
1972                dev_dbg(fman->dev, "%s: Didn't perform FManV3 reset due to Errata A007273!\n",
1973                        __func__);
1974#endif
1975        }
1976_return:
1977        return err;
1978}
1979#endif /* __rtems__ */
1980
1981static int fman_init(struct fman *fman)
1982{
1983        struct fman_cfg *cfg = NULL;
1984        int err = 0, i, count;
1985
1986        if (is_init_done(fman->cfg))
1987                return -EINVAL;
1988
1989        fman->state->count1_micro_bit = FM_TIMESTAMP_1_USEC_BIT;
1990
1991        cfg = fman->cfg;
1992
1993        /* clear revision-dependent non existing exception */
1994        if (fman->state->rev_info.major < 6)
1995                fman->state->exceptions &= ~FMAN_EX_BMI_DISPATCH_RAM_ECC;
1996
1997        if (fman->state->rev_info.major >= 6)
1998                fman->state->exceptions &= ~FMAN_EX_QMI_SINGLE_ECC;
1999
2000        /* clear CPG */
2001        memset_io((void __iomem *)(fman->base_addr + CGP_OFFSET), 0,
2002                  fman->state->fm_port_num_of_cg);
2003
2004        /* Save LIODN info before FMan reset
2005         * Skipping non-existent port 0 (i = 1)
2006         */
2007        for (i = 1; i < FMAN_LIODN_TBL; i++) {
2008                u32 liodn_base;
2009
2010                fman->liodn_offset[i] =
2011                        ioread32be(&fman->bmi_regs->fmbm_spliodn[i - 1]);
2012                liodn_base = ioread32be(&fman->dma_regs->fmdmplr[i / 2]);
2013                if (i % 2) {
2014                        /* FMDM_PLR LSB holds LIODN base for odd ports */
2015                        liodn_base &= DMA_LIODN_BASE_MASK;
2016                } else {
2017                        /* FMDM_PLR MSB holds LIODN base for even ports */
2018                        liodn_base >>= DMA_LIODN_SHIFT;
2019                        liodn_base &= DMA_LIODN_BASE_MASK;
2020                }
2021                fman->liodn_base[i] = liodn_base;
2022        }
2023
2024        err = fman_reset(fman);
2025        if (err)
2026                return err;
2027
2028        if (ioread32be(&fman->qmi_regs->fmqm_gs) & QMI_GS_HALT_NOT_BUSY) {
2029                resume(fman->fpm_regs);
2030                /* Wait until QMI is not in halt not busy state */
2031                count = 100;
2032                do {
2033                        udelay(1);
2034                } while (((ioread32be(&fman->qmi_regs->fmqm_gs)) &
2035                         QMI_GS_HALT_NOT_BUSY) && --count);
2036                if (count == 0)
2037                        dev_warn(fman->dev, "%s: QMI is in halt not busy state\n",
2038                                 __func__);
2039        }
2040
2041        if (clear_iram(fman) != 0)
2042                return -EINVAL;
2043
2044        cfg->exceptions = fman->state->exceptions;
2045
2046        /* Init DMA Registers */
2047
2048        err = dma_init(fman);
2049        if (err != 0) {
2050                free_init_resources(fman);
2051                return err;
2052        }
2053
2054        /* Init FPM Registers */
2055        fpm_init(fman->fpm_regs, fman->cfg);
2056
2057        /* define common resources */
2058        /* allocate MURAM for FIFO according to total size */
2059        fman->fifo_offset = fman_muram_alloc(fman->muram,
2060                                             fman->state->total_fifo_size);
2061        if (IS_ERR_VALUE(fman->fifo_offset)) {
2062                free_init_resources(fman);
2063                dev_err(fman->dev, "%s: MURAM alloc for BMI FIFO failed\n",
2064                        __func__);
2065                return -ENOMEM;
2066        }
2067
2068        cfg->fifo_base_addr = fman->fifo_offset;
2069        cfg->total_fifo_size = fman->state->total_fifo_size;
2070        cfg->total_num_of_tasks = fman->state->total_num_of_tasks;
2071        cfg->clk_freq = fman->state->fm_clk_freq;
2072
2073        /* Init BMI Registers */
2074        bmi_init(fman->bmi_regs, fman->cfg);
2075
2076        /* Init QMI Registers */
2077        qmi_init(fman->qmi_regs, fman->cfg);
2078
2079        err = enable(fman, cfg);
2080        if (err != 0)
2081                return err;
2082
2083        enable_time_stamp(fman);
2084
2085        kfree(fman->cfg);
2086        fman->cfg = NULL;
2087
2088        return 0;
2089}
2090
2091static int fman_set_exception(struct fman *fman,
2092                              enum fman_exceptions exception, bool enable)
2093{
2094        u32 bit_mask = 0;
2095
2096        if (!is_init_done(fman->cfg))
2097                return -EINVAL;
2098
2099        bit_mask = get_exception_flag(exception);
2100        if (bit_mask) {
2101                if (enable)
2102                        fman->state->exceptions |= bit_mask;
2103                else
2104                        fman->state->exceptions &= ~bit_mask;
2105        } else {
2106                dev_err(fman->dev, "%s: Undefined exception (%d)\n",
2107                        __func__, exception);
2108                return -EINVAL;
2109        }
2110
2111        return set_exception(fman, exception, enable);
2112}
2113
2114/**
2115 * fman_register_intr
2116 * @fman:       A Pointer to FMan device
2117 * @mod:        Calling module
2118 * @mod_id:     Module id (if more than 1 exists, '0' if not)
2119 * @intr_type:  Interrupt type (error/normal) selection.
2120 * @f_isr:      The interrupt service routine.
2121 * @h_src_arg:  Argument to be passed to f_isr.
2122 *
2123 * Used to register an event handler to be processed by FMan
2124 *
2125 * Return: 0 on success; Error code otherwise.
2126 */
2127void fman_register_intr(struct fman *fman, enum fman_event_modules module,
2128                        u8 mod_id, enum fman_intr_type intr_type,
2129                        void (*isr_cb)(void *src_arg), void *src_arg)
2130{
2131        int event = 0;
2132
2133        event = get_module_event(module, mod_id, intr_type);
2134        WARN_ON(event >= FMAN_EV_CNT);
2135
2136        /* register in local FM structure */
2137        fman->intr_mng[event].isr_cb = isr_cb;
2138        fman->intr_mng[event].src_handle = src_arg;
2139}
2140EXPORT_SYMBOL(fman_register_intr);
2141
2142/**
2143 * fman_unregister_intr
2144 * @fman:       A Pointer to FMan device
2145 * @mod:        Calling module
2146 * @mod_id:     Module id (if more than 1 exists, '0' if not)
2147 * @intr_type:  Interrupt type (error/normal) selection.
2148 *
2149 * Used to unregister an event handler to be processed by FMan
2150 *
2151 * Return: 0 on success; Error code otherwise.
2152 */
2153void fman_unregister_intr(struct fman *fman, enum fman_event_modules module,
2154                          u8 mod_id, enum fman_intr_type intr_type)
2155{
2156        int event = 0;
2157
2158        event = get_module_event(module, mod_id, intr_type);
2159        WARN_ON(event >= FMAN_EV_CNT);
2160
2161        fman->intr_mng[event].isr_cb = NULL;
2162        fman->intr_mng[event].src_handle = NULL;
2163}
2164EXPORT_SYMBOL(fman_unregister_intr);
2165
2166/**
2167 * fman_set_port_params
2168 * @fman:               A Pointer to FMan device
2169 * @port_params:        Port parameters
2170 *
2171 * Used by FMan Port to pass parameters to the FMan
2172 *
2173 * Return: 0 on success; Error code otherwise.
2174 */
2175int fman_set_port_params(struct fman *fman,
2176                         struct fman_port_init_params *port_params)
2177{
2178        int err;
2179        unsigned long flags;
2180        u8 port_id = port_params->port_id, mac_id;
2181
2182        spin_lock_irqsave(&fman->spinlock, flags);
2183
2184        err = set_num_of_tasks(fman, port_params->port_id,
2185                               &port_params->num_of_tasks,
2186                               &port_params->num_of_extra_tasks);
2187        if (err)
2188                goto return_err;
2189
2190        /* TX Ports */
2191        if (port_params->port_type != FMAN_PORT_TYPE_RX) {
2192                u32 enq_th, deq_th, reg;
2193
2194                /* update qmi ENQ/DEQ threshold */
2195                fman->state->accumulated_num_of_deq_tnums +=
2196                        port_params->deq_pipeline_depth;
2197                enq_th = (ioread32be(&fman->qmi_regs->fmqm_gc) &
2198                          QMI_CFG_ENQ_MASK) >> QMI_CFG_ENQ_SHIFT;
2199                /* if enq_th is too big, we reduce it to the max value
2200                 * that is still 0
2201                 */
2202                if (enq_th >= (fman->state->qmi_max_num_of_tnums -
2203                    fman->state->accumulated_num_of_deq_tnums)) {
2204                        enq_th =
2205                        fman->state->qmi_max_num_of_tnums -
2206                        fman->state->accumulated_num_of_deq_tnums - 1;
2207
2208                        reg = ioread32be(&fman->qmi_regs->fmqm_gc);
2209                        reg &= ~QMI_CFG_ENQ_MASK;
2210                        reg |= (enq_th << QMI_CFG_ENQ_SHIFT);
2211                        iowrite32be(reg, &fman->qmi_regs->fmqm_gc);
2212                }
2213
2214                deq_th = ioread32be(&fman->qmi_regs->fmqm_gc) &
2215                                    QMI_CFG_DEQ_MASK;
2216                /* if deq_th is too small, we enlarge it to the min
2217                 * value that is still 0.
2218                 * depTh may not be larger than 63
2219                 * (fman->state->qmi_max_num_of_tnums-1).
2220                 */
2221                if ((deq_th <= fman->state->accumulated_num_of_deq_tnums) &&
2222                    (deq_th < fman->state->qmi_max_num_of_tnums - 1)) {
2223                        deq_th = fman->state->accumulated_num_of_deq_tnums + 1;
2224                        reg = ioread32be(&fman->qmi_regs->fmqm_gc);
2225                        reg &= ~QMI_CFG_DEQ_MASK;
2226                        reg |= deq_th;
2227                        iowrite32be(reg, &fman->qmi_regs->fmqm_gc);
2228                }
2229        }
2230
2231        err = set_size_of_fifo(fman, port_params->port_id,
2232                               &port_params->size_of_fifo,
2233                               &port_params->extra_size_of_fifo);
2234        if (err)
2235                goto return_err;
2236
2237        err = set_num_of_open_dmas(fman, port_params->port_id,
2238                                   &port_params->num_of_open_dmas,
2239                                   &port_params->num_of_extra_open_dmas);
2240        if (err)
2241                goto return_err;
2242
2243        set_port_liodn(fman, port_id, fman->liodn_base[port_id],
2244                       fman->liodn_offset[port_id]);
2245
2246        if (fman->state->rev_info.major < 6)
2247                set_port_order_restoration(fman->fpm_regs, port_id);
2248
2249        mac_id = hw_port_id_to_sw_port_id(fman->state->rev_info.major, port_id);
2250
2251        if (port_params->max_frame_length >= fman->state->mac_mfl[mac_id]) {
2252                fman->state->port_mfl[mac_id] = port_params->max_frame_length;
2253        } else {
2254                dev_warn(fman->dev, "%s: Port (%d) max_frame_length is smaller than MAC (%d) current MTU\n",
2255                         __func__, port_id, mac_id);
2256                err = -EINVAL;
2257                goto return_err;
2258        }
2259
2260        spin_unlock_irqrestore(&fman->spinlock, flags);
2261
2262        return 0;
2263
2264return_err:
2265        spin_unlock_irqrestore(&fman->spinlock, flags);
2266        return err;
2267}
2268EXPORT_SYMBOL(fman_set_port_params);
2269
2270/**
2271 * fman_reset_mac
2272 * @fman:       A Pointer to FMan device
2273 * @mac_id:     MAC id to be reset
2274 *
2275 * Reset a specific MAC
2276 *
2277 * Return: 0 on success; Error code otherwise.
2278 */
2279int fman_reset_mac(struct fman *fman, u8 mac_id)
2280{
2281        struct fman_fpm_regs __iomem *fpm_rg = fman->fpm_regs;
2282        u32 msk, timeout = 100;
2283
2284        if (fman->state->rev_info.major >= 6) {
2285                dev_err(fman->dev, "%s: FMan MAC reset no available for FMan V3!\n",
2286                        __func__);
2287                return -EINVAL;
2288        }
2289
2290        /* Get the relevant bit mask */
2291        switch (mac_id) {
2292        case 0:
2293                msk = FPM_RSTC_MAC0_RESET;
2294                break;
2295        case 1:
2296                msk = FPM_RSTC_MAC1_RESET;
2297                break;
2298        case 2:
2299                msk = FPM_RSTC_MAC2_RESET;
2300                break;
2301        case 3:
2302                msk = FPM_RSTC_MAC3_RESET;
2303                break;
2304        case 4:
2305                msk = FPM_RSTC_MAC4_RESET;
2306                break;
2307        case 5:
2308                msk = FPM_RSTC_MAC5_RESET;
2309                break;
2310        case 6:
2311                msk = FPM_RSTC_MAC6_RESET;
2312                break;
2313        case 7:
2314                msk = FPM_RSTC_MAC7_RESET;
2315                break;
2316        case 8:
2317                msk = FPM_RSTC_MAC8_RESET;
2318                break;
2319        case 9:
2320                msk = FPM_RSTC_MAC9_RESET;
2321                break;
2322        default:
2323                dev_warn(fman->dev, "%s: Illegal MAC Id [%d]\n",
2324                         __func__, mac_id);
2325                return -EINVAL;
2326        }
2327
2328        /* reset */
2329        iowrite32be(msk, &fpm_rg->fm_rstc);
2330        while ((ioread32be(&fpm_rg->fm_rstc) & msk) && --timeout)
2331                udelay(10);
2332
2333        if (!timeout)
2334                return -EIO;
2335
2336        return 0;
2337}
2338EXPORT_SYMBOL(fman_reset_mac);
2339
2340/**
2341 * fman_set_mac_max_frame
2342 * @fman:       A Pointer to FMan device
2343 * @mac_id:     MAC id
2344 * @mfl:        Maximum frame length
2345 *
2346 * Set maximum frame length of specific MAC in FMan driver
2347 *
2348 * Return: 0 on success; Error code otherwise.
2349 */
2350int fman_set_mac_max_frame(struct fman *fman, u8 mac_id, u16 mfl)
2351{
2352        /* if port is already initialized, check that MaxFrameLength is smaller
2353         * or equal to the port's max
2354         */
2355        if ((!fman->state->port_mfl[mac_id]) ||
2356            (mfl <= fman->state->port_mfl[mac_id])) {
2357                fman->state->mac_mfl[mac_id] = mfl;
2358        } else {
2359                dev_warn(fman->dev, "%s: MAC max_frame_length is larger than Port max_frame_length\n",
2360                         __func__);
2361                return -EINVAL;
2362        }
2363        return 0;
2364}
2365EXPORT_SYMBOL(fman_set_mac_max_frame);
2366
2367/**
2368 * fman_get_clock_freq
2369 * @fman:       A Pointer to FMan device
2370 *
2371 * Get FMan clock frequency
2372 *
2373 * Return: FMan clock frequency
2374 */
2375u16 fman_get_clock_freq(struct fman *fman)
2376{
2377        return fman->state->fm_clk_freq;
2378}
2379
2380/**
2381 * fman_get_bmi_max_fifo_size
2382 * @fman:       A Pointer to FMan device
2383 *
2384 * Get FMan maximum FIFO size
2385 *
2386 * Return: FMan Maximum FIFO size
2387 */
2388u32 fman_get_bmi_max_fifo_size(struct fman *fman)
2389{
2390        return fman->state->bmi_max_fifo_size;
2391}
2392EXPORT_SYMBOL(fman_get_bmi_max_fifo_size);
2393
2394/**
2395 * fman_get_revision
2396 * @fman                - Pointer to the FMan module
2397 * @rev_info            - A structure of revision information parameters.
2398 *
2399 * Returns the FM revision
2400 *
2401 * Allowed only following fman_init().
2402 *
2403 * Return: 0 on success; Error code otherwise.
2404 */
2405void fman_get_revision(struct fman *fman, struct fman_rev_info *rev_info)
2406{
2407        u32 tmp;
2408
2409        tmp = ioread32be(&fman->fpm_regs->fm_ip_rev_1);
2410        rev_info->major = (u8)((tmp & FPM_REV1_MAJOR_MASK) >>
2411                                FPM_REV1_MAJOR_SHIFT);
2412        rev_info->minor = tmp & FPM_REV1_MINOR_MASK;
2413}
2414EXPORT_SYMBOL(fman_get_revision);
2415
2416/**
2417 * fman_get_qman_channel_id
2418 * @fman:       A Pointer to FMan device
2419 * @port_id:    Port id
2420 *
2421 * Get QMan channel ID associated to the Port id
2422 *
2423 * Return: QMan channel ID
2424 */
2425u32 fman_get_qman_channel_id(struct fman *fman, u32 port_id)
2426{
2427        int i;
2428
2429        if (fman->state->rev_info.major >= 6) {
2430                u32 port_ids[] = {0x30, 0x31, 0x28, 0x29, 0x2a, 0x2b,
2431                                  0x2c, 0x2d, 0x2, 0x3, 0x4, 0x5, 0x7, 0x7};
2432                for (i = 0; i < fman->state->num_of_qman_channels; i++) {
2433                        if (port_ids[i] == port_id)
2434                                break;
2435                }
2436        } else {
2437                u32 port_ids[] = {0x30, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x1,
2438                                  0x2, 0x3, 0x4, 0x5, 0x7, 0x7};
2439                for (i = 0; i < fman->state->num_of_qman_channels; i++) {
2440                        if (port_ids[i] == port_id)
2441                                break;
2442                }
2443        }
2444
2445        if (i == fman->state->num_of_qman_channels)
2446                return 0;
2447
2448        return fman->state->qman_channel_base + i;
2449}
2450EXPORT_SYMBOL(fman_get_qman_channel_id);
2451
2452/**
2453 * fman_get_mem_region
2454 * @fman:       A Pointer to FMan device
2455 *
2456 * Get FMan memory region
2457 *
2458 * Return: A structure with FMan memory region information
2459 */
2460struct resource *fman_get_mem_region(struct fman *fman)
2461{
2462        return fman->state->res;
2463}
2464EXPORT_SYMBOL(fman_get_mem_region);
2465
2466/* Bootargs defines */
2467/* Extra headroom for RX buffers - Default, min and max */
2468#define FSL_FM_RX_EXTRA_HEADROOM        64
2469#define FSL_FM_RX_EXTRA_HEADROOM_MIN    16
2470#define FSL_FM_RX_EXTRA_HEADROOM_MAX    384
2471
2472/* Maximum frame length */
2473#define FSL_FM_MAX_FRAME_SIZE                   1522
2474#define FSL_FM_MAX_POSSIBLE_FRAME_SIZE          9600
2475#define FSL_FM_MIN_POSSIBLE_FRAME_SIZE          64
2476
2477/* Extra headroom for Rx buffers.
2478 * FMan is instructed to allocate, on the Rx path, this amount of
2479 * space at the beginning of a data buffer, beside the DPA private
2480 * data area and the IC fields.
2481 * Does not impact Tx buffer layout.
2482 * Configurable from bootargs. 64 by default, it's needed on
2483 * particular forwarding scenarios that add extra headers to the
2484 * forwarded frame.
2485 */
2486static int fsl_fm_rx_extra_headroom = FSL_FM_RX_EXTRA_HEADROOM;
2487module_param(fsl_fm_rx_extra_headroom, int, 0);
2488MODULE_PARM_DESC(fsl_fm_rx_extra_headroom, "Extra headroom for Rx buffers");
2489
2490/* Max frame size, across all interfaces.
2491 * Configurable from bootargs, to avoid allocating oversized (socket)
2492 * buffers when not using jumbo frames.
2493 * Must be large enough to accommodate the network MTU, but small enough
2494 * to avoid wasting skb memory.
2495 *
2496 * Could be overridden once, at boot-time, via the
2497 * fm_set_max_frm() callback.
2498 */
2499#ifndef __rtems__
2500static int fsl_fm_max_frm = FSL_FM_MAX_FRAME_SIZE;
2501#else /* __rtems__ */
2502static int fsl_fm_max_frm = FSL_FM_MAX_POSSIBLE_FRAME_SIZE;
2503#endif /* __rtems__ */
2504module_param(fsl_fm_max_frm, int, 0);
2505MODULE_PARM_DESC(fsl_fm_max_frm, "Maximum frame size, across all interfaces");
2506
2507/**
2508 * fman_get_max_frm
2509 *
2510 * Return: Max frame length configured in the FM driver
2511 */
2512u16 fman_get_max_frm(void)
2513{
2514        static bool fm_check_mfl;
2515
2516        if (!fm_check_mfl) {
2517                if (fsl_fm_max_frm > FSL_FM_MAX_POSSIBLE_FRAME_SIZE ||
2518                    fsl_fm_max_frm < FSL_FM_MIN_POSSIBLE_FRAME_SIZE) {
2519                        pr_warn("Invalid fsl_fm_max_frm value (%d) in bootargs, valid range is %d-%d. Falling back to the default (%d)\n",
2520                                fsl_fm_max_frm,
2521                                FSL_FM_MIN_POSSIBLE_FRAME_SIZE,
2522                                FSL_FM_MAX_POSSIBLE_FRAME_SIZE,
2523                                FSL_FM_MAX_FRAME_SIZE);
2524                        fsl_fm_max_frm = FSL_FM_MAX_FRAME_SIZE;
2525                }
2526                fm_check_mfl = true;
2527        }
2528
2529        return fsl_fm_max_frm;
2530}
2531EXPORT_SYMBOL(fman_get_max_frm);
2532
2533/**
2534 * fman_get_rx_extra_headroom
2535 *
2536 * Return: Extra headroom size configured in the FM driver
2537 */
2538int fman_get_rx_extra_headroom(void)
2539{
2540        static bool fm_check_rx_extra_headroom;
2541
2542        if (!fm_check_rx_extra_headroom) {
2543                if (fsl_fm_rx_extra_headroom > FSL_FM_RX_EXTRA_HEADROOM_MAX ||
2544                    fsl_fm_rx_extra_headroom < FSL_FM_RX_EXTRA_HEADROOM_MIN) {
2545                        pr_warn("Invalid fsl_fm_rx_extra_headroom value (%d) in bootargs, valid range is %d-%d. Falling back to the default (%d)\n",
2546                                fsl_fm_rx_extra_headroom,
2547                                FSL_FM_RX_EXTRA_HEADROOM_MIN,
2548                                FSL_FM_RX_EXTRA_HEADROOM_MAX,
2549                                FSL_FM_RX_EXTRA_HEADROOM);
2550                        fsl_fm_rx_extra_headroom = FSL_FM_RX_EXTRA_HEADROOM;
2551                }
2552
2553                fm_check_rx_extra_headroom = true;
2554                fsl_fm_rx_extra_headroom = ALIGN(fsl_fm_rx_extra_headroom, 16);
2555        }
2556
2557        return fsl_fm_rx_extra_headroom;
2558}
2559EXPORT_SYMBOL(fman_get_rx_extra_headroom);
2560
2561/**
2562 * fman_bind
2563 * @dev:        FMan OF device pointer
2564 *
2565 * Bind to a specific FMan device.
2566 *
2567 * Allowed only after the port was created.
2568 *
2569 * Return: A pointer to the FMan device
2570 */
2571struct fman *fman_bind(struct device *fm_dev)
2572{
2573        return (struct fman *)(dev_get_drvdata(get_device(fm_dev)));
2574}
2575EXPORT_SYMBOL(fman_bind);
2576
2577static irqreturn_t fman_err_irq(int irq, void *handle)
2578{
2579        struct fman *fman = (struct fman *)handle;
2580        u32 pending;
2581        struct fman_fpm_regs __iomem *fpm_rg;
2582        irqreturn_t single_ret, ret = IRQ_NONE;
2583
2584        if (!is_init_done(fman->cfg))
2585                return IRQ_NONE;
2586
2587        fpm_rg = fman->fpm_regs;
2588
2589        /* error interrupts */
2590        pending = ioread32be(&fpm_rg->fm_epi);
2591        if (!pending)
2592                return IRQ_NONE;
2593
2594        if (pending & ERR_INTR_EN_BMI) {
2595                single_ret = bmi_err_event(fman);
2596                if (single_ret == IRQ_HANDLED)
2597                        ret = IRQ_HANDLED;
2598        }
2599        if (pending & ERR_INTR_EN_QMI) {
2600                single_ret = qmi_err_event(fman);
2601                if (single_ret == IRQ_HANDLED)
2602                        ret = IRQ_HANDLED;
2603        }
2604        if (pending & ERR_INTR_EN_FPM) {
2605                single_ret = fpm_err_event(fman);
2606                if (single_ret == IRQ_HANDLED)
2607                        ret = IRQ_HANDLED;
2608        }
2609        if (pending & ERR_INTR_EN_DMA) {
2610                single_ret = dma_err_event(fman);
2611                if (single_ret == IRQ_HANDLED)
2612                        ret = IRQ_HANDLED;
2613        }
2614        if (pending & ERR_INTR_EN_MURAM) {
2615                single_ret = muram_err_intr(fman);
2616                if (single_ret == IRQ_HANDLED)
2617                        ret = IRQ_HANDLED;
2618        }
2619
2620        /* MAC error interrupts */
2621        if (pending & ERR_INTR_EN_MAC0) {
2622                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 0);
2623                if (single_ret == IRQ_HANDLED)
2624                        ret = IRQ_HANDLED;
2625        }
2626        if (pending & ERR_INTR_EN_MAC1) {
2627                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 1);
2628                if (single_ret == IRQ_HANDLED)
2629                        ret = IRQ_HANDLED;
2630        }
2631        if (pending & ERR_INTR_EN_MAC2) {
2632                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 2);
2633                if (single_ret == IRQ_HANDLED)
2634                        ret = IRQ_HANDLED;
2635        }
2636        if (pending & ERR_INTR_EN_MAC3) {
2637                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 3);
2638                if (single_ret == IRQ_HANDLED)
2639                        ret = IRQ_HANDLED;
2640        }
2641        if (pending & ERR_INTR_EN_MAC4) {
2642                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 4);
2643                if (single_ret == IRQ_HANDLED)
2644                        ret = IRQ_HANDLED;
2645        }
2646        if (pending & ERR_INTR_EN_MAC5) {
2647                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 5);
2648                if (single_ret == IRQ_HANDLED)
2649                        ret = IRQ_HANDLED;
2650        }
2651        if (pending & ERR_INTR_EN_MAC6) {
2652                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 6);
2653                if (single_ret == IRQ_HANDLED)
2654                        ret = IRQ_HANDLED;
2655        }
2656        if (pending & ERR_INTR_EN_MAC7) {
2657                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 7);
2658                if (single_ret == IRQ_HANDLED)
2659                        ret = IRQ_HANDLED;
2660        }
2661        if (pending & ERR_INTR_EN_MAC8) {
2662                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 8);
2663                if (single_ret == IRQ_HANDLED)
2664                        ret = IRQ_HANDLED;
2665        }
2666        if (pending & ERR_INTR_EN_MAC9) {
2667                single_ret = call_mac_isr(fman, FMAN_EV_ERR_MAC0 + 9);
2668                if (single_ret == IRQ_HANDLED)
2669                        ret = IRQ_HANDLED;
2670        }
2671
2672        return ret;
2673}
2674
2675static irqreturn_t fman_irq(int irq, void *handle)
2676{
2677        struct fman *fman = (struct fman *)handle;
2678        u32 pending;
2679        struct fman_fpm_regs __iomem *fpm_rg;
2680        irqreturn_t single_ret, ret = IRQ_NONE;
2681
2682        if (!is_init_done(fman->cfg))
2683                return IRQ_NONE;
2684
2685        fpm_rg = fman->fpm_regs;
2686
2687        /* normal interrupts */
2688        pending = ioread32be(&fpm_rg->fm_npi);
2689        if (!pending)
2690                return IRQ_NONE;
2691
2692        if (pending & INTR_EN_QMI) {
2693                single_ret = qmi_event(fman);
2694                if (single_ret == IRQ_HANDLED)
2695                        ret = IRQ_HANDLED;
2696        }
2697
2698        /* MAC interrupts */
2699        if (pending & INTR_EN_MAC0) {
2700                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 0);
2701                if (single_ret == IRQ_HANDLED)
2702                        ret = IRQ_HANDLED;
2703        }
2704        if (pending & INTR_EN_MAC1) {
2705                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 1);
2706                if (single_ret == IRQ_HANDLED)
2707                        ret = IRQ_HANDLED;
2708        }
2709        if (pending & INTR_EN_MAC2) {
2710                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 2);
2711                if (single_ret == IRQ_HANDLED)
2712                        ret = IRQ_HANDLED;
2713        }
2714        if (pending & INTR_EN_MAC3) {
2715                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 3);
2716                if (single_ret == IRQ_HANDLED)
2717                        ret = IRQ_HANDLED;
2718        }
2719        if (pending & INTR_EN_MAC4) {
2720                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 4);
2721                if (single_ret == IRQ_HANDLED)
2722                        ret = IRQ_HANDLED;
2723        }
2724        if (pending & INTR_EN_MAC5) {
2725                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 5);
2726                if (single_ret == IRQ_HANDLED)
2727                        ret = IRQ_HANDLED;
2728        }
2729        if (pending & INTR_EN_MAC6) {
2730                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 6);
2731                if (single_ret == IRQ_HANDLED)
2732                        ret = IRQ_HANDLED;
2733        }
2734        if (pending & INTR_EN_MAC7) {
2735                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 7);
2736                if (single_ret == IRQ_HANDLED)
2737                        ret = IRQ_HANDLED;
2738        }
2739        if (pending & INTR_EN_MAC8) {
2740                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 8);
2741                if (single_ret == IRQ_HANDLED)
2742                        ret = IRQ_HANDLED;
2743        }
2744        if (pending & INTR_EN_MAC9) {
2745                single_ret = call_mac_isr(fman, FMAN_EV_MAC0 + 9);
2746                if (single_ret == IRQ_HANDLED)
2747                        ret = IRQ_HANDLED;
2748        }
2749
2750        return ret;
2751}
2752
2753#ifndef __rtems__
2754static const struct of_device_id fman_muram_match[] = {
2755        {
2756                .compatible = "fsl,fman-muram"},
2757        {}
2758};
2759MODULE_DEVICE_TABLE(of, fman_muram_match);
2760#endif /* __rtems__ */
2761
2762static struct fman *read_dts_node(struct platform_device *of_dev)
2763{
2764        struct fman *fman;
2765#ifndef __rtems__
2766        struct device_node *fm_node, *muram_node;
2767        struct resource *res;
2768#else /* __rtems__ */
2769        const char *fdt = bsp_fdt_get();
2770        struct device_node *fm_node;
2771#endif /* __rtems__ */
2772        u32 val, range[2];
2773        int err, irq;
2774#ifndef __rtems__
2775        struct clk *clk;
2776        u32 clk_rate;
2777#endif /* __rtems__ */
2778        phys_addr_t phys_base_addr;
2779#ifndef __rtems__
2780        resource_size_t mem_size;
2781#endif /* __rtems__ */
2782
2783        fman = kzalloc(sizeof(*fman), GFP_KERNEL);
2784        if (!fman)
2785                return NULL;
2786
2787        fm_node = of_node_get(of_dev->dev.of_node);
2788
2789        err = of_property_read_u32(fm_node, "cell-index", &val);
2790        if (err) {
2791                dev_err(&of_dev->dev, "%s: failed to read cell-index for %s\n",
2792                        __func__, fm_node->full_name);
2793                goto fman_node_put;
2794        }
2795        fman->dts_params.id = (u8)val;
2796
2797#ifndef __rtems__
2798        /* Get the FM interrupt */
2799        res = platform_get_resource(of_dev, IORESOURCE_IRQ, 0);
2800        if (!res) {
2801                dev_err(&of_dev->dev, "%s: Can't get FMan IRQ resource\n",
2802                        __func__);
2803                goto fman_node_put;
2804        }
2805        irq = res->start;
2806
2807        /* Get the FM error interrupt */
2808        res = platform_get_resource(of_dev, IORESOURCE_IRQ, 1);
2809        if (!res) {
2810                dev_err(&of_dev->dev, "%s: Can't get FMan Error IRQ resource\n",
2811                        __func__);
2812                goto fman_node_put;
2813        }
2814        fman->dts_params.err_irq = res->start;
2815
2816        /* Get the FM address */
2817        res = platform_get_resource(of_dev, IORESOURCE_MEM, 0);
2818        if (!res) {
2819                dev_err(&of_dev->dev, "%s: Can't get FMan memory resource\n",
2820                        __func__);
2821                goto fman_node_put;
2822        }
2823
2824        phys_base_addr = res->start;
2825        mem_size = resource_size(res);
2826
2827#else /* __rtems__ */
2828        irq = of_irq_to_resource(fm_node, 0, NULL);
2829        fman->dts_params.err_irq = of_irq_to_resource(fm_node, 1, NULL);
2830        phys_base_addr = of_dev->dev.base;
2831        fman->dts_params.base_addr = (void *)(uintptr_t)phys_base_addr;
2832#endif /* __rtems__ */
2833
2834#ifndef __rtems__
2835        clk = of_clk_get(fm_node, 0);
2836        if (IS_ERR(clk)) {
2837                dev_err(&of_dev->dev, "%s: Failed to get FM%d clock structure\n",
2838                        __func__, fman->dts_params.id);
2839                goto fman_node_put;
2840        }
2841
2842        clk_rate = clk_get_rate(clk);
2843        if (!clk_rate) {
2844                dev_err(&of_dev->dev, "%s: Failed to determine FM%d clock rate\n",
2845                        __func__, fman->dts_params.id);
2846                goto fman_node_put;
2847        }
2848        /* Rounding to MHz */
2849        fman->dts_params.clk_freq = DIV_ROUND_UP(clk_rate, 1000000);
2850#else /* __rtems__ */
2851        /* FIXME */
2852        fman->dts_params.clk_freq = 733;
2853#endif /* __rtems__ */
2854
2855        err = of_property_read_u32_array(fm_node, "fsl,qman-channel-range",
2856                                         &range[0], 2);
2857        if (err) {
2858                dev_err(&of_dev->dev, "%s: failed to read fsl,qman-channel-range for %s\n",
2859                        __func__, fm_node->full_name);
2860                goto fman_node_put;
2861        }
2862        fman->dts_params.qman_channel_base = range[0];
2863        fman->dts_params.num_of_qman_channels = range[1];
2864
2865        /* Get the MURAM base address and size */
2866#ifndef __rtems__
2867        /* FIXME */
2868        muram_node = of_find_matching_node(fm_node, fman_muram_match);
2869        if (!muram_node) {
2870                dev_err(&of_dev->dev, "%s: could not find MURAM node\n",
2871                        __func__);
2872                goto fman_node_put;
2873        }
2874
2875        err = of_address_to_resource(muram_node, 0,
2876                                     &fman->dts_params.muram_res);
2877        if (err) {
2878                of_node_put(muram_node);
2879                dev_err(&of_dev->dev, "%s: of_address_to_resource() = %d\n",
2880                        __func__, err);
2881                goto fman_node_put;
2882        }
2883#else /* __rtems__ */
2884        {
2885                int node = fdt_node_offset_by_compatible(fdt,
2886                    fm_node->offset, "fsl,fman-muram");
2887                struct device_node muram_node = {
2888                        .offset = node
2889                };
2890                struct resource res;
2891
2892                err = of_address_to_resource(&muram_node, 0, &res);
2893                if (err != 0) {
2894                        pr_err("could not find MURAM node\n");
2895                        goto fman_node_put;
2896                }
2897                fman->dts_params.muram_res.start = phys_base_addr + res.start;
2898                fman->dts_params.muram_res.end = phys_base_addr + res.end - 1;
2899        }
2900#endif /* __rtems__ */
2901#ifndef __rtems__
2902        of_node_put(muram_node);
2903#endif /* __rtems__ */
2904
2905        err = devm_request_irq(&of_dev->dev, irq, fman_irq, 0, "fman", fman);
2906        if (err < 0) {
2907                dev_err(&of_dev->dev, "%s: irq %d allocation failed (error = %d)\n",
2908                        __func__, irq, err);
2909                goto fman_free;
2910        }
2911
2912        if (fman->dts_params.err_irq != 0) {
2913                err = devm_request_irq(&of_dev->dev, fman->dts_params.err_irq,
2914                                       fman_err_irq, IRQF_SHARED,
2915                                       "fman-err", fman);
2916                if (err < 0) {
2917                        dev_err(&of_dev->dev, "%s: irq %d allocation failed (error = %d)\n",
2918                                __func__, fman->dts_params.err_irq, err);
2919                        goto fman_free;
2920                }
2921        }
2922
2923#ifndef __rtems__
2924        fman->dts_params.res =
2925                devm_request_mem_region(&of_dev->dev, phys_base_addr,
2926                                        mem_size, "fman");
2927        if (!fman->dts_params.res) {
2928                dev_err(&of_dev->dev, "%s: request_mem_region() failed\n",
2929                        __func__);
2930                goto fman_free;
2931        }
2932
2933        fman->dts_params.base_addr =
2934                devm_ioremap(&of_dev->dev, phys_base_addr, mem_size);
2935        if (!fman->dts_params.base_addr) {
2936                dev_err(&of_dev->dev, "%s: devm_ioremap() failed\n", __func__);
2937                goto fman_free;
2938        }
2939
2940        fman->dev = &of_dev->dev;
2941
2942        err = of_platform_populate(fm_node, NULL, NULL, &of_dev->dev);
2943        if (err) {
2944                dev_err(&of_dev->dev, "%s: of_platform_populate() failed\n",
2945                        __func__);
2946                goto fman_free;
2947        }
2948#endif /* __rtems__ */
2949
2950        return fman;
2951
2952fman_node_put:
2953        of_node_put(fm_node);
2954fman_free:
2955        kfree(fman);
2956        return NULL;
2957}
2958
2959static int fman_probe(struct platform_device *of_dev)
2960{
2961        struct fman *fman;
2962        struct device *dev;
2963        int err;
2964
2965        dev = &of_dev->dev;
2966
2967        fman = read_dts_node(of_dev);
2968        if (!fman)
2969                return -EIO;
2970
2971        err = fman_config(fman);
2972        if (err) {
2973                dev_err(dev, "%s: FMan config failed\n", __func__);
2974                return -EINVAL;
2975        }
2976
2977        if (fman_init(fman) != 0) {
2978                dev_err(dev, "%s: FMan init failed\n", __func__);
2979                return -EINVAL;
2980        }
2981
2982        if (fman->dts_params.err_irq == 0) {
2983                fman_set_exception(fman, FMAN_EX_DMA_BUS_ERROR, false);
2984                fman_set_exception(fman, FMAN_EX_DMA_READ_ECC, false);
2985                fman_set_exception(fman, FMAN_EX_DMA_SYSTEM_WRITE_ECC, false);
2986                fman_set_exception(fman, FMAN_EX_DMA_FM_WRITE_ECC, false);
2987                fman_set_exception(fman, FMAN_EX_DMA_SINGLE_PORT_ECC, false);
2988                fman_set_exception(fman, FMAN_EX_FPM_STALL_ON_TASKS, false);
2989                fman_set_exception(fman, FMAN_EX_FPM_SINGLE_ECC, false);
2990                fman_set_exception(fman, FMAN_EX_FPM_DOUBLE_ECC, false);
2991                fman_set_exception(fman, FMAN_EX_QMI_SINGLE_ECC, false);
2992                fman_set_exception(fman, FMAN_EX_QMI_DOUBLE_ECC, false);
2993                fman_set_exception(fman,
2994                                   FMAN_EX_QMI_DEQ_FROM_UNKNOWN_PORTID, false);
2995                fman_set_exception(fman, FMAN_EX_BMI_LIST_RAM_ECC, false);
2996                fman_set_exception(fman, FMAN_EX_BMI_STORAGE_PROFILE_ECC,
2997                                   false);
2998                fman_set_exception(fman, FMAN_EX_BMI_STATISTICS_RAM_ECC, false);
2999                fman_set_exception(fman, FMAN_EX_BMI_DISPATCH_RAM_ECC, false);
3000        }
3001
3002        dev_set_drvdata(dev, fman);
3003
3004        dev_dbg(dev, "FMan%d probed\n", fman->dts_params.id);
3005
3006        return 0;
3007}
3008
3009#ifndef __rtems__
3010static const struct of_device_id fman_match[] = {
3011        {
3012                .compatible = "fsl,fman"},
3013        {}
3014};
3015
3016MODULE_DEVICE_TABLE(of, fman_match);
3017
3018static struct platform_driver fman_driver = {
3019        .driver = {
3020                .name = "fsl-fman",
3021                .of_match_table = fman_match,
3022        },
3023        .probe = fman_probe,
3024};
3025
3026static int __init fman_load(void)
3027{
3028        int err;
3029
3030        pr_debug("FSL DPAA FMan driver\n");
3031
3032        err = platform_driver_register(&fman_driver);
3033        if (err < 0)
3034                pr_err("Error, platform_driver_register() = %d\n", err);
3035
3036        return err;
3037}
3038module_init(fman_load);
3039
3040static void __exit fman_unload(void)
3041{
3042        platform_driver_unregister(&fman_driver);
3043}
3044module_exit(fman_unload);
3045
3046MODULE_LICENSE("Dual BSD/GPL");
3047MODULE_DESCRIPTION("Freescale DPAA Frame Manager driver");
3048#else /* __rtems__ */
3049#include <sys/cdefs.h>
3050#include <sys/param.h>
3051#include <sys/systm.h>
3052#include <sys/bus.h>
3053#include <sys/kernel.h>
3054
3055int
3056fman_reset(struct fman *fman)
3057{
3058
3059        /*
3060         * Ignore errata A007273, since we do not disable the Ethernet MAC
3061         * clocks.
3062         */
3063
3064        out_be32(&fman->fpm_regs->fm_rstc, FPM_RSTC_FM_RESET);
3065        /* Memory barrier */
3066        mb();
3067        usleep_range(100, 300);
3068
3069        if (!!(ioread32be(&fman->qmi_regs->fmqm_gs) &
3070            QMI_GS_HALT_NOT_BUSY)) {
3071                usleep_range(100, 300);
3072        }
3073
3074        return (0);
3075}
3076
3077struct fman_softc {
3078        struct platform_device of_dev;
3079        struct device_node dn;
3080};
3081
3082static int
3083fman_dev_probe_fdt(struct fman_softc *sc, int unit)
3084{
3085        const char *fdt = bsp_fdt_get();
3086        const char *name = "fsl,fman";
3087        int node = 0;
3088
3089        while (1) {
3090                node = fdt_node_offset_by_compatible(fdt, node, name);
3091                if (node >= 0) {
3092                        int len;
3093                        const fdt32_t *p = fdt_getprop(fdt, node, "cell-index", &len);
3094
3095                        if (p != NULL && len == sizeof(*p)) {
3096                                if (fdt32_to_cpu(*p) == (uint32_t)unit) {
3097                                        sc->dn.offset = node;
3098                                        sc->dn.full_name = name;
3099                                        sc->of_dev.dev.of_node = &sc->dn;
3100                                        sc->of_dev.dev.base = (uintptr_t)&qoriq.fman[unit];
3101                                        return (BUS_PROBE_DEFAULT);
3102                                }
3103                        } else {
3104                                return (ENXIO);
3105                        }
3106                } else {
3107                        return (ENXIO);
3108                }
3109        }
3110}
3111
3112static int
3113fman_dev_probe(device_t dev)
3114{
3115        struct fman_softc *sc = device_get_softc(dev);
3116
3117        device_set_desc(dev, "FMan");
3118
3119        return (fman_dev_probe_fdt(sc, device_get_unit(dev)));
3120}
3121
3122static int
3123fman_dev_attach(device_t dev)
3124{
3125        const char *fdt = bsp_fdt_get();
3126        struct fman_softc *sc = device_get_softc(dev);
3127        int node;
3128        int err;
3129
3130        err = fman_probe(&sc->of_dev);
3131        if (err != 0) {
3132                return (ENXIO);
3133        }
3134
3135        node = fdt_first_subnode(fdt, sc->dn.offset);
3136        while (node >= 0) {
3137                struct fman_ivars *ivars =
3138                    kzalloc(sizeof(*ivars), GFP_KERNEL);
3139                device_t child;
3140
3141                if (ivars == NULL) {
3142                        return (ENOMEM);
3143                }
3144
3145                ivars->dn.offset = node;
3146                ivars->of_dev.dev.of_node = &ivars->dn;
3147                ivars->of_dev.dev.base = sc->of_dev.dev.base;
3148                ivars->fman = dev_get_drvdata(&sc->of_dev.dev);
3149
3150                child = device_add_child(dev, NULL, -1);
3151                if (child == NULL) {
3152                        kfree(ivars);
3153                        return (ENOMEM);
3154                }
3155
3156                device_set_ivars(child, ivars);
3157
3158                err = device_probe_and_attach(child);
3159                if (err != 0) {
3160                        kfree(ivars);
3161                }
3162
3163                node = fdt_next_subnode(fdt, node);
3164        }
3165
3166        return (0);
3167}
3168
3169static int
3170fman_dev_detach(device_t dev)
3171{
3172        struct fman_softc *sc = device_get_softc(dev);
3173        int err;
3174
3175        err = bus_generic_detach(dev);
3176        if (err == 0) {
3177                fman_reset(dev_get_drvdata(&sc->of_dev.dev));
3178        }
3179
3180        return (err);
3181}
3182
3183static device_method_t fman_methods[] = {
3184        /* Device interface */
3185        DEVMETHOD(device_probe, fman_dev_probe),
3186        DEVMETHOD(device_attach, fman_dev_attach),
3187        DEVMETHOD(device_detach, fman_dev_detach),
3188        DEVMETHOD(device_suspend, bus_generic_suspend),
3189        DEVMETHOD(device_resume, bus_generic_resume),
3190        DEVMETHOD(device_shutdown, bus_generic_shutdown),
3191
3192        DEVMETHOD_END
3193};
3194
3195driver_t fman_driver = {
3196        .name = "fman",
3197        .methods = fman_methods,
3198        .size = sizeof(struct fman_softc),
3199};
3200
3201static devclass_t fman_devclass;
3202
3203DRIVER_MODULE(fman, nexus, fman_driver, fman_devclass, 0, 0);
3204#endif /* __rtems__ */
Note: See TracBrowser for help on using the repository browser.