1/* 2 * Hawkboard.org based on TI's OMAP-L138 Platform 3 * 4 * Initial code: Syed Mohammed Khasim 5 * 6 * Copyright (C) 2009 Texas Instruments Incorporated - https://www.ti.com 7 * 8 * This file is licensed under the terms of the GNU General Public License 9 * version 2. This program is licensed "as is" without any warranty of 10 * any kind, whether express or implied. 11 */ 12#include <linux/kernel.h> 13#include <linux/init.h> 14#include <linux/console.h> 15#include <linux/interrupt.h> 16#include <linux/gpio.h> 17#include <linux/gpio/machine.h> 18#include <linux/mtd/partitions.h> 19#include <linux/mtd/rawnand.h> 20#include <linux/platform_data/gpio-davinci.h> 21#include <linux/platform_data/mtd-davinci.h> 22#include <linux/platform_data/mtd-davinci-aemif.h> 23#include <linux/platform_data/ti-aemif.h> 24#include <linux/regulator/fixed.h> 25#include <linux/regulator/machine.h> 26 27#include <asm/mach-types.h> 28#include <asm/mach/arch.h> 29 30#include <mach/common.h> 31#include <mach/da8xx.h> 32#include <mach/mux.h> 33 34#define HAWKBOARD_PHY_ID "davinci_mdio-0:07" 35 36#define DA850_USB1_VBUS_PIN GPIO_TO_PIN(2, 4) 37#define DA850_USB1_OC_PIN GPIO_TO_PIN(6, 13) 38 39static short omapl138_hawk_mii_pins[] __initdata = { 40 DA850_MII_TXEN, DA850_MII_TXCLK, DA850_MII_COL, DA850_MII_TXD_3, 41 DA850_MII_TXD_2, DA850_MII_TXD_1, DA850_MII_TXD_0, DA850_MII_RXER, 42 DA850_MII_CRS, DA850_MII_RXCLK, DA850_MII_RXDV, DA850_MII_RXD_3, 43 DA850_MII_RXD_2, DA850_MII_RXD_1, DA850_MII_RXD_0, DA850_MDIO_CLK, 44 DA850_MDIO_D, 45 -1 46}; 47 48static __init void omapl138_hawk_config_emac(void) 49{ 50 void __iomem *cfgchip3 = DA8XX_SYSCFG0_VIRT(DA8XX_CFGCHIP3_REG); 51 int ret; 52 u32 val; 53 struct davinci_soc_info *soc_info = &davinci_soc_info; 54 55 val = __raw_readl(cfgchip3); 56 val &= ~BIT(8); 57 ret = davinci_cfg_reg_list(omapl138_hawk_mii_pins); 58 if (ret) { 59 pr_warn("%s: CPGMAC/MII mux setup failed: %d\n", __func__, ret); 60 return; 61 } 62 63 /* configure the CFGCHIP3 register for MII */ 64 __raw_writel(val, cfgchip3); 65 pr_info("EMAC: MII PHY configured\n"); 66 67 soc_info->emac_pdata->phy_id = HAWKBOARD_PHY_ID; 68 69 ret = da8xx_register_emac(); 70 if (ret) 71 pr_warn("%s: EMAC registration failed: %d\n", __func__, ret); 72} 73 74/* 75 * The following EDMA channels/slots are not being used by drivers (for 76 * example: Timer, GPIO, UART events etc) on da850/omap-l138 EVM/Hawkboard, 77 * hence they are being reserved for codecs on the DSP side. 78 */ 79static const s16 da850_dma0_rsv_chans[][2] = { 80 /* (offset, number) */ 81 { 8, 6}, 82 {24, 4}, 83 {30, 2}, 84 {-1, -1} 85}; 86 87static const s16 da850_dma0_rsv_slots[][2] = { 88 /* (offset, number) */ 89 { 8, 6}, 90 {24, 4}, 91 {30, 50}, 92 {-1, -1} 93}; 94 95static const s16 da850_dma1_rsv_chans[][2] = { 96 /* (offset, number) */ 97 { 0, 28}, 98 {30, 2}, 99 {-1, -1} 100}; 101 102static const s16 da850_dma1_rsv_slots[][2] = { 103 /* (offset, number) */ 104 { 0, 28}, 105 {30, 90}, 106 {-1, -1} 107}; 108 109static struct edma_rsv_info da850_edma_cc0_rsv = { 110 .rsv_chans = da850_dma0_rsv_chans, 111 .rsv_slots = da850_dma0_rsv_slots, 112}; 113 114static struct edma_rsv_info da850_edma_cc1_rsv = { 115 .rsv_chans = da850_dma1_rsv_chans, 116 .rsv_slots = da850_dma1_rsv_slots, 117}; 118 119static struct edma_rsv_info *da850_edma_rsv[2] = { 120 &da850_edma_cc0_rsv, 121 &da850_edma_cc1_rsv, 122}; 123 124static const short hawk_mmcsd0_pins[] = { 125 DA850_MMCSD0_DAT_0, DA850_MMCSD0_DAT_1, DA850_MMCSD0_DAT_2, 126 DA850_MMCSD0_DAT_3, DA850_MMCSD0_CLK, DA850_MMCSD0_CMD, 127 DA850_GPIO3_12, DA850_GPIO3_13, 128 -1 129}; 130 131#define DA850_HAWK_MMCSD_CD_PIN GPIO_TO_PIN(3, 12) 132#define DA850_HAWK_MMCSD_WP_PIN GPIO_TO_PIN(3, 13) 133 134static struct gpiod_lookup_table mmc_gpios_table = { 135 .dev_id = "da830-mmc.0", 136 .table = { 137 GPIO_LOOKUP("davinci_gpio", DA850_HAWK_MMCSD_CD_PIN, "cd", 138 GPIO_ACTIVE_LOW), 139 GPIO_LOOKUP("davinci_gpio", DA850_HAWK_MMCSD_WP_PIN, "wp", 140 GPIO_ACTIVE_LOW), 141 }, 142}; 143 144static struct davinci_mmc_config da850_mmc_config = { 145 .wires = 4, 146 .max_freq = 50000000, 147 .caps = MMC_CAP_MMC_HIGHSPEED | MMC_CAP_SD_HIGHSPEED, 148}; 149 150static __init void omapl138_hawk_mmc_init(void) 151{ 152 int ret; 153 154 ret = davinci_cfg_reg_list(hawk_mmcsd0_pins); 155 if (ret) { 156 pr_warn("%s: MMC/SD0 mux setup failed: %d\n", __func__, ret); 157 return; 158 } 159 160 gpiod_add_lookup_table(&mmc_gpios_table); 161 162 ret = da8xx_register_mmcsd0(&da850_mmc_config); 163 if (ret) { 164 pr_warn("%s: MMC/SD0 registration failed: %d\n", __func__, ret); 165 goto mmc_setup_mmcsd_fail; 166 } 167 168 return; 169 170mmc_setup_mmcsd_fail: 171 gpiod_remove_lookup_table(&mmc_gpios_table); 172} 173 174static struct mtd_partition omapl138_hawk_nandflash_partition[] = { 175 { 176 .name = "u-boot env", 177 .offset = 0, 178 .size = SZ_128K, 179 .mask_flags = MTD_WRITEABLE, 180 }, 181 { 182 .name = "u-boot", 183 .offset = MTDPART_OFS_APPEND, 184 .size = SZ_512K, 185 .mask_flags = MTD_WRITEABLE, 186 }, 187 { 188 .name = "free space", 189 .offset = MTDPART_OFS_APPEND, 190 .size = MTDPART_SIZ_FULL, 191 .mask_flags = 0, 192 }, 193}; 194 195static struct davinci_aemif_timing omapl138_hawk_nandflash_timing = { 196 .wsetup = 24, 197 .wstrobe = 21, 198 .whold = 14, 199 .rsetup = 19, 200 .rstrobe = 50, 201 .rhold = 0, 202 .ta = 20, 203}; 204 205static struct davinci_nand_pdata omapl138_hawk_nandflash_data = { 206 .core_chipsel = 1, 207 .parts = omapl138_hawk_nandflash_partition, 208 .nr_parts = ARRAY_SIZE(omapl138_hawk_nandflash_partition), 209 .engine_type = NAND_ECC_ENGINE_TYPE_ON_HOST, 210 .ecc_bits = 4, 211 .bbt_options = NAND_BBT_USE_FLASH, 212 .options = NAND_BUSWIDTH_16, 213 .timing = &omapl138_hawk_nandflash_timing, 214 .mask_chipsel = 0, 215 .mask_ale = 0, 216 .mask_cle = 0, 217}; 218 219static struct resource omapl138_hawk_nandflash_resource[] = { 220 { 221 .start = DA8XX_AEMIF_CS3_BASE, 222 .end = DA8XX_AEMIF_CS3_BASE + SZ_32M, 223 .flags = IORESOURCE_MEM, 224 }, 225 { 226 .start = DA8XX_AEMIF_CTL_BASE, 227 .end = DA8XX_AEMIF_CTL_BASE + SZ_32K, 228 .flags = IORESOURCE_MEM, 229 }, 230}; 231 232static struct resource omapl138_hawk_aemif_resource[] = { 233 { 234 .start = DA8XX_AEMIF_CTL_BASE, 235 .end = DA8XX_AEMIF_CTL_BASE + SZ_32K, 236 .flags = IORESOURCE_MEM, 237 } 238}; 239 240static struct aemif_abus_data omapl138_hawk_aemif_abus_data[] = { 241 { 242 .cs = 3, 243 } 244}; 245 246static struct platform_device omapl138_hawk_aemif_devices[] = { 247 { 248 .name = "davinci_nand", 249 .id = -1, 250 .dev = { 251 .platform_data = &omapl138_hawk_nandflash_data, 252 }, 253 .resource = omapl138_hawk_nandflash_resource, 254 .num_resources = ARRAY_SIZE(omapl138_hawk_nandflash_resource), 255 } 256}; 257 258static struct aemif_platform_data omapl138_hawk_aemif_pdata = { 259 .cs_offset = 2, 260 .abus_data = omapl138_hawk_aemif_abus_data, 261 .num_abus_data = ARRAY_SIZE(omapl138_hawk_aemif_abus_data), 262 .sub_devices = omapl138_hawk_aemif_devices, 263 .num_sub_devices = ARRAY_SIZE(omapl138_hawk_aemif_devices), 264}; 265 266static struct platform_device omapl138_hawk_aemif_device = { 267 .name = "ti-aemif", 268 .id = -1, 269 .dev = { 270 .platform_data = &omapl138_hawk_aemif_pdata, 271 }, 272 .resource = omapl138_hawk_aemif_resource, 273 .num_resources = ARRAY_SIZE(omapl138_hawk_aemif_resource), 274}; 275 276static const short omapl138_hawk_nand_pins[] = { 277 DA850_EMA_WAIT_1, DA850_NEMA_OE, DA850_NEMA_WE, DA850_NEMA_CS_3, 278 DA850_EMA_D_0, DA850_EMA_D_1, DA850_EMA_D_2, DA850_EMA_D_3, 279 DA850_EMA_D_4, DA850_EMA_D_5, DA850_EMA_D_6, DA850_EMA_D_7, 280 DA850_EMA_D_8, DA850_EMA_D_9, DA850_EMA_D_10, DA850_EMA_D_11, 281 DA850_EMA_D_12, DA850_EMA_D_13, DA850_EMA_D_14, DA850_EMA_D_15, 282 DA850_EMA_A_1, DA850_EMA_A_2, 283 -1 284}; 285 286static int omapl138_hawk_register_aemif(void) 287{ 288 int ret; 289 290 ret = davinci_cfg_reg_list(omapl138_hawk_nand_pins); 291 if (ret) 292 pr_warn("%s: NAND mux setup failed: %d\n", __func__, ret); 293 294 return platform_device_register(&omapl138_hawk_aemif_device); 295} 296 297static const short da850_hawk_usb11_pins[] = { 298 DA850_GPIO2_4, DA850_GPIO6_13, 299 -1 300}; 301 302static struct regulator_consumer_supply hawk_usb_supplies[] = { 303 REGULATOR_SUPPLY("vbus", NULL), 304}; 305 306static struct regulator_init_data hawk_usb_vbus_data = { 307 .consumer_supplies = hawk_usb_supplies, 308 .num_consumer_supplies = ARRAY_SIZE(hawk_usb_supplies), 309 .constraints = { 310 .valid_ops_mask = REGULATOR_CHANGE_STATUS, 311 }, 312}; 313 314static struct fixed_voltage_config hawk_usb_vbus = { 315 .supply_name = "vbus", 316 .microvolts = 3300000, 317 .init_data = &hawk_usb_vbus_data, 318}; 319 320static struct platform_device hawk_usb_vbus_device = { 321 .name = "reg-fixed-voltage", 322 .id = 0, 323 .dev = { 324 .platform_data = &hawk_usb_vbus, 325 }, 326}; 327 328static struct gpiod_lookup_table hawk_usb_oc_gpio_lookup = { 329 .dev_id = "ohci-da8xx", 330 .table = { 331 GPIO_LOOKUP("davinci_gpio", DA850_USB1_OC_PIN, "oc", 0), 332 { } 333 }, 334}; 335 336static struct gpiod_lookup_table hawk_usb_vbus_gpio_lookup = { 337 .dev_id = "reg-fixed-voltage.0", 338 .table = { 339 GPIO_LOOKUP("davinci_gpio", DA850_USB1_VBUS_PIN, NULL, 0), 340 { } 341 }, 342}; 343 344static struct gpiod_lookup_table *hawk_usb_gpio_lookups[] = { 345 &hawk_usb_oc_gpio_lookup, 346 &hawk_usb_vbus_gpio_lookup, 347}; 348 349static struct da8xx_ohci_root_hub omapl138_hawk_usb11_pdata = { 350 /* TPS2087 switch @ 5V */ 351 .potpgt = (3 + 1) / 2, /* 3 ms max */ 352}; 353 354static __init void omapl138_hawk_usb_init(void) 355{ 356 int ret; 357 358 ret = davinci_cfg_reg_list(da850_hawk_usb11_pins); 359 if (ret) { 360 pr_warn("%s: USB 1.1 PinMux setup failed: %d\n", __func__, ret); 361 return; 362 } 363 364 ret = da8xx_register_usb_phy_clocks(); 365 if (ret) 366 pr_warn("%s: USB PHY CLK registration failed: %d\n", 367 __func__, ret); 368 369 gpiod_add_lookup_tables(hawk_usb_gpio_lookups, 370 ARRAY_SIZE(hawk_usb_gpio_lookups)); 371 372 ret = da8xx_register_usb_phy(); 373 if (ret) 374 pr_warn("%s: USB PHY registration failed: %d\n", 375 __func__, ret); 376 377 ret = platform_device_register(&hawk_usb_vbus_device); 378 if (ret) { 379 pr_warn("%s: Unable to register the vbus supply\n", __func__); 380 return; 381 } 382 383 ret = da8xx_register_usb11(&omapl138_hawk_usb11_pdata); 384 if (ret) 385 pr_warn("%s: USB 1.1 registration failed: %d\n", __func__, ret); 386 387 return; 388} 389 390static __init void omapl138_hawk_init(void) 391{ 392 int ret; 393 394 da850_register_clocks(); 395 396 ret = da850_register_gpio(); 397 if (ret) 398 pr_warn("%s: GPIO init failed: %d\n", __func__, ret); 399 400 davinci_serial_init(da8xx_serial_device); 401 402 omapl138_hawk_config_emac(); 403 404 ret = da850_register_edma(da850_edma_rsv); 405 if (ret) 406 pr_warn("%s: EDMA registration failed: %d\n", __func__, ret); 407 408 omapl138_hawk_mmc_init(); 409 410 omapl138_hawk_usb_init(); 411 412 ret = omapl138_hawk_register_aemif(); 413 if (ret) 414 pr_warn("%s: aemif registration failed: %d\n", __func__, ret); 415 416 ret = da8xx_register_watchdog(); 417 if (ret) 418 pr_warn("%s: watchdog registration failed: %d\n", 419 __func__, ret); 420 421 ret = da8xx_register_rproc(); 422 if (ret) 423 pr_warn("%s: dsp/rproc registration failed: %d\n", 424 __func__, ret); 425 426 regulator_has_full_constraints(); 427} 428 429#ifdef CONFIG_SERIAL_8250_CONSOLE 430static int __init omapl138_hawk_console_init(void) 431{ 432 if (!machine_is_omapl138_hawkboard()) 433 return 0; 434 435 return add_preferred_console("ttyS", 2, "115200"); 436} 437console_initcall(omapl138_hawk_console_init); 438#endif 439 440static void __init omapl138_hawk_map_io(void) 441{ 442 da850_init(); 443} 444 445MACHINE_START(OMAPL138_HAWKBOARD, "AM18x/OMAP-L138 Hawkboard") 446 .atag_offset = 0x100, 447 .map_io = omapl138_hawk_map_io, 448 .init_irq = da850_init_irq, 449 .init_time = da850_init_time, 450 .init_machine = omapl138_hawk_init, 451 .init_late = davinci_init_late, 452 .dma_zone_size = SZ_128M, 453 .reserve = da8xx_rproc_reserve_cma, 454MACHINE_END 455