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 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 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)
 255 {
 256         struct platform_device *pdev;
 257
 258         switch (id) {
 259         case 0:
 260                 switch (ar71xx_eth0_data.phy_if_mode) {
 261                 case PHY_INTERFACE_MODE_MII:
 262                         ar71xx_eth0_data.mii_if = MII0_CTRL_IF_MII;
 263                         break;
 264                 case PHY_INTERFACE_MODE_GMII:
 265                         ar71xx_eth0_data.mii_if = MII0_CTRL_IF_GMII;
 266                         break;
 267                 case PHY_INTERFACE_MODE_RGMII:
 268                         ar71xx_eth0_data.mii_if = MII0_CTRL_IF_RGMII;
 269                         break;
 270                 case PHY_INTERFACE_MODE_RMII:
 271                         ar71xx_eth0_data.mii_if = MII0_CTRL_IF_RMII;
 272                         break;
 273                 default:
 274                         BUG();
 275                 }
 276                 memcpy(ar71xx_eth0_data.mac_addr, ar71xx_mac_base, ETH_ALEN);
 277                 ar71xx_eth0_data.mac_addr[5] += ar71xx_eth_instance;
 278                 pdev = &ar71xx_eth0_device;
 279                 break;
 280         case 1:
 281                 switch (ar71xx_eth1_data.phy_if_mode) {
 282                 case PHY_INTERFACE_MODE_RMII:
 283                         ar71xx_eth1_data.mii_if = MII1_CTRL_IF_RMII;
 284                         break;
 285                 case PHY_INTERFACE_MODE_RGMII:
 286                         ar71xx_eth1_data.mii_if = MII1_CTRL_IF_RGMII;
 287                         break;
 288                 default:
 289                         BUG();
 290                 }
 291                 memcpy(ar71xx_eth1_data.mac_addr, ar71xx_mac_base, ETH_ALEN);
 292                 ar71xx_eth1_data.mac_addr[5] += ar71xx_eth_instance;
 293                 pdev = &ar71xx_eth1_device;
 294                 break;
 295         default:
 296                 pdev = NULL;
 297                 break;
 298         }
 299
 300         if (pdev) {
 301                 platform_device_register(pdev);
 302                 ar71xx_eth_instance++;
 303         }
 304 }
 305
 306 static struct resource ar71xx_spi_resources[] = {
 307         [0] = {
 308                 .start  = AR71XX_SPI_BASE,
 309                 .end    = AR71XX_SPI_BASE + AR71XX_SPI_SIZE - 1,
 310                 .flags  = IORESOURCE_MEM,
 311         },
 312 };
 313
 314 static struct platform_device ar71xx_spi_device = {
 315         .name           = "ar71xx-spi",
 316         .id             = -1,
 317         .resource       = ar71xx_spi_resources,
 318         .num_resources  = ARRAY_SIZE(ar71xx_spi_resources),
 319 };
 320
 321 void __init ar71xx_add_device_spi(struct ar71xx_spi_platform_data *pdata,
 322                                 struct spi_board_info const *info,
 323                                 unsigned n)
 324 {
 325         ar71xx_gpio_function_enable(GPIO_FUNC_SPI_EN);
 326
 327         spi_register_board_info(info, n);
 328         ar71xx_spi_device.dev.platform_data = pdata;
 329         platform_device_register(&ar71xx_spi_device);
 330 }
 331
 332 void __init ar71xx_add_device_leds_gpio(int id, unsigned num_leds,
 333                                 struct gpio_led *leds)
 334 {
 335         struct platform_device *pdev;
 336         struct gpio_led_platform_data pdata;
 337         struct gpio_led *p;
 338         int err;
 339
 340         p = kmalloc(num_leds * sizeof(*p), GFP_KERNEL);
 341         if (!p)
 342                 return;
 343
 344         memcpy(p, leds, num_leds * sizeof(*p));
 345
 346         pdev = platform_device_alloc("leds-gpio", id);
 347         if (!pdev)
 348                 goto err_free_leds;
 349
 350         memset(&pdata, 0, sizeof(pdata));
 351         pdata.num_leds = num_leds;
 352         pdata.leds = leds;
 353
 354         err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
 355         if (err)
 356                 goto err_put_pdev;
 357
 358         err = platform_device_add(pdev);
 359         if (err)
 360                 goto err_put_pdev;
 361
 362         return;
 363
 364 err_put_pdev:
 365         platform_device_put(pdev);
 366
 367 err_free_leds:
 368         kfree(p);
 369 }
 370
 371 void __init ar71xx_add_device_gpio_buttons(int id,
 372                                            unsigned poll_interval,
 373                                            unsigned nbuttons,
 374                                            struct gpio_button *buttons)
 375 {
 376         struct platform_device *pdev;
 377         struct gpio_buttons_platform_data pdata;
 378         struct gpio_button *p;
 379         int err;
 380
 381         p = kmalloc(nbuttons * sizeof(*p), GFP_KERNEL);
 382         if (!p)
 383                 return;
 384
 385         memcpy(p, buttons, nbuttons * sizeof(*p));
 386
 387         pdev = platform_device_alloc("gpio-buttons", id);
 388         if (!pdev)
 389                 goto err_free_buttons;
 390
 391         memset(&pdata, 0, sizeof(pdata));
 392         pdata.poll_interval = poll_interval;
 393         pdata.nbuttons = nbuttons;
 394         pdata.buttons = p;
 395
 396         err = platform_device_add_data(pdev, &pdata, sizeof(pdata));
 397         if (err)
 398                 goto err_put_pdev;
 399
 400
 401         err = platform_device_add(pdev);
 402         if (err)
 403                 goto err_put_pdev;
 404
 405         return;
 406
 407 err_put_pdev:
 408         platform_device_put(pdev);
 409
 410 err_free_buttons:
 411         kfree(p);
 412 }
 413
 414 void __init ar71xx_add_device_wdt(void)
 415 {
 416         platform_device_register_simple("ar71xx-wdt", -1, NULL, 0);
 417 }
 418
 419 void __init ar71xx_set_mac_base(unsigned char *mac)
 420 {
 421         memcpy(ar71xx_mac_base, mac, ETH_ALEN);
 422 }
 423
 424 void __init ar71xx_parse_mac_addr(char *mac_str)
 425 {
 426         u8 tmp[ETH_ALEN];
 427         int t;
 428
 429         t = sscanf(mac_str, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
 430                         &tmp[0], &tmp[1], &tmp[2], &tmp[3], &tmp[4], &tmp[5]);
 431
 432         if (t == ETH_ALEN)
 433                 ar71xx_set_mac_base(tmp);
 434         else
 435                 printk(KERN_DEBUG "AR71XX: failed to parse mac address "
 436                                 "\"%s\"\n", mac_str);
 437 }
 438
 439 static int __init ar71xx_machine_setup(void)
 440 {
 441         ar71xx_gpio_init();
 442
 443         ar71xx_add_device_uart();
 444         ar71xx_add_device_wdt();
 445
 446         mips_machine_setup();
 447         return 0;
 448 }
 449
 450 arch_initcall(ar71xx_machine_setup);