drivers/ks8695eth.c

   1 /*
   2  * ks8695eth.c -- KS8695 ethernet driver
   3  *
   4  * (C) Copyright 2004-2005, Greg Ungerer <greg.ungerer@opengear.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /****************************************************************************/
  22
  23 #include <common.h>
  24
  25 #ifdef  CONFIG_DRIVER_KS8695ETH
  26 #include <malloc.h>
  27 #include <net.h>
  28 #include <asm/io.h>
  29 #include <asm/arch/platform.h>
  30
  31 /****************************************************************************/
  32
  33 /*
  34  * Hardware register access to the KS8695 LAN ethernet port
  35  * (well, it is the 4 port switch really).
  36  */
  37 #define ks8695_read(a)    *((volatile unsigned long *) (KS8695_IO_BASE + (a)))
  38 #define ks8695_write(a,v) *((volatile unsigned long *) (KS8695_IO_BASE + (a))) = (v)
  39
  40 /****************************************************************************/
  41
  42 /*
  43  * Define the descriptor in-memory data structures.
  44  */
  45 struct ks8695_txdesc {
  46         uint32_t        owner;
  47         uint32_t        ctrl;
  48         uint32_t        addr;
  49         uint32_t        next;
  50 };
  51
  52 struct ks8695_rxdesc {
  53         uint32_t        status;
  54         uint32_t        ctrl;
  55         uint32_t        addr;
  56         uint32_t        next;
  57 };
  58
  59 /****************************************************************************/
  60
  61 /*
  62  * Allocate local data structures to use for receiving and sending
  63  * packets. Just to keep it all nice and simple.
  64  */
  65
  66 #define TXDESCS         4
  67 #define RXDESCS         4
  68 #define BUFSIZE         2048
  69
  70 volatile struct ks8695_txdesc ks8695_tx[TXDESCS] __attribute__((aligned(256)));
  71 volatile struct ks8695_rxdesc ks8695_rx[RXDESCS] __attribute__((aligned(256)));
  72 volatile uint8_t ks8695_bufs[BUFSIZE*(TXDESCS+RXDESCS)] __attribute__((aligned(2048)));;
  73
  74 /****************************************************************************/
  75
  76 /*
  77  *      Ideally we want to use the MAC address stored in flash.
  78  *      But we do some sanity checks in case they are not present
  79  *      first.
  80  */
  81 unsigned char eth_mac[] = {
  82         0x00, 0x13, 0xc6, 0x00, 0x00, 0x00
  83 };
  84
  85 void ks8695_getmac(void)
  86 {
  87         unsigned char *fp;
  88         int i;
  89
  90         /* Check if flash MAC is valid */
  91         fp = (unsigned char *) 0x0201c000;
  92         for (i = 0; (i < 6); i++) {
  93                 if ((fp[i] != 0) && (fp[i] != 0xff))
  94                         break;
  95         }
  96
  97         /* If we found a valid looking MAC address then use it */
  98         if (i < 6)
  99                 memcpy(&eth_mac[0], fp, 6);
 100 }
 101
 102 /****************************************************************************/
 103
 104 void eth_reset(bd_t *bd)
 105 {
 106         int i;
 107
 108         debug ("%s(%d): eth_reset()\n", __FILE__, __LINE__);
 109
 110         /* Reset the ethernet engines first */
 111         ks8695_write(KS8695_LAN_DMA_TX, 0x80000000);
 112         ks8695_write(KS8695_LAN_DMA_RX, 0x80000000);
 113
 114         ks8695_getmac();
 115
 116         /* Set MAC address */
 117         ks8695_write(KS8695_LAN_MAC_LOW, (eth_mac[5] | (eth_mac[4] << 8) |
 118                 (eth_mac[3] << 16) | (eth_mac[2] << 24)));
 119         ks8695_write(KS8695_LAN_MAC_HIGH, (eth_mac[1] | (eth_mac[0] << 8)));
 120
 121         /* Turn the 4 port switch on */
 122         i = ks8695_read(KS8695_SWITCH_CTRL0);
 123         ks8695_write(KS8695_SWITCH_CTRL0, (i | 0x1));
 124         /* ks8695_write(KS8695_WAN_CONTROL, 0x3f000066); */
 125
 126         /* Initialize descriptor rings */
 127         for (i = 0; (i < TXDESCS); i++) {
 128                 ks8695_tx[i].owner = 0;
 129                 ks8695_tx[i].ctrl = 0;
 130                 ks8695_tx[i].addr = (uint32_t) &ks8695_bufs[i*BUFSIZE];
 131                 ks8695_tx[i].next = (uint32_t) &ks8695_tx[i+1];
 132         }
 133         ks8695_tx[TXDESCS-1].ctrl = 0x02000000;
 134         ks8695_tx[TXDESCS-1].next = (uint32_t) &ks8695_tx[0];
 135
 136         for (i = 0; (i < RXDESCS); i++) {
 137                 ks8695_rx[i].status = 0x80000000;
 138                 ks8695_rx[i].ctrl = BUFSIZE - 4;
 139                 ks8695_rx[i].addr = (uint32_t) &ks8695_bufs[(i+TXDESCS)*BUFSIZE];
 140                 ks8695_rx[i].next = (uint32_t) &ks8695_rx[i+1];
 141         }
 142         ks8695_rx[RXDESCS-1].ctrl |= 0x00080000;
 143         ks8695_rx[RXDESCS-1].next = (uint32_t) &ks8695_rx[0];
 144
 145         /* The KS8695 is pretty slow reseting the ethernets... */
 146         udelay(2000000);
 147
 148         /* Enable the ethernet engine */
 149         ks8695_write(KS8695_LAN_TX_LIST, (uint32_t) &ks8695_tx[0]);
 150         ks8695_write(KS8695_LAN_RX_LIST, (uint32_t) &ks8695_rx[0]);
 151         ks8695_write(KS8695_LAN_DMA_TX, 0x3);
 152         ks8695_write(KS8695_LAN_DMA_RX, 0x71);
 153         ks8695_write(KS8695_LAN_DMA_RX_START, 0x1);
 154
 155         printf("KS8695 ETHERNET: ");
 156         for (i = 0; (i < 5); i++) {
 157                 bd->bi_enetaddr[i] = eth_mac[i];
 158                 printf("%02x:", eth_mac[i]);
 159         }
 160         bd->bi_enetaddr[i] = eth_mac[i];
 161         printf("%02x\n", eth_mac[i]);
 162 }
 163
 164 /****************************************************************************/
 165
 166 int eth_init(bd_t *bd)
 167 {
 168         debug ("%s(%d): eth_init()\n", __FILE__, __LINE__);
 169
 170         eth_reset(bd);
 171         return 0;
 172 }
 173
 174 /****************************************************************************/
 175
 176 void eth_halt(void)
 177 {
 178         debug ("%s(%d): eth_halt()\n", __FILE__, __LINE__);
 179
 180         /* Reset the ethernet engines */
 181         ks8695_write(KS8695_LAN_DMA_TX, 0x80000000);
 182         ks8695_write(KS8695_LAN_DMA_RX, 0x80000000);
 183 }
 184
 185 /****************************************************************************/
 186
 187 int eth_rx(void)
 188 {
 189         volatile struct ks8695_rxdesc *dp;
 190         int i, len = 0;
 191
 192         debug ("%s(%d): eth_rx()\n", __FILE__, __LINE__);
 193
 194         for (i = 0; (i < RXDESCS); i++) {
 195                 dp= &ks8695_rx[i];
 196                 if ((dp->status & 0x80000000) == 0) {
 197                         len = (dp->status & 0x7ff) - 4;
 198                         NetReceive((void *) dp->addr, len);
 199                         dp->status = 0x80000000;
 200                         ks8695_write(KS8695_LAN_DMA_RX_START, 0x1);
 201                         break;
 202                 }
 203         }
 204
 205         return len;
 206 }
 207
 208 /****************************************************************************/
 209
 210 int eth_send(volatile void *packet, int len)
 211 {
 212         volatile struct ks8695_txdesc *dp;
 213         static int next = 0;
 214
 215         debug ("%s(%d): eth_send(packet=%x,len=%d)\n", __FILE__, __LINE__,
 216                 packet, len);
 217
 218         dp = &ks8695_tx[next];
 219         memcpy((void *) dp->addr, (void *) packet, len);
 220
 221         if (len < 64) {
 222                 memset((void *) (dp->addr + len), 0, 64-len);
 223                 len = 64;
 224         }
 225
 226         dp->ctrl = len | 0xe0000000;
 227         dp->owner = 0x80000000;
 228
 229         ks8695_write(KS8695_LAN_DMA_TX, 0x3);
 230         ks8695_write(KS8695_LAN_DMA_TX_START, 0x1);
 231
 232         if (++next >= TXDESCS)
 233                 next = 0;
 234
 235         return len;
 236 }
 237
 238 #endif  /* CONFIG_DRIVER_KS8695ETH */