[mirror_ubuntu-jammy-kernel.git] / arch / arm / mach-integrator / impd1.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  linux/arch/arm/mach-integrator/impd1.c
 *
 *  Copyright (C) 2003 Deep Blue Solutions Ltd, All Rights Reserved.
 *
 *  This file provides the core support for the IM-PD1 module.
 *
 * Module / boot parameters.
 *   lmid=n   impd1.lmid=n - set the logic module position in stack to 'n'
 */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/amba/bus.h>
#include <linux/amba/clcd.h>
#include <linux/amba/mmci.h>
#include <linux/io.h>
#include <linux/platform_data/clk-integrator.h>
#include <linux/slab.h>
#include <linux/irqchip/arm-vic.h>
#include <linux/gpio/machine.h>

#include <linux/sizes.h>
#include "lm.h"
#include "impd1.h"

static int module_id;

module_param_named(lmid, module_id, int, 0444);
MODULE_PARM_DESC(lmid, "logic module stack position");

struct impd1_module {
	void __iomem	*base;
	void __iomem	*vic_base;
};

void impd1_tweak_control(struct device *dev, u32 mask, u32 val)
{
	struct impd1_module *impd1 = dev_get_drvdata(dev);
	u32 cur;

	val &= mask;
	cur = readl(impd1->base + IMPD1_CTRL) & ~mask;
	writel(cur | val, impd1->base + IMPD1_CTRL);
}

EXPORT_SYMBOL(impd1_tweak_control);

/*
 * MMC support
 */
static struct mmci_platform_data mmc_data = {
	.ocr_mask	= MMC_VDD_32_33|MMC_VDD_33_34,
};

/*
 * CLCD support
 */
#define PANEL		PROSPECTOR

#define LTM10C209		1
#define PROSPECTOR		2
#define SVGA			3
#define VGA			4

#if PANEL == VGA
#define PANELTYPE	vga
static struct clcd_panel vga = {
	.mode		= {
		.name		= "VGA",
		.refresh	= 60,
		.xres		= 640,
		.yres		= 480,
		.pixclock	= 39721,
		.left_margin	= 40,
		.right_margin	= 24,
		.upper_margin	= 32,
		.lower_margin	= 11,
		.hsync_len	= 96,
		.vsync_len	= 2,
		.sync		= 0,
		.vmode		= FB_VMODE_NONINTERLACED,
	},
	.width		= -1,
	.height		= -1,
	.tim2		= TIM2_BCD | TIM2_IPC,
	.cntl		= CNTL_LCDTFT | CNTL_LCDVCOMP(1),
	.caps		= CLCD_CAP_5551,
	.connector	= IMPD1_CTRL_DISP_VGA,
	.bpp		= 16,
	.grayscale	= 0,
};

#elif PANEL == SVGA
#define PANELTYPE	svga
static struct clcd_panel svga = {
	.mode		= {
		.name		= "SVGA",
		.refresh	= 0,
		.xres		= 800,
		.yres		= 600,
		.pixclock	= 27778,
		.left_margin	= 20,
		.right_margin	= 20,
		.upper_margin	= 5,
		.lower_margin	= 5,
		.hsync_len	= 164,
		.vsync_len	= 62,
		.sync		= 0,
		.vmode		= FB_VMODE_NONINTERLACED,
	},
	.width		= -1,
	.height		= -1,
	.tim2		= TIM2_BCD,
	.cntl		= CNTL_LCDTFT | CNTL_LCDVCOMP(1),
	.connector	= IMPD1_CTRL_DISP_VGA,
	.caps		= CLCD_CAP_5551,
	.bpp		= 16,
	.grayscale	= 0,
};

#elif PANEL == PROSPECTOR
#define PANELTYPE	prospector
static struct clcd_panel prospector = {
	.mode		= {
		.name		= "PROSPECTOR",
		.refresh	= 0,
		.xres		= 640,
		.yres		= 480,
		.pixclock	= 40000,
		.left_margin	= 33,
		.right_margin	= 64,
		.upper_margin	= 36,
		.lower_margin	= 7,
		.hsync_len	= 64,
		.vsync_len	= 25,
		.sync		= FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
		.vmode		= FB_VMODE_NONINTERLACED,
	},
	.width		= -1,
	.height		= -1,
	.tim2		= TIM2_BCD,
	.cntl		= CNTL_LCDTFT | CNTL_LCDVCOMP(1),
	.caps		= CLCD_CAP_5551,
	.fixedtimings	= 1,
	.connector	= IMPD1_CTRL_DISP_LCD,
	.bpp		= 16,
	.grayscale	= 0,
};

