arch/arm/mach-at91/at91sam9g45_devices.c

   1 /*
   2  *  On-Chip devices setup code for the AT91SAM9G45 family
   3  *
   4  *  Copyright (C) 2009 Atmel Corporation.
   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  */
  12 #include <asm/mach/arch.h>
  13 #include <asm/mach/map.h>
  14
  15 #include <linux/dma-mapping.h>
  16 #include <linux/gpio.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/i2c-gpio.h>
  19 #include <linux/atmel-mci.h>
  20
  21 #include <linux/fb.h>
  22 #include <video/atmel_lcdc.h>
  23
  24 #include <mach/board.h>
  25 #include <mach/at91sam9g45.h>
  26 #include <mach/at91sam9g45_matrix.h>
  27 #include <mach/at91sam9_smc.h>
  28 #include <mach/at_hdmac.h>
  29 #include <mach/atmel-mci.h>
  30
  31 #include "generic.h"
  32
  33
  34 /* --------------------------------------------------------------------
  35  *  HDMAC - AHB DMA Controller
  36  * -------------------------------------------------------------------- */
  37
  38 #if defined(CONFIG_AT_HDMAC) || defined(CONFIG_AT_HDMAC_MODULE)
  39 static u64 hdmac_dmamask = DMA_BIT_MASK(32);
  40
  41 static struct at_dma_platform_data atdma_pdata = {
  42         .nr_channels    = 8,
  43 };
  44
  45 static struct resource hdmac_resources[] = {
  46         [0] = {
  47                 .start  = AT91_BASE_SYS + AT91_DMA,
  48                 .end    = AT91_BASE_SYS + AT91_DMA + SZ_512 - 1,
  49                 .flags  = IORESOURCE_MEM,
  50         },
  51         [1] = {
  52                 .start  = AT91SAM9G45_ID_DMA,
  53                 .end    = AT91SAM9G45_ID_DMA,
  54                 .flags  = IORESOURCE_IRQ,
  55         },
  56 };
  57
  58 static struct platform_device at_hdmac_device = {
  59         .name           = "at_hdmac",
  60         .id             = -1,
  61         .dev            = {
  62                                 .dma_mask               = &hdmac_dmamask,
  63                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
  64                                 .platform_data          = &atdma_pdata,
  65         },
  66         .resource       = hdmac_resources,
  67         .num_resources  = ARRAY_SIZE(hdmac_resources),
  68 };
  69
  70 void __init at91_add_device_hdmac(void)
  71 {
  72         dma_cap_set(DMA_MEMCPY, atdma_pdata.cap_mask);
  73         dma_cap_set(DMA_SLAVE, atdma_pdata.cap_mask);
  74         platform_device_register(&at_hdmac_device);
  75 }
  76 #else
  77 void __init at91_add_device_hdmac(void) {}
  78 #endif
  79
  80
  81 /* --------------------------------------------------------------------
  82  *  USB Host (OHCI)
  83  * -------------------------------------------------------------------- */
  84
  85 #if defined(CONFIG_USB_OHCI_HCD) || defined(CONFIG_USB_OHCI_HCD_MODULE)
  86 static u64 ohci_dmamask = DMA_BIT_MASK(32);
  87 static struct at91_usbh_data usbh_ohci_data;
  88
  89 static struct resource usbh_ohci_resources[] = {
  90         [0] = {
  91                 .start  = AT91SAM9G45_OHCI_BASE,
  92                 .end    = AT91SAM9G45_OHCI_BASE + SZ_1M - 1,
  93                 .flags  = IORESOURCE_MEM,
  94         },
  95         [1] = {
  96                 .start  = AT91SAM9G45_ID_UHPHS,
  97                 .end    = AT91SAM9G45_ID_UHPHS,
  98                 .flags  = IORESOURCE_IRQ,
  99         },
 100 };
 101
 102 static struct platform_device at91_usbh_ohci_device = {
 103         .name           = "at91_ohci",
 104         .id             = -1,
 105         .dev            = {
 106                                 .dma_mask               = &ohci_dmamask,
 107                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 108                                 .platform_data          = &usbh_ohci_data,
 109         },
 110         .resource       = usbh_ohci_resources,
 111         .num_resources  = ARRAY_SIZE(usbh_ohci_resources),
 112 };
 113
 114 void __init at91_add_device_usbh_ohci(struct at91_usbh_data *data)
 115 {
 116         int i;
 117
 118         if (!data)
 119                 return;
 120
 121         /* Enable VBus control for UHP ports */
 122         for (i = 0; i < data->ports; i++) {
 123                 if (data->vbus_pin[i])
 124                         at91_set_gpio_output(data->vbus_pin[i], 0);
 125         }
 126
 127         /* Enable overcurrent notification */
 128         for (i = 0; i < data->ports; i++) {
 129                 if (data->overcurrent_pin[i])
 130                         at91_set_gpio_input(data->overcurrent_pin[i], 1);
 131         }
 132
 133         usbh_ohci_data = *data;
 134         platform_device_register(&at91_usbh_ohci_device);
 135 }
 136 #else
 137 void __init at91_add_device_usbh_ohci(struct at91_usbh_data *data) {}
 138 #endif
 139
 140
 141 /* --------------------------------------------------------------------
 142  *  USB Host HS (EHCI)
 143  *  Needs an OHCI host for low and full speed management
 144  * -------------------------------------------------------------------- */
 145
 146 #if defined(CONFIG_USB_EHCI_HCD) || defined(CONFIG_USB_EHCI_HCD_MODULE)
 147 static u64 ehci_dmamask = DMA_BIT_MASK(32);
 148 static struct at91_usbh_data usbh_ehci_data;
 149
 150 static struct resource usbh_ehci_resources[] = {
 151         [0] = {
 152                 .start  = AT91SAM9G45_EHCI_BASE,
 153                 .end    = AT91SAM9G45_EHCI_BASE + SZ_1M - 1,
 154                 .flags  = IORESOURCE_MEM,
 155         },
 156         [1] = {
 157                 .start  = AT91SAM9G45_ID_UHPHS,
 158                 .end    = AT91SAM9G45_ID_UHPHS,
 159                 .flags  = IORESOURCE_IRQ,
 160         },
 161 };
 162
 163 static struct platform_device at91_usbh_ehci_device = {
 164         .name           = "atmel-ehci",
 165         .id             = -1,
 166         .dev            = {
 167                                 .dma_mask               = &ehci_dmamask,
 168                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 169                                 .platform_data          = &usbh_ehci_data,
 170         },
 171         .resource       = usbh_ehci_resources,
 172         .num_resources  = ARRAY_SIZE(usbh_ehci_resources),
 173 };
 174
 175 void __init at91_add_device_usbh_ehci(struct at91_usbh_data *data)
 176 {
 177         int i;
 178
 179         if (!data)
 180                 return;
 181
 182         /* Enable VBus control for UHP ports */
 183         for (i = 0; i < data->ports; i++) {
 184                 if (data->vbus_pin[i])
 185                         at91_set_gpio_output(data->vbus_pin[i], 0);
 186         }
 187
 188         usbh_ehci_data = *data;
 189         platform_device_register(&at91_usbh_ehci_device);
 190 }
 191 #else
 192 void __init at91_add_device_usbh_ehci(struct at91_usbh_data *data) {}
 193 #endif
 194
 195
 196 /* --------------------------------------------------------------------
 197  *  USB HS Device (Gadget)
 198  * -------------------------------------------------------------------- */
 199
 200 #if defined(CONFIG_USB_GADGET_ATMEL_USBA) || defined(CONFIG_USB_GADGET_ATMEL_USBA_MODULE)
 201 static struct resource usba_udc_resources[] = {
 202         [0] = {
 203                 .start  = AT91SAM9G45_UDPHS_FIFO,
 204                 .end    = AT91SAM9G45_UDPHS_FIFO + SZ_512K - 1,
 205                 .flags  = IORESOURCE_MEM,
 206         },
 207         [1] = {
 208                 .start  = AT91SAM9G45_BASE_UDPHS,
 209                 .end    = AT91SAM9G45_BASE_UDPHS + SZ_1K - 1,
 210                 .flags  = IORESOURCE_MEM,
 211         },
 212         [2] = {
 213                 .start  = AT91SAM9G45_ID_UDPHS,
 214                 .end    = AT91SAM9G45_ID_UDPHS,
 215                 .flags  = IORESOURCE_IRQ,
 216         },
 217 };
 218
 219 #define EP(nam, idx, maxpkt, maxbk, dma, isoc)                  \
 220         [idx] = {                                               \
 221                 .name           = nam,                          \
 222                 .index          = idx,                          \
 223                 .fifo_size      = maxpkt,                       \
 224                 .nr_banks       = maxbk,                        \
 225                 .can_dma        = dma,                          \
 226                 .can_isoc       = isoc,                         \
 227         }
 228
 229 static struct usba_ep_data usba_udc_ep[] __initdata = {
 230         EP("ep0", 0, 64, 1, 0, 0),
 231         EP("ep1", 1, 1024, 2, 1, 1),
 232         EP("ep2", 2, 1024, 2, 1, 1),
 233         EP("ep3", 3, 1024, 3, 1, 0),
 234         EP("ep4", 4, 1024, 3, 1, 0),
 235         EP("ep5", 5, 1024, 3, 1, 1),
 236         EP("ep6", 6, 1024, 3, 1, 1),
 237 };
 238
 239 #undef EP
 240
 241 /*
 242  * pdata doesn't have room for any endpoints, so we need to
 243  * append room for the ones we need right after it.
 244  */
 245 static struct {
 246         struct usba_platform_data pdata;
 247         struct usba_ep_data ep[7];
 248 } usba_udc_data;
 249
 250 static struct platform_device at91_usba_udc_device = {
 251         .name           = "atmel_usba_udc",
 252         .id             = -1,
 253         .dev            = {
 254                                 .platform_data  = &usba_udc_data.pdata,
 255         },
 256         .resource       = usba_udc_resources,
 257         .num_resources  = ARRAY_SIZE(usba_udc_resources),
 258 };
 259
 260 void __init at91_add_device_usba(struct usba_platform_data *data)
 261 {
 262         usba_udc_data.pdata.vbus_pin = -EINVAL;
 263         usba_udc_data.pdata.num_ep = ARRAY_SIZE(usba_udc_ep);
 264         memcpy(usba_udc_data.ep, usba_udc_ep, sizeof(usba_udc_ep));
 265
 266         if (data && data->vbus_pin > 0) {
 267                 at91_set_gpio_input(data->vbus_pin, 0);
 268                 at91_set_deglitch(data->vbus_pin, 1);
 269                 usba_udc_data.pdata.vbus_pin = data->vbus_pin;
 270         }
 271
 272         /* Pullup pin is handled internally by USB device peripheral */
 273
 274         platform_device_register(&at91_usba_udc_device);
 275 }
 276 #else
 277 void __init at91_add_device_usba(struct usba_platform_data *data) {}
 278 #endif
 279
 280
 281 /* --------------------------------------------------------------------
 282  *  Ethernet
 283  * -------------------------------------------------------------------- */
 284
 285 #if defined(CONFIG_MACB) || defined(CONFIG_MACB_MODULE)
 286 static u64 eth_dmamask = DMA_BIT_MASK(32);
 287 static struct at91_eth_data eth_data;
 288
 289 static struct resource eth_resources[] = {
 290         [0] = {
 291                 .start  = AT91SAM9G45_BASE_EMAC,
 292                 .end    = AT91SAM9G45_BASE_EMAC + SZ_16K - 1,
 293                 .flags  = IORESOURCE_MEM,
 294         },
 295         [1] = {
 296                 .start  = AT91SAM9G45_ID_EMAC,
 297                 .end    = AT91SAM9G45_ID_EMAC,
 298                 .flags  = IORESOURCE_IRQ,
 299         },
 300 };
 301
 302 static struct platform_device at91sam9g45_eth_device = {
 303         .name           = "macb",
 304         .id             = -1,
 305         .dev            = {
 306                                 .dma_mask               = &eth_dmamask,
 307                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 308                                 .platform_data          = &eth_data,
 309         },
 310         .resource       = eth_resources,
 311         .num_resources  = ARRAY_SIZE(eth_resources),
 312 };
 313
 314 void __init at91_add_device_eth(struct at91_eth_data *data)
 315 {
 316         if (!data)
 317                 return;
 318
 319         if (data->phy_irq_pin) {
 320                 at91_set_gpio_input(data->phy_irq_pin, 0);
 321                 at91_set_deglitch(data->phy_irq_pin, 1);
 322         }
 323
 324         /* Pins used for MII and RMII */
 325         at91_set_A_periph(AT91_PIN_PA17, 0);    /* ETXCK_EREFCK */
 326         at91_set_A_periph(AT91_PIN_PA15, 0);    /* ERXDV */
 327         at91_set_A_periph(AT91_PIN_PA12, 0);    /* ERX0 */
 328         at91_set_A_periph(AT91_PIN_PA13, 0);    /* ERX1 */
 329         at91_set_A_periph(AT91_PIN_PA16, 0);    /* ERXER */
 330         at91_set_A_periph(AT91_PIN_PA14, 0);    /* ETXEN */
 331         at91_set_A_periph(AT91_PIN_PA10, 0);    /* ETX0 */
 332         at91_set_A_periph(AT91_PIN_PA11, 0);    /* ETX1 */
 333         at91_set_A_periph(AT91_PIN_PA19, 0);    /* EMDIO */
 334         at91_set_A_periph(AT91_PIN_PA18, 0);    /* EMDC */
 335
 336         if (!data->is_rmii) {
 337                 at91_set_B_periph(AT91_PIN_PA29, 0);    /* ECRS */
 338                 at91_set_B_periph(AT91_PIN_PA30, 0);    /* ECOL */
 339                 at91_set_B_periph(AT91_PIN_PA8,  0);    /* ERX2 */
 340                 at91_set_B_periph(AT91_PIN_PA9,  0);    /* ERX3 */
 341                 at91_set_B_periph(AT91_PIN_PA28, 0);    /* ERXCK */
 342                 at91_set_B_periph(AT91_PIN_PA6,  0);    /* ETX2 */
 343                 at91_set_B_periph(AT91_PIN_PA7,  0);    /* ETX3 */
 344                 at91_set_B_periph(AT91_PIN_PA27, 0);    /* ETXER */
 345         }
 346
 347         eth_data = *data;
 348         platform_device_register(&at91sam9g45_eth_device);
 349 }
 350 #else
 351 void __init at91_add_device_eth(struct at91_eth_data *data) {}
 352 #endif
 353
 354
 355 /* --------------------------------------------------------------------
 356  *  MMC / SD
 357  * -------------------------------------------------------------------- */
 358
 359 #if defined(CONFIG_MMC_ATMELMCI) || defined(CONFIG_MMC_ATMELMCI_MODULE)
 360 static u64 mmc_dmamask = DMA_BIT_MASK(32);
 361 static struct mci_platform_data mmc0_data, mmc1_data;
 362
 363 static struct resource mmc0_resources[] = {
 364         [0] = {
 365                 .start  = AT91SAM9G45_BASE_MCI0,
 366                 .end    = AT91SAM9G45_BASE_MCI0 + SZ_16K - 1,
 367                 .flags  = IORESOURCE_MEM,
 368         },
 369         [1] = {
 370                 .start  = AT91SAM9G45_ID_MCI0,
 371                 .end    = AT91SAM9G45_ID_MCI0,
 372                 .flags  = IORESOURCE_IRQ,
 373         },
 374 };
 375
 376 static struct platform_device at91sam9g45_mmc0_device = {
 377         .name           = "atmel_mci",
 378         .id             = 0,
 379         .dev            = {
 380                                 .dma_mask               = &mmc_dmamask,
 381                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 382                                 .platform_data          = &mmc0_data,
 383         },
 384         .resource       = mmc0_resources,
 385         .num_resources  = ARRAY_SIZE(mmc0_resources),
 386 };
 387
 388 static struct resource mmc1_resources[] = {
 389         [0] = {
 390                 .start  = AT91SAM9G45_BASE_MCI1,
 391                 .end    = AT91SAM9G45_BASE_MCI1 + SZ_16K - 1,
 392                 .flags  = IORESOURCE_MEM,
 393         },
 394         [1] = {
 395                 .start  = AT91SAM9G45_ID_MCI1,
 396                 .end    = AT91SAM9G45_ID_MCI1,
 397                 .flags  = IORESOURCE_IRQ,
 398         },
 399 };
 400
 401 static struct platform_device at91sam9g45_mmc1_device = {
 402         .name           = "atmel_mci",
 403         .id             = 1,
 404         .dev            = {
 405                                 .dma_mask               = &mmc_dmamask,
 406                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 407                                 .platform_data          = &mmc1_data,
 408         },
 409         .resource       = mmc1_resources,
 410         .num_resources  = ARRAY_SIZE(mmc1_resources),
 411 };
 412
 413 /* Consider only one slot : slot 0 */
 414 void __init at91_add_device_mci(short mmc_id, struct mci_platform_data *data)
 415 {
 416
 417         if (!data)
 418                 return;
 419
 420         /* Must have at least one usable slot */
 421         if (!data->slot[0].bus_width)
 422                 return;
 423
 424 #if defined(CONFIG_AT_HDMAC) || defined(CONFIG_AT_HDMAC_MODULE)
 425         {
 426         struct at_dma_slave     *atslave;
 427         struct mci_dma_data     *alt_atslave;
 428
 429         alt_atslave = kzalloc(sizeof(struct mci_dma_data), GFP_KERNEL);
 430         atslave = &alt_atslave->sdata;
 431
 432         /* DMA slave channel configuration */
 433         atslave->dma_dev = &at_hdmac_device.dev;
 434         atslave->reg_width = AT_DMA_SLAVE_WIDTH_32BIT;
 435         atslave->cfg = ATC_FIFOCFG_HALFFIFO
 436                         | ATC_SRC_H2SEL_HW | ATC_DST_H2SEL_HW;
 437         atslave->ctrla = ATC_SCSIZE_16 | ATC_DCSIZE_16;
 438         if (mmc_id == 0)        /* MCI0 */
 439                 atslave->cfg |= ATC_SRC_PER(AT_DMA_ID_MCI0)
 440                               | ATC_DST_PER(AT_DMA_ID_MCI0);
 441
 442         else                    /* MCI1 */
 443                 atslave->cfg |= ATC_SRC_PER(AT_DMA_ID_MCI1)
 444                               | ATC_DST_PER(AT_DMA_ID_MCI1);
 445
 446         data->dma_slave = alt_atslave;
 447         }
 448 #endif
 449
 450
 451         /* input/irq */
 452         if (data->slot[0].detect_pin) {
 453                 at91_set_gpio_input(data->slot[0].detect_pin, 1);
 454                 at91_set_deglitch(data->slot[0].detect_pin, 1);
 455         }
 456         if (data->slot[0].wp_pin)
 457                 at91_set_gpio_input(data->slot[0].wp_pin, 1);
 458
 459         if (mmc_id == 0) {              /* MCI0 */
 460
 461                 /* CLK */
 462                 at91_set_A_periph(AT91_PIN_PA0, 0);
 463
 464                 /* CMD */
 465                 at91_set_A_periph(AT91_PIN_PA1, 1);
 466
 467                 /* DAT0, maybe DAT1..DAT3 and maybe DAT4..DAT7 */
 468                 at91_set_A_periph(AT91_PIN_PA2, 1);
 469                 if (data->slot[0].bus_width == 4) {
 470                         at91_set_A_periph(AT91_PIN_PA3, 1);
 471                         at91_set_A_periph(AT91_PIN_PA4, 1);
 472                         at91_set_A_periph(AT91_PIN_PA5, 1);
 473                         if (data->slot[0].bus_width == 8) {
 474                                 at91_set_A_periph(AT91_PIN_PA6, 1);
 475                                 at91_set_A_periph(AT91_PIN_PA7, 1);
 476                                 at91_set_A_periph(AT91_PIN_PA8, 1);
 477                                 at91_set_A_periph(AT91_PIN_PA9, 1);
 478                         }
 479                 }
 480
 481                 mmc0_data = *data;
 482                 platform_device_register(&at91sam9g45_mmc0_device);
 483
 484         } else {                        /* MCI1 */
 485
 486                 /* CLK */
 487                 at91_set_A_periph(AT91_PIN_PA31, 0);
 488
 489                 /* CMD */
 490                 at91_set_A_periph(AT91_PIN_PA22, 1);
 491
 492                 /* DAT0, maybe DAT1..DAT3 and maybe DAT4..DAT7 */
 493                 at91_set_A_periph(AT91_PIN_PA23, 1);
 494                 if (data->slot[0].bus_width == 4) {
 495                         at91_set_A_periph(AT91_PIN_PA24, 1);
 496                         at91_set_A_periph(AT91_PIN_PA25, 1);
 497                         at91_set_A_periph(AT91_PIN_PA26, 1);
 498                         if (data->slot[0].bus_width == 8) {
 499                                 at91_set_A_periph(AT91_PIN_PA27, 1);
 500                                 at91_set_A_periph(AT91_PIN_PA28, 1);
 501                                 at91_set_A_periph(AT91_PIN_PA29, 1);
 502                                 at91_set_A_periph(AT91_PIN_PA30, 1);
 503                         }
 504                 }
 505
 506                 mmc1_data = *data;
 507                 platform_device_register(&at91sam9g45_mmc1_device);
 508
 509         }
 510 }
 511 #else
 512 void __init at91_add_device_mci(short mmc_id, struct mci_platform_data *data) {}
 513 #endif
 514
 515
 516 /* --------------------------------------------------------------------
 517  *  NAND / SmartMedia
 518  * -------------------------------------------------------------------- */
 519
 520 #if defined(CONFIG_MTD_NAND_ATMEL) || defined(CONFIG_MTD_NAND_ATMEL_MODULE)
 521 static struct atmel_nand_data nand_data;
 522
 523 #define NAND_BASE       AT91_CHIPSELECT_3
 524
 525 static struct resource nand_resources[] = {
 526         [0] = {
 527                 .start  = NAND_BASE,
 528                 .end    = NAND_BASE + SZ_256M - 1,
 529                 .flags  = IORESOURCE_MEM,
 530         },
 531         [1] = {
 532                 .start  = AT91_BASE_SYS + AT91_ECC,
 533                 .end    = AT91_BASE_SYS + AT91_ECC + SZ_512 - 1,
 534                 .flags  = IORESOURCE_MEM,
 535         }
 536 };
 537
 538 static struct platform_device at91sam9g45_nand_device = {
 539         .name           = "atmel_nand",
 540         .id             = -1,
 541         .dev            = {
 542                                 .platform_data  = &nand_data,
 543         },
 544         .resource       = nand_resources,
 545         .num_resources  = ARRAY_SIZE(nand_resources),
 546 };
 547
 548 void __init at91_add_device_nand(struct atmel_nand_data *data)
 549 {
 550         unsigned long csa;
 551
 552         if (!data)
 553                 return;
 554
 555         csa = at91_sys_read(AT91_MATRIX_EBICSA);
 556         at91_sys_write(AT91_MATRIX_EBICSA, csa | AT91_MATRIX_EBI_CS3A_SMC_SMARTMEDIA);
 557
 558         /* enable pin */
 559         if (data->enable_pin)
 560                 at91_set_gpio_output(data->enable_pin, 1);
 561
 562         /* ready/busy pin */
 563         if (data->rdy_pin)
 564                 at91_set_gpio_input(data->rdy_pin, 1);
 565
 566         /* card detect pin */
 567         if (data->det_pin)
 568                 at91_set_gpio_input(data->det_pin, 1);
 569
 570         nand_data = *data;
 571         platform_device_register(&at91sam9g45_nand_device);
 572 }
 573 #else
 574 void __init at91_add_device_nand(struct atmel_nand_data *data) {}
 575 #endif
 576
 577
 578 /* --------------------------------------------------------------------
 579  *  TWI (i2c)
 580  * -------------------------------------------------------------------- */
 581
 582 /*
 583  * Prefer the GPIO code since the TWI controller isn't robust
 584  * (gets overruns and underruns under load) and can only issue
 585  * repeated STARTs in one scenario (the driver doesn't yet handle them).
 586  */
 587 #if defined(CONFIG_I2C_GPIO) || defined(CONFIG_I2C_GPIO_MODULE)
 588 static struct i2c_gpio_platform_data pdata_i2c0 = {
 589         .sda_pin                = AT91_PIN_PA20,
 590         .sda_is_open_drain      = 1,
 591         .scl_pin                = AT91_PIN_PA21,
 592         .scl_is_open_drain      = 1,
 593         .udelay                 = 5,            /* ~100 kHz */
 594 };
 595
 596 static struct platform_device at91sam9g45_twi0_device = {
 597         .name                   = "i2c-gpio",
 598         .id                     = 0,
 599         .dev.platform_data      = &pdata_i2c0,
 600 };
 601
 602 static struct i2c_gpio_platform_data pdata_i2c1 = {
 603         .sda_pin                = AT91_PIN_PB10,
 604         .sda_is_open_drain      = 1,
 605         .scl_pin                = AT91_PIN_PB11,
 606         .scl_is_open_drain      = 1,
 607         .udelay                 = 5,            /* ~100 kHz */
 608 };
 609
 610 static struct platform_device at91sam9g45_twi1_device = {
 611         .name                   = "i2c-gpio",
 612         .id                     = 1,
 613         .dev.platform_data      = &pdata_i2c1,
 614 };
 615
 616 void __init at91_add_device_i2c(short i2c_id, struct i2c_board_info *devices, int nr_devices)
 617 {
 618         i2c_register_board_info(i2c_id, devices, nr_devices);
 619
 620         if (i2c_id == 0) {
 621                 at91_set_GPIO_periph(AT91_PIN_PA20, 1);         /* TWD (SDA) */
 622                 at91_set_multi_drive(AT91_PIN_PA20, 1);
 623
 624                 at91_set_GPIO_periph(AT91_PIN_PA21, 1);         /* TWCK (SCL) */
 625                 at91_set_multi_drive(AT91_PIN_PA21, 1);
 626
 627                 platform_device_register(&at91sam9g45_twi0_device);
 628         } else {
 629                 at91_set_GPIO_periph(AT91_PIN_PB10, 1);         /* TWD (SDA) */
 630                 at91_set_multi_drive(AT91_PIN_PB10, 1);
 631
 632                 at91_set_GPIO_periph(AT91_PIN_PB11, 1);         /* TWCK (SCL) */
 633                 at91_set_multi_drive(AT91_PIN_PB11, 1);
 634
 635                 platform_device_register(&at91sam9g45_twi1_device);
 636         }
 637 }
 638
 639 #elif defined(CONFIG_I2C_AT91) || defined(CONFIG_I2C_AT91_MODULE)
 640 static struct resource twi0_resources[] = {
 641         [0] = {
 642                 .start  = AT91SAM9G45_BASE_TWI0,
 643                 .end    = AT91SAM9G45_BASE_TWI0 + SZ_16K - 1,
 644                 .flags  = IORESOURCE_MEM,
 645         },
 646         [1] = {
 647                 .start  = AT91SAM9G45_ID_TWI0,
 648                 .end    = AT91SAM9G45_ID_TWI0,
 649                 .flags  = IORESOURCE_IRQ,
 650         },
 651 };
 652
 653 static struct platform_device at91sam9g45_twi0_device = {
 654         .name           = "at91_i2c",
 655         .id             = 0,
 656         .resource       = twi0_resources,
 657         .num_resources  = ARRAY_SIZE(twi0_resources),
 658 };
 659
 660 static struct resource twi1_resources[] = {
 661         [0] = {
 662                 .start  = AT91SAM9G45_BASE_TWI1,
 663                 .end    = AT91SAM9G45_BASE_TWI1 + SZ_16K - 1,
 664                 .flags  = IORESOURCE_MEM,
 665         },
 666         [1] = {
 667                 .start  = AT91SAM9G45_ID_TWI1,
 668                 .end    = AT91SAM9G45_ID_TWI1,
 669                 .flags  = IORESOURCE_IRQ,
 670         },
 671 };
 672
 673 static struct platform_device at91sam9g45_twi1_device = {
 674         .name           = "at91_i2c",
 675         .id             = 1,
 676         .resource       = twi1_resources,
 677         .num_resources  = ARRAY_SIZE(twi1_resources),
 678 };
 679
 680 void __init at91_add_device_i2c(short i2c_id, struct i2c_board_info *devices, int nr_devices)
 681 {
 682         i2c_register_board_info(i2c_id, devices, nr_devices);
 683
 684         /* pins used for TWI interface */
 685         if (i2c_id == 0) {
 686                 at91_set_A_periph(AT91_PIN_PA20, 0);            /* TWD */
 687                 at91_set_multi_drive(AT91_PIN_PA20, 1);
 688
 689                 at91_set_A_periph(AT91_PIN_PA21, 0);            /* TWCK */
 690                 at91_set_multi_drive(AT91_PIN_PA21, 1);
 691
 692                 platform_device_register(&at91sam9g45_twi0_device);
 693         } else {
 694                 at91_set_A_periph(AT91_PIN_PB10, 0);            /* TWD */
 695                 at91_set_multi_drive(AT91_PIN_PB10, 1);
 696
 697                 at91_set_A_periph(AT91_PIN_PB11, 0);            /* TWCK */
 698                 at91_set_multi_drive(AT91_PIN_PB11, 1);
 699
 700                 platform_device_register(&at91sam9g45_twi1_device);
 701         }
 702 }
 703 #else
 704 void __init at91_add_device_i2c(short i2c_id, struct i2c_board_info *devices, int nr_devices) {}
 705 #endif
 706
 707
 708 /* --------------------------------------------------------------------
 709  *  SPI
 710  * -------------------------------------------------------------------- */
 711
 712 #if defined(CONFIG_SPI_ATMEL) || defined(CONFIG_SPI_ATMEL_MODULE)
 713 static u64 spi_dmamask = DMA_BIT_MASK(32);
 714
 715 static struct resource spi0_resources[] = {
 716         [0] = {
 717                 .start  = AT91SAM9G45_BASE_SPI0,
 718                 .end    = AT91SAM9G45_BASE_SPI0 + SZ_16K - 1,
 719                 .flags  = IORESOURCE_MEM,
 720         },
 721         [1] = {
 722                 .start  = AT91SAM9G45_ID_SPI0,
 723                 .end    = AT91SAM9G45_ID_SPI0,
 724                 .flags  = IORESOURCE_IRQ,
 725         },
 726 };
 727
 728 static struct platform_device at91sam9g45_spi0_device = {
 729         .name           = "atmel_spi",
 730         .id             = 0,
 731         .dev            = {
 732                                 .dma_mask               = &spi_dmamask,
 733                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 734         },
 735         .resource       = spi0_resources,
 736         .num_resources  = ARRAY_SIZE(spi0_resources),
 737 };
 738
 739 static const unsigned spi0_standard_cs[4] = { AT91_PIN_PB3, AT91_PIN_PB18, AT91_PIN_PB19, AT91_PIN_PD27 };
 740
 741 static struct resource spi1_resources[] = {
 742         [0] = {
 743                 .start  = AT91SAM9G45_BASE_SPI1,
 744                 .end    = AT91SAM9G45_BASE_SPI1 + SZ_16K - 1,
 745                 .flags  = IORESOURCE_MEM,
 746         },
 747         [1] = {
 748                 .start  = AT91SAM9G45_ID_SPI1,
 749                 .end    = AT91SAM9G45_ID_SPI1,
 750                 .flags  = IORESOURCE_IRQ,
 751         },
 752 };
 753
 754 static struct platform_device at91sam9g45_spi1_device = {
 755         .name           = "atmel_spi",
 756         .id             = 1,
 757         .dev            = {
 758                                 .dma_mask               = &spi_dmamask,
 759                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 760         },
 761         .resource       = spi1_resources,
 762         .num_resources  = ARRAY_SIZE(spi1_resources),
 763 };
 764
 765 static const unsigned spi1_standard_cs[4] = { AT91_PIN_PB17, AT91_PIN_PD28, AT91_PIN_PD18, AT91_PIN_PD19 };
 766
 767 void __init at91_add_device_spi(struct spi_board_info *devices, int nr_devices)
 768 {
 769         int i;
 770         unsigned long cs_pin;
 771         short enable_spi0 = 0;
 772         short enable_spi1 = 0;
 773
 774         /* Choose SPI chip-selects */
 775         for (i = 0; i < nr_devices; i++) {
 776                 if (devices[i].controller_data)
 777                         cs_pin = (unsigned long) devices[i].controller_data;
 778                 else if (devices[i].bus_num == 0)
 779                         cs_pin = spi0_standard_cs[devices[i].chip_select];
 780                 else
 781                         cs_pin = spi1_standard_cs[devices[i].chip_select];
 782
 783                 if (devices[i].bus_num == 0)
 784                         enable_spi0 = 1;
 785                 else
 786                         enable_spi1 = 1;
 787
 788                 /* enable chip-select pin */
 789                 at91_set_gpio_output(cs_pin, 1);
 790
 791                 /* pass chip-select pin to driver */
 792                 devices[i].controller_data = (void *) cs_pin;
 793         }
 794
 795         spi_register_board_info(devices, nr_devices);
 796
 797         /* Configure SPI bus(es) */
 798         if (enable_spi0) {
 799                 at91_set_A_periph(AT91_PIN_PB0, 0);     /* SPI0_MISO */
 800                 at91_set_A_periph(AT91_PIN_PB1, 0);     /* SPI0_MOSI */
 801                 at91_set_A_periph(AT91_PIN_PB2, 0);     /* SPI0_SPCK */
 802
 803                 platform_device_register(&at91sam9g45_spi0_device);
 804         }
 805         if (enable_spi1) {
 806                 at91_set_A_periph(AT91_PIN_PB14, 0);    /* SPI1_MISO */
 807                 at91_set_A_periph(AT91_PIN_PB15, 0);    /* SPI1_MOSI */
 808                 at91_set_A_periph(AT91_PIN_PB16, 0);    /* SPI1_SPCK */
 809
 810                 platform_device_register(&at91sam9g45_spi1_device);
 811         }
 812 }
 813 #else
 814 void __init at91_add_device_spi(struct spi_board_info *devices, int nr_devices) {}
 815 #endif
 816
 817
 818 /* --------------------------------------------------------------------
 819  *  AC97
 820  * -------------------------------------------------------------------- */
 821
 822 #if defined(CONFIG_SND_ATMEL_AC97C) || defined(CONFIG_SND_ATMEL_AC97C_MODULE)
 823 static u64 ac97_dmamask = DMA_BIT_MASK(32);
 824 static struct ac97c_platform_data ac97_data;
 825
 826 static struct resource ac97_resources[] = {
 827         [0] = {
 828                 .start  = AT91SAM9G45_BASE_AC97C,
 829                 .end    = AT91SAM9G45_BASE_AC97C + SZ_16K - 1,
 830                 .flags  = IORESOURCE_MEM,
 831         },
 832         [1] = {
 833                 .start  = AT91SAM9G45_ID_AC97C,
 834                 .end    = AT91SAM9G45_ID_AC97C,
 835                 .flags  = IORESOURCE_IRQ,
 836         },
 837 };
 838
 839 static struct platform_device at91sam9g45_ac97_device = {
 840         .name           = "atmel_ac97c",
 841         .id             = 0,
 842         .dev            = {
 843                                 .dma_mask               = &ac97_dmamask,
 844                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 845                                 .platform_data          = &ac97_data,
 846         },
 847         .resource       = ac97_resources,
 848         .num_resources  = ARRAY_SIZE(ac97_resources),
 849 };
 850
 851 void __init at91_add_device_ac97(struct ac97c_platform_data *data)
 852 {
 853         if (!data)
 854                 return;
 855
 856         at91_set_A_periph(AT91_PIN_PD8, 0);     /* AC97FS */
 857         at91_set_A_periph(AT91_PIN_PD9, 0);     /* AC97CK */
 858         at91_set_A_periph(AT91_PIN_PD7, 0);     /* AC97TX */
 859         at91_set_A_periph(AT91_PIN_PD6, 0);     /* AC97RX */
 860
 861         /* reset */
 862         if (data->reset_pin)
 863                 at91_set_gpio_output(data->reset_pin, 0);
 864
 865         ac97_data = *data;
 866         platform_device_register(&at91sam9g45_ac97_device);
 867 }
 868 #else
 869 void __init at91_add_device_ac97(struct ac97c_platform_data *data) {}
 870 #endif
 871
 872
 873 /* --------------------------------------------------------------------
 874  *  LCD Controller
 875  * -------------------------------------------------------------------- */
 876
 877 #if defined(CONFIG_FB_ATMEL) || defined(CONFIG_FB_ATMEL_MODULE)
 878 static u64 lcdc_dmamask = DMA_BIT_MASK(32);
 879 static struct atmel_lcdfb_info lcdc_data;
 880
 881 static struct resource lcdc_resources[] = {
 882         [0] = {
 883                 .start  = AT91SAM9G45_LCDC_BASE,
 884                 .end    = AT91SAM9G45_LCDC_BASE + SZ_4K - 1,
 885                 .flags  = IORESOURCE_MEM,
 886         },
 887         [1] = {
 888                 .start  = AT91SAM9G45_ID_LCDC,
 889                 .end    = AT91SAM9G45_ID_LCDC,
 890                 .flags  = IORESOURCE_IRQ,
 891         },
 892 };
 893
 894 static struct platform_device at91_lcdc_device = {
 895         .name           = "atmel_lcdfb",
 896         .id             = 0,
 897         .dev            = {
 898                                 .dma_mask               = &lcdc_dmamask,
 899                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
 900                                 .platform_data          = &lcdc_data,
 901         },
 902         .resource       = lcdc_resources,
 903         .num_resources  = ARRAY_SIZE(lcdc_resources),
 904 };
 905
 906 void __init at91_add_device_lcdc(struct atmel_lcdfb_info *data)
 907 {
 908         if (!data)
 909                 return;
 910
 911         at91_set_A_periph(AT91_PIN_PE0, 0);     /* LCDDPWR */
 912
 913         at91_set_A_periph(AT91_PIN_PE2, 0);     /* LCDCC */
 914         at91_set_A_periph(AT91_PIN_PE3, 0);     /* LCDVSYNC */
 915         at91_set_A_periph(AT91_PIN_PE4, 0);     /* LCDHSYNC */
 916         at91_set_A_periph(AT91_PIN_PE5, 0);     /* LCDDOTCK */
 917         at91_set_A_periph(AT91_PIN_PE6, 0);     /* LCDDEN */
 918         at91_set_A_periph(AT91_PIN_PE7, 0);     /* LCDD0 */
 919         at91_set_A_periph(AT91_PIN_PE8, 0);     /* LCDD1 */
 920         at91_set_A_periph(AT91_PIN_PE9, 0);     /* LCDD2 */
 921         at91_set_A_periph(AT91_PIN_PE10, 0);    /* LCDD3 */
 922         at91_set_A_periph(AT91_PIN_PE11, 0);    /* LCDD4 */
 923         at91_set_A_periph(AT91_PIN_PE12, 0);    /* LCDD5 */
 924         at91_set_A_periph(AT91_PIN_PE13, 0);    /* LCDD6 */
 925         at91_set_A_periph(AT91_PIN_PE14, 0);    /* LCDD7 */
 926         at91_set_A_periph(AT91_PIN_PE15, 0);    /* LCDD8 */
 927         at91_set_A_periph(AT91_PIN_PE16, 0);    /* LCDD9 */
 928         at91_set_A_periph(AT91_PIN_PE17, 0);    /* LCDD10 */
 929         at91_set_A_periph(AT91_PIN_PE18, 0);    /* LCDD11 */
 930         at91_set_A_periph(AT91_PIN_PE19, 0);    /* LCDD12 */
 931         at91_set_A_periph(AT91_PIN_PE20, 0);    /* LCDD13 */
 932         at91_set_A_periph(AT91_PIN_PE21, 0);    /* LCDD14 */
 933         at91_set_A_periph(AT91_PIN_PE22, 0);    /* LCDD15 */
 934         at91_set_A_periph(AT91_PIN_PE23, 0);    /* LCDD16 */
 935         at91_set_A_periph(AT91_PIN_PE24, 0);    /* LCDD17 */
 936         at91_set_A_periph(AT91_PIN_PE25, 0);    /* LCDD18 */
 937         at91_set_A_periph(AT91_PIN_PE26, 0);    /* LCDD19 */
 938         at91_set_A_periph(AT91_PIN_PE27, 0);    /* LCDD20 */
 939         at91_set_A_periph(AT91_PIN_PE28, 0);    /* LCDD21 */
 940         at91_set_A_periph(AT91_PIN_PE29, 0);    /* LCDD22 */
 941         at91_set_A_periph(AT91_PIN_PE30, 0);    /* LCDD23 */
 942
 943         lcdc_data = *data;
 944         platform_device_register(&at91_lcdc_device);
 945 }
 946 #else
 947 void __init at91_add_device_lcdc(struct atmel_lcdfb_info *data) {}
 948 #endif
 949
 950
 951 /* --------------------------------------------------------------------
 952  *  Timer/Counter block
 953  * -------------------------------------------------------------------- */
 954
 955 #ifdef CONFIG_ATMEL_TCLIB
 956 static struct resource tcb0_resources[] = {
 957         [0] = {
 958                 .start  = AT91SAM9G45_BASE_TCB0,
 959                 .end    = AT91SAM9G45_BASE_TCB0 + SZ_16K - 1,
 960                 .flags  = IORESOURCE_MEM,
 961         },
 962         [1] = {
 963                 .start  = AT91SAM9G45_ID_TCB,
 964                 .end    = AT91SAM9G45_ID_TCB,
 965                 .flags  = IORESOURCE_IRQ,
 966         },
 967 };
 968
 969 static struct platform_device at91sam9g45_tcb0_device = {
 970         .name           = "atmel_tcb",
 971         .id             = 0,
 972         .resource       = tcb0_resources,
 973         .num_resources  = ARRAY_SIZE(tcb0_resources),
 974 };
 975
 976 /* TCB1 begins with TC3 */
 977 static struct resource tcb1_resources[] = {
 978         [0] = {
 979                 .start  = AT91SAM9G45_BASE_TCB1,
 980                 .end    = AT91SAM9G45_BASE_TCB1 + SZ_16K - 1,
 981                 .flags  = IORESOURCE_MEM,
 982         },
 983         [1] = {
 984                 .start  = AT91SAM9G45_ID_TCB,
 985                 .end    = AT91SAM9G45_ID_TCB,
 986                 .flags  = IORESOURCE_IRQ,
 987         },
 988 };
 989
 990 static struct platform_device at91sam9g45_tcb1_device = {
 991         .name           = "atmel_tcb",
 992         .id             = 1,
 993         .resource       = tcb1_resources,
 994         .num_resources  = ARRAY_SIZE(tcb1_resources),
 995 };
 996
 997 static void __init at91_add_device_tc(void)
 998 {
 999         platform_device_register(&at91sam9g45_tcb0_device);
1000         platform_device_register(&at91sam9g45_tcb1_device);
1001 }
1002 #else
1003 static void __init at91_add_device_tc(void) { }
1004 #endif
1005
1006
1007 /* --------------------------------------------------------------------
1008  *  RTC
1009  * -------------------------------------------------------------------- */
1010
1011 #if defined(CONFIG_RTC_DRV_AT91RM9200) || defined(CONFIG_RTC_DRV_AT91RM9200_MODULE)
1012 static struct platform_device at91sam9g45_rtc_device = {
1013         .name           = "at91_rtc",
1014         .id             = -1,
1015         .num_resources  = 0,
1016 };
1017
1018 static void __init at91_add_device_rtc(void)
1019 {
1020         platform_device_register(&at91sam9g45_rtc_device);
1021 }
1022 #else
1023 static void __init at91_add_device_rtc(void) {}
1024 #endif
1025
1026
1027 /* --------------------------------------------------------------------
1028  *  Touchscreen
1029  * -------------------------------------------------------------------- */
1030
1031 #if defined(CONFIG_TOUCHSCREEN_ATMEL_TSADCC) || defined(CONFIG_TOUCHSCREEN_ATMEL_TSADCC_MODULE)
1032 static u64 tsadcc_dmamask = DMA_BIT_MASK(32);
1033 static struct at91_tsadcc_data tsadcc_data;
1034
1035 static struct resource tsadcc_resources[] = {
1036         [0] = {
1037                 .start  = AT91SAM9G45_BASE_TSC,
1038                 .end    = AT91SAM9G45_BASE_TSC + SZ_16K - 1,
1039                 .flags  = IORESOURCE_MEM,
1040         },
1041         [1] = {
1042                 .start  = AT91SAM9G45_ID_TSC,
1043                 .end    = AT91SAM9G45_ID_TSC,
1044                 .flags  = IORESOURCE_IRQ,
1045         }
1046 };
1047
1048 static struct platform_device at91sam9g45_tsadcc_device = {
1049         .name           = "atmel_tsadcc",
1050         .id             = -1,
1051         .dev            = {
1052                                 .dma_mask               = &tsadcc_dmamask,
1053                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1054                                 .platform_data          = &tsadcc_data,
1055         },
1056         .resource       = tsadcc_resources,
1057         .num_resources  = ARRAY_SIZE(tsadcc_resources),
1058 };
1059
1060 void __init at91_add_device_tsadcc(struct at91_tsadcc_data *data)
1061 {
1062         if (!data)
1063                 return;
1064
1065         at91_set_gpio_input(AT91_PIN_PD20, 0);  /* AD0_XR */
1066         at91_set_gpio_input(AT91_PIN_PD21, 0);  /* AD1_XL */
1067         at91_set_gpio_input(AT91_PIN_PD22, 0);  /* AD2_YT */
1068         at91_set_gpio_input(AT91_PIN_PD23, 0);  /* AD3_TB */
1069
1070         tsadcc_data = *data;
1071         platform_device_register(&at91sam9g45_tsadcc_device);
1072 }
1073 #else
1074 void __init at91_add_device_tsadcc(struct at91_tsadcc_data *data) {}
1075 #endif
1076
1077
1078 /* --------------------------------------------------------------------
1079  *  RTT
1080  * -------------------------------------------------------------------- */
1081
1082 static struct resource rtt_resources[] = {
1083         {
1084                 .start  = AT91_BASE_SYS + AT91_RTT,
1085                 .end    = AT91_BASE_SYS + AT91_RTT + SZ_16 - 1,
1086                 .flags  = IORESOURCE_MEM,
1087         }
1088 };
1089
1090 static struct platform_device at91sam9g45_rtt_device = {
1091         .name           = "at91_rtt",
1092         .id             = 0,
1093         .resource       = rtt_resources,
1094         .num_resources  = ARRAY_SIZE(rtt_resources),
1095 };
1096
1097 static void __init at91_add_device_rtt(void)
1098 {
1099         platform_device_register(&at91sam9g45_rtt_device);
1100 }
1101
1102
1103 /* --------------------------------------------------------------------
1104  *  Watchdog
1105  * -------------------------------------------------------------------- */
1106
1107 #if defined(CONFIG_AT91SAM9X_WATCHDOG) || defined(CONFIG_AT91SAM9X_WATCHDOG_MODULE)
1108 static struct platform_device at91sam9g45_wdt_device = {
1109         .name           = "at91_wdt",
1110         .id             = -1,
1111         .num_resources  = 0,
1112 };
1113
1114 static void __init at91_add_device_watchdog(void)
1115 {
1116         platform_device_register(&at91sam9g45_wdt_device);
1117 }
1118 #else
1119 static void __init at91_add_device_watchdog(void) {}
1120 #endif
1121
1122
1123 /* --------------------------------------------------------------------
1124  *  PWM
1125  * --------------------------------------------------------------------*/
1126
1127 #if defined(CONFIG_ATMEL_PWM) || defined(CONFIG_ATMEL_PWM_MODULE)
1128 static u32 pwm_mask;
1129
1130 static struct resource pwm_resources[] = {
1131         [0] = {
1132                 .start  = AT91SAM9G45_BASE_PWMC,
1133                 .end    = AT91SAM9G45_BASE_PWMC + SZ_16K - 1,
1134                 .flags  = IORESOURCE_MEM,
1135         },
1136         [1] = {
1137                 .start  = AT91SAM9G45_ID_PWMC,
1138                 .end    = AT91SAM9G45_ID_PWMC,
1139                 .flags  = IORESOURCE_IRQ,
1140         },
1141 };
1142
1143 static struct platform_device at91sam9g45_pwm0_device = {
1144         .name   = "atmel_pwm",
1145         .id     = -1,
1146         .dev    = {
1147                 .platform_data          = &pwm_mask,
1148         },
1149         .resource       = pwm_resources,
1150         .num_resources  = ARRAY_SIZE(pwm_resources),
1151 };
1152
1153 void __init at91_add_device_pwm(u32 mask)
1154 {
1155         if (mask & (1 << AT91_PWM0))
1156                 at91_set_B_periph(AT91_PIN_PD24, 1);    /* enable PWM0 */
1157
1158         if (mask & (1 << AT91_PWM1))
1159                 at91_set_B_periph(AT91_PIN_PD31, 1);    /* enable PWM1 */
1160
1161         if (mask & (1 << AT91_PWM2))
1162                 at91_set_B_periph(AT91_PIN_PD26, 1);    /* enable PWM2 */
1163
1164         if (mask & (1 << AT91_PWM3))
1165                 at91_set_B_periph(AT91_PIN_PD0, 1);     /* enable PWM3 */
1166
1167         pwm_mask = mask;
1168
1169         platform_device_register(&at91sam9g45_pwm0_device);
1170 }
1171 #else
1172 void __init at91_add_device_pwm(u32 mask) {}
1173 #endif
1174
1175
1176 /* --------------------------------------------------------------------
1177  *  SSC -- Synchronous Serial Controller
1178  * -------------------------------------------------------------------- */
1179
1180 #if defined(CONFIG_ATMEL_SSC) || defined(CONFIG_ATMEL_SSC_MODULE)
1181 static u64 ssc0_dmamask = DMA_BIT_MASK(32);
1182
1183 static struct resource ssc0_resources[] = {
1184         [0] = {
1185                 .start  = AT91SAM9G45_BASE_SSC0,
1186                 .end    = AT91SAM9G45_BASE_SSC0 + SZ_16K - 1,
1187                 .flags  = IORESOURCE_MEM,
1188         },
1189         [1] = {
1190                 .start  = AT91SAM9G45_ID_SSC0,
1191                 .end    = AT91SAM9G45_ID_SSC0,
1192                 .flags  = IORESOURCE_IRQ,
1193         },
1194 };
1195
1196 static struct platform_device at91sam9g45_ssc0_device = {
1197         .name   = "ssc",
1198         .id     = 0,
1199         .dev    = {
1200                 .dma_mask               = &ssc0_dmamask,
1201                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1202         },
1203         .resource       = ssc0_resources,
1204         .num_resources  = ARRAY_SIZE(ssc0_resources),
1205 };
1206
1207 static inline void configure_ssc0_pins(unsigned pins)
1208 {
1209         if (pins & ATMEL_SSC_TF)
1210                 at91_set_A_periph(AT91_PIN_PD1, 1);
1211         if (pins & ATMEL_SSC_TK)
1212                 at91_set_A_periph(AT91_PIN_PD0, 1);
1213         if (pins & ATMEL_SSC_TD)
1214                 at91_set_A_periph(AT91_PIN_PD2, 1);
1215         if (pins & ATMEL_SSC_RD)
1216                 at91_set_A_periph(AT91_PIN_PD3, 1);
1217         if (pins & ATMEL_SSC_RK)
1218                 at91_set_A_periph(AT91_PIN_PD4, 1);
1219         if (pins & ATMEL_SSC_RF)
1220                 at91_set_A_periph(AT91_PIN_PD5, 1);
1221 }
1222
1223 static u64 ssc1_dmamask = DMA_BIT_MASK(32);
1224
1225 static struct resource ssc1_resources[] = {
1226         [0] = {
1227                 .start  = AT91SAM9G45_BASE_SSC1,
1228                 .end    = AT91SAM9G45_BASE_SSC1 + SZ_16K - 1,
1229                 .flags  = IORESOURCE_MEM,
1230         },
1231         [1] = {
1232                 .start  = AT91SAM9G45_ID_SSC1,
1233                 .end    = AT91SAM9G45_ID_SSC1,
1234                 .flags  = IORESOURCE_IRQ,
1235         },
1236 };
1237
1238 static struct platform_device at91sam9g45_ssc1_device = {
1239         .name   = "ssc",
1240         .id     = 1,
1241         .dev    = {
1242                 .dma_mask               = &ssc1_dmamask,
1243                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1244         },
1245         .resource       = ssc1_resources,
1246         .num_resources  = ARRAY_SIZE(ssc1_resources),
1247 };
1248
1249 static inline void configure_ssc1_pins(unsigned pins)
1250 {
1251         if (pins & ATMEL_SSC_TF)
1252                 at91_set_A_periph(AT91_PIN_PD14, 1);
1253         if (pins & ATMEL_SSC_TK)
1254                 at91_set_A_periph(AT91_PIN_PD12, 1);
1255         if (pins & ATMEL_SSC_TD)
1256                 at91_set_A_periph(AT91_PIN_PD10, 1);
1257         if (pins & ATMEL_SSC_RD)
1258                 at91_set_A_periph(AT91_PIN_PD11, 1);
1259         if (pins & ATMEL_SSC_RK)
1260                 at91_set_A_periph(AT91_PIN_PD13, 1);
1261         if (pins & ATMEL_SSC_RF)
1262                 at91_set_A_periph(AT91_PIN_PD15, 1);
1263 }
1264
1265 /*
1266  * SSC controllers are accessed through library code, instead of any
1267  * kind of all-singing/all-dancing driver.  For example one could be
1268  * used by a particular I2S audio codec's driver, while another one
1269  * on the same system might be used by a custom data capture driver.
1270  */
1271 void __init at91_add_device_ssc(unsigned id, unsigned pins)
1272 {
1273         struct platform_device *pdev;
1274
1275         /*
1276          * NOTE: caller is responsible for passing information matching
1277          * "pins" to whatever will be using each particular controller.
1278          */
1279         switch (id) {
1280         case AT91SAM9G45_ID_SSC0:
1281                 pdev = &at91sam9g45_ssc0_device;
1282                 configure_ssc0_pins(pins);
1283                 break;
1284         case AT91SAM9G45_ID_SSC1:
1285                 pdev = &at91sam9g45_ssc1_device;
1286                 configure_ssc1_pins(pins);
1287                 break;
1288         default:
1289                 return;
1290         }
1291
1292         platform_device_register(pdev);
1293 }
1294
1295 #else
1296 void __init at91_add_device_ssc(unsigned id, unsigned pins) {}
1297 #endif
1298
1299
1300 /* --------------------------------------------------------------------
1301  *  UART
1302  * -------------------------------------------------------------------- */
1303
1304 #if defined(CONFIG_SERIAL_ATMEL)
1305 static struct resource dbgu_resources[] = {
1306         [0] = {
1307                 .start  = AT91_VA_BASE_SYS + AT91_DBGU,
1308                 .end    = AT91_VA_BASE_SYS + AT91_DBGU + SZ_512 - 1,
1309                 .flags  = IORESOURCE_MEM,
1310         },
1311         [1] = {
1312                 .start  = AT91_ID_SYS,
1313                 .end    = AT91_ID_SYS,
1314                 .flags  = IORESOURCE_IRQ,
1315         },
1316 };
1317
1318 static struct atmel_uart_data dbgu_data = {
1319         .use_dma_tx     = 0,
1320         .use_dma_rx     = 0,
1321         .regs           = (void __iomem *)(AT91_VA_BASE_SYS + AT91_DBGU),
1322 };
1323
1324 static u64 dbgu_dmamask = DMA_BIT_MASK(32);
1325
1326 static struct platform_device at91sam9g45_dbgu_device = {
1327         .name           = "atmel_usart",
1328         .id             = 0,
1329         .dev            = {
1330                                 .dma_mask               = &dbgu_dmamask,
1331                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1332                                 .platform_data          = &dbgu_data,
1333         },
1334         .resource       = dbgu_resources,
1335         .num_resources  = ARRAY_SIZE(dbgu_resources),
1336 };
1337
1338 static inline void configure_dbgu_pins(void)
1339 {
1340         at91_set_A_periph(AT91_PIN_PB12, 0);            /* DRXD */
1341         at91_set_A_periph(AT91_PIN_PB13, 1);            /* DTXD */
1342 }
1343
1344 static struct resource uart0_resources[] = {
1345         [0] = {
1346                 .start  = AT91SAM9G45_BASE_US0,
1347                 .end    = AT91SAM9G45_BASE_US0 + SZ_16K - 1,
1348                 .flags  = IORESOURCE_MEM,
1349         },
1350         [1] = {
1351                 .start  = AT91SAM9G45_ID_US0,
1352                 .end    = AT91SAM9G45_ID_US0,
1353                 .flags  = IORESOURCE_IRQ,
1354         },
1355 };
1356
1357 static struct atmel_uart_data uart0_data = {
1358         .use_dma_tx     = 1,
1359         .use_dma_rx     = 1,
1360 };
1361
1362 static u64 uart0_dmamask = DMA_BIT_MASK(32);
1363
1364 static struct platform_device at91sam9g45_uart0_device = {
1365         .name           = "atmel_usart",
1366         .id             = 1,
1367         .dev            = {
1368                                 .dma_mask               = &uart0_dmamask,
1369                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1370                                 .platform_data          = &uart0_data,
1371         },
1372         .resource       = uart0_resources,
1373         .num_resources  = ARRAY_SIZE(uart0_resources),
1374 };
1375
1376 static inline void configure_usart0_pins(unsigned pins)
1377 {
1378         at91_set_A_periph(AT91_PIN_PB19, 1);            /* TXD0 */
1379         at91_set_A_periph(AT91_PIN_PB18, 0);            /* RXD0 */
1380
1381         if (pins & ATMEL_UART_RTS)
1382                 at91_set_B_periph(AT91_PIN_PB17, 0);    /* RTS0 */
1383         if (pins & ATMEL_UART_CTS)
1384                 at91_set_B_periph(AT91_PIN_PB15, 0);    /* CTS0 */
1385 }
1386
1387 static struct resource uart1_resources[] = {
1388         [0] = {
1389                 .start  = AT91SAM9G45_BASE_US1,
1390                 .end    = AT91SAM9G45_BASE_US1 + SZ_16K - 1,
1391                 .flags  = IORESOURCE_MEM,
1392         },
1393         [1] = {
1394                 .start  = AT91SAM9G45_ID_US1,
1395                 .end    = AT91SAM9G45_ID_US1,
1396                 .flags  = IORESOURCE_IRQ,
1397         },
1398 };
1399
1400 static struct atmel_uart_data uart1_data = {
1401         .use_dma_tx     = 1,
1402         .use_dma_rx     = 1,
1403 };
1404
1405 static u64 uart1_dmamask = DMA_BIT_MASK(32);
1406
1407 static struct platform_device at91sam9g45_uart1_device = {
1408         .name           = "atmel_usart",
1409         .id             = 2,
1410         .dev            = {
1411                                 .dma_mask               = &uart1_dmamask,
1412                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1413                                 .platform_data          = &uart1_data,
1414         },
1415         .resource       = uart1_resources,
1416         .num_resources  = ARRAY_SIZE(uart1_resources),
1417 };
1418
1419 static inline void configure_usart1_pins(unsigned pins)
1420 {
1421         at91_set_A_periph(AT91_PIN_PB4, 1);             /* TXD1 */
1422         at91_set_A_periph(AT91_PIN_PB5, 0);             /* RXD1 */
1423
1424         if (pins & ATMEL_UART_RTS)
1425                 at91_set_A_periph(AT91_PIN_PD16, 0);    /* RTS1 */
1426         if (pins & ATMEL_UART_CTS)
1427                 at91_set_A_periph(AT91_PIN_PD17, 0);    /* CTS1 */
1428 }
1429
1430 static struct resource uart2_resources[] = {
1431         [0] = {
1432                 .start  = AT91SAM9G45_BASE_US2,
1433                 .end    = AT91SAM9G45_BASE_US2 + SZ_16K - 1,
1434                 .flags  = IORESOURCE_MEM,
1435         },
1436         [1] = {
1437                 .start  = AT91SAM9G45_ID_US2,
1438                 .end    = AT91SAM9G45_ID_US2,
1439                 .flags  = IORESOURCE_IRQ,
1440         },
1441 };
1442
1443 static struct atmel_uart_data uart2_data = {
1444         .use_dma_tx     = 1,
1445         .use_dma_rx     = 1,
1446 };
1447
1448 static u64 uart2_dmamask = DMA_BIT_MASK(32);
1449
1450 static struct platform_device at91sam9g45_uart2_device = {
1451         .name           = "atmel_usart",
1452         .id             = 3,
1453         .dev            = {
1454                                 .dma_mask               = &uart2_dmamask,
1455                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1456                                 .platform_data          = &uart2_data,
1457         },
1458         .resource       = uart2_resources,
1459         .num_resources  = ARRAY_SIZE(uart2_resources),
1460 };
1461
1462 static inline void configure_usart2_pins(unsigned pins)
1463 {
1464         at91_set_A_periph(AT91_PIN_PB6, 1);             /* TXD2 */
1465         at91_set_A_periph(AT91_PIN_PB7, 0);             /* RXD2 */
1466
1467         if (pins & ATMEL_UART_RTS)
1468                 at91_set_B_periph(AT91_PIN_PC9, 0);     /* RTS2 */
1469         if (pins & ATMEL_UART_CTS)
1470                 at91_set_B_periph(AT91_PIN_PC11, 0);    /* CTS2 */
1471 }
1472
1473 static struct resource uart3_resources[] = {
1474         [0] = {
1475                 .start  = AT91SAM9G45_BASE_US3,
1476                 .end    = AT91SAM9G45_BASE_US3 + SZ_16K - 1,
1477                 .flags  = IORESOURCE_MEM,
1478         },
1479         [1] = {
1480                 .start  = AT91SAM9G45_ID_US3,
1481                 .end    = AT91SAM9G45_ID_US3,
1482                 .flags  = IORESOURCE_IRQ,
1483         },
1484 };
1485
1486 static struct atmel_uart_data uart3_data = {
1487         .use_dma_tx     = 1,
1488         .use_dma_rx     = 1,
1489 };
1490
1491 static u64 uart3_dmamask = DMA_BIT_MASK(32);
1492
1493 static struct platform_device at91sam9g45_uart3_device = {
1494         .name           = "atmel_usart",
1495         .id             = 4,
1496         .dev            = {
1497                                 .dma_mask               = &uart3_dmamask,
1498                                 .coherent_dma_mask      = DMA_BIT_MASK(32),
1499                                 .platform_data          = &uart3_data,
1500         },
1501         .resource       = uart3_resources,
1502         .num_resources  = ARRAY_SIZE(uart3_resources),
1503 };
1504
1505 static inline void configure_usart3_pins(unsigned pins)
1506 {
1507         at91_set_A_periph(AT91_PIN_PB8, 1);             /* TXD3 */
1508         at91_set_A_periph(AT91_PIN_PB9, 0);             /* RXD3 */
1509
1510         if (pins & ATMEL_UART_RTS)
1511                 at91_set_B_periph(AT91_PIN_PA23, 0);    /* RTS3 */
1512         if (pins & ATMEL_UART_CTS)
1513                 at91_set_B_periph(AT91_PIN_PA24, 0);    /* CTS3 */
1514 }
1515
1516 static struct platform_device *__initdata at91_uarts[ATMEL_MAX_UART];   /* the UARTs to use */
1517 struct platform_device *atmel_default_console_device;   /* the serial console device */
1518
1519 void __init at91_register_uart(unsigned id, unsigned portnr, unsigned pins)
1520 {
1521         struct platform_device *pdev;
1522         struct atmel_uart_data *pdata;
1523
1524         switch (id) {
1525                 case 0:         /* DBGU */
1526                         pdev = &at91sam9g45_dbgu_device;
1527                         configure_dbgu_pins();
1528                         break;
1529                 case AT91SAM9G45_ID_US0:
1530                         pdev = &at91sam9g45_uart0_device;
1531                         configure_usart0_pins(pins);
1532                         break;
1533                 case AT91SAM9G45_ID_US1:
1534                         pdev = &at91sam9g45_uart1_device;
1535                         configure_usart1_pins(pins);
1536                         break;
1537                 case AT91SAM9G45_ID_US2:
1538                         pdev = &at91sam9g45_uart2_device;
1539                         configure_usart2_pins(pins);
1540                         break;
1541                 case AT91SAM9G45_ID_US3:
1542                         pdev = &at91sam9g45_uart3_device;
1543                         configure_usart3_pins(pins);
1544                         break;
1545                 default:
1546                         return;
1547         }
1548         pdata = pdev->dev.platform_data;
1549         pdata->num = portnr;            /* update to mapped ID */
1550
1551         if (portnr < ATMEL_MAX_UART)
1552                 at91_uarts[portnr] = pdev;
1553 }
1554
1555 void __init at91_set_serial_console(unsigned portnr)
1556 {
1557         if (portnr < ATMEL_MAX_UART) {
1558                 atmel_default_console_device = at91_uarts[portnr];
1559                 at91sam9g45_set_console_clock(at91_uarts[portnr]->id);
1560         }
1561 }
1562
1563 void __init at91_add_device_serial(void)
1564 {
1565         int i;
1566
1567         for (i = 0; i < ATMEL_MAX_UART; i++) {
1568                 if (at91_uarts[i])
1569                         platform_device_register(at91_uarts[i]);
1570         }
1571
1572         if (!atmel_default_console_device)
1573                 printk(KERN_INFO "AT91: No default serial console defined.\n");
1574 }
1575 #else
1576 void __init at91_register_uart(unsigned id, unsigned portnr, unsigned pins) {}
1577 void __init at91_set_serial_console(unsigned portnr) {}
1578 void __init at91_add_device_serial(void) {}
1579 #endif
1580
1581
1582 /* -------------------------------------------------------------------- */
1583 /*
1584  * These devices are always present and don't need any board-specific
1585  * setup.
1586  */
1587 static int __init at91_add_standard_devices(void)
1588 {
1589         at91_add_device_hdmac();
1590         at91_add_device_rtc();
1591         at91_add_device_rtt();
1592         at91_add_device_watchdog();
1593         at91_add_device_tc();
1594         return 0;
1595 }
1596
1597 arch_initcall(at91_add_standard_devices);