2 * Hitachi (now Renesas) SCA-II HD64572 driver for Linux
4 * Copyright (C) 1998-2008 Krzysztof Halasa <khc@pm.waw.pl>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of version 2 of the GNU General Public License
8 * as published by the Free Software Foundation.
10 * Source of information: HD64572 SCA-II User's Manual
12 * We use the following SCA memory map:
14 * Packet buffer descriptor rings - starting from winbase or win0base:
15 * rx_ring_buffers * sizeof(pkt_desc) = logical channel #0 RX ring
16 * tx_ring_buffers * sizeof(pkt_desc) = logical channel #0 TX ring
17 * rx_ring_buffers * sizeof(pkt_desc) = logical channel #1 RX ring (if used)
18 * tx_ring_buffers * sizeof(pkt_desc) = logical channel #1 TX ring (if used)
20 * Packet data buffers - starting from winbase + buff_offset:
21 * rx_ring_buffers * HDLC_MAX_MRU = logical channel #0 RX buffers
22 * tx_ring_buffers * HDLC_MAX_MRU = logical channel #0 TX buffers
23 * rx_ring_buffers * HDLC_MAX_MRU = logical channel #0 RX buffers (if used)
24 * tx_ring_buffers * HDLC_MAX_MRU = logical channel #0 TX buffers (if used)
27 #include <linux/bitops.h>
28 #include <linux/errno.h>
29 #include <linux/fcntl.h>
30 #include <linux/hdlc.h>
32 #include <linux/init.h>
33 #include <linux/interrupt.h>
34 #include <linux/ioport.h>
35 #include <linux/jiffies.h>
36 #include <linux/kernel.h>
37 #include <linux/module.h>
38 #include <linux/netdevice.h>
39 #include <linux/skbuff.h>
40 #include <linux/slab.h>
41 #include <linux/string.h>
42 #include <linux/types.h>
44 #include <asm/system.h>
45 #include <asm/uaccess.h>
48 #define NAPI_WEIGHT 16
50 #define get_msci(port) (phy_node(port) ? MSCI1_OFFSET : MSCI0_OFFSET)
51 #define get_dmac_rx(port) (phy_node(port) ? DMAC1RX_OFFSET : DMAC0RX_OFFSET)
52 #define get_dmac_tx(port) (phy_node(port) ? DMAC1TX_OFFSET : DMAC0TX_OFFSET)
54 static int sca_poll(struct napi_struct
*napi
, int budget
);
56 static inline struct net_device
*port_to_dev(port_t
*port
)
61 static inline port_t
* dev_to_port(struct net_device
*dev
)
63 return dev_to_hdlc(dev
)->priv
;
66 static inline void enable_intr(port_t
*port
)
68 /* enable DMIB and MSCI RXINTA interrupts */
69 sca_outl(sca_inl(IER0
, port
->card
) |
70 (phy_node(port
) ? 0x08002200 : 0x00080022), IER0
, port
->card
);
73 static inline void disable_intr(port_t
*port
)
75 sca_outl(sca_inl(IER0
, port
->card
) &
76 (phy_node(port
) ? 0x00FF00FF : 0xFF00FF00), IER0
, port
->card
);
79 static inline u16
next_desc(port_t
*port
, u16 desc
, int transmit
)
81 return (desc
+ 1) % (transmit
? port_to_card(port
)->tx_ring_buffers
82 : port_to_card(port
)->rx_ring_buffers
);
86 static inline u16
desc_abs_number(port_t
*port
, u16 desc
, int transmit
)
88 u16 rx_buffs
= port_to_card(port
)->rx_ring_buffers
;
89 u16 tx_buffs
= port_to_card(port
)->tx_ring_buffers
;
91 desc
%= (transmit
? tx_buffs
: rx_buffs
); // called with "X + 1" etc.
92 return log_node(port
) * (rx_buffs
+ tx_buffs
) +
93 transmit
* rx_buffs
+ desc
;
97 static inline u16
desc_offset(port_t
*port
, u16 desc
, int transmit
)
99 /* Descriptor offset always fits in 16 bytes */
100 return desc_abs_number(port
, desc
, transmit
) * sizeof(pkt_desc
);
104 static inline pkt_desc __iomem
*desc_address(port_t
*port
, u16 desc
,
107 return (pkt_desc __iomem
*)(winbase(port_to_card(port
))
108 + desc_offset(port
, desc
, transmit
));
112 static inline u32
buffer_offset(port_t
*port
, u16 desc
, int transmit
)
114 return port_to_card(port
)->buff_offset
+
115 desc_abs_number(port
, desc
, transmit
) * (u32
)HDLC_MAX_MRU
;
119 static inline void sca_set_carrier(port_t
*port
)
121 if (!(sca_in(get_msci(port
) + ST3
, port_to_card(port
)) & ST3_DCD
)) {
123 printk(KERN_DEBUG
"%s: sca_set_carrier on\n",
124 port_to_dev(port
)->name
);
126 netif_carrier_on(port_to_dev(port
));
129 printk(KERN_DEBUG
"%s: sca_set_carrier off\n",
130 port_to_dev(port
)->name
);
132 netif_carrier_off(port_to_dev(port
));
137 static void sca_init_port(port_t
*port
)
139 card_t
*card
= port_to_card(port
);
146 for (transmit
= 0; transmit
< 2; transmit
++) {
147 u16 dmac
= transmit
? get_dmac_tx(port
) : get_dmac_rx(port
);
148 u16 buffs
= transmit
? card
->tx_ring_buffers
149 : card
->rx_ring_buffers
;
151 for (i
= 0; i
< buffs
; i
++) {
152 pkt_desc __iomem
*desc
= desc_address(port
, i
, transmit
);
153 u16 chain_off
= desc_offset(port
, i
+ 1, transmit
);
154 u32 buff_off
= buffer_offset(port
, i
, transmit
);
156 writel(chain_off
, &desc
->cp
);
157 writel(buff_off
, &desc
->bp
);
158 writew(0, &desc
->len
);
159 writeb(0, &desc
->stat
);
162 /* DMA disable - to halt state */
163 sca_out(0, transmit
? DSR_TX(phy_node(port
)) :
164 DSR_RX(phy_node(port
)), card
);
165 /* software ABORT - to initial state */
166 sca_out(DCR_ABORT
, transmit
? DCR_TX(phy_node(port
)) :
167 DCR_RX(phy_node(port
)), card
);
169 /* current desc addr */
170 sca_outl(desc_offset(port
, 0, transmit
), dmac
+ CDAL
, card
);
172 sca_outl(desc_offset(port
, buffs
- 1, transmit
),
175 sca_outl(desc_offset(port
, 0, transmit
), dmac
+ EDAL
,
178 /* clear frame end interrupt counter */
179 sca_out(DCR_CLEAR_EOF
, transmit
? DCR_TX(phy_node(port
)) :
180 DCR_RX(phy_node(port
)), card
);
182 if (!transmit
) { /* Receive */
183 /* set buffer length */
184 sca_outw(HDLC_MAX_MRU
, dmac
+ BFLL
, card
);
185 /* Chain mode, Multi-frame */
186 sca_out(0x14, DMR_RX(phy_node(port
)), card
);
187 sca_out(DIR_EOME
, DIR_RX(phy_node(port
)), card
);
189 sca_out(DSR_DE
, DSR_RX(phy_node(port
)), card
);
190 } else { /* Transmit */
191 /* Chain mode, Multi-frame */
192 sca_out(0x14, DMR_TX(phy_node(port
)), card
);
193 /* enable underflow interrupts */
194 sca_out(DIR_EOME
, DIR_TX(phy_node(port
)), card
);
197 sca_set_carrier(port
);
198 netif_napi_add(port_to_dev(port
), &port
->napi
, sca_poll
, NAPI_WEIGHT
);
202 /* MSCI interrupt service */
203 static inline void sca_msci_intr(port_t
*port
)
205 u16 msci
= get_msci(port
);
206 card_t
* card
= port_to_card(port
);
208 if (sca_in(msci
+ ST1
, card
) & ST1_CDCD
) {
209 /* Reset MSCI CDCD status bit */
210 sca_out(ST1_CDCD
, msci
+ ST1
, card
);
211 sca_set_carrier(port
);
216 static inline void sca_rx(card_t
*card
, port_t
*port
, pkt_desc __iomem
*desc
,
219 struct net_device
*dev
= port_to_dev(port
);
224 len
= readw(&desc
->len
);
225 skb
= dev_alloc_skb(len
);
227 dev
->stats
.rx_dropped
++;
231 buff
= buffer_offset(port
, rxin
, 0);
232 memcpy_fromio(skb
->data
, winbase(card
) + buff
, len
);
236 printk(KERN_DEBUG
"%s RX(%i):", dev
->name
, skb
->len
);
239 dev
->stats
.rx_packets
++;
240 dev
->stats
.rx_bytes
+= skb
->len
;
241 skb
->protocol
= hdlc_type_trans(skb
, dev
);
242 netif_receive_skb(skb
);
246 /* Receive DMA service */
247 static inline int sca_rx_done(port_t
*port
, int budget
)
249 struct net_device
*dev
= port_to_dev(port
);
250 u16 dmac
= get_dmac_rx(port
);
251 card_t
*card
= port_to_card(port
);
252 u8 stat
= sca_in(DSR_RX(phy_node(port
)), card
); /* read DMA Status */
255 /* Reset DSR status bits */
256 sca_out((stat
& (DSR_EOT
| DSR_EOM
| DSR_BOF
| DSR_COF
)) | DSR_DWE
,
257 DSR_RX(phy_node(port
)), card
);
260 /* Dropped one or more frames */
261 dev
->stats
.rx_over_errors
++;
263 while (received
< budget
) {
264 u32 desc_off
= desc_offset(port
, port
->rxin
, 0);
265 pkt_desc __iomem
*desc
;
266 u32 cda
= sca_inl(dmac
+ CDAL
, card
);
268 if ((cda
>= desc_off
) && (cda
< desc_off
+ sizeof(pkt_desc
)))
269 break; /* No frame received */
271 desc
= desc_address(port
, port
->rxin
, 0);
272 stat
= readb(&desc
->stat
);
273 if (!(stat
& ST_RX_EOM
))
274 port
->rxpart
= 1; /* partial frame received */
275 else if ((stat
& ST_ERROR_MASK
) || port
->rxpart
) {
276 dev
->stats
.rx_errors
++;
277 if (stat
& ST_RX_OVERRUN
)
278 dev
->stats
.rx_fifo_errors
++;
279 else if ((stat
& (ST_RX_SHORT
| ST_RX_ABORT
|
280 ST_RX_RESBIT
)) || port
->rxpart
)
281 dev
->stats
.rx_frame_errors
++;
282 else if (stat
& ST_RX_CRC
)
283 dev
->stats
.rx_crc_errors
++;
284 if (stat
& ST_RX_EOM
)
285 port
->rxpart
= 0; /* received last fragment */
287 sca_rx(card
, port
, desc
, port
->rxin
);
291 /* Set new error descriptor address */
292 sca_outl(desc_off
, dmac
+ EDAL
, card
);
293 port
->rxin
= next_desc(port
, port
->rxin
, 0);
296 /* make sure RX DMA is enabled */
297 sca_out(DSR_DE
, DSR_RX(phy_node(port
)), card
);
302 /* Transmit DMA service */
303 static inline void sca_tx_done(port_t
*port
)
305 struct net_device
*dev
= port_to_dev(port
);
306 card_t
* card
= port_to_card(port
);
309 spin_lock(&port
->lock
);
311 stat
= sca_in(DSR_TX(phy_node(port
)), card
); /* read DMA Status */
313 /* Reset DSR status bits */
314 sca_out((stat
& (DSR_EOT
| DSR_EOM
| DSR_BOF
| DSR_COF
)) | DSR_DWE
,
315 DSR_TX(phy_node(port
)), card
);
318 pkt_desc __iomem
*desc
= desc_address(port
, port
->txlast
, 1);
319 u8 stat
= readb(&desc
->stat
);
321 if (!(stat
& ST_TX_OWNRSHP
))
322 break; /* not yet transmitted */
323 if (stat
& ST_TX_UNDRRUN
) {
324 dev
->stats
.tx_errors
++;
325 dev
->stats
.tx_fifo_errors
++;
327 dev
->stats
.tx_packets
++;
328 dev
->stats
.tx_bytes
+= readw(&desc
->len
);
330 writeb(0, &desc
->stat
); /* Free descriptor */
331 port
->txlast
= next_desc(port
, port
->txlast
, 1);
334 netif_wake_queue(dev
);
335 spin_unlock(&port
->lock
);
339 static int sca_poll(struct napi_struct
*napi
, int budget
)
341 port_t
*port
= container_of(napi
, port_t
, napi
);
342 u32 isr0
= sca_inl(ISR0
, port
->card
);
345 if (isr0
& (port
->phy_node
? 0x08000000 : 0x00080000))
348 if (isr0
& (port
->phy_node
? 0x00002000 : 0x00000020))
351 if (isr0
& (port
->phy_node
? 0x00000200 : 0x00000002))
352 received
= sca_rx_done(port
, budget
);
354 if (received
< budget
) {
355 netif_rx_complete(port
->dev
, napi
);
362 static irqreturn_t
sca_intr(int irq
, void *dev_id
)
364 card_t
*card
= dev_id
;
365 u32 isr0
= sca_inl(ISR0
, card
);
368 for (i
= 0; i
< 2; i
++) {
369 port_t
*port
= get_port(card
, i
);
370 if (port
&& (isr0
& (i
? 0x08002200 : 0x00080022))) {
373 netif_rx_schedule(port
->dev
, &port
->napi
);
377 return IRQ_RETVAL(handled
);
381 static void sca_set_port(port_t
*port
)
383 card_t
* card
= port_to_card(port
);
384 u16 msci
= get_msci(port
);
385 u8 md2
= sca_in(msci
+ MD2
, card
);
386 unsigned int tmc
, br
= 10, brv
= 1024;
389 if (port
->settings
.clock_rate
> 0) {
390 /* Try lower br for better accuracy*/
393 brv
>>= 1; /* brv = 2^9 = 512 max in specs */
395 /* Baud Rate = CLOCK_BASE / TMC / 2^BR */
396 tmc
= CLOCK_BASE
/ brv
/ port
->settings
.clock_rate
;
397 }while (br
> 1 && tmc
<= 128);
401 br
= 0; /* For baud=CLOCK_BASE we use tmc=1 br=0 */
403 } else if (tmc
> 255)
404 tmc
= 256; /* tmc=0 means 256 - low baud rates */
406 port
->settings
.clock_rate
= CLOCK_BASE
/ brv
/ tmc
;
408 br
= 9; /* Minimum clock rate */
409 tmc
= 256; /* 8bit = 0 */
410 port
->settings
.clock_rate
= CLOCK_BASE
/ (256 * 512);
413 port
->rxs
= (port
->rxs
& ~CLK_BRG_MASK
) | br
;
414 port
->txs
= (port
->txs
& ~CLK_BRG_MASK
) | br
;
417 /* baud divisor - time constant*/
418 sca_out(port
->tmc
, msci
+ TMCR
, card
);
419 sca_out(port
->tmc
, msci
+ TMCT
, card
);
422 sca_out(port
->rxs
, msci
+ RXS
, card
);
423 sca_out(port
->txs
, msci
+ TXS
, card
);
425 if (port
->settings
.loopback
)
428 md2
&= ~MD2_LOOPBACK
;
430 sca_out(md2
, msci
+ MD2
, card
);
435 static void sca_open(struct net_device
*dev
)
437 port_t
*port
= dev_to_port(dev
);
438 card_t
* card
= port_to_card(port
);
439 u16 msci
= get_msci(port
);
442 switch(port
->encoding
) {
443 case ENCODING_NRZ
: md2
= MD2_NRZ
; break;
444 case ENCODING_NRZI
: md2
= MD2_NRZI
; break;
445 case ENCODING_FM_MARK
: md2
= MD2_FM_MARK
; break;
446 case ENCODING_FM_SPACE
: md2
= MD2_FM_SPACE
; break;
447 default: md2
= MD2_MANCHESTER
;
450 if (port
->settings
.loopback
)
453 switch(port
->parity
) {
454 case PARITY_CRC16_PR0
: md0
= MD0_HDLC
| MD0_CRC_16_0
; break;
455 case PARITY_CRC16_PR1
: md0
= MD0_HDLC
| MD0_CRC_16
; break;
456 case PARITY_CRC32_PR1_CCITT
: md0
= MD0_HDLC
| MD0_CRC_ITU32
; break;
457 case PARITY_CRC16_PR1_CCITT
: md0
= MD0_HDLC
| MD0_CRC_ITU
; break;
458 default: md0
= MD0_HDLC
| MD0_CRC_NONE
;
461 sca_out(CMD_RESET
, msci
+ CMD
, card
);
462 sca_out(md0
, msci
+ MD0
, card
);
463 sca_out(0x00, msci
+ MD1
, card
); /* no address field check */
464 sca_out(md2
, msci
+ MD2
, card
);
465 sca_out(0x7E, msci
+ IDL
, card
); /* flag character 0x7E */
466 /* Skip the rest of underrun frame */
467 sca_out(CTL_IDLE
| CTL_URCT
| CTL_URSKP
, msci
+ CTL
, card
);
468 sca_out(0x0F, msci
+ RNR
, card
); /* +1=RX DMA activation condition */
469 sca_out(0x3C, msci
+ TFS
, card
); /* +1 = TX start */
470 sca_out(0x38, msci
+ TCR
, card
); /* =Critical TX DMA activ condition */
471 sca_out(0x38, msci
+ TNR0
, card
); /* =TX DMA activation condition */
472 sca_out(0x3F, msci
+ TNR1
, card
); /* +1=TX DMA deactivation condition*/
474 /* We're using the following interrupts:
475 - RXINTA (DCD changes only)
476 - DMIB (EOM - single frame transfer complete)
478 sca_outl(IE0_RXINTA
| IE0_CDCD
, msci
+ IE0
, card
);
480 sca_out(port
->tmc
, msci
+ TMCR
, card
);
481 sca_out(port
->tmc
, msci
+ TMCT
, card
);
482 sca_out(port
->rxs
, msci
+ RXS
, card
);
483 sca_out(port
->txs
, msci
+ TXS
, card
);
484 sca_out(CMD_TX_ENABLE
, msci
+ CMD
, card
);
485 sca_out(CMD_RX_ENABLE
, msci
+ CMD
, card
);
487 sca_set_carrier(port
);
489 napi_enable(&port
->napi
);
490 netif_start_queue(dev
);
494 static void sca_close(struct net_device
*dev
)
496 port_t
*port
= dev_to_port(dev
);
499 sca_out(CMD_RESET
, get_msci(port
) + CMD
, port_to_card(port
));
501 napi_disable(&port
->napi
);
502 netif_stop_queue(dev
);
506 static int sca_attach(struct net_device
*dev
, unsigned short encoding
,
507 unsigned short parity
)
509 if (encoding
!= ENCODING_NRZ
&&
510 encoding
!= ENCODING_NRZI
&&
511 encoding
!= ENCODING_FM_MARK
&&
512 encoding
!= ENCODING_FM_SPACE
&&
513 encoding
!= ENCODING_MANCHESTER
)
516 if (parity
!= PARITY_NONE
&&
517 parity
!= PARITY_CRC16_PR0
&&
518 parity
!= PARITY_CRC16_PR1
&&
519 parity
!= PARITY_CRC32_PR1_CCITT
&&
520 parity
!= PARITY_CRC16_PR1_CCITT
)
523 dev_to_port(dev
)->encoding
= encoding
;
524 dev_to_port(dev
)->parity
= parity
;
530 static void sca_dump_rings(struct net_device
*dev
)
532 port_t
*port
= dev_to_port(dev
);
533 card_t
*card
= port_to_card(port
);
536 printk(KERN_DEBUG
"RX ring: CDA=%u EDA=%u DSR=%02X in=%u %sactive",
537 sca_inl(get_dmac_rx(port
) + CDAL
, card
),
538 sca_inl(get_dmac_rx(port
) + EDAL
, card
),
539 sca_in(DSR_RX(phy_node(port
)), card
), port
->rxin
,
540 sca_in(DSR_RX(phy_node(port
)), card
) & DSR_DE
? "" : "in");
541 for (cnt
= 0; cnt
< port_to_card(port
)->rx_ring_buffers
; cnt
++)
542 printk(" %02X", readb(&(desc_address(port
, cnt
, 0)->stat
)));
544 printk("\n" KERN_DEBUG
"TX ring: CDA=%u EDA=%u DSR=%02X in=%u "
546 sca_inl(get_dmac_tx(port
) + CDAL
, card
),
547 sca_inl(get_dmac_tx(port
) + EDAL
, card
),
548 sca_in(DSR_TX(phy_node(port
)), card
), port
->txin
, port
->txlast
,
549 sca_in(DSR_TX(phy_node(port
)), card
) & DSR_DE
? "" : "in");
551 for (cnt
= 0; cnt
< port_to_card(port
)->tx_ring_buffers
; cnt
++)
552 printk(" %02X", readb(&(desc_address(port
, cnt
, 1)->stat
)));
555 printk(KERN_DEBUG
"MSCI: MD: %02x %02x %02x,"
556 " ST: %02x %02x %02x %02x %02x, FST: %02x CST: %02x %02x\n",
557 sca_in(get_msci(port
) + MD0
, card
),
558 sca_in(get_msci(port
) + MD1
, card
),
559 sca_in(get_msci(port
) + MD2
, card
),
560 sca_in(get_msci(port
) + ST0
, card
),
561 sca_in(get_msci(port
) + ST1
, card
),
562 sca_in(get_msci(port
) + ST2
, card
),
563 sca_in(get_msci(port
) + ST3
, card
),
564 sca_in(get_msci(port
) + ST4
, card
),
565 sca_in(get_msci(port
) + FST
, card
),
566 sca_in(get_msci(port
) + CST0
, card
),
567 sca_in(get_msci(port
) + CST1
, card
));
569 printk(KERN_DEBUG
"ILAR: %02x ISR: %08x %08x\n", sca_in(ILAR
, card
),
570 sca_inl(ISR0
, card
), sca_inl(ISR1
, card
));
572 #endif /* DEBUG_RINGS */
575 static int sca_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
577 port_t
*port
= dev_to_port(dev
);
578 card_t
*card
= port_to_card(port
);
579 pkt_desc __iomem
*desc
;
582 spin_lock_irq(&port
->lock
);
584 desc
= desc_address(port
, port
->txin
+ 1, 1);
585 BUG_ON(readb(&desc
->stat
)); /* previous xmit should stop queue */
588 printk(KERN_DEBUG
"%s TX(%i):", dev
->name
, skb
->len
);
592 desc
= desc_address(port
, port
->txin
, 1);
593 buff
= buffer_offset(port
, port
->txin
, 1);
595 memcpy_toio(winbase(card
) + buff
, skb
->data
, len
);
597 writew(len
, &desc
->len
);
598 writeb(ST_TX_EOM
, &desc
->stat
);
599 dev
->trans_start
= jiffies
;
601 port
->txin
= next_desc(port
, port
->txin
, 1);
602 sca_outl(desc_offset(port
, port
->txin
, 1),
603 get_dmac_tx(port
) + EDAL
, card
);
605 sca_out(DSR_DE
, DSR_TX(phy_node(port
)), card
); /* Enable TX DMA */
607 desc
= desc_address(port
, port
->txin
+ 1, 1);
608 if (readb(&desc
->stat
)) /* allow 1 packet gap */
609 netif_stop_queue(dev
);
611 spin_unlock_irq(&port
->lock
);
618 static u32 __devinit
sca_detect_ram(card_t
*card
, u8 __iomem
*rambase
,
621 /* Round RAM size to 32 bits, fill from end to start */
622 u32 i
= ramsize
&= ~3;
626 writel(i
^ 0x12345678, rambase
+ i
);
629 for (i
= 0; i
< ramsize
; i
+= 4) {
630 if (readl(rambase
+ i
) != (i
^ 0x12345678))
638 static void __devinit
sca_init(card_t
*card
, int wait_states
)
640 sca_out(wait_states
, WCRL
, card
); /* Wait Control */
641 sca_out(wait_states
, WCRM
, card
);
642 sca_out(wait_states
, WCRH
, card
);
644 sca_out(0, DMER
, card
); /* DMA Master disable */
645 sca_out(0x03, PCR
, card
); /* DMA priority */
646 sca_out(0, DSR_RX(0), card
); /* DMA disable - to halt state */
647 sca_out(0, DSR_TX(0), card
);
648 sca_out(0, DSR_RX(1), card
);
649 sca_out(0, DSR_TX(1), card
);
650 sca_out(DMER_DME
, DMER
, card
); /* DMA Master enable */
This page took 0.066151 seconds and 6 git commands to generate.