#elif PANEL == LTM10C209
#define PANELTYPE	ltm10c209
/*
 * Untested.
 */
static struct clcd_panel ltm10c209 = {
	.mode		= {
		.name		= "LTM10C209",
		.refresh	= 0,
		.xres		= 640,
		.yres		= 480,
		.pixclock	= 40000,
		.left_margin	= 20,
		.right_margin	= 20,
		.upper_margin	= 19,
		.lower_margin	= 19,
		.hsync_len	= 20,
		.vsync_len	= 10,
		.sync		= FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
		.vmode		= FB_VMODE_NONINTERLACED,
	},
	.width		= -1,
	.height		= -1,
	.tim2		= TIM2_BCD,
	.cntl		= CNTL_LCDTFT | CNTL_LCDVCOMP(1),
	.caps		= CLCD_CAP_5551,
	.fixedtimings	= 1,
	.connector	= IMPD1_CTRL_DISP_LCD,
	.bpp		= 16,
	.grayscale	= 0,
};
#endif

/*
 * Disable all display connectors on the interface module.
 */
static void impd1fb_clcd_disable(struct clcd_fb *fb)
{
	impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK, 0);
}

/*
 * Enable the relevant connector on the interface module.
 */
static void impd1fb_clcd_enable(struct clcd_fb *fb)
{
	impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK,
			fb->panel->connector | IMPD1_CTRL_DISP_ENABLE);
}

static int impd1fb_clcd_setup(struct clcd_fb *fb)
{
	unsigned long framebase = fb->dev->res.start + 0x01000000;
	unsigned long framesize = SZ_1M;
	int ret = 0;

	fb->panel = &PANELTYPE;

	if (!request_mem_region(framebase, framesize, "clcd framebuffer")) {
		printk(KERN_ERR "IM-PD1: unable to reserve framebuffer\n");
		return -EBUSY;
	}

	fb->fb.screen_base = ioremap(framebase, framesize);
	if (!fb->fb.screen_base) {
		printk(KERN_ERR "IM-PD1: unable to map framebuffer\n");
		ret = -ENOMEM;
		goto free_buffer;
	}

	fb->fb.fix.smem_start	= framebase;
	fb->fb.fix.smem_len	= framesize;

	return 0;

 free_buffer:
	release_mem_region(framebase, framesize);
	return ret;
}

static int impd1fb_clcd_mmap(struct clcd_fb *fb, struct vm_area_struct *vma)
{
	unsigned long start, size;

	start = vma->vm_pgoff + (fb->fb.fix.smem_start >> PAGE_SHIFT);
	size = vma->vm_end - vma->vm_start;

	return remap_pfn_range(vma, vma->vm_start, start, size,
			       vma->vm_page_prot);
}

static void impd1fb_clcd_remove(struct clcd_fb *fb)
{
	iounmap(fb->fb.screen_base);
	release_mem_region(fb->fb.fix.smem_start, fb->fb.fix.smem_len);
}

static struct clcd_board impd1_clcd_data = {
	.name		= "IM-PD/1",
	.caps		= CLCD_CAP_5551 | CLCD_CAP_888,
	.check		= clcdfb_check,
	.decode		= clcdfb_decode,
	.disable	= impd1fb_clcd_disable,
	.enable		= impd1fb_clcd_enable,
	.setup		= impd1fb_clcd_setup,
	.mmap		= impd1fb_clcd_mmap,
	.remove		= impd1fb_clcd_remove,
};

struct impd1_device {
	unsigned long	offset;
	unsigned int	irq[2];
	unsigned int	id;
	void		*platform_data;
};

