]> git.sur5r.net Git - u-boot/blob - drivers/net/sh_eth.h
Merge branch 'master' of git://git.denx.de/u-boot-mpc85xx
[u-boot] / drivers / net / sh_eth.h
1 /*
2  * sh_eth.h - Driver for Renesas SuperH ethernet controler.
3  *
4  * Copyright (C) 2008 - 2012 Renesas Solutions Corp.
5  * Copyright (c) 2008 - 2012 Nobuhiro Iwamatsu
6  * Copyright (c) 2007 Carlos Munoz <carlos@kenati.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #include <netdev.h>
24 #include <asm/types.h>
25
26 #define SHETHER_NAME "sh_eth"
27
28 #if defined(CONFIG_SH)
29 /* Malloc returns addresses in the P1 area (cacheable). However we need to
30    use area P2 (non-cacheable) */
31 #define ADDR_TO_P2(addr)        ((((int)(addr) & ~0xe0000000) | 0xa0000000))
32
33 /* The ethernet controller needs to use physical addresses */
34 #if defined(CONFIG_SH_32BIT)
35 #define ADDR_TO_PHY(addr)       ((((int)(addr) & ~0xe0000000) | 0x40000000))
36 #else
37 #define ADDR_TO_PHY(addr)       ((int)(addr) & ~0xe0000000)
38 #endif
39 #elif defined(CONFIG_ARM)
40 #define inl             readl
41 #define outl    writel
42 #define ADDR_TO_PHY(addr)       ((int)(addr))
43 #define ADDR_TO_P2(addr)        (addr)
44 #endif /* defined(CONFIG_SH) */
45
46 /* Number of supported ports */
47 #define MAX_PORT_NUM    2
48
49 /* Buffers must be big enough to hold the largest ethernet frame. Also, rx
50    buffers must be a multiple of 32 bytes */
51 #define MAX_BUF_SIZE    (48 * 32)
52
53 /* The number of tx descriptors must be large enough to point to 5 or more
54    frames. If each frame uses 2 descriptors, at least 10 descriptors are needed.
55    We use one descriptor per frame */
56 #define NUM_TX_DESC             8
57
58 /* The size of the tx descriptor is determined by how much padding is used.
59    4, 20, or 52 bytes of padding can be used */
60 #define TX_DESC_PADDING         4
61 #define TX_DESC_SIZE            (12 + TX_DESC_PADDING)
62
63 /* Tx descriptor. We always use 3 bytes of padding */
64 struct tx_desc_s {
65         volatile u32 td0;
66         u32 td1;
67         u32 td2;                /* Buffer start */
68         u32 padding;
69 };
70
71 /* There is no limitation in the number of rx descriptors */
72 #define NUM_RX_DESC     8
73
74 /* The size of the rx descriptor is determined by how much padding is used.
75    4, 20, or 52 bytes of padding can be used */
76 #define RX_DESC_PADDING         4
77 #define RX_DESC_SIZE            (12 + RX_DESC_PADDING)
78
79 /* Rx descriptor. We always use 4 bytes of padding */
80 struct rx_desc_s {
81         volatile u32 rd0;
82         volatile u32 rd1;
83         u32 rd2;                /* Buffer start */
84         u32 padding;
85 };
86
87 struct sh_eth_info {
88         struct tx_desc_s *tx_desc_malloc;
89         struct tx_desc_s *tx_desc_base;
90         struct tx_desc_s *tx_desc_cur;
91         struct rx_desc_s *rx_desc_malloc;
92         struct rx_desc_s *rx_desc_base;
93         struct rx_desc_s *rx_desc_cur;
94         u8 *rx_buf_malloc;
95         u8 *rx_buf_base;
96         u8 mac_addr[6];
97         u8 phy_addr;
98         struct eth_device *dev;
99         struct phy_device *phydev;
100 };
101
102 struct sh_eth_dev {
103         int port;
104         struct sh_eth_info port_info[MAX_PORT_NUM];
105 };
106
107 /* from linux/drivers/net/ethernet/renesas/sh_eth.h */
108 enum {
109         /* E-DMAC registers */
110         EDSR = 0,
111         EDMR,
112         EDTRR,
113         EDRRR,
114         EESR,
115         EESIPR,
116         TDLAR,
117         TDFAR,
118         TDFXR,
119         TDFFR,
120         RDLAR,
121         RDFAR,
122         RDFXR,
123         RDFFR,
124         TRSCER,
125         RMFCR,
126         TFTR,
127         FDR,
128         RMCR,
129         EDOCR,
130         TFUCR,
131         RFOCR,
132         FCFTR,
133         RPADIR,
134         TRIMD,
135         RBWAR,
136         TBRAR,
137
138         /* Ether registers */
139         ECMR,
140         ECSR,
141         ECSIPR,
142         PIR,
143         PSR,
144         RDMLR,
145         PIPR,
146         RFLR,
147         IPGR,
148         APR,
149         MPR,
150         PFTCR,
151         PFRCR,
152         RFCR,
153         RFCF,
154         TPAUSER,
155         TPAUSECR,
156         BCFR,
157         BCFRR,
158         GECMR,
159         BCULR,
160         MAHR,
161         MALR,
162         TROCR,
163         CDCR,
164         LCCR,
165         CNDCR,
166         CEFCR,
167         FRECR,
168         TSFRCR,
169         TLFRCR,
170         CERCR,
171         CEECR,
172         MAFCR,
173         RTRATE,
174         CSMR,
175         RMII_MII,
176
177         /* This value must be written at last. */
178         SH_ETH_MAX_REGISTER_OFFSET,
179 };
180
181 static const u16 sh_eth_offset_gigabit[SH_ETH_MAX_REGISTER_OFFSET] = {
182         [EDSR]  = 0x0000,
183         [EDMR]  = 0x0400,
184         [EDTRR] = 0x0408,
185         [EDRRR] = 0x0410,
186         [EESR]  = 0x0428,
187         [EESIPR]        = 0x0430,
188         [TDLAR] = 0x0010,
189         [TDFAR] = 0x0014,
190         [TDFXR] = 0x0018,
191         [TDFFR] = 0x001c,
192         [RDLAR] = 0x0030,
193         [RDFAR] = 0x0034,
194         [RDFXR] = 0x0038,
195         [RDFFR] = 0x003c,
196         [TRSCER]        = 0x0438,
197         [RMFCR] = 0x0440,
198         [TFTR]  = 0x0448,
199         [FDR]   = 0x0450,
200         [RMCR]  = 0x0458,
201         [RPADIR]        = 0x0460,
202         [FCFTR] = 0x0468,
203         [CSMR] = 0x04E4,
204
205         [ECMR]  = 0x0500,
206         [ECSR]  = 0x0510,
207         [ECSIPR]        = 0x0518,
208         [PIR]   = 0x0520,
209         [PSR]   = 0x0528,
210         [PIPR]  = 0x052c,
211         [RFLR]  = 0x0508,
212         [APR]   = 0x0554,
213         [MPR]   = 0x0558,
214         [PFTCR] = 0x055c,
215         [PFRCR] = 0x0560,
216         [TPAUSER]       = 0x0564,
217         [GECMR] = 0x05b0,
218         [BCULR] = 0x05b4,
219         [MAHR]  = 0x05c0,
220         [MALR]  = 0x05c8,
221         [TROCR] = 0x0700,
222         [CDCR]  = 0x0708,
223         [LCCR]  = 0x0710,
224         [CEFCR] = 0x0740,
225         [FRECR] = 0x0748,
226         [TSFRCR]        = 0x0750,
227         [TLFRCR]        = 0x0758,
228         [RFCR]  = 0x0760,
229         [CERCR] = 0x0768,
230         [CEECR] = 0x0770,
231         [MAFCR] = 0x0778,
232         [RMII_MII] =  0x0790,
233 };
234
235 static const u16 sh_eth_offset_fast_sh4[SH_ETH_MAX_REGISTER_OFFSET] = {
236         [ECMR]  = 0x0100,
237         [RFLR]  = 0x0108,
238         [ECSR]  = 0x0110,
239         [ECSIPR]        = 0x0118,
240         [PIR]   = 0x0120,
241         [PSR]   = 0x0128,
242         [RDMLR] = 0x0140,
243         [IPGR]  = 0x0150,
244         [APR]   = 0x0154,
245         [MPR]   = 0x0158,
246         [TPAUSER]       = 0x0164,
247         [RFCF]  = 0x0160,
248         [TPAUSECR]      = 0x0168,
249         [BCFRR] = 0x016c,
250         [MAHR]  = 0x01c0,
251         [MALR]  = 0x01c8,
252         [TROCR] = 0x01d0,
253         [CDCR]  = 0x01d4,
254         [LCCR]  = 0x01d8,
255         [CNDCR] = 0x01dc,
256         [CEFCR] = 0x01e4,
257         [FRECR] = 0x01e8,
258         [TSFRCR]        = 0x01ec,
259         [TLFRCR]        = 0x01f0,
260         [RFCR]  = 0x01f4,
261         [MAFCR] = 0x01f8,
262         [RTRATE]        = 0x01fc,
263
264         [EDMR]  = 0x0000,
265         [EDTRR] = 0x0008,
266         [EDRRR] = 0x0010,
267         [TDLAR] = 0x0018,
268         [RDLAR] = 0x0020,
269         [EESR]  = 0x0028,
270         [EESIPR]        = 0x0030,
271         [TRSCER]        = 0x0038,
272         [RMFCR] = 0x0040,
273         [TFTR]  = 0x0048,
274         [FDR]   = 0x0050,
275         [RMCR]  = 0x0058,
276         [TFUCR] = 0x0064,
277         [RFOCR] = 0x0068,
278         [FCFTR] = 0x0070,
279         [RPADIR]        = 0x0078,
280         [TRIMD] = 0x007c,
281         [RBWAR] = 0x00c8,
282         [RDFAR] = 0x00cc,
283         [TBRAR] = 0x00d4,
284         [TDFAR] = 0x00d8,
285 };
286
287 /* Register Address */
288 #if defined(CONFIG_CPU_SH7763) || defined(CONFIG_CPU_SH7734)
289 #define SH_ETH_TYPE_GETHER
290 #define BASE_IO_ADDR    0xfee00000
291 #elif defined(CONFIG_CPU_SH7757) || defined(CONFIG_CPU_SH7752)
292 #if defined(CONFIG_SH_ETHER_USE_GETHER)
293 #define SH_ETH_TYPE_GETHER
294 #define BASE_IO_ADDR    0xfee00000
295 #else
296 #define SH_ETH_TYPE_ETHER
297 #define BASE_IO_ADDR    0xfef00000
298 #endif
299 #elif defined(CONFIG_CPU_SH7724)
300 #define SH_ETH_TYPE_ETHER
301 #define BASE_IO_ADDR    0xA4600000
302 #elif defined(CONFIG_R8A7740)
303 #define SH_ETH_TYPE_GETHER
304 #define BASE_IO_ADDR    0xE9A00000
305 #endif
306
307 /*
308  * Register's bits
309  * Copy from Linux driver source code
310  */
311 #if defined(SH_ETH_TYPE_GETHER)
312 /* EDSR */
313 enum EDSR_BIT {
314         EDSR_ENT = 0x01, EDSR_ENR = 0x02,
315 };
316 #define EDSR_ENALL (EDSR_ENT|EDSR_ENR)
317 #endif
318
319 /* EDMR */
320 enum DMAC_M_BIT {
321         EDMR_DL1 = 0x20, EDMR_DL0 = 0x10,
322 #if defined(SH_ETH_TYPE_GETHER)
323         EDMR_SRST       = 0x03, /* Receive/Send reset */
324         EMDR_DESC_R     = 0x30, /* Descriptor reserve size */
325         EDMR_EL         = 0x40, /* Litte endian */
326 #elif defined(SH_ETH_TYPE_ETHER)
327         EDMR_SRST       = 0x01,
328         EMDR_DESC_R     = 0x30, /* Descriptor reserve size */
329         EDMR_EL         = 0x40, /* Litte endian */
330 #else
331         EDMR_SRST = 0x01,
332 #endif
333 };
334
335 /* RFLR */
336 #define RFLR_RFL_MIN    0x05EE  /* Recv Frame length 1518 byte */
337
338 /* EDTRR */
339 enum DMAC_T_BIT {
340 #if defined(SH_ETH_TYPE_GETHER)
341         EDTRR_TRNS = 0x03,
342 #else
343         EDTRR_TRNS = 0x01,
344 #endif
345 };
346
347 /* GECMR */
348 enum GECMR_BIT {
349 #if defined(CONFIG_CPU_SH7757) || defined(CONFIG_CPU_SH7752)
350         GECMR_1000B = 0x20, GECMR_100B = 0x01, GECMR_10B = 0x00,
351 #else
352         GECMR_1000B = 0x01, GECMR_100B = 0x04, GECMR_10B = 0x00,
353 #endif
354 };
355
356 /* EDRRR*/
357 enum EDRRR_R_BIT {
358         EDRRR_R = 0x01,
359 };
360
361 /* TPAUSER */
362 enum TPAUSER_BIT {
363         TPAUSER_TPAUSE = 0x0000ffff,
364         TPAUSER_UNLIMITED = 0,
365 };
366
367 /* BCFR */
368 enum BCFR_BIT {
369         BCFR_RPAUSE = 0x0000ffff,
370         BCFR_UNLIMITED = 0,
371 };
372
373 /* PIR */
374 enum PIR_BIT {
375         PIR_MDI = 0x08, PIR_MDO = 0x04, PIR_MMD = 0x02, PIR_MDC = 0x01,
376 };
377
378 /* PSR */
379 enum PHY_STATUS_BIT { PHY_ST_LINK = 0x01, };
380
381 /* EESR */
382 enum EESR_BIT {
383
384 #if defined(SH_ETH_TYPE_ETHER)
385         EESR_TWB  = 0x40000000,
386 #else
387         EESR_TWB  = 0xC0000000,
388         EESR_TC1  = 0x20000000,
389         EESR_TUC  = 0x10000000,
390         EESR_ROC  = 0x80000000,
391 #endif
392         EESR_TABT = 0x04000000,
393         EESR_RABT = 0x02000000, EESR_RFRMER = 0x01000000,
394 #if defined(SH_ETH_TYPE_ETHER)
395         EESR_ADE  = 0x00800000,
396 #endif
397         EESR_ECI  = 0x00400000,
398         EESR_FTC  = 0x00200000, EESR_TDE  = 0x00100000,
399         EESR_TFE  = 0x00080000, EESR_FRC  = 0x00040000,
400         EESR_RDE  = 0x00020000, EESR_RFE  = 0x00010000,
401 #if defined(SH_ETH_TYPE_ETHER)
402         EESR_CND  = 0x00000800,
403 #endif
404         EESR_DLC  = 0x00000400,
405         EESR_CD   = 0x00000200, EESR_RTO  = 0x00000100,
406         EESR_RMAF = 0x00000080, EESR_CEEF = 0x00000040,
407         EESR_CELF = 0x00000020, EESR_RRF  = 0x00000010,
408         rESR_RTLF = 0x00000008, EESR_RTSF = 0x00000004,
409         EESR_PRE  = 0x00000002, EESR_CERF = 0x00000001,
410 };
411
412
413 #if defined(SH_ETH_TYPE_GETHER)
414 # define TX_CHECK (EESR_TC1 | EESR_FTC)
415 # define EESR_ERR_CHECK (EESR_TWB | EESR_TABT | EESR_RABT | EESR_RDE \
416                 | EESR_RFRMER | EESR_TFE | EESR_TDE | EESR_ECI)
417 # define TX_ERROR_CEHCK (EESR_TWB | EESR_TABT | EESR_TDE | EESR_TFE)
418
419 #else
420 # define TX_CHECK (EESR_FTC | EESR_CND | EESR_DLC | EESR_CD | EESR_RTO)
421 # define EESR_ERR_CHECK (EESR_TWB | EESR_TABT | EESR_RABT | EESR_RDE \
422                 | EESR_RFRMER | EESR_ADE | EESR_TFE | EESR_TDE | EESR_ECI)
423 # define TX_ERROR_CEHCK (EESR_TWB | EESR_TABT | EESR_ADE | EESR_TDE | EESR_TFE)
424 #endif
425
426 /* EESIPR */
427 enum DMAC_IM_BIT {
428         DMAC_M_TWB = 0x40000000, DMAC_M_TABT = 0x04000000,
429         DMAC_M_RABT = 0x02000000,
430         DMAC_M_RFRMER = 0x01000000, DMAC_M_ADF = 0x00800000,
431         DMAC_M_ECI = 0x00400000, DMAC_M_FTC = 0x00200000,
432         DMAC_M_TDE = 0x00100000, DMAC_M_TFE = 0x00080000,
433         DMAC_M_FRC = 0x00040000, DMAC_M_RDE = 0x00020000,
434         DMAC_M_RFE = 0x00010000, DMAC_M_TINT4 = 0x00000800,
435         DMAC_M_TINT3 = 0x00000400, DMAC_M_TINT2 = 0x00000200,
436         DMAC_M_TINT1 = 0x00000100, DMAC_M_RINT8 = 0x00000080,
437         DMAC_M_RINT5 = 0x00000010, DMAC_M_RINT4 = 0x00000008,
438         DMAC_M_RINT3 = 0x00000004, DMAC_M_RINT2 = 0x00000002,
439         DMAC_M_RINT1 = 0x00000001,
440 };
441
442 /* Receive descriptor bit */
443 enum RD_STS_BIT {
444         RD_RACT = 0x80000000, RD_RDLE = 0x40000000,
445         RD_RFP1 = 0x20000000, RD_RFP0 = 0x10000000,
446         RD_RFE = 0x08000000, RD_RFS10 = 0x00000200,
447         RD_RFS9 = 0x00000100, RD_RFS8 = 0x00000080,
448         RD_RFS7 = 0x00000040, RD_RFS6 = 0x00000020,
449         RD_RFS5 = 0x00000010, RD_RFS4 = 0x00000008,
450         RD_RFS3 = 0x00000004, RD_RFS2 = 0x00000002,
451         RD_RFS1 = 0x00000001,
452 };
453 #define RDF1ST  RD_RFP1
454 #define RDFEND  RD_RFP0
455 #define RD_RFP  (RD_RFP1|RD_RFP0)
456
457 /* RDFFR*/
458 enum RDFFR_BIT {
459         RDFFR_RDLF = 0x01,
460 };
461
462 /* FCFTR */
463 enum FCFTR_BIT {
464         FCFTR_RFF2 = 0x00040000, FCFTR_RFF1 = 0x00020000,
465         FCFTR_RFF0 = 0x00010000, FCFTR_RFD2 = 0x00000004,
466         FCFTR_RFD1 = 0x00000002, FCFTR_RFD0 = 0x00000001,
467 };
468 #define FIFO_F_D_RFF    (FCFTR_RFF2|FCFTR_RFF1|FCFTR_RFF0)
469 #define FIFO_F_D_RFD    (FCFTR_RFD2|FCFTR_RFD1|FCFTR_RFD0)
470
471 /* Transfer descriptor bit */
472 enum TD_STS_BIT {
473 #if defined(SH_ETH_TYPE_GETHER) || defined(SH_ETH_TYPE_ETHER)
474         TD_TACT = 0x80000000,
475 #else
476         TD_TACT = 0x7fffffff,
477 #endif
478         TD_TDLE = 0x40000000, TD_TFP1 = 0x20000000,
479         TD_TFP0 = 0x10000000,
480 };
481 #define TDF1ST  TD_TFP1
482 #define TDFEND  TD_TFP0
483 #define TD_TFP  (TD_TFP1|TD_TFP0)
484
485 /* RMCR */
486 enum RECV_RST_BIT { RMCR_RST = 0x01, };
487 /* ECMR */
488 enum FELIC_MODE_BIT {
489 #if defined(SH_ETH_TYPE_GETHER)
490         ECMR_TRCCM=0x04000000, ECMR_RCSC= 0x00800000, ECMR_DPAD= 0x00200000,
491         ECMR_RZPF = 0x00100000,
492 #endif
493         ECMR_ZPF = 0x00080000, ECMR_PFR = 0x00040000, ECMR_RXF = 0x00020000,
494         ECMR_TXF = 0x00010000, ECMR_MCT = 0x00002000, ECMR_PRCEF = 0x00001000,
495         ECMR_PMDE = 0x00000200, ECMR_RE = 0x00000040, ECMR_TE = 0x00000020,
496         ECMR_ILB = 0x00000008, ECMR_ELB = 0x00000004, ECMR_DM = 0x00000002,
497         ECMR_PRM = 0x00000001,
498 #ifdef CONFIG_CPU_SH7724
499         ECMR_RTM = 0x00000010,
500 #endif
501
502 };
503
504 #if defined(SH_ETH_TYPE_GETHER)
505 #define ECMR_CHG_DM     (ECMR_TRCCM | ECMR_RZPF | ECMR_ZPF | ECMR_PFR | ECMR_RXF | \
506                                                 ECMR_TXF | ECMR_MCT)
507 #elif defined(SH_ETH_TYPE_ETHER)
508 #define ECMR_CHG_DM (ECMR_ZPF | ECMR_PFR | ECMR_RXF | ECMR_TXF)
509 #else
510 #define ECMR_CHG_DM     (ECMR_ZPF | ECMR_PFR | ECMR_RXF | ECMR_TXF | ECMR_MCT)
511 #endif
512
513 /* ECSR */
514 enum ECSR_STATUS_BIT {
515 #if defined(SH_ETH_TYPE_ETHER)
516         ECSR_BRCRX = 0x20, ECSR_PSRTO = 0x10,
517 #endif
518         ECSR_LCHNG = 0x04,
519         ECSR_MPD = 0x02, ECSR_ICD = 0x01,
520 };
521
522 #if defined(SH_ETH_TYPE_GETHER)
523 # define ECSR_INIT (ECSR_ICD | ECSIPR_MPDIP)
524 #else
525 # define ECSR_INIT (ECSR_BRCRX | ECSR_PSRTO | \
526                         ECSR_LCHNG | ECSR_ICD | ECSIPR_MPDIP)
527 #endif
528
529 /* ECSIPR */
530 enum ECSIPR_STATUS_MASK_BIT {
531 #if defined(SH_ETH_TYPE_ETHER)
532         ECSIPR_BRCRXIP = 0x20,
533         ECSIPR_PSRTOIP = 0x10,
534 #elif defined(SH_ETY_TYPE_GETHER)
535         ECSIPR_PSRTOIP = 0x10,
536         ECSIPR_PHYIP = 0x08,
537 #endif
538         ECSIPR_LCHNGIP = 0x04,
539         ECSIPR_MPDIP = 0x02,
540         ECSIPR_ICDIP = 0x01,
541 };
542
543 #if defined(SH_ETH_TYPE_GETHER)
544 # define ECSIPR_INIT (ECSIPR_LCHNGIP | ECSIPR_ICDIP | ECSIPR_MPDIP)
545 #else
546 # define ECSIPR_INIT (ECSIPR_BRCRXIP | ECSIPR_PSRTOIP | ECSIPR_LCHNGIP | \
547                                 ECSIPR_ICDIP | ECSIPR_MPDIP)
548 #endif
549
550 /* APR */
551 enum APR_BIT {
552         APR_AP = 0x00000004,
553 };
554
555 /* MPR */
556 enum MPR_BIT {
557         MPR_MP = 0x00000006,
558 };
559
560 /* TRSCER */
561 enum DESC_I_BIT {
562         DESC_I_TINT4 = 0x0800, DESC_I_TINT3 = 0x0400, DESC_I_TINT2 = 0x0200,
563         DESC_I_TINT1 = 0x0100, DESC_I_RINT8 = 0x0080, DESC_I_RINT5 = 0x0010,
564         DESC_I_RINT4 = 0x0008, DESC_I_RINT3 = 0x0004, DESC_I_RINT2 = 0x0002,
565         DESC_I_RINT1 = 0x0001,
566 };
567
568 /* RPADIR */
569 enum RPADIR_BIT {
570         RPADIR_PADS1 = 0x20000, RPADIR_PADS0 = 0x10000,
571         RPADIR_PADR = 0x0003f,
572 };
573
574 #if defined(SH_ETH_TYPE_GETHER)
575 # define RPADIR_INIT (0x00)
576 #else
577 # define RPADIR_INIT (RPADIR_PADS1)
578 #endif
579
580 /* FDR */
581 enum FIFO_SIZE_BIT {
582         FIFO_SIZE_T = 0x00000700, FIFO_SIZE_R = 0x00000007,
583 };
584
585 static inline unsigned long sh_eth_reg_addr(struct sh_eth_dev *eth,
586                                             int enum_index)
587 {
588 #if defined(SH_ETH_TYPE_GETHER)
589         const u16 *reg_offset = sh_eth_offset_gigabit;
590 #elif defined(SH_ETH_TYPE_ETHER)
591         const u16 *reg_offset = sh_eth_offset_fast_sh4;
592 #else
593 #error
594 #endif
595         return BASE_IO_ADDR + reg_offset[enum_index] + 0x800 * eth->port;
596 }
597
598 static inline void sh_eth_write(struct sh_eth_dev *eth, unsigned long data,
599                                 int enum_index)
600 {
601         outl(data, sh_eth_reg_addr(eth, enum_index));
602 }
603
604 static inline unsigned long sh_eth_read(struct sh_eth_dev *eth,
605                                         int enum_index)
606 {
607         return inl(sh_eth_reg_addr(eth, enum_index));
608 }