target/linux/ar71xx/files/arch/mips/ar71xx/platform.c

   1 /*
   2  *  Atheros AR71xx SoC platform devices
   3  *
   4  *  Copyright (C) 2008 Gabor Juhos <juhosg@openwrt.org>
   5  *  Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org>
   6  *
   7  *  Parts of this file are based on Atheros' 2.6.15 BSP
   8  *
   9  *  This program is free software; you can redistribute it and/or modify it
  10  *  under the terms of the GNU General Public License version 2 as published
  11  *  by the Free Software Foundation.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/delay.h>
  17 #include <linux/dma-mapping.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/serial_8250.h>
  20
  21 #include <asm/mips_machine.h>
  22 #include <asm/mach-ar71xx/ar71xx.h>
  23 #include <asm/mach-ar71xx/platform.h>
  24
  25 static u8 ar71xx_mac_base[ETH_ALEN] __initdata;
  26
  27 /*
  28  * OHCI (USB full speed host controller)
  29  */
  30 static struct resource ar71xx_usb_ohci_resources[] = {
  31         [0] = {
  32                 .start  = AR71XX_OHCI_BASE,
  33                 .end    = AR71XX_OHCI_BASE + AR71XX_OHCI_SIZE - 1,
  34                 .flags  = IORESOURCE_MEM,
  35         },
  36         [1] = {
  37                 .start  = AR71XX_MISC_IRQ_OHCI,
  38                 .end    = AR71XX_MISC_IRQ_OHCI,
  39                 .flags  = IORESOURCE_IRQ,
  40         },
  41 };
  42
  43 static u64 ar71xx_ohci_dmamask = DMA_BIT_MASK(32);
  44 static struct platform_device ar71xx_usb_ohci_device = {
  45         .name           = "ar71xx-ohci",
  46         .id             = -1,
  47         .resource       = ar71xx_usb_ohci_resources,
  48         .num_resources  = ARRAY_SIZE(ar71xx_usb_ohci_resources),
  49         .dev = {
  50                 .dma_mask               = &ar71xx_ohci_dmamask,
  51                 .coherent_dma_mask      = DMA_BIT_MASK(32),
  52         },
  53 };
  54
  55 /*
  56  * EHCI (USB full speed host controller)
  57  */
  58 static struct resource ar71xx_usb_ehci_resources[] = {
  59         [0] = {
  60                 .start  = AR71XX_EHCI_BASE,
  61                 .end    = AR71XX_EHCI_BASE + AR71XX_EHCI_SIZE - 1,
  62                 .flags  = IORESOURCE_MEM,
  63         },
  64         [1] = {
  65                 .start  = AR71XX_CPU_IRQ_USB,
  66                 .end    = AR71XX_CPU_IRQ_USB,
  67                 .flags  = IORESOURCE_IRQ,
  68         },
  69 };
  70
  71 static u64 ar71xx_ehci_dmamask = DMA_BIT_MASK(32);
  72 static struct platform_device ar71xx_usb_ehci_device = {
  73         .name           = "ar71xx-ehci",
  74         .id             = -1,
  75         .resource       = ar71xx_usb_ehci_resources,
  76         .num_resources  = ARRAY_SIZE(ar71xx_usb_ehci_resources),
  77         .dev = {
  78                 .dma_mask               = &ar71xx_ehci_dmamask,
  79                 .coherent_dma_mask      = DMA_BIT_MASK(32),
  80         },
  81 };
  82
  83 #define AR71XX_USB_RESET_MASK \
  84         (RESET_MODULE_USB_HOST | RESET_MODULE_USB_PHY \
  85         | RESET_MODULE_USB_OHCI_DLL)
  86
  87 void __init ar71xx_add_device_usb(void)
  88 {
  89         ar71xx_device_stop(AR71XX_USB_RESET_MASK);
  90         mdelay(1000);
  91         ar71xx_device_start(AR71XX_USB_RESET_MASK);
  92
  93         /* Turning on the Buff and Desc swap bits */
  94         ar71xx_usb_ctrl_wr(USB_CTRL_REG_CONFIG, 0xf0000);
  95
  96         /* WAR for HW bug. Here it adjusts the duration between two SOFS */
  97         ar71xx_usb_ctrl_wr(USB_CTRL_REG_FLADJ, 0x20c00);
  98
  99         mdelay(900);
 100
 101         platform_device_register(&ar71xx_usb_ohci_device);
 102         platform_device_register(&ar71xx_usb_ehci_device);
 103 }
 104
 105 #ifdef CONFIG_AR71XX_EARLY_SERIAL
 106 static void __init ar71xx_add_device_uart(void) {};
 107 #else
 108 static struct resource ar71xx_uart_resources[] = {
 109         {
 110                 .start  = AR71XX_UART_BASE,
 111                 .end    = AR71XX_UART_BASE + AR71XX_UART_SIZE - 1,
 112                 .flags  = IORESOURCE_MEM,
 113         },
 114 };
 115
 116 #define AR71XX_UART_FLAGS (UPF_BOOT_AUTOCONF | UPF_SKIP_TEST | UPF_IOREMAP)
 117 static struct plat_serial8250_port ar71xx_uart_data[] = {
 118         {
 119                 .mapbase        = AR71XX_UART_BASE,
 120                 .irq            = AR71XX_MISC_IRQ_UART,
 121                 .flags          = AR71XX_UART_FLAGS,
 122                 .iotype         = UPIO_MEM32,
 123                 .regshift       = 2,
 124         }, {
 125                 /* terminating entry */
 126         }
 127 };
 128
 129 static struct platform_device ar71xx_uart_device = {
 130         .name           = "serial8250",
 131         .id             = PLAT8250_DEV_PLATFORM,
 132         .resource       = ar71xx_uart_resources,
 133         .num_resources  = ARRAY_SIZE(ar71xx_uart_resources),
 134         .dev = {
 135                 .platform_data  = ar71xx_uart_data
 136         },
 137 };
 138
 139 static void __init ar71xx_add_device_uart(void)
 140 {
 141         ar71xx_uart_data[0].uartclk = ar71xx_ahb_freq;
 142         platform_device_register(&ar71xx_uart_device);
 143 }
 144 #endif /* CONFIG_AR71XX_EARLY_SERIAL */
 145
 146 static struct resource ar71xx_mdio_resources[] = {
 147         {
 148                 .name   = "mdio_base",
 149                 .flags  = IORESOURCE_MEM,
 150                 .start  = AR71XX_GE0_BASE + 0x20,
 151                 .end    = AR71XX_GE0_BASE + 0x38 - 1,
 152         }
 153 };
 154
 155 static struct ag71xx_mdio_platform_data ar71xx_mdio_data = {
 156         .phy_mask       = 0xffffffff,
 157 };
 158
 159 static struct platform_device ar71xx_mdio_device = {
 160         .name           = "ag71xx-mdio",
 161         .id             = -1,
 162         .resource       = ar71xx_mdio_resources,
 163         .num_resources  = ARRAY_SIZE(ar71xx_mdio_resources),
 164         .dev = {
 165                 .platform_data = &ar71xx_mdio_data,
 166         },
 167 };
 168
 169 void __init ar71xx_add_device_mdio(u32 phy_mask)
 170 {
 171         ar71xx_mdio_data.phy_mask = phy_mask;
 172         platform_device_register(&ar71xx_mdio_device);
 173 }
 174
 175 static struct resource ar71xx_eth0_resources[] = {
 176         {
 177                 .name   = "mac_base",
 178                 .flags  = IORESOURCE_MEM,
 179                 .start  = AR71XX_GE0_BASE,
 180                 .end    = AR71XX_GE0_BASE + 0x20 - 1,
 181         }, {
 182                 .name   = "mac_base2",
 183                 .flags  = IORESOURCE_MEM,
 184                 .start  = AR71XX_GE0_BASE + 0x38,
 185                 .end    = AR71XX_GE0_BASE + 0x200 - 1,
 186         }, {
 187                 .name   = "mii_ctrl",
 188                 .flags  = IORESOURCE_MEM,
 189                 .start  = AR71XX_MII_BASE + MII_REG_MII0_CTRL,
 190                 .end    = AR71XX_MII_BASE + MII_REG_MII0_CTRL + 3,
 191         }, {
 192                 .name   = "mac_irq",
 193                 .flags  = IORESOURCE_IRQ,
 194                 .start  = AR71XX_CPU_IRQ_GE0,
 195                 .end    = AR71XX_CPU_IRQ_GE0,
 196         },
 197 };
 198
 199 static struct ag71xx_platform_data ar71xx_eth0_data = {
 200         .reset_bit      = RESET_MODULE_GE0_MAC,
 201         .flush_reg      = DDR_REG_FLUSH_GE0,
 202 };
 203
 204 static struct platform_device ar71xx_eth0_device = {
 205         .name           = "ag71xx",
 206         .id             = 0,
 207         .resource       = ar71xx_eth0_resources,
 208         .num_resources  = ARRAY_SIZE(ar71xx_eth0_resources),
 209         .dev = {
 210                 .platform_data = &ar71xx_eth0_data,
 211         },
 212 };
 213
 214 static struct resource ar71xx_eth1_resources[] = {
 215         {
 216                 .name   = "mac_base",
 217                 .flags  = IORESOURCE_MEM,
 218                 .start  = AR71XX_GE1_BASE,
 219                 .end    = AR71XX_GE1_BASE + 0x20 - 1,
 220         }, {
 221                 .name   = "mac_base2",
 222                 .flags  = IORESOURCE_MEM,
 223                 .start  = AR71XX_GE1_BASE + 0x38,
 224                 .end    = AR71XX_GE1_BASE + 0x200 - 1,
 225         }, {
 226                 .name   = "mii_ctrl",
 227                 .flags  = IORESOURCE_MEM,
 228                 .start  = AR71XX_MII_BASE + MII_REG_MII1_CTRL,
 229                 .end    = AR71XX_MII_BASE + MII_REG_MII1_CTRL + 3,
 230         }, {
 231                 .name   = "mac_irq",
 232                 .flags  = IORESOURCE_IRQ,
 233                 .start  = AR71XX_CPU_IRQ_GE1,
 234                 .end    = AR71XX_CPU_IRQ_GE1,
 235         },
 236 };
 237
 238 static struct ag71xx_platform_data ar71xx_eth1_data = {
 239         .reset_bit      = RESET_MODULE_GE1_MAC,
 240         .flush_reg      = DDR_REG_FLUSH_GE1,
 241 };
 242
 243 static struct platform_device ar71xx_eth1_device = {
 244         .name           = "ag71xx",
 245         .id             = 1,
 246         .resource       = ar71xx_eth1_resources,
 247         .num_resources  = ARRAY_SIZE(ar71xx_eth1_resources),
 248         .dev = {
 249                 .platform_data = &ar71xx_eth1_data,
 250         },
 251 };
 252
 253 static int ar71xx_eth_instance __initdata;
 254 void __init ar71xx_add_device_eth(unsigned int id, phy_interface_t phy_if_mode,
 255                                 u32 phy_mask)
 256 {
 257         struct platform_device *pdev;
 258
 259         switch (id) {
 260         case 0:
 261                 switch (phy_if_mode) {
 262                 case PHY_INTERFACE_MODE_MII:
 263                         ar71xx_eth0_data.mii_if = MII0_CTRL_IF_MII;
 264                         break;
 265                 case PHY_INTERFACE_MODE_GMII:
 266                         ar71xx_eth0_data.mii_if = MII0_CTRL_IF_GMII;
 267                         break;
 268                 case PHY_INTERFACE_MODE_RGMII:
 269                         ar71xx_eth0_data.mii_if = MII0_CTRL_IF_RGMII;
 270                         break;
 271                 case PHY_INTERFACE_MODE_RMII:
 272                         ar71xx_eth0_data.mii_if = MII0_CTRL_IF_RMII;
 273                         break;
 274                 default:
 275                         BUG();
 276                 }
 277                 memcpy(ar71xx_eth0_data.mac_addr, ar71xx_mac_base, ETH_ALEN);
 278                 ar71xx_eth0_data.mac_addr[5] += ar71xx_eth_instance;
 279                 ar71xx_eth0_data.phy_if_mode = phy_if_mode;
 280                 ar71xx_eth0_data.phy_mask = phy_mask;
 281                 pdev = &ar71xx_eth0_device;
 282                 break;
 283         case 1:
 284                 switch (phy_if_mode) {
 285                 case PHY_INTERFACE_MODE_RMII:
 286                         ar71xx_eth1_data.mii_if = MII1_CTRL_IF_RMII;
 287                         break;
 288                 case PHY_INTERFACE_MODE_RGMII:
 289                         ar71xx_eth1_data.mii_if = MII1_CTRL_IF_RGMII;
 290                         break;
 291                 default:
 292                         BUG();
 293                 }
 294                 memcpy(ar71xx_eth1_data.mac_addr, ar71xx_mac_base, ETH_ALEN);
 295                 ar71xx_eth1_data.mac_addr[5] += ar71xx_eth_instance;
 296                 ar71xx_eth1_data.phy_if_mode = phy_if_mode;
 297                 ar71xx_eth1_data.phy_mask = phy_mask;
 298                 pdev = &ar71xx_eth1_device;
 299                 break;
 300         default:
 301                 pdev = NULL;
 302                 break;
 303         }
 304
 305         if (pdev) {
 306                 platform_device_register(pdev);
 307                 ar71xx_eth_instance++;
 308         }
 309 }
 310
 311 static struct resource ar71xx_spi_resources[] = {
 312         [0] = {
 313                 .start  = AR71XX_SPI_BASE,
 314                 .end    = AR71XX_SPI_BASE + AR71XX_SPI_SIZE - 1,
 315                 .flags  = IORESOURCE_MEM,
 316         },
 317 };
 318
 319 static struct platform_device ar71xx_spi_device = {
 320         .name           = "ar71xx-spi",
 321         .id             = -1,
 322         .resource       = ar71xx_spi_resources,
 323         .num_resources  = ARRAY_SIZE(ar71xx_spi_resources),
 324 };
 325
 326 void __init ar71xx_add_device_spi(struct ar71xx_spi_platform_data *pdata,
 327                                 struct spi_board_info const *info,
 328                                 unsigned n)
 329 {
 330         ar71xx_gpio_function_enable(GPIO_FUNC_SPI_EN);
 331
 332         spi_register_board_info(info, n);
 333         ar71xx_spi_device.dev.platform_data = pdata;
 334         platform_device_register(&ar71xx_spi_device);
 335 }
 336
 337 void __init ar71xx_add_device_leds_gpio(int id, unsigned num_leds,
 338                                 struct gpio_led *leds)
 339 {
 340         struct platform_device *pdev;
 341         struct gpio_led_platform_data pdata;
 342         struct gpio_led *p;
 343         int err;
 344
 345         p = kmalloc(num_leds * sizeof(*p), GFP_KERNEL);
 346         if (!p)
 347                 return;
 348
 349         memcpy(p, leds, num_leds * sizeof(*p));
 350
 351         pdev = platform_device_alloc("leds-gpio", id);
 352         if (!pdev)
 353                 goto err_free_leds;
 354
 355         pdata.num_leds = num_leds;
 356         pdata.leds = leds;
 357
 358         err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
 359         if (err)
 360                 goto err_put_pdev;
 361
 362         err = platform_device_add(pdev);
 363         if (err)
 364                 goto err_put_pdev;
 365
 366         return;
 367
 368 err_put_pdev:
 369         platform_device_put(pdev);
 370
 371 err_free_leds:
 372         kfree(p);
 373 }
 374
 375 void __init ar71xx_add_device_gpio_buttons(int id,
 376                                            unsigned poll_interval,
 377                                            unsigned nbuttons,
 378                                            struct gpio_button *buttons)
 379 {
 380         struct platform_device *pdev;
 381         struct gpio_buttons_platform_data pdata;
 382         struct gpio_button *p;
 383         int err;
 384
 385         p = kmalloc(nbuttons * sizeof(*p), GFP_KERNEL);
 386         if (!p)
 387                 return;
 388
 389         memcpy(p, buttons, nbuttons * sizeof(*p));
 390
 391         pdev = platform_device_alloc("gpio-buttons", id);
 392         if (!pdev)
 393                 goto err_free_buttons;
 394
 395         pdata.poll_interval = poll_interval;
 396         pdata.nbuttons = nbuttons;
 397         pdata.buttons = p;
 398
 399         err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
 400         if (err)
 401                 goto err_put_pdev;
 402
 403
 404         err = platform_device_add(pdev);
 405         if (err)
 406                 goto err_put_pdev;
 407
 408         return;
 409
 410 err_put_pdev:
 411         platform_device_put(pdev);
 412
 413 err_free_buttons:
 414         kfree(p);
 415 }
 416
 417 void __init ar71xx_set_mac_base(char *mac_str)
 418 {
 419         u8 tmp[ETH_ALEN];
 420         int t;
 421
 422         t = sscanf(mac_str, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
 423                         &tmp[0], &tmp[1], &tmp[2], &tmp[3], &tmp[4], &tmp[5]);
 424
 425         if (t == ETH_ALEN)
 426                 memcpy(ar71xx_mac_base, tmp, ETH_ALEN);
 427         else
 428                 printk(KERN_DEBUG "AR71XX: failed to parse mac address "
 429                                 "\"%s\"\n", mac_str);
 430 }
 431
 432 static int __init ar71xx_machine_setup(void)
 433 {
 434         ar71xx_print_cmdline();
 435
 436         ar71xx_gpio_init();
 437
 438         ar71xx_add_device_uart();
 439
 440         mips_machine_setup();
 441         return 0;
 442 }
 443
 444 arch_initcall(ar71xx_machine_setup);