static struct impd1_device impd1_devs[] = {
	{
		.offset	= 0x00100000,
		.irq	= { 1 },
		.id	= 0x00141011,
	}, {
		.offset	= 0x00200000,
		.irq	= { 2 },
		.id	= 0x00141011,
	}, {
		.offset	= 0x00300000,
		.irq	= { 3 },
		.id	= 0x00041022,
	}, {
		.offset	= 0x00400000,
		.irq	= { 4 },
		.id	= 0x00041061,
	}, {
		.offset	= 0x00500000,
		.irq	= { 5 },
		.id	= 0x00041061,
	}, {
		.offset	= 0x00600000,
		.irq	= { 6 },
		.id	= 0x00041130,
	}, {
		.offset	= 0x00700000,
		.irq	= { 7, 8 },
		.id	= 0x00041181,
		.platform_data = &mmc_data,
	}, {
		.offset	= 0x00800000,
		.irq	= { 9 },
		.id	= 0x00041041,
	}, {
		.offset	= 0x01000000,
		.irq	= { 11 },
		.id	= 0x00041110,
		.platform_data = &impd1_clcd_data,
	}
};

/*
 * Valid IRQs: 0 thru 9 and 11, 10 unused.
 */
#define IMPD1_VALID_IRQS 0x00000bffU

/*
 * As this module is bool, it is OK to have this as __ref() - no
 * probe calls will be done after the initial system bootup, as devices
 * are discovered as part of the machine startup.
 */
static int __ref impd1_probe(struct lm_device *dev)
{
	struct impd1_module *impd1;
	int irq_base;
	int i;

	if (dev->id != module_id)
		return -EINVAL;

	if (!devm_request_mem_region(&dev->dev, dev->resource.start,
				     SZ_4K, "LM registers"))
		return -EBUSY;

	impd1 = devm_kzalloc(&dev->dev, sizeof(struct impd1_module),
			     GFP_KERNEL);
	if (!impd1)
		return -ENOMEM;

	impd1->base = devm_ioremap(&dev->dev, dev->resource.start, SZ_4K);
	if (!impd1->base)
		return -ENOMEM;

	integrator_impd1_clk_init(impd1->base, dev->id);

	if (!devm_request_mem_region(&dev->dev,
				     dev->resource.start + 0x03000000,
				     SZ_4K, "VIC"))
		return -EBUSY;

	impd1->vic_base = devm_ioremap(&dev->dev,
				       dev->resource.start + 0x03000000,
				       SZ_4K);
	if (!impd1->vic_base)
		return -ENOMEM;

	irq_base = vic_init_cascaded(impd1->vic_base, dev->irq,
				     IMPD1_VALID_IRQS, 0);

	lm_set_drvdata(dev, impd1);

	dev_info(&dev->dev, "IM-PD1 found at 0x%08lx\n",
		 (unsigned long)dev->resource.start);

	for (i = 0; i < ARRAY_SIZE(impd1_devs); i++) {
		struct impd1_device *idev = impd1_devs + i;
		struct amba_device *d;
		unsigned long pc_base;
		char devname[32];
		int irq1 = idev->irq[0];
		int irq2 = idev->irq[1];

		/* Translate IRQs to IM-PD1 local numberspace */
		if (irq1)
			irq1 += irq_base;
		if (irq2)
			irq2 += irq_base;

		pc_base = dev->resource.start + idev->offset;
		snprintf(devname, 32, "lm%x:%5.5lx", dev->id, idev->offset >> 12);

		/* Add GPIO descriptor lookup table for the PL061 block */
		if (idev->offset == 0x00400000) {
			struct gpiod_lookup_table *lookup;
			char *chipname;
			char *mmciname;

			lookup = devm_kzalloc(&dev->dev,
					      struct_size(lookup, table, 3),
					      GFP_KERNEL);
			chipname = devm_kstrdup(&dev->dev, devname, GFP_KERNEL);
			mmciname = devm_kasprintf(&dev->dev, GFP_KERNEL,
						  "lm%x:00700", dev->id);
			if (!lookup || !chipname || !mmciname)
				return -ENOMEM;

			lookup->dev_id = mmciname;
			/*
			 * Offsets on GPIO block 1:
			 * 3 = MMC WP (write protect)
			 * 4 = MMC CD (card detect)
			 *
			 * Offsets on GPIO block 2:
			 * 0 = Up key
			 * 1 = Down key
			 * 2 = Left key
			 * 3 = Right key
			 * 4 = Key lower left
			 * 5 = Key lower right
			 */
			/* We need the two MMCI GPIO entries */
			lookup->table[0].chip_label = chipname;
			lookup->table[0].chip_hwnum = 3;
			lookup->table[0].con_id = "wp";
			lookup->table[1].chip_label = chipname;
			lookup->table[1].chip_hwnum = 4;
			lookup->table[1].con_id = "cd";
			lookup->table[1].flags = GPIO_ACTIVE_LOW;
			gpiod_add_lookup_table(lookup);
		}

		d = amba_ahb_device_add_res(&dev->dev, devname, pc_base, SZ_4K,
					    irq1, irq2,
					    idev->platform_data, idev->id,
					    &dev->resource);
		if (IS_ERR(d)) {
			dev_err(&dev->dev, "unable to register device: %ld\n", PTR_ERR(d));
			continue;
		}
	}

	return 0;
}

