1389 lines
29 KiB
C
1389 lines
29 KiB
C
/*
|
|
* Copyright (C) 2008 Google, Inc.
|
|
* Copyright (c) 2008-2012, The Linux Foundation. All rights reserved.
|
|
*
|
|
* This software is licensed under the terms of the GNU General Public
|
|
* License version 2, as published by the Free Software Foundation, and
|
|
* may be copied, distributed, and modified under those terms.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/msm_rotator.h>
|
|
#include <linux/dma-mapping.h>
|
|
#include <mach/kgsl.h>
|
|
#include <linux/regulator/machine.h>
|
|
#include <linux/init.h>
|
|
#include <mach/irqs.h>
|
|
#include <mach/msm_iomap.h>
|
|
#include <mach/dma.h>
|
|
#include <mach/board.h>
|
|
#include <asm/clkdev.h>
|
|
#include <linux/msm_ion.h>
|
|
#include "devices.h"
|
|
#include "footswitch.h"
|
|
|
|
#include <asm/mach/flash.h>
|
|
|
|
#include <asm/mach/mmc.h>
|
|
#include <mach/msm_hsusb.h>
|
|
#ifdef CONFIG_PMIC8058
|
|
#include <linux/mfd/pmic8058.h>
|
|
#endif
|
|
#include <mach/dal_axi.h>
|
|
#include <mach/msm_memtypes.h>
|
|
#include "pm.h"
|
|
#include "irq.h"
|
|
|
|
struct platform_device msm7x30_device_acpuclk = {
|
|
.name = "acpuclk-7x30",
|
|
.id = -1,
|
|
};
|
|
|
|
/* EBI THERMAL DRIVER */
|
|
static struct resource msm_ebi0_thermal_resources[] = {
|
|
{
|
|
.start = 0xA8600000,
|
|
.end = 0xA86005FF,
|
|
.name = "physbase",
|
|
.flags = IORESOURCE_MEM
|
|
}
|
|
};
|
|
|
|
struct platform_device msm_ebi0_thermal = {
|
|
.name = "msm_popmem-tm",
|
|
.id = 0,
|
|
.num_resources = 1,
|
|
.resource = msm_ebi0_thermal_resources
|
|
};
|
|
|
|
static struct resource msm_ebi1_thermal_resources[] = {
|
|
{
|
|
.start = 0xA8700000,
|
|
.end = 0xA87005FF,
|
|
.name = "physbase",
|
|
.flags = IORESOURCE_MEM
|
|
}
|
|
};
|
|
|
|
struct platform_device msm_ebi1_thermal = {
|
|
.name = "msm_popmem-tm",
|
|
.id = 1,
|
|
.num_resources = 1,
|
|
.resource = msm_ebi1_thermal_resources
|
|
};
|
|
|
|
static struct resource resources_adsp[] = {
|
|
{
|
|
.start = INT_ADSP_A9_A11,
|
|
.end = INT_ADSP_A9_A11,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_adsp_device = {
|
|
.name = "msm_adsp",
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(resources_adsp),
|
|
.resource = resources_adsp,
|
|
};
|
|
|
|
static struct resource resources_uart1[] = {
|
|
{
|
|
.start = INT_UART1,
|
|
.end = INT_UART1,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = MSM7X30_UART1_PHYS,
|
|
.end = MSM7X30_UART1_PHYS + MSM7X30_UART1_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
};
|
|
|
|
static struct resource resources_uart2[] = {
|
|
{
|
|
.start = INT_UART2,
|
|
.end = INT_UART2,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = MSM7X30_UART2_PHYS,
|
|
.end = MSM7X30_UART2_PHYS + MSM7X30_UART2_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
.name = "uart_resource"
|
|
},
|
|
};
|
|
|
|
static struct resource resources_uart3[] = {
|
|
{
|
|
.start = INT_UART3,
|
|
.end = INT_UART3,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = MSM7X30_UART3_PHYS,
|
|
.end = MSM7X30_UART3_PHYS + MSM7X30_UART3_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_uart1 = {
|
|
.name = "msm_serial",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(resources_uart1),
|
|
.resource = resources_uart1,
|
|
};
|
|
|
|
struct platform_device msm_device_uart2 = {
|
|
.name = "msm_serial",
|
|
.id = 1,
|
|
.num_resources = ARRAY_SIZE(resources_uart2),
|
|
.resource = resources_uart2,
|
|
};
|
|
|
|
struct platform_device msm_device_uart3 = {
|
|
.name = "msm_serial",
|
|
.id = 2,
|
|
.num_resources = ARRAY_SIZE(resources_uart3),
|
|
.resource = resources_uart3,
|
|
};
|
|
|
|
#define MSM_UART1DM_PHYS 0xA3300000
|
|
#define MSM_UART2DM_PHYS 0xA3200000
|
|
static struct resource msm_uart1_dm_resources[] = {
|
|
{
|
|
.start = MSM_UART1DM_PHYS,
|
|
.end = MSM_UART1DM_PHYS + PAGE_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_UART1DM_IRQ,
|
|
.end = INT_UART1DM_IRQ,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = INT_UART1DM_RX,
|
|
.end = INT_UART1DM_RX,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = DMOV_HSUART1_TX_CHAN,
|
|
.end = DMOV_HSUART1_RX_CHAN,
|
|
.name = "uartdm_channels",
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
{
|
|
.start = DMOV_HSUART1_TX_CRCI,
|
|
.end = DMOV_HSUART1_RX_CRCI,
|
|
.name = "uartdm_crci",
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
};
|
|
|
|
static u64 msm_uart_dm1_dma_mask = DMA_BIT_MASK(32);
|
|
|
|
struct platform_device msm_device_uart_dm1 = {
|
|
.name = "msm_serial_hs",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(msm_uart1_dm_resources),
|
|
.resource = msm_uart1_dm_resources,
|
|
.dev = {
|
|
.dma_mask = &msm_uart_dm1_dma_mask,
|
|
.coherent_dma_mask = DMA_BIT_MASK(32),
|
|
},
|
|
};
|
|
|
|
static struct resource msm_uart2_dm_resources[] = {
|
|
{
|
|
.start = MSM_UART2DM_PHYS,
|
|
.end = MSM_UART2DM_PHYS + PAGE_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_UART2DM_IRQ,
|
|
.end = INT_UART2DM_IRQ,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = INT_UART2DM_RX,
|
|
.end = INT_UART2DM_RX,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = DMOV_HSUART2_TX_CHAN,
|
|
.end = DMOV_HSUART2_RX_CHAN,
|
|
.name = "uartdm_channels",
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
{
|
|
.start = DMOV_HSUART2_TX_CRCI,
|
|
.end = DMOV_HSUART2_RX_CRCI,
|
|
.name = "uartdm_crci",
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
};
|
|
|
|
static u64 msm_uart_dm2_dma_mask = DMA_BIT_MASK(32);
|
|
|
|
struct platform_device msm_device_uart_dm2 = {
|
|
.name = "msm_serial_hs",
|
|
.id = 1,
|
|
.num_resources = ARRAY_SIZE(msm_uart2_dm_resources),
|
|
.resource = msm_uart2_dm_resources,
|
|
.dev = {
|
|
.dma_mask = &msm_uart_dm2_dma_mask,
|
|
.coherent_dma_mask = DMA_BIT_MASK(32),
|
|
},
|
|
};
|
|
|
|
#define MSM_I2C_SIZE SZ_4K
|
|
#define MSM_I2C_PHYS 0xACD00000
|
|
#define MSM_I2C_2_PHYS 0xACF00000
|
|
static struct resource resources_i2c_2[] = {
|
|
{
|
|
.start = MSM_I2C_2_PHYS,
|
|
.end = MSM_I2C_2_PHYS + MSM_I2C_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_PWB_I2C_2,
|
|
.end = INT_PWB_I2C_2,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_i2c_2 = {
|
|
.name = "msm_i2c",
|
|
.id = 2,
|
|
.num_resources = ARRAY_SIZE(resources_i2c_2),
|
|
.resource = resources_i2c_2,
|
|
};
|
|
|
|
static struct resource resources_i2c[] = {
|
|
{
|
|
.start = MSM_I2C_PHYS,
|
|
.end = MSM_I2C_PHYS + MSM_I2C_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_PWB_I2C,
|
|
.end = INT_PWB_I2C,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_i2c = {
|
|
.name = "msm_i2c",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(resources_i2c),
|
|
.resource = resources_i2c,
|
|
};
|
|
|
|
#ifdef CONFIG_MSM_CAMERA_V4L2
|
|
static struct resource msm_csic_resources[] = {
|
|
{
|
|
.name = "csic",
|
|
.start = 0xA6100000,
|
|
.end = 0xA6100000 + 0x00000400 - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "csic",
|
|
.start = INT_CSI,
|
|
.end = INT_CSI,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct resource msm_vfe_resources[] = {
|
|
{
|
|
.name = "msm_vfe",
|
|
.start = 0xA6000000,
|
|
.end = 0xA6000000 + SZ_1M - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "msm_vfe",
|
|
.start = INT_VFE,
|
|
.end = INT_VFE,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "msm_camif",
|
|
.start = 0xAB000000,
|
|
.end = 0xAB000000 + SZ_1K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
};
|
|
|
|
static struct resource msm_vpe_resources[] = {
|
|
{
|
|
.name = "vpe",
|
|
.start = 0xAD200000,
|
|
.end = 0xAD200000 + SZ_1M - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "vpe",
|
|
.start = INT_VPE,
|
|
.end = INT_VPE,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_csic0 = {
|
|
.name = "msm_csic",
|
|
.id = 0,
|
|
.resource = msm_csic_resources,
|
|
.num_resources = ARRAY_SIZE(msm_csic_resources),
|
|
};
|
|
|
|
struct platform_device msm_device_vfe = {
|
|
.name = "msm_vfe",
|
|
.id = 0,
|
|
.resource = msm_vfe_resources,
|
|
.num_resources = ARRAY_SIZE(msm_vfe_resources),
|
|
};
|
|
|
|
struct platform_device msm_device_vpe = {
|
|
.name = "msm_vpe",
|
|
.id = 0,
|
|
.resource = msm_vpe_resources,
|
|
.num_resources = ARRAY_SIZE(msm_vpe_resources),
|
|
};
|
|
#endif
|
|
|
|
#define MSM_QUP_PHYS 0xA8301000
|
|
#define MSM_GSBI_QUP_I2C_PHYS 0xA8300000
|
|
#define MSM_QUP_SIZE SZ_4K
|
|
static struct resource resources_qup[] = {
|
|
{
|
|
.name = "qup_phys_addr",
|
|
.start = MSM_QUP_PHYS,
|
|
.end = MSM_QUP_PHYS + MSM_QUP_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "gsbi_qup_i2c_addr",
|
|
.start = MSM_GSBI_QUP_I2C_PHYS,
|
|
.end = MSM_GSBI_QUP_I2C_PHYS + 4 - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "qup_in_intr",
|
|
.start = INT_PWB_QUP_IN,
|
|
.end = INT_PWB_QUP_IN,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "qup_out_intr",
|
|
.start = INT_PWB_QUP_OUT,
|
|
.end = INT_PWB_QUP_OUT,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "qup_err_intr",
|
|
.start = INT_PWB_QUP_ERR,
|
|
.end = INT_PWB_QUP_ERR,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct platform_device qup_device_i2c = {
|
|
.name = "qup_i2c",
|
|
.id = 4,
|
|
.num_resources = ARRAY_SIZE(resources_qup),
|
|
.resource = resources_qup,
|
|
};
|
|
|
|
#ifdef CONFIG_MSM_SSBI
|
|
#define MSM_SSBI_PMIC1_PHYS 0xAD900000
|
|
static struct resource msm_ssbi_pmic1_resources[] = {
|
|
{
|
|
.start = MSM_SSBI_PMIC1_PHYS,
|
|
.end = MSM_SSBI_PMIC1_PHYS + SZ_4K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_ssbi_pmic1 = {
|
|
.name = "msm_ssbi",
|
|
.id = 0,
|
|
.resource = msm_ssbi_pmic1_resources,
|
|
.num_resources = ARRAY_SIZE(msm_ssbi_pmic1_resources),
|
|
};
|
|
#endif
|
|
|
|
#ifdef CONFIG_I2C_SSBI
|
|
#define MSM_SSBI7_PHYS 0xAC800000
|
|
static struct resource msm_ssbi7_resources[] = {
|
|
{
|
|
.name = "ssbi_base",
|
|
.start = MSM_SSBI7_PHYS,
|
|
.end = MSM_SSBI7_PHYS + SZ_4K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_ssbi7 = {
|
|
.name = "i2c_ssbi",
|
|
.id = 7,
|
|
.num_resources = ARRAY_SIZE(msm_ssbi7_resources),
|
|
.resource = msm_ssbi7_resources,
|
|
};
|
|
#endif /* CONFIG_I2C_SSBI */
|
|
|
|
#define MSM_HSUSB_PHYS 0xA3600000
|
|
static struct resource resources_hsusb_otg[] = {
|
|
{
|
|
.start = MSM_HSUSB_PHYS,
|
|
.end = MSM_HSUSB_PHYS + SZ_1K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_USB_HS,
|
|
.end = INT_USB_HS,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static u64 dma_mask = 0xffffffffULL;
|
|
struct platform_device msm_device_hsusb_otg = {
|
|
.name = "msm_hsusb_otg",
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(resources_hsusb_otg),
|
|
.resource = resources_hsusb_otg,
|
|
.dev = {
|
|
.dma_mask = &dma_mask,
|
|
.coherent_dma_mask = 0xffffffffULL,
|
|
},
|
|
};
|
|
|
|
static struct resource resources_hsusb_peripheral[] = {
|
|
{
|
|
.start = MSM_HSUSB_PHYS,
|
|
.end = MSM_HSUSB_PHYS + SZ_1K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_USB_HS,
|
|
.end = INT_USB_HS,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct resource resources_gadget_peripheral[] = {
|
|
{
|
|
.start = MSM_HSUSB_PHYS,
|
|
.end = MSM_HSUSB_PHYS + SZ_1K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_USB_HS,
|
|
.end = INT_USB_HS,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_hsusb_peripheral = {
|
|
.name = "msm_hsusb_peripheral",
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(resources_hsusb_peripheral),
|
|
.resource = resources_hsusb_peripheral,
|
|
.dev = {
|
|
.dma_mask = &dma_mask,
|
|
.coherent_dma_mask = 0xffffffffULL,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_gadget_peripheral = {
|
|
.name = "msm_hsusb",
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(resources_gadget_peripheral),
|
|
.resource = resources_gadget_peripheral,
|
|
.dev = {
|
|
.dma_mask = &dma_mask,
|
|
.coherent_dma_mask = 0xffffffffULL,
|
|
},
|
|
};
|
|
|
|
static struct resource resources_hsusb_host[] = {
|
|
{
|
|
.start = MSM_HSUSB_PHYS,
|
|
.end = MSM_HSUSB_PHYS + SZ_1K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_USB_HS,
|
|
.end = INT_USB_HS,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_hsusb_host = {
|
|
.name = "msm_hsusb_host",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(resources_hsusb_host),
|
|
.resource = resources_hsusb_host,
|
|
.dev = {
|
|
.dma_mask = &dma_mask,
|
|
.coherent_dma_mask = 0xffffffffULL,
|
|
},
|
|
};
|
|
|
|
static struct platform_device *msm_host_devices[] = {
|
|
&msm_device_hsusb_host,
|
|
};
|
|
|
|
int msm_add_host(unsigned int host, struct msm_usb_host_platform_data *plat)
|
|
{
|
|
struct platform_device *pdev;
|
|
|
|
pdev = msm_host_devices[host];
|
|
if (!pdev)
|
|
return -ENODEV;
|
|
pdev->dev.platform_data = plat;
|
|
return platform_device_register(pdev);
|
|
}
|
|
|
|
struct platform_device asoc_msm_pcm = {
|
|
.name = "msm-dsp-audio",
|
|
.id = 0,
|
|
};
|
|
|
|
struct platform_device asoc_msm_dai0 = {
|
|
.name = "msm-codec-dai",
|
|
.id = 0,
|
|
};
|
|
|
|
struct platform_device asoc_msm_dai1 = {
|
|
.name = "msm-cpu-dai",
|
|
.id = 0,
|
|
};
|
|
|
|
#if defined (CONFIG_SND_MSM_MVS_DAI_SOC)
|
|
struct platform_device asoc_msm_mvs = {
|
|
.name = "msm-mvs-audio",
|
|
.id = 0,
|
|
};
|
|
|
|
struct platform_device asoc_mvs_dai0 = {
|
|
.name = "mvs-codec-dai",
|
|
.id = 0,
|
|
};
|
|
|
|
struct platform_device asoc_mvs_dai1 = {
|
|
.name = "mvs-cpu-dai",
|
|
.id = 0,
|
|
};
|
|
#endif
|
|
|
|
#define MSM_NAND_PHYS 0xA0200000
|
|
#define MSM_NANDC01_PHYS 0xA0240000
|
|
#define MSM_NANDC10_PHYS 0xA0280000
|
|
#define MSM_NANDC11_PHYS 0xA02C0000
|
|
#define EBI2_REG_BASE 0xA0000000
|
|
static struct resource resources_nand[] = {
|
|
[0] = {
|
|
.name = "msm_nand_dmac",
|
|
.start = DMOV_NAND_CHAN,
|
|
.end = DMOV_NAND_CHAN,
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
[1] = {
|
|
.name = "msm_nand_phys",
|
|
.start = MSM_NAND_PHYS,
|
|
.end = MSM_NAND_PHYS + 0x7FF,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[2] = {
|
|
.name = "msm_nandc01_phys",
|
|
.start = MSM_NANDC01_PHYS,
|
|
.end = MSM_NANDC01_PHYS + 0x7FF,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[3] = {
|
|
.name = "msm_nandc10_phys",
|
|
.start = MSM_NANDC10_PHYS,
|
|
.end = MSM_NANDC10_PHYS + 0x7FF,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[4] = {
|
|
.name = "msm_nandc11_phys",
|
|
.start = MSM_NANDC11_PHYS,
|
|
.end = MSM_NANDC11_PHYS + 0x7FF,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
[5] = {
|
|
.name = "ebi2_reg_base",
|
|
.start = EBI2_REG_BASE,
|
|
.end = EBI2_REG_BASE + 0x60,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
};
|
|
|
|
static struct resource resources_otg[] = {
|
|
{
|
|
.start = MSM_HSUSB_PHYS,
|
|
.end = MSM_HSUSB_PHYS + SZ_1K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_USB_HS,
|
|
.end = INT_USB_HS,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "vbus_on",
|
|
.start = PMIC8058_IRQ_BASE + PM8058_CHGVAL_IRQ,
|
|
.end = PMIC8058_IRQ_BASE + PM8058_CHGVAL_IRQ,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_otg = {
|
|
.name = "msm_otg",
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(resources_otg),
|
|
.resource = resources_otg,
|
|
.dev = {
|
|
.coherent_dma_mask = 0xffffffffULL,
|
|
},
|
|
};
|
|
|
|
struct flash_platform_data msm_nand_data = {
|
|
.version = VERSION_2,
|
|
};
|
|
|
|
struct platform_device msm_device_nand = {
|
|
.name = "msm_nand",
|
|
.id = -1,
|
|
.num_resources = ARRAY_SIZE(resources_nand),
|
|
.resource = resources_nand,
|
|
.dev = {
|
|
.platform_data = &msm_nand_data,
|
|
},
|
|
};
|
|
|
|
static struct msm_pm_irq_calls msm7x30_pm_irq_calls = {
|
|
.irq_pending = msm_irq_pending,
|
|
.idle_sleep_allowed = msm_irq_idle_sleep_allowed,
|
|
.enter_sleep1 = msm_irq_enter_sleep1,
|
|
.enter_sleep2 = msm_irq_enter_sleep2,
|
|
.exit_sleep1 = msm_irq_exit_sleep1,
|
|
.exit_sleep2 = msm_irq_exit_sleep2,
|
|
.exit_sleep3 = msm_irq_exit_sleep3,
|
|
};
|
|
|
|
void __init msm_pm_register_irqs(void)
|
|
{
|
|
msm_pm_set_irq_extns(&msm7x30_pm_irq_calls);
|
|
}
|
|
|
|
static struct resource smd_resource[] = {
|
|
{
|
|
.name = "a9_m2a_0",
|
|
.start = INT_A9_M2A_0,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "a9_m2a_5",
|
|
.start = INT_A9_M2A_5,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "adsp_a11_smsm",
|
|
.start = INT_ADSP_A11,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct smd_subsystem_config smd_config_list[] = {
|
|
{
|
|
.irq_config_id = SMD_MODEM,
|
|
.subsys_name = "modem",
|
|
.edge = SMD_APPS_MODEM,
|
|
|
|
.smd_int.irq_name = "a9_m2a_0",
|
|
.smd_int.flags = IRQF_TRIGGER_RISING,
|
|
.smd_int.irq_id = -1,
|
|
.smd_int.device_name = "smd_dev",
|
|
.smd_int.dev_id = 0,
|
|
|
|
.smd_int.out_bit_pos = 1 << 0,
|
|
.smd_int.out_base = (void __iomem *)MSM_APCS_GCC_BASE,
|
|
.smd_int.out_offset = 0x8,
|
|
|
|
.smsm_int.irq_name = "a9_m2a_5",
|
|
.smsm_int.flags = IRQF_TRIGGER_RISING,
|
|
.smsm_int.irq_id = -1,
|
|
.smsm_int.device_name = "smd_dev",
|
|
.smsm_int.dev_id = 0,
|
|
|
|
.smsm_int.out_bit_pos = 1 << 5,
|
|
.smsm_int.out_base = (void __iomem *)MSM_APCS_GCC_BASE,
|
|
.smsm_int.out_offset = 0x8,
|
|
|
|
}
|
|
};
|
|
|
|
static struct smd_platform smd_platform_data = {
|
|
.num_ss_configs = ARRAY_SIZE(smd_config_list),
|
|
.smd_ss_configs = smd_config_list,
|
|
};
|
|
|
|
struct platform_device msm_device_smd = {
|
|
.name = "msm_smd",
|
|
.id = -1,
|
|
.resource = smd_resource,
|
|
.num_resources = ARRAY_SIZE(smd_resource),
|
|
.dev = {
|
|
.platform_data = &smd_platform_data,
|
|
}
|
|
|
|
};
|
|
|
|
static struct resource msm_dmov_resource[] = {
|
|
{
|
|
.start = INT_ADM_AARM,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = 0xAC400000,
|
|
.end = 0xAC400000 + SZ_4K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
};
|
|
|
|
static struct msm_dmov_pdata msm_dmov_pdata = {
|
|
.sd = 2,
|
|
.sd_size = 0x400,
|
|
};
|
|
|
|
struct platform_device msm_device_dmov = {
|
|
.name = "msm_dmov",
|
|
.id = -1,
|
|
.resource = msm_dmov_resource,
|
|
.num_resources = ARRAY_SIZE(msm_dmov_resource),
|
|
.dev = {
|
|
.platform_data = &msm_dmov_pdata,
|
|
},
|
|
};
|
|
|
|
#define MSM_SDC1_BASE 0xA0400000
|
|
#define MSM_SDC2_BASE 0xA0500000
|
|
#define MSM_SDC3_BASE 0xA3000000
|
|
#define MSM_SDC4_BASE 0xA3100000
|
|
static struct resource resources_sdc1[] = {
|
|
{
|
|
.name = "core_mem",
|
|
.start = MSM_SDC1_BASE,
|
|
.end = MSM_SDC1_BASE + SZ_4K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "core_irq",
|
|
.start = INT_SDC1_0,
|
|
.end = INT_SDC1_1,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "dma_chnl",
|
|
.start = DMOV_SDC1_CHAN,
|
|
.end = DMOV_SDC1_CHAN,
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
{
|
|
.name = "dma_crci",
|
|
.start = DMOV_SDC1_CRCI,
|
|
.end = DMOV_SDC1_CRCI,
|
|
.flags = IORESOURCE_DMA,
|
|
}
|
|
};
|
|
|
|
static struct resource resources_sdc2[] = {
|
|
{
|
|
.name = "core_mem",
|
|
.start = MSM_SDC2_BASE,
|
|
.end = MSM_SDC2_BASE + SZ_4K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "core_irq",
|
|
.start = INT_SDC2_0,
|
|
.end = INT_SDC2_1,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "dma_chnl",
|
|
.start = DMOV_NAND_CHAN,
|
|
.end = DMOV_NAND_CHAN,
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
{
|
|
.name = "dma_crci",
|
|
.start = DMOV_SDC2_CRCI,
|
|
.end = DMOV_SDC2_CRCI,
|
|
.flags = IORESOURCE_DMA,
|
|
}
|
|
};
|
|
|
|
static struct resource resources_sdc3[] = {
|
|
{
|
|
.name = "core_mem",
|
|
.start = MSM_SDC3_BASE,
|
|
.end = MSM_SDC3_BASE + SZ_4K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "core_irq",
|
|
.start = INT_SDC3_0,
|
|
.end = INT_SDC3_1,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "dma_chnl",
|
|
.start = DMOV_SDC3_CHAN,
|
|
.end = DMOV_SDC3_CHAN,
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
{
|
|
.name = "dma_crci",
|
|
.start = DMOV_SDC3_CRCI,
|
|
.end = DMOV_SDC3_CRCI,
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
};
|
|
|
|
static struct resource resources_sdc4[] = {
|
|
{
|
|
.name = "core_mem",
|
|
.start = MSM_SDC4_BASE,
|
|
.end = MSM_SDC4_BASE + SZ_4K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "core_irq",
|
|
.start = INT_SDC4_0,
|
|
.end = INT_SDC4_1,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.name = "dma_chnl",
|
|
.start = DMOV_SDC4_CHAN,
|
|
.end = DMOV_SDC4_CHAN,
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
{
|
|
.name = "dma_crci",
|
|
.start = DMOV_SDC4_CRCI,
|
|
.end = DMOV_SDC4_CRCI,
|
|
.flags = IORESOURCE_DMA,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_sdc1 = {
|
|
.name = "msm_sdcc",
|
|
.id = 1,
|
|
.num_resources = ARRAY_SIZE(resources_sdc1),
|
|
.resource = resources_sdc1,
|
|
.dev = {
|
|
.coherent_dma_mask = 0xffffffff,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_sdc2 = {
|
|
.name = "msm_sdcc",
|
|
.id = 2,
|
|
.num_resources = ARRAY_SIZE(resources_sdc2),
|
|
.resource = resources_sdc2,
|
|
.dev = {
|
|
.coherent_dma_mask = 0xffffffff,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_sdc3 = {
|
|
.name = "msm_sdcc",
|
|
.id = 3,
|
|
.num_resources = ARRAY_SIZE(resources_sdc3),
|
|
.resource = resources_sdc3,
|
|
.dev = {
|
|
.coherent_dma_mask = 0xffffffff,
|
|
},
|
|
};
|
|
|
|
struct platform_device msm_device_sdc4 = {
|
|
.name = "msm_sdcc",
|
|
.id = 4,
|
|
.num_resources = ARRAY_SIZE(resources_sdc4),
|
|
.resource = resources_sdc4,
|
|
.dev = {
|
|
.coherent_dma_mask = 0xffffffff,
|
|
},
|
|
};
|
|
|
|
static struct platform_device *msm_sdcc_devices[] __initdata = {
|
|
&msm_device_sdc1,
|
|
&msm_device_sdc2,
|
|
&msm_device_sdc3,
|
|
&msm_device_sdc4,
|
|
};
|
|
|
|
int __init msm_add_sdcc(unsigned int controller, struct mmc_platform_data *plat)
|
|
{
|
|
struct platform_device *pdev;
|
|
|
|
if (controller < 1 || controller > 4)
|
|
return -EINVAL;
|
|
|
|
pdev = msm_sdcc_devices[controller-1];
|
|
pdev->dev.platform_data = plat;
|
|
return platform_device_register(pdev);
|
|
}
|
|
|
|
static struct resource msm_vidc_720p_resources[] = {
|
|
{
|
|
.start = 0xA3B00000,
|
|
.end = 0xA3B00000 + SZ_4K - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_MFC720,
|
|
.end = INT_MFC720,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
struct msm_vidc_platform_data vidc_platform_data = {
|
|
.memtype = ION_CAMERA_HEAP_ID,
|
|
.enable_ion = 1,
|
|
.disable_dmx = 0,
|
|
.cont_mode_dpb_count = 8
|
|
};
|
|
|
|
struct platform_device msm_device_vidc_720p = {
|
|
.name = "msm_vidc",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(msm_vidc_720p_resources),
|
|
.resource = msm_vidc_720p_resources,
|
|
.dev = {
|
|
.platform_data = &vidc_platform_data,
|
|
},
|
|
};
|
|
|
|
#if defined(CONFIG_FB_MSM_MDP40)
|
|
#define MDP_BASE 0xA3F00000
|
|
#define PMDH_BASE 0xAD600000
|
|
#define EMDH_BASE 0xAD700000
|
|
#define TVENC_BASE 0xAD400000
|
|
#else
|
|
#define MDP_BASE 0xAA200000
|
|
#define PMDH_BASE 0xAA600000
|
|
#define EMDH_BASE 0xAA700000
|
|
#define TVENC_BASE 0xAA400000
|
|
#endif
|
|
|
|
static struct resource msm_mdp_resources[] = {
|
|
{
|
|
.name = "mdp",
|
|
.start = MDP_BASE,
|
|
.end = MDP_BASE + 0x000F0000 - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_MDP,
|
|
.end = INT_MDP,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct resource msm_mddi_resources[] = {
|
|
{
|
|
.name = "pmdh",
|
|
.start = PMDH_BASE,
|
|
.end = PMDH_BASE + PAGE_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
}
|
|
};
|
|
|
|
static struct resource msm_mddi_ext_resources[] = {
|
|
{
|
|
.name = "emdh",
|
|
.start = EMDH_BASE,
|
|
.end = EMDH_BASE + PAGE_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
}
|
|
};
|
|
|
|
static struct resource msm_ebi2_lcd_resources[] = {
|
|
{
|
|
.name = "base",
|
|
.start = 0xa0d00000,
|
|
.end = 0xa0d00000 + PAGE_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "lcd01",
|
|
.start = 0x98000000,
|
|
.end = 0x98000000 + 0x80000 - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = "lcd02",
|
|
.start = 0x9c000000,
|
|
.end = 0x9c000000 + 0x80000 - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
};
|
|
|
|
static struct resource msm_tvenc_resources[] = {
|
|
{
|
|
.name = "tvenc",
|
|
.start = TVENC_BASE,
|
|
.end = TVENC_BASE + PAGE_SIZE - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
}
|
|
};
|
|
|
|
#ifdef CONFIG_FB_MSM_TVOUT
|
|
static struct resource tvout_device_resources[] = {
|
|
{
|
|
.name = "tvout_device_irq",
|
|
.start = INT_TV_ENC,
|
|
.end = INT_TV_ENC,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
#endif
|
|
|
|
static struct platform_device msm_mdp_device = {
|
|
.name = "mdp",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(msm_mdp_resources),
|
|
.resource = msm_mdp_resources,
|
|
};
|
|
|
|
static struct platform_device msm_mddi_device = {
|
|
.name = "mddi",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(msm_mddi_resources),
|
|
.resource = msm_mddi_resources,
|
|
};
|
|
|
|
static struct platform_device msm_mddi_ext_device = {
|
|
.name = "mddi_ext",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(msm_mddi_ext_resources),
|
|
.resource = msm_mddi_ext_resources,
|
|
};
|
|
|
|
static struct platform_device msm_ebi2_lcd_device = {
|
|
.name = "ebi2_lcd",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(msm_ebi2_lcd_resources),
|
|
.resource = msm_ebi2_lcd_resources,
|
|
};
|
|
|
|
struct platform_device msm_lcdc_device = {
|
|
.name = "lcdc",
|
|
.id = 0,
|
|
};
|
|
|
|
static struct platform_device msm_dtv_device = {
|
|
.name = "dtv",
|
|
.id = 0,
|
|
};
|
|
|
|
static struct platform_device msm_tvenc_device = {
|
|
.name = "tvenc",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(msm_tvenc_resources),
|
|
.resource = msm_tvenc_resources,
|
|
};
|
|
|
|
#ifdef CONFIG_FB_MSM_TVOUT
|
|
static struct platform_device tvout_msm_device = {
|
|
.name = "tvout_device",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(tvout_device_resources),
|
|
.resource = tvout_device_resources,
|
|
};
|
|
#endif
|
|
|
|
/* TSIF begin */
|
|
#if defined(CONFIG_TSIF) || defined(CONFIG_TSIF_MODULE)
|
|
|
|
#define MSM_TSIF_PHYS (0xa3400000)
|
|
#define MSM_TSIF_SIZE (0x200)
|
|
|
|
static struct resource tsif_resources[] = {
|
|
[0] = {
|
|
.flags = IORESOURCE_IRQ,
|
|
.start = INT_TSIF,
|
|
.end = INT_TSIF,
|
|
},
|
|
[1] = {
|
|
.flags = IORESOURCE_MEM,
|
|
.start = MSM_TSIF_PHYS,
|
|
.end = MSM_TSIF_PHYS + MSM_TSIF_SIZE - 1,
|
|
},
|
|
[2] = {
|
|
.flags = IORESOURCE_DMA,
|
|
.start = DMOV_TSIF_CHAN,
|
|
.end = DMOV_TSIF_CRCI,
|
|
},
|
|
};
|
|
|
|
static void tsif_release(struct device *dev)
|
|
{
|
|
dev_info(dev, "release\n");
|
|
}
|
|
|
|
struct platform_device msm_device_tsif = {
|
|
.name = "msm_tsif",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(tsif_resources),
|
|
.resource = tsif_resources,
|
|
.dev = {
|
|
.release = tsif_release,
|
|
},
|
|
};
|
|
#endif /* defined(CONFIG_TSIF) || defined(CONFIG_TSIF_MODULE) */
|
|
/* TSIF end */
|
|
|
|
|
|
|
|
#ifdef CONFIG_MSM_ROTATOR
|
|
static struct resource resources_msm_rotator[] = {
|
|
{
|
|
.start = 0xA3E00000,
|
|
.end = 0xA3F00000 - 1,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.start = INT_ROTATOR,
|
|
.end = INT_ROTATOR,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct msm_rot_clocks rotator_clocks[] = {
|
|
{
|
|
.clk_name = "core_clk",
|
|
.clk_type = ROTATOR_CORE_CLK,
|
|
.clk_rate = 0,
|
|
},
|
|
{
|
|
.clk_name = "iface_clk",
|
|
.clk_type = ROTATOR_PCLK,
|
|
.clk_rate = 0,
|
|
},
|
|
{
|
|
.clk_name = "mem_clk",
|
|
.clk_type = ROTATOR_IMEM_CLK,
|
|
.clk_rate = 0,
|
|
},
|
|
};
|
|
|
|
static struct msm_rotator_platform_data rotator_pdata = {
|
|
.number_of_clocks = ARRAY_SIZE(rotator_clocks),
|
|
.hardware_version_number = 0x1000303,
|
|
.rotator_clks = rotator_clocks,
|
|
};
|
|
|
|
struct platform_device msm_rotator_device = {
|
|
.name = "msm_rotator",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(resources_msm_rotator),
|
|
.resource = resources_msm_rotator,
|
|
.dev = {
|
|
.platform_data = &rotator_pdata,
|
|
},
|
|
};
|
|
#endif
|
|
|
|
static void __init msm_register_device(struct platform_device *pdev, void *data)
|
|
{
|
|
int ret;
|
|
|
|
pdev->dev.platform_data = data;
|
|
|
|
ret = platform_device_register(pdev);
|
|
if (ret)
|
|
dev_err(&pdev->dev,
|
|
"%s: platform_device_register() failed = %d\n",
|
|
__func__, ret);
|
|
}
|
|
|
|
void __init msm_fb_register_device(char *name, void *data)
|
|
{
|
|
if (!strncmp(name, "mdp", 3))
|
|
msm_register_device(&msm_mdp_device, data);
|
|
else if (!strncmp(name, "pmdh", 4))
|
|
msm_register_device(&msm_mddi_device, data);
|
|
else if (!strncmp(name, "emdh", 4))
|
|
msm_register_device(&msm_mddi_ext_device, data);
|
|
else if (!strncmp(name, "ebi2", 4))
|
|
msm_register_device(&msm_ebi2_lcd_device, data);
|
|
else if (!strncmp(name, "tvenc", 5))
|
|
msm_register_device(&msm_tvenc_device, data);
|
|
else if (!strncmp(name, "lcdc", 4))
|
|
msm_register_device(&msm_lcdc_device, data);
|
|
else if (!strncmp(name, "dtv", 3))
|
|
msm_register_device(&msm_dtv_device, data);
|
|
#ifdef CONFIG_FB_MSM_TVOUT
|
|
else if (!strncmp(name, "tvout_device", 12))
|
|
msm_register_device(&tvout_msm_device, data);
|
|
#endif
|
|
else
|
|
printk(KERN_ERR "%s: unknown device! %s\n", __func__, name);
|
|
}
|
|
|
|
static struct platform_device msm_camera_device = {
|
|
.name = "msm_camera",
|
|
.id = 0,
|
|
};
|
|
|
|
void __init msm_camera_register_device(void *res, uint32_t num,
|
|
void *data)
|
|
{
|
|
msm_camera_device.num_resources = num;
|
|
msm_camera_device.resource = res;
|
|
|
|
msm_register_device(&msm_camera_device, data);
|
|
}
|
|
|
|
struct resource kgsl_3d0_resources[] = {
|
|
{
|
|
.name = KGSL_3D0_REG_MEMORY,
|
|
.start = 0xA3500000, /* 3D GRP address */
|
|
.end = 0xA351ffff,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = KGSL_3D0_IRQ,
|
|
.start = INT_GRP_3D,
|
|
.end = INT_GRP_3D,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct kgsl_device_platform_data kgsl_3d0_pdata = {
|
|
.pwrlevel = {
|
|
{
|
|
.gpu_freq = 245760000,
|
|
.bus_freq = 192000000,
|
|
},
|
|
{
|
|
.gpu_freq = 192000000,
|
|
.bus_freq = 152000000,
|
|
},
|
|
{
|
|
.gpu_freq = 192000000,
|
|
.bus_freq = 0,
|
|
},
|
|
},
|
|
.init_level = 0,
|
|
.num_levels = 3,
|
|
.set_grp_async = set_grp3d_async,
|
|
.idle_timeout = HZ/20,
|
|
.idle_needed = true,
|
|
.clk_map = KGSL_CLK_SRC | KGSL_CLK_CORE |
|
|
KGSL_CLK_IFACE | KGSL_CLK_MEM,
|
|
};
|
|
|
|
struct platform_device msm_kgsl_3d0 = {
|
|
.name = "kgsl-3d0",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(kgsl_3d0_resources),
|
|
.resource = kgsl_3d0_resources,
|
|
.dev = {
|
|
.platform_data = &kgsl_3d0_pdata,
|
|
},
|
|
};
|
|
|
|
static struct resource kgsl_2d0_resources[] = {
|
|
{
|
|
.name = KGSL_2D0_REG_MEMORY,
|
|
.start = 0xA3900000, /* Z180 base address */
|
|
.end = 0xA3900FFF,
|
|
.flags = IORESOURCE_MEM,
|
|
},
|
|
{
|
|
.name = KGSL_2D0_IRQ,
|
|
.start = INT_GRP_2D,
|
|
.end = INT_GRP_2D,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct kgsl_device_platform_data kgsl_2d0_pdata = {
|
|
.pwrlevel = {
|
|
{
|
|
.gpu_freq = 0,
|
|
.bus_freq = 192000000,
|
|
},
|
|
},
|
|
.init_level = 0,
|
|
.num_levels = 1,
|
|
/* HW workaround, run Z180 SYNC @ 192 MHZ */
|
|
.set_grp_async = NULL,
|
|
.idle_timeout = HZ/10,
|
|
.idle_needed = true,
|
|
.clk_map = KGSL_CLK_CORE | KGSL_CLK_IFACE,
|
|
};
|
|
|
|
struct platform_device msm_kgsl_2d0 = {
|
|
.name = "kgsl-2d0",
|
|
.id = 0,
|
|
.num_resources = ARRAY_SIZE(kgsl_2d0_resources),
|
|
.resource = kgsl_2d0_resources,
|
|
.dev = {
|
|
.platform_data = &kgsl_2d0_pdata,
|
|
},
|
|
};
|
|
|
|
struct platform_device *msm_footswitch_devices[] = {
|
|
FS_PCOM(FS_GFX2D0, "vdd", "kgsl-2d0.0"),
|
|
FS_PCOM(FS_GFX3D, "vdd", "kgsl-3d0.0"),
|
|
FS_PCOM(FS_MDP, "vdd", "mdp.0"),
|
|
FS_PCOM(FS_MFC, "fs_mfc", NULL),
|
|
FS_PCOM(FS_ROT, "vdd", "msm_rotator.0"),
|
|
FS_PCOM(FS_VFE, "fs_vfe", NULL),
|
|
FS_PCOM(FS_VPE, "fs_vpe", NULL),
|
|
};
|
|
unsigned msm_num_footswitch_devices = ARRAY_SIZE(msm_footswitch_devices);
|
|
|
|
static struct resource gpio_resources[] = {
|
|
{
|
|
.start = INT_GPIO_GROUP1,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
{
|
|
.start = INT_GPIO_GROUP2,
|
|
.flags = IORESOURCE_IRQ,
|
|
},
|
|
};
|
|
|
|
static struct platform_device msm_device_gpio = {
|
|
.name = "msmgpio",
|
|
.id = -1,
|
|
.resource = gpio_resources,
|
|
.num_resources = ARRAY_SIZE(gpio_resources),
|
|
};
|
|
|
|
static int __init msm7630_init_gpio(void)
|
|
{
|
|
platform_device_register(&msm_device_gpio);
|
|
return 0;
|
|
}
|
|
|
|
postcore_initcall(msm7630_init_gpio);
|