Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1/*
2 * Copyright (C) 2007 Google, Inc.
3 * Copyright (C) 2011 Intel, Inc.
4 * Copyright (C) 2013 Intel, Inc.
5 *
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 */
16
17#include <linux/kernel.h>
18#include <linux/init.h>
19#include <linux/interrupt.h>
20#include <linux/irq.h>
21#include <linux/platform_device.h>
22#include <linux/slab.h>
23#include <linux/io.h>
24
25#define PDEV_BUS_OP_DONE (0x00)
26#define PDEV_BUS_OP_REMOVE_DEV (0x04)
27#define PDEV_BUS_OP_ADD_DEV (0x08)
28
29#define PDEV_BUS_OP_INIT (0x00)
30
31#define PDEV_BUS_OP (0x00)
32#define PDEV_BUS_GET_NAME (0x04)
33#define PDEV_BUS_NAME_LEN (0x08)
34#define PDEV_BUS_ID (0x0c)
35#define PDEV_BUS_IO_BASE (0x10)
36#define PDEV_BUS_IO_SIZE (0x14)
37#define PDEV_BUS_IRQ (0x18)
38#define PDEV_BUS_IRQ_COUNT (0x1c)
39
40struct pdev_bus_dev {
41 struct list_head list;
42 struct platform_device pdev;
43 struct resource resources[0];
44};
45
46static void goldfish_pdev_worker(struct work_struct *work);
47
48static void __iomem *pdev_bus_base;
49static unsigned long pdev_bus_addr;
50static unsigned long pdev_bus_len;
51static u32 pdev_bus_irq;
52static LIST_HEAD(pdev_bus_new_devices);
53static LIST_HEAD(pdev_bus_registered_devices);
54static LIST_HEAD(pdev_bus_removed_devices);
55static DECLARE_WORK(pdev_bus_worker, goldfish_pdev_worker);
56
57
58static void goldfish_pdev_worker(struct work_struct *work)
59{
60 int ret;
61 struct pdev_bus_dev *pos, *n;
62
63 list_for_each_entry_safe(pos, n, &pdev_bus_removed_devices, list) {
64 list_del(&pos->list);
65 platform_device_unregister(&pos->pdev);
66 kfree(pos);
67 }
68 list_for_each_entry_safe(pos, n, &pdev_bus_new_devices, list) {
69 list_del(&pos->list);
70 ret = platform_device_register(&pos->pdev);
71 if (ret)
72 pr_err("goldfish_pdev_worker failed to register device, %s\n",
73 pos->pdev.name);
74 list_add_tail(&pos->list, &pdev_bus_registered_devices);
75 }
76}
77
78static void goldfish_pdev_remove(void)
79{
80 struct pdev_bus_dev *pos, *n;
81 u32 base;
82
83 base = readl(pdev_bus_base + PDEV_BUS_IO_BASE);
84
85 list_for_each_entry_safe(pos, n, &pdev_bus_new_devices, list) {
86 if (pos->resources[0].start == base) {
87 list_del(&pos->list);
88 kfree(pos);
89 return;
90 }
91 }
92 list_for_each_entry_safe(pos, n, &pdev_bus_registered_devices, list) {
93 if (pos->resources[0].start == base) {
94 list_del(&pos->list);
95 list_add_tail(&pos->list, &pdev_bus_removed_devices);
96 schedule_work(&pdev_bus_worker);
97 return;
98 }
99 };
100 pr_err("goldfish_pdev_remove could not find device at %x\n", base);
101}
102
103static int goldfish_new_pdev(void)
104{
105 struct pdev_bus_dev *dev;
106 u32 name_len;
107 u32 irq = -1, irq_count;
108 int resource_count = 2;
109 u32 base;
110 char *name;
111
112 base = readl(pdev_bus_base + PDEV_BUS_IO_BASE);
113
114 irq_count = readl(pdev_bus_base + PDEV_BUS_IRQ_COUNT);
115 name_len = readl(pdev_bus_base + PDEV_BUS_NAME_LEN);
116 if (irq_count)
117 resource_count++;
118
119 dev = kzalloc(sizeof(*dev) +
120 sizeof(struct resource) * resource_count +
121 name_len + 1 + sizeof(*dev->pdev.dev.dma_mask), GFP_ATOMIC);
122 if (dev == NULL)
123 return -ENOMEM;
124
125 dev->pdev.num_resources = resource_count;
126 dev->pdev.resource = (struct resource *)(dev + 1);
127 dev->pdev.name = name = (char *)(dev->pdev.resource + resource_count);
128 dev->pdev.dev.coherent_dma_mask = ~0;
129 dev->pdev.dev.dma_mask = (void *)(dev->pdev.name + name_len + 1);
130 *dev->pdev.dev.dma_mask = ~0;
131
132 writel((unsigned long)name, pdev_bus_base + PDEV_BUS_GET_NAME);
133 name[name_len] = '\0';
134 dev->pdev.id = readl(pdev_bus_base + PDEV_BUS_ID);
135 dev->pdev.resource[0].start = base;
136 dev->pdev.resource[0].end = base +
137 readl(pdev_bus_base + PDEV_BUS_IO_SIZE) - 1;
138 dev->pdev.resource[0].flags = IORESOURCE_MEM;
139 if (irq_count) {
140 irq = readl(pdev_bus_base + PDEV_BUS_IRQ);
141 dev->pdev.resource[1].start = irq;
142 dev->pdev.resource[1].end = irq + irq_count - 1;
143 dev->pdev.resource[1].flags = IORESOURCE_IRQ;
144 }
145
146 pr_debug("goldfish_new_pdev %s at %x irq %d\n", name, base, irq);
147 list_add_tail(&dev->list, &pdev_bus_new_devices);
148 schedule_work(&pdev_bus_worker);
149
150 return 0;
151}
152
153static irqreturn_t goldfish_pdev_bus_interrupt(int irq, void *dev_id)
154{
155 irqreturn_t ret = IRQ_NONE;
156 while (1) {
157 u32 op = readl(pdev_bus_base + PDEV_BUS_OP);
158 switch (op) {
159 case PDEV_BUS_OP_DONE:
160 return IRQ_NONE;
161
162 case PDEV_BUS_OP_REMOVE_DEV:
163 goldfish_pdev_remove();
164 break;
165
166 case PDEV_BUS_OP_ADD_DEV:
167 goldfish_new_pdev();
168 break;
169 }
170 ret = IRQ_HANDLED;
171 }
172 return ret;
173}
174
175static int goldfish_pdev_bus_probe(struct platform_device *pdev)
176{
177 int ret;
178 struct resource *r;
179
180 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
181 if (r == NULL)
182 return -EINVAL;
183
184 pdev_bus_addr = r->start;
185 pdev_bus_len = resource_size(r);
186
187 if (request_mem_region(pdev_bus_addr, pdev_bus_len, "goldfish")) {
188 dev_err(&pdev->dev, "unable to reserve Goldfish MMIO.\n");
189 return -EBUSY;
190 }
191
192 pdev_bus_base = ioremap(pdev_bus_addr, pdev_bus_len);
193 if (pdev_bus_base == NULL) {
194 ret = -ENOMEM;
195 dev_err(&pdev->dev, "unable to map Goldfish MMIO.\n");
196 goto free_resources;
197 }
198
199 r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
200 if (r == NULL) {
201 ret = -ENOENT;
202 goto free_map;
203 }
204
205 pdev_bus_irq = r->start;
206
207 ret = request_irq(pdev_bus_irq, goldfish_pdev_bus_interrupt,
208 IRQF_SHARED, "goldfish_pdev_bus", pdev);
209 if (ret) {
210 dev_err(&pdev->dev, "unable to request Goldfish IRQ\n");
211 goto free_map;
212 }
213
214 writel(PDEV_BUS_OP_INIT, pdev_bus_base + PDEV_BUS_OP);
215 return 0;
216
217free_map:
218 iounmap(pdev_bus_base);
219free_resources:
220 release_mem_region(pdev_bus_addr, pdev_bus_len);
221 return ret;
222}
223
224static int goldfish_pdev_bus_remove(struct platform_device *pdev)
225{
226 iounmap(pdev_bus_base);
227 free_irq(pdev_bus_irq, pdev);
228 release_mem_region(pdev_bus_addr, pdev_bus_len);
229 return 0;
230}
231
232static struct platform_driver goldfish_pdev_bus_driver = {
233 .probe = goldfish_pdev_bus_probe,
234 .remove = goldfish_pdev_bus_remove,
235 .driver = {
236 .name = "goldfish_pdev_bus"
237 }
238};
239
240module_platform_driver(goldfish_pdev_bus_driver);