static int impd1_remove_one(struct device *dev, void *data)
{
	device_unregister(dev);
	return 0;
}

static void impd1_remove(struct lm_device *dev)
{
	device_for_each_child(&dev->dev, NULL, impd1_remove_one);
	integrator_impd1_clk_exit(dev->id);

	lm_set_drvdata(dev, NULL);
}

static struct lm_driver impd1_driver = {
	.drv = {
		.name	= "impd1",
		/*
		 * As we're dropping the probe() function, suppress driver
		 * binding from sysfs.
		 */
		.suppress_bind_attrs = true,
	},
	.probe		= impd1_probe,
	.remove		= impd1_remove,
};

static int __init impd1_init(void)
{
	return lm_driver_register(&impd1_driver);
}

static void __exit impd1_exit(void)
{
	lm_driver_unregister(&impd1_driver);
}

module_init(impd1_init);
module_exit(impd1_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Integrator/IM-PD1 logic module core driver");
MODULE_AUTHOR("Deep Blue Solutions Ltd");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
1da177e4 LT	2	/*
	3	* linux/arch/arm/mach-integrator/impd1.c
	4	*
	5	* Copyright (C) 2003 Deep Blue Solutions Ltd, All Rights Reserved.
	6	*
1da177e4 LT	7	* This file provides the core support for the IM-PD1 module.
	8	*
	9	* Module / boot parameters.
	10	* lmid=n impd1.lmid=n - set the logic module position in stack to 'n'
	11	*/
	12	#include <linux/module.h>
	13	#include <linux/moduleparam.h>
	14	#include <linux/init.h>
	15	#include <linux/device.h>
	16	#include <linux/errno.h>
	17	#include <linux/mm.h>
a62c80e5 RK	18	#include <linux/amba/bus.h>
a62c80e5 RK	19	#include <linux/amba/clcd.h>
684284b6	20	#include <linux/amba/mmci.h>
fced80c7	21	#include <linux/io.h>
70ee6577	22	#include <linux/platform_data/clk-integrator.h>
5a0e3ad6	23	#include <linux/slab.h>
52d555ff	24	#include <linux/irqchip/arm-vic.h>
684284b6	25	#include <linux/gpio/machine.h>
1da177e4	26
87dfb311	27	#include <linux/sizes.h>
c36928ad	28	#include "lm.h"
cc0cc4ca	29	#include "impd1.h"
1da177e4	30
1da177e4 LT	31	static int module_id;
	32
	33	module_param_named(lmid, module_id, int, 0444);
	34	MODULE_PARM_DESC(lmid, "logic module stack position");
	35
	36	struct impd1_module {
	37	void __iomem *base;
52d555ff	38	void __iomem *vic_base;
9bf5b2ef RK	39	};
9bf5b2ef RK	40
1da177e4 LT	41	void impd1_tweak_control(struct device *dev, u32 mask, u32 val)
	42	{
	43	struct impd1_module *impd1 = dev_get_drvdata(dev);
	44	u32 cur;
	45
	46	val &= mask;
	47	cur = readl(impd1->base + IMPD1_CTRL) & ~mask;
	48	writel(cur \| val, impd1->base + IMPD1_CTRL);
	49	}
	50
	51	EXPORT_SYMBOL(impd1_tweak_control);
	52
684284b6 LW	53	/*
	54	* MMC support
	55	*/
	56	static struct mmci_platform_data mmc_data = {
	57	.ocr_mask = MMC_VDD_32_33\|MMC_VDD_33_34,
	58	};
	59
1da177e4 LT	60	/*
	61	* CLCD support
	62	*/
	63	#define PANEL PROSPECTOR
	64
	65	#define LTM10C209 1
	66	#define PROSPECTOR 2
	67	#define SVGA 3
	68	#define VGA 4
	69
	70	#if PANEL == VGA
	71	#define PANELTYPE vga
	72	static struct clcd_panel vga = {
	73	.mode = {
	74	.name = "VGA",
	75	.refresh = 60,
	76	.xres = 640,
	77	.yres = 480,
	78	.pixclock = 39721,
	79	.left_margin = 40,
	80	.right_margin = 24,
	81	.upper_margin = 32,
	82	.lower_margin = 11,
	83	.hsync_len = 96,
	84	.vsync_len = 2,
	85	.sync = 0,
	86	.vmode = FB_VMODE_NONINTERLACED,
	87	},
	88	.width = -1,
	89	.height = -1,
	90	.tim2 = TIM2_BCD \| TIM2_IPC,
	91	.cntl = CNTL_LCDTFT \| CNTL_LCDVCOMP(1),
9dfec4fe	92	.caps = CLCD_CAP_5551,
1da177e4 LT	93	.connector = IMPD1_CTRL_DISP_VGA,
	94	.bpp = 16,
	95	.grayscale = 0,
	96	};
	97
	98	#elif PANEL == SVGA
	99	#define PANELTYPE svga
	100	static struct clcd_panel svga = {
	101	.mode = {
	102	.name = "SVGA",
	103	.refresh = 0,
	104	.xres = 800,
	105	.yres = 600,
	106	.pixclock = 27778,
	107	.left_margin = 20,
	108	.right_margin = 20,
	109	.upper_margin = 5,
	110	.lower_margin = 5,
	111	.hsync_len = 164,
	112	.vsync_len = 62,
	113	.sync = 0,
	114	.vmode = FB_VMODE_NONINTERLACED,
	115	},
	116	.width = -1,
	117	.height = -1,
	118	.tim2 = TIM2_BCD,
	119	.cntl = CNTL_LCDTFT \| CNTL_LCDVCOMP(1),
	120	.connector = IMPD1_CTRL_DISP_VGA,
9dfec4fe	121	.caps = CLCD_CAP_5551,
1da177e4 LT	122	.bpp = 16,
	123	.grayscale = 0,
	124	};
	125
	126	#elif PANEL == PROSPECTOR
	127	#define PANELTYPE prospector
	128	static struct clcd_panel prospector = {
	129	.mode = {
	130	.name = "PROSPECTOR",
	131	.refresh = 0,
	132	.xres = 640,
	133	.yres = 480,
	134	.pixclock = 40000,
	135	.left_margin = 33,
	136	.right_margin = 64,
	137	.upper_margin = 36,
	138	.lower_margin = 7,
	139	.hsync_len = 64,
	140	.vsync_len = 25,
	141	.sync = FB_SYNC_HOR_HIGH_ACT \| FB_SYNC_VERT_HIGH_ACT,
	142	.vmode = FB_VMODE_NONINTERLACED,
	143	},
	144	.width = -1,
	145	.height = -1,
	146	.tim2 = TIM2_BCD,
	147	.cntl = CNTL_LCDTFT \| CNTL_LCDVCOMP(1),
9dfec4fe	148	.caps = CLCD_CAP_5551,
1da177e4 LT	149	.fixedtimings = 1,
	150	.connector = IMPD1_CTRL_DISP_LCD,
	151	.bpp = 16,
	152	.grayscale = 0,
	153	};
	154
	155	#elif PANEL == LTM10C209
	156	#define PANELTYPE ltm10c209
	157	/*
	158	* Untested.
	159	*/
	160	static struct clcd_panel ltm10c209 = {
	161	.mode = {
	162	.name = "LTM10C209",
	163	.refresh = 0,
	164	.xres = 640,
	165	.yres = 480,
	166	.pixclock = 40000,
	167	.left_margin = 20,
	168	.right_margin = 20,
	169	.upper_margin = 19,
	170	.lower_margin = 19,
	171	.hsync_len = 20,
	172	.vsync_len = 10,
	173	.sync = FB_SYNC_HOR_HIGH_ACT \| FB_SYNC_VERT_HIGH_ACT,
	174	.vmode = FB_VMODE_NONINTERLACED,
	175	},
	176	.width = -1,
	177	.height = -1,
	178	.tim2 = TIM2_BCD,
	179	.cntl = CNTL_LCDTFT \| CNTL_LCDVCOMP(1),
9dfec4fe	180	.caps = CLCD_CAP_5551,
1da177e4 LT	181	.fixedtimings = 1,
	182	.connector = IMPD1_CTRL_DISP_LCD,
	183	.bpp = 16,
	184	.grayscale = 0,
	185	};
	186	#endif
	187
	188	/*
	189	* Disable all display connectors on the interface module.
	190	*/
	191	static void impd1fb_clcd_disable(struct clcd_fb *fb)
	192	{
	193	impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK, 0);
	194	}
	195
	196	/*
	197	* Enable the relevant connector on the interface module.
	198	*/
	199	static void impd1fb_clcd_enable(struct clcd_fb *fb)
	200	{
	201	impd1_tweak_control(fb->dev->dev.parent, IMPD1_CTRL_DISP_MASK,
	202	fb->panel->connector \| IMPD1_CTRL_DISP_ENABLE);
	203	}
	204
	205	static int impd1fb_clcd_setup(struct clcd_fb *fb)
	206	{
	207	unsigned long framebase = fb->dev->res.start + 0x01000000;
	208	unsigned long framesize = SZ_1M;
	209	int ret = 0;
	210
	211	fb->panel = &PANELTYPE;
	212
	213	if (!request_mem_region(framebase, framesize, "clcd framebuffer")) {
	214	printk(KERN_ERR "IM-PD1: unable to reserve framebuffer\n");
	215	return -EBUSY;
	216	}
	217
	218	fb->fb.screen_base = ioremap(framebase, framesize);
	219	if (!fb->fb.screen_base) {
	220	printk(KERN_ERR "IM-PD1: unable to map framebuffer\n");
	221	ret = -ENOMEM;
	222	goto free_buffer;
	223	}
	224
	225	fb->fb.fix.smem_start = framebase;
	226	fb->fb.fix.smem_len = framesize;
	227
	228	return 0;
	229
	230	free_buffer:
	231	release_mem_region(framebase, framesize);
	232	return ret;
	233	}
	234
	235	static int impd1fb_clcd_mmap(struct clcd_fb fb, struct vm_area_struct vma)
	236	{
	237	unsigned long start, size;
	238
	239	start = vma->vm_pgoff + (fb->fb.fix.smem_start >> PAGE_SHIFT);
	240	size = vma->vm_end - vma->vm_start;
	241
	242	return remap_pfn_range(vma, vma->vm_start, start, size,
	243	vma->vm_page_prot);
	244	}
