git.oblomov.eu Git - linux-2.6/blob - arch/mips/momentum/ocelot_3/platform.c

   1 #include <linux/delay.h>
   2 #include <linux/if_ether.h>
   3 #include <linux/ioport.h>
   4 #include <linux/mv643xx.h>
   5 #include <linux/platform_device.h>
   6
   7 #include "ocelot_3_fpga.h"
   8
   9 #if defined(CONFIG_MV643XX_ETH) || defined(CONFIG_MV643XX_ETH_MODULE)
  10
  11 static struct resource mv643xx_eth_shared_resources[] = {
  12         [0] = {
  13                 .name   = "ethernet shared base",
  14                 .start  = 0xf1000000 + MV643XX_ETH_SHARED_REGS,
  15                 .end    = 0xf1000000 + MV643XX_ETH_SHARED_REGS +
  16                                        MV643XX_ETH_SHARED_REGS_SIZE - 1,
  17                 .flags  = IORESOURCE_MEM,
  18         },
  19 };
  20
  21 static struct platform_device mv643xx_eth_shared_device = {
  22         .name           = MV643XX_ETH_SHARED_NAME,
  23         .id             = 0,
  24         .num_resources  = ARRAY_SIZE(mv643xx_eth_shared_resources),
  25         .resource       = mv643xx_eth_shared_resources,
  26 };
  27
  28 #define MV_SRAM_BASE                    0xfe000000UL
  29 #define MV_SRAM_SIZE                    (256 * 1024)
  30
  31 #define MV_SRAM_RXRING_SIZE             (MV_SRAM_SIZE / 4)
  32 #define MV_SRAM_TXRING_SIZE             (MV_SRAM_SIZE / 4)
  33
  34 #define MV_SRAM_BASE_ETH0               MV_SRAM_BASE
  35 #define MV_SRAM_BASE_ETH1               (MV_SRAM_BASE + (MV_SRAM_SIZE / 2))
  36
  37 #define MV64x60_IRQ_ETH_0 48
  38 #define MV64x60_IRQ_ETH_1 49
  39 #define MV64x60_IRQ_ETH_2 50
  40
  41 static struct resource mv64x60_eth0_resources[] = {
  42         [0] = {
  43                 .name   = "eth0 irq",
  44                 .start  = MV64x60_IRQ_ETH_0,
  45                 .end    = MV64x60_IRQ_ETH_0,
  46                 .flags  = IORESOURCE_IRQ,
  47         },
  48 };
  49
  50 static char eth0_mac_addr[ETH_ALEN];
  51
  52 static struct mv643xx_eth_platform_data eth0_pd = {
  53         .mac_addr       = eth0_mac_addr,
  54
  55         .tx_sram_addr   = MV_SRAM_BASE_ETH0,
  56         .tx_sram_size   = MV_SRAM_TXRING_SIZE,
  57         .tx_queue_size  = MV_SRAM_TXRING_SIZE / 16,
  58
  59         .rx_sram_addr   = MV_SRAM_BASE_ETH0 + MV_SRAM_TXRING_SIZE,
  60         .rx_sram_size   = MV_SRAM_RXRING_SIZE,
  61         .rx_queue_size  = MV_SRAM_RXRING_SIZE / 16,
  62 };
  63
  64 static struct platform_device eth0_device = {
  65         .name           = MV643XX_ETH_NAME,
  66         .id             = 0,
  67         .num_resources  = ARRAY_SIZE(mv64x60_eth0_resources),
  68         .resource       = mv64x60_eth0_resources,
  69         .dev = {
  70                 .platform_data = &eth0_pd,
  71         },
  72 };
  73
  74 static struct resource mv64x60_eth1_resources[] = {
  75         [0] = {
  76                 .name   = "eth1 irq",
  77                 .start  = MV64x60_IRQ_ETH_1,
  78                 .end    = MV64x60_IRQ_ETH_1,
  79                 .flags  = IORESOURCE_IRQ,
  80         },
  81 };
  82
  83 static char eth1_mac_addr[ETH_ALEN];
  84
  85 static struct mv643xx_eth_platform_data eth1_pd = {
  86         .mac_addr       = eth1_mac_addr,
  87
  88         .tx_sram_addr   = MV_SRAM_BASE_ETH1,
  89         .tx_sram_size   = MV_SRAM_TXRING_SIZE,
  90         .tx_queue_size  = MV_SRAM_TXRING_SIZE / 16,
  91
  92         .rx_sram_addr   = MV_SRAM_BASE_ETH1 + MV_SRAM_TXRING_SIZE,
  93         .rx_sram_size   = MV_SRAM_RXRING_SIZE,
  94         .rx_queue_size  = MV_SRAM_RXRING_SIZE / 16,
  95 };
  96
  97 static struct platform_device eth1_device = {
  98         .name           = MV643XX_ETH_NAME,
  99         .id             = 1,
 100         .num_resources  = ARRAY_SIZE(mv64x60_eth1_resources),
 101         .resource       = mv64x60_eth1_resources,
 102         .dev = {
 103                 .platform_data = &eth1_pd,
 104         },
 105 };
 106
 107 static struct resource mv64x60_eth2_resources[] = {
 108         [0] = {
 109                 .name   = "eth2 irq",
 110                 .start  = MV64x60_IRQ_ETH_2,
 111                 .end    = MV64x60_IRQ_ETH_2,
 112                 .flags  = IORESOURCE_IRQ,
 113         },
 114 };
 115
 116 static char eth2_mac_addr[ETH_ALEN];
 117
 118 static struct mv643xx_eth_platform_data eth2_pd = {
 119         .mac_addr       = eth2_mac_addr,
 120 };
 121
 122 static struct platform_device eth2_device = {
 123         .name           = MV643XX_ETH_NAME,
 124         .id             = 2,
 125         .num_resources  = ARRAY_SIZE(mv64x60_eth2_resources),
 126         .resource       = mv64x60_eth2_resources,
 127         .dev = {
 128                 .platform_data = &eth2_pd,
 129         },
 130 };
 131
 132 static struct platform_device *mv643xx_eth_pd_devs[] __initdata = {
 133         &mv643xx_eth_shared_device,
 134         &eth0_device,
 135         &eth1_device,
 136         &eth2_device,
 137 };
 138
 139 static u8 __init exchange_bit(u8 val, u8 cs)
 140 {
 141         /* place the data */
 142         OCELOT_FPGA_WRITE((val << 2) | cs, EEPROM_MODE);
 143         udelay(1);
 144
 145         /* turn the clock on */
 146         OCELOT_FPGA_WRITE((val << 2) | cs | 0x2, EEPROM_MODE);
 147         udelay(1);
 148
 149         /* turn the clock off and read-strobe */
 150         OCELOT_FPGA_WRITE((val << 2) | cs | 0x10, EEPROM_MODE);
 151
 152         /* return the data */
 153         return (OCELOT_FPGA_READ(EEPROM_MODE) >> 3) & 0x1;
 154 }
 155
 156 static void __init get_mac(char dest[6])
 157 {
 158         u8 read_opcode[12] = {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 159         int i,j;
 160
 161         for (i = 0; i < 12; i++)
 162                 exchange_bit(read_opcode[i], 1);
 163
 164         for (j = 0; j < 6; j++) {
 165                 dest[j] = 0;
 166                 for (i = 0; i < 8; i++) {
 167                         dest[j] <<= 1;
 168                         dest[j] |= exchange_bit(0, 1);
 169                 }
 170         }
 171
 172         /* turn off CS */
 173         exchange_bit(0,0);
 174 }
 175
 176 /*
 177  * Copy and increment ethernet MAC address by a small value.
 178  *
 179  * This is useful for systems where the only one MAC address is stored in
 180  * non-volatile memory for multiple ports.
 181  */
 182 static inline void eth_mac_add(unsigned char *dst, unsigned char *src,
 183         unsigned int add)
 184 {
 185         int i;
 186
 187         BUG_ON(add >= 256);
 188
 189         for (i = ETH_ALEN; i >= 0; i--) {
 190                 dst[i] = src[i] + add;
 191                 add = dst[i] < src[i];          /* compute carry */
 192         }
 193
 194         WARN_ON(add);
 195 }
 196
 197 static int __init mv643xx_eth_add_pds(void)
 198 {
 199         unsigned char mac[ETH_ALEN];
 200         int ret;
 201
 202         get_mac(mac);
 203         eth_mac_add(eth0_mac_addr, mac, 0);
 204         eth_mac_add(eth1_mac_addr, mac, 1);
 205         eth_mac_add(eth2_mac_addr, mac, 2);
 206         ret = platform_add_devices(mv643xx_eth_pd_devs,
 207                         ARRAY_SIZE(mv643xx_eth_pd_devs));
 208
 209         return ret;
 210 }
 211
 212 device_initcall(mv643xx_eth_add_pds);
 213
 214 #endif /* defined(CONFIG_MV643XX_ETH) || defined(CONFIG_MV643XX_ETH_MODULE) */