245
246	static void impd1fb_clcd_remove(struct clcd_fb *fb)
247	{
248	iounmap(fb->fb.screen_base);
249	release_mem_region(fb->fb.fix.smem_start, fb->fb.fix.smem_len);
250	}
251
252	static struct clcd_board impd1_clcd_data = {
253	.name = "IM-PD/1",
9dfec4fe	254	.caps = CLCD_CAP_5551 \| CLCD_CAP_888,
1da177e4 LT	255	.check = clcdfb_check,
	256	.decode = clcdfb_decode,
	257	.disable = impd1fb_clcd_disable,
	258	.enable = impd1fb_clcd_enable,
	259	.setup = impd1fb_clcd_setup,
	260	.mmap = impd1fb_clcd_mmap,
	261	.remove = impd1fb_clcd_remove,
	262	};
	263
	264	struct impd1_device {
	265	unsigned long offset;
	266	unsigned int irq[2];
	267	unsigned int id;
	268	void *platform_data;
	269	};
	270
	271	static struct impd1_device impd1_devs[] = {
	272	{
1da177e4 LT	273	.offset = 0x00100000,
	274	.irq = { 1 },
	275	.id = 0x00141011,
	276	}, {
	277	.offset = 0x00200000,
	278	.irq = { 2 },
	279	.id = 0x00141011,
	280	}, {
	281	.offset = 0x00300000,
	282	.irq = { 3 },
	283	.id = 0x00041022,
	284	}, {
	285	.offset = 0x00400000,
	286	.irq = { 4 },
	287	.id = 0x00041061,
	288	}, {
	289	.offset = 0x00500000,
	290	.irq = { 5 },
	291	.id = 0x00041061,
	292	}, {
	293	.offset = 0x00600000,
	294	.irq = { 6 },
	295	.id = 0x00041130,
	296	}, {
	297	.offset = 0x00700000,
	298	.irq = { 7, 8 },
	299	.id = 0x00041181,
684284b6	300	.platform_data = &mmc_data,
1da177e4 LT	301	}, {
	302	.offset = 0x00800000,
	303	.irq = { 9 },
	304	.id = 0x00041041,
	305	}, {
	306	.offset = 0x01000000,
	307	.irq = { 11 },
	308	.id = 0x00041110,
	309	.platform_data = &impd1_clcd_data,
	310	}
	311	};
	312
52d555ff LW	313	/*
	314	* Valid IRQs: 0 thru 9 and 11, 10 unused.
	315	*/
	316	#define IMPD1_VALID_IRQS 0x00000bffU
	317
e1318391	318	/*
bd721ea7	319	* As this module is bool, it is OK to have this as __ref() - no
e1318391 LW	320	* probe calls will be done after the initial system bootup, as devices
	321	* are discovered as part of the machine startup.
	322	*/
bd721ea7	323	static int __ref impd1_probe(struct lm_device *dev)
1da177e4 LT	324	{
1da177e4 LT	325	struct impd1_module *impd1;
52d555ff	326	int irq_base;
31d951e2	327	int i;
1da177e4 LT	328
	329	if (dev->id != module_id)
	330	return -EINVAL;
	331
31d951e2 LW	332	if (!devm_request_mem_region(&dev->dev, dev->resource.start,
31d951e2 LW	333	SZ_4K, "LM registers"))
1da177e4 LT	334	return -EBUSY;
1da177e4 LT	335
31d951e2 LW	336	impd1 = devm_kzalloc(&dev->dev, sizeof(struct impd1_module),
	337	GFP_KERNEL);
	338	if (!impd1)
	339	return -ENOMEM;
1da177e4	340
31d951e2 LW	341	impd1->base = devm_ioremap(&dev->dev, dev->resource.start, SZ_4K);
	342	if (!impd1->base)
	343	return -ENOMEM;
1da177e4	344
52d555ff LW	345	integrator_impd1_clk_init(impd1->base, dev->id);
	346
	347	if (!devm_request_mem_region(&dev->dev,
	348	dev->resource.start + 0x03000000,
	349	SZ_4K, "VIC"))
	350	return -EBUSY;
1da177e4	351
52d555ff LW	352	impd1->vic_base = devm_ioremap(&dev->dev,
	353	dev->resource.start + 0x03000000,
	354	SZ_4K);
	355	if (!impd1->vic_base)
	356	return -ENOMEM;
1da177e4	357
52d555ff LW	358	irq_base = vic_init_cascaded(impd1->vic_base, dev->irq,
	359	IMPD1_VALID_IRQS, 0);
	360
	361	lm_set_drvdata(dev, impd1);
	362
	363	dev_info(&dev->dev, "IM-PD1 found at 0x%08lx\n",
	364	(unsigned long)dev->resource.start);
d72fbdf0	365
1da177e4 LT	366	for (i = 0; i < ARRAY_SIZE(impd1_devs); i++) {
	367	struct impd1_device *idev = impd1_devs + i;
	368	struct amba_device *d;
	369	unsigned long pc_base;
4ff35d86	370	char devname[32];
52d555ff LW	371	int irq1 = idev->irq[0];
	372	int irq2 = idev->irq[1];
	373
	374	/* Translate IRQs to IM-PD1 local numberspace */
	375	if (irq1)
	376	irq1 += irq_base;
	377	if (irq2)
	378	irq2 += irq_base;
1da177e4 LT	379
1da177e4 LT	380	pc_base = dev->resource.start + idev->offset;
4ff35d86	381	snprintf(devname, 32, "lm%x:%5.5lx", dev->id, idev->offset >> 12);
684284b6 LW	382
	383	/* Add GPIO descriptor lookup table for the PL061 block */
	384	if (idev->offset == 0x00400000) {
	385	struct gpiod_lookup_table *lookup;
	386	char *chipname;
	387	char *mmciname;
	388
	389	lookup = devm_kzalloc(&dev->dev,
21face6f	390	struct_size(lookup, table, 3),
684284b6 LW	391	GFP_KERNEL);
684284b6 LW	392	chipname = devm_kstrdup(&dev->dev, devname, GFP_KERNEL);
df209c43 NMG	393	mmciname = devm_kasprintf(&dev->dev, GFP_KERNEL,
	394	"lm%x:00700", dev->id);
	395	if (!lookup \|\| !chipname \|\| !mmciname)
	396	return -ENOMEM;
	397
684284b6 LW	398	lookup->dev_id = mmciname;
	399	/*
	400	* Offsets on GPIO block 1:
	401	* 3 = MMC WP (write protect)
	402	* 4 = MMC CD (card detect)
	403	*
	404	* Offsets on GPIO block 2:
	405	* 0 = Up key
	406	* 1 = Down key
	407	* 2 = Left key
	408	* 3 = Right key
	409	* 4 = Key lower left
	410	* 5 = Key lower right
	411	*/
	412	/* We need the two MMCI GPIO entries */
	413	lookup->table[0].chip_label = chipname;
	414	lookup->table[0].chip_hwnum = 3;
	415	lookup->table[0].con_id = "wp";
	416	lookup->table[1].chip_label = chipname;
	417	lookup->table[1].chip_hwnum = 4;
	418	lookup->table[1].con_id = "cd";
	419	lookup->table[1].flags = GPIO_ACTIVE_LOW;
	420	gpiod_add_lookup_table(lookup);
	421	}
	422
2148b93a	423	d = amba_ahb_device_add_res(&dev->dev, devname, pc_base, SZ_4K,
52d555ff	424	irq1, irq2,
2148b93a LW	425	idev->platform_data, idev->id,
2148b93a LW	426	&dev->resource);
4ff35d86 LW	427	if (IS_ERR(d)) {
4ff35d86 LW	428	dev_err(&dev->dev, "unable to register device: %ld\n", PTR_ERR(d));
1da177e4	429	continue;
1da177e4 LT	430	}
	431	}
	432
	433	return 0;
1da177e4 LT	434	}
1da177e4 LT	435
d1856637 RK	436	static int impd1_remove_one(struct device dev, void data)
	437	{
	438	device_unregister(dev);
	439	return 0;
	440	}
	441
1da177e4 LT	442	static void impd1_remove(struct lm_device *dev)
1da177e4 LT	443	{
d1856637	444	device_for_each_child(&dev->dev, NULL, impd1_remove_one);
70ee6577	445	integrator_impd1_clk_exit(dev->id);
1da177e4 LT	446
1da177e4 LT	447	lm_set_drvdata(dev, NULL);
1da177e4 LT	448	}
	449
	450	static struct lm_driver impd1_driver = {
	451	.drv = {
	452	.name = "impd1",
e1318391 LW	453	/*
	454	* As we're dropping the probe() function, suppress driver
	455	* binding from sysfs.
	456	*/
	457	.suppress_bind_attrs = true,
1da177e4 LT	458	},
	459	.probe = impd1_probe,
	460	.remove = impd1_remove,
	461	};
	462
	463	static int __init impd1_init(void)
	464	{
	465	return lm_driver_register(&impd1_driver);
	466	}
	467
	468	static void __exit impd1_exit(void)
	469	{
	470	lm_driver_unregister(&impd1_driver);
	471	}
	472
	473	module_init(impd1_init);
	474	module_exit(impd1_exit);
	475
	476	MODULE_LICENSE("GPL");
	477	MODULE_DESCRIPTION("Integrator/IM-PD1 logic module core driver");
	478	MODULE_AUTHOR("Deep Blue Solutions Ltd");