1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42#include <linux/module.h>
43#include <linux/device.h>
44#include <linux/string.h>
45#include <linux/slab.h>
46#include <linux/platform_device.h>
47#include <linux/uio_driver.h>
48#include <linux/of_address.h>
49#include <linux/of_irq.h>
50
51#include <asm/fsl_lbc.h>
52
53#define MAX_BANKS 8
54
55struct fsl_elbc_gpcm {
56 struct device *dev;
57 struct fsl_lbc_regs __iomem *lbc;
58 u32 bank;
59 const char *name;
60
61 void (*init)(struct uio_info *info);
62 void (*shutdown)(struct uio_info *info, bool init_err);
63 irqreturn_t (*irq_handler)(int irq, struct uio_info *info);
64};
65
66static ssize_t reg_show(struct device *dev, struct device_attribute *attr,
67 char *buf);
68static ssize_t reg_store(struct device *dev, struct device_attribute *attr,
69 const char *buf, size_t count);
70
71static DEVICE_ATTR(reg_br, 0664, reg_show, reg_store);
72static DEVICE_ATTR(reg_or, 0664, reg_show, reg_store);
73
74static ssize_t reg_show(struct device *dev, struct device_attribute *attr,
75 char *buf)
76{
77 struct uio_info *info = dev_get_drvdata(dev);
78 struct fsl_elbc_gpcm *priv = info->priv;
79 struct fsl_lbc_bank *bank = &priv->lbc->bank[priv->bank];
80
81 if (attr == &dev_attr_reg_br) {
82 return scnprintf(buf, PAGE_SIZE, "0x%08x\n",
83 in_be32(&bank->br));
84
85 } else if (attr == &dev_attr_reg_or) {
86 return scnprintf(buf, PAGE_SIZE, "0x%08x\n",
87 in_be32(&bank->or));
88 }
89
90 return 0;
91}
92
93static ssize_t reg_store(struct device *dev, struct device_attribute *attr,
94 const char *buf, size_t count)
95{
96 struct uio_info *info = dev_get_drvdata(dev);
97 struct fsl_elbc_gpcm *priv = info->priv;
98 struct fsl_lbc_bank *bank = &priv->lbc->bank[priv->bank];
99 unsigned long val;
100 u32 reg_br_cur;
101 u32 reg_or_cur;
102 u32 reg_new;
103
104
105 if (kstrtoul(buf, 0, &val) != 0)
106 return -EINVAL;
107 reg_new = (u32)val;
108
109
110 reg_br_cur = in_be32(&bank->br);
111 reg_or_cur = in_be32(&bank->or);
112
113 if (attr == &dev_attr_reg_br) {
114
115 if ((reg_br_cur & reg_or_cur & BR_BA) !=
116 (reg_new & reg_or_cur & BR_BA)) {
117 return -EINVAL;
118 }
119
120
121 if ((reg_new & BR_MSEL) != BR_MS_GPCM)
122 return -EINVAL;
123
124
125 out_be32(&bank->br, reg_new | BR_V);
126
127 } else if (attr == &dev_attr_reg_or) {
128
129 if ((reg_or_cur & OR_GPCM_AM) != (reg_new & OR_GPCM_AM))
130 return -EINVAL;
131
132
133 out_be32(&bank->or, reg_new);
134
135 } else {
136 return -EINVAL;
137 }
138
139 return count;
140}
141
142#ifdef CONFIG_UIO_FSL_ELBC_GPCM_NETX5152
143#define DPM_HOST_WIN0_OFFSET 0xff00
144#define DPM_HOST_INT_STAT0 0xe0
145#define DPM_HOST_INT_EN0 0xf0
146#define DPM_HOST_INT_MASK 0xe600ffff
147#define DPM_HOST_INT_GLOBAL_EN 0x80000000
148
149static irqreturn_t netx5152_irq_handler(int irq, struct uio_info *info)
150{
151 void __iomem *reg_int_en = info->mem[0].internal_addr +
152 DPM_HOST_WIN0_OFFSET +
153 DPM_HOST_INT_EN0;
154 void __iomem *reg_int_stat = info->mem[0].internal_addr +
155 DPM_HOST_WIN0_OFFSET +
156 DPM_HOST_INT_STAT0;
157
158
159 if ((ioread32(reg_int_en) & ioread32(reg_int_stat) &
160 DPM_HOST_INT_MASK) == 0) {
161 return IRQ_NONE;
162 }
163
164
165 iowrite32(ioread32(reg_int_en) & ~DPM_HOST_INT_GLOBAL_EN, reg_int_en);
166
167 return IRQ_HANDLED;
168}
169
170static void netx5152_init(struct uio_info *info)
171{
172 unsigned long win0_offset = DPM_HOST_WIN0_OFFSET;
173 struct fsl_elbc_gpcm *priv = info->priv;
174 const void *prop;
175
176
177 prop = of_get_property(priv->dev->of_node,
178 "netx5152,init-win0-offset", NULL);
179 if (prop)
180 win0_offset = of_read_ulong(prop, 1);
181
182
183 iowrite32(0, info->mem[0].internal_addr + win0_offset +
184 DPM_HOST_INT_EN0);
185}
186
187static void netx5152_shutdown(struct uio_info *info, bool init_err)
188{
189 if (init_err)
190 return;
191
192
193 iowrite32(0, info->mem[0].internal_addr + DPM_HOST_WIN0_OFFSET +
194 DPM_HOST_INT_EN0);
195}
196#endif
197
198static void setup_periph(struct fsl_elbc_gpcm *priv,
199 const char *type)
200{
201#ifdef CONFIG_UIO_FSL_ELBC_GPCM_NETX5152
202 if (strcmp(type, "netx5152") == 0) {
203 priv->irq_handler = netx5152_irq_handler;
204 priv->init = netx5152_init;
205 priv->shutdown = netx5152_shutdown;
206 priv->name = "netX 51/52";
207 return;
208 }
209#endif
210}
211
212static int check_of_data(struct fsl_elbc_gpcm *priv,
213 struct resource *res,
214 u32 reg_br, u32 reg_or)
215{
216
217 if (priv->bank >= MAX_BANKS) {
218 dev_err(priv->dev, "invalid bank\n");
219 return -ENODEV;
220 }
221
222
223 if ((reg_br & BR_MSEL) != BR_MS_GPCM) {
224 dev_err(priv->dev, "unsupported mode\n");
225 return -ENODEV;
226 }
227
228
229 if ((~(reg_or & OR_GPCM_AM) + 1) != resource_size(res)) {
230 dev_err(priv->dev, "address mask / size mismatch\n");
231 return -ENODEV;
232 }
233
234
235 if ((reg_br & reg_or & BR_BA) != fsl_lbc_addr(res->start)) {
236 dev_err(priv->dev, "base address mismatch\n");
237 return -ENODEV;
238 }
239
240 return 0;
241}
242
243static int get_of_data(struct fsl_elbc_gpcm *priv, struct device_node *node,
244 struct resource *res, u32 *reg_br,
245 u32 *reg_or, unsigned int *irq, char **name)
246{
247 const char *dt_name;
248 const char *type;
249 int ret;
250
251
252 ret = of_address_to_resource(node, 0, res);
253 if (ret) {
254 dev_err(priv->dev, "failed to get resource\n");
255 return ret;
256 }
257
258
259 ret = of_property_read_u32(node, "reg", &priv->bank);
260 if (ret) {
261 dev_err(priv->dev, "failed to get bank number\n");
262 return ret;
263 }
264
265
266 ret = of_property_read_u32(node, "elbc-gpcm-br", reg_br);
267 if (ret) {
268 dev_err(priv->dev, "missing elbc-gpcm-br value\n");
269 return ret;
270 }
271
272
273 ret = of_property_read_u32(node, "elbc-gpcm-or", reg_or);
274 if (ret) {
275 dev_err(priv->dev, "missing elbc-gpcm-or value\n");
276 return ret;
277 }
278
279
280 priv->name = "generic";
281 if (of_property_read_string(node, "device_type", &type) == 0)
282 setup_periph(priv, type);
283
284
285 *irq = irq_of_parse_and_map(node, 0);
286
287
288 ret = check_of_data(priv, res, *reg_br, *reg_or);
289 if (ret)
290 return ret;
291
292
293 if (of_property_read_string(node, "uio_name", &dt_name) != 0)
294 dt_name = "eLBC_GPCM";
295 *name = kstrdup(dt_name, GFP_KERNEL);
296 if (!*name)
297 return -ENOMEM;
298
299 return 0;
300}
301
302static int uio_fsl_elbc_gpcm_probe(struct platform_device *pdev)
303{
304 struct device_node *node = pdev->dev.of_node;
305 struct fsl_elbc_gpcm *priv;
306 struct uio_info *info;
307 char *uio_name = NULL;
308 struct resource res;
309 unsigned int irq;
310 u32 reg_br_cur;
311 u32 reg_or_cur;
312 u32 reg_br_new;
313 u32 reg_or_new;
314 int ret;
315
316 if (!fsl_lbc_ctrl_dev || !fsl_lbc_ctrl_dev->regs)
317 return -ENODEV;
318
319
320 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
321 if (!priv)
322 return -ENOMEM;
323 priv->dev = &pdev->dev;
324 priv->lbc = fsl_lbc_ctrl_dev->regs;
325
326
327 ret = get_of_data(priv, node, &res, ®_br_new, ®_or_new,
328 &irq, &uio_name);
329 if (ret)
330 goto out_err0;
331
332
333 info = kzalloc(sizeof(*info), GFP_KERNEL);
334 if (!info) {
335 ret = -ENOMEM;
336 goto out_err0;
337 }
338
339
340 reg_br_cur = in_be32(&priv->lbc->bank[priv->bank].br);
341 reg_or_cur = in_be32(&priv->lbc->bank[priv->bank].or);
342
343
344 if ((reg_br_cur & BR_V)) {
345 if ((reg_br_cur & BR_MSEL) != BR_MS_GPCM ||
346 (reg_br_cur & reg_or_cur & BR_BA)
347 != fsl_lbc_addr(res.start)) {
348 dev_err(priv->dev,
349 "bank in use by another peripheral\n");
350 ret = -ENODEV;
351 goto out_err1;
352 }
353
354
355 if ((reg_br_cur & ~(BR_BA | BR_V)) !=
356 (reg_br_new & ~(BR_BA | BR_V))) {
357 dev_warn(priv->dev,
358 "modifying BR settings: 0x%08x -> 0x%08x",
359 reg_br_cur, reg_br_new);
360 }
361 if ((reg_or_cur & ~OR_GPCM_AM) != (reg_or_new & ~OR_GPCM_AM)) {
362 dev_warn(priv->dev,
363 "modifying OR settings: 0x%08x -> 0x%08x",
364 reg_or_cur, reg_or_new);
365 }
366 }
367
368
369 reg_br_new &= ~(BR_BA | BR_MSEL);
370 reg_br_new |= fsl_lbc_addr(res.start) | BR_MS_GPCM | BR_V;
371 out_be32(&priv->lbc->bank[priv->bank].or, reg_or_new);
372 out_be32(&priv->lbc->bank[priv->bank].br, reg_br_new);
373
374
375 info->mem[0].internal_addr = ioremap(res.start, resource_size(&res));
376 if (!info->mem[0].internal_addr) {
377 dev_err(priv->dev, "failed to map chip region\n");
378 ret = -ENODEV;
379 goto out_err1;
380 }
381
382
383 info->mem[0].name = kasprintf(GFP_KERNEL, "%pOFn", node);
384 info->mem[0].addr = res.start;
385 info->mem[0].size = resource_size(&res);
386 info->mem[0].memtype = UIO_MEM_PHYS;
387 info->priv = priv;
388 info->name = uio_name;
389 info->version = "0.0.1";
390 if (irq != NO_IRQ) {
391 if (priv->irq_handler) {
392 info->irq = irq;
393 info->irq_flags = IRQF_SHARED;
394 info->handler = priv->irq_handler;
395 } else {
396 irq = NO_IRQ;
397 dev_warn(priv->dev, "ignoring irq, no handler\n");
398 }
399 }
400
401 if (priv->init)
402 priv->init(info);
403
404
405 if (uio_register_device(priv->dev, info) != 0) {
406 dev_err(priv->dev, "UIO registration failed\n");
407 ret = -ENODEV;
408 goto out_err2;
409 }
410
411
412 platform_set_drvdata(pdev, info);
413
414
415 ret = device_create_file(priv->dev, &dev_attr_reg_br);
416 if (ret)
417 goto out_err3;
418 ret = device_create_file(priv->dev, &dev_attr_reg_or);
419 if (ret)
420 goto out_err4;
421
422 dev_info(priv->dev,
423 "eLBC/GPCM device (%s) at 0x%llx, bank %d, irq=%d\n",
424 priv->name, (unsigned long long)res.start, priv->bank,
425 irq != NO_IRQ ? irq : -1);
426
427 return 0;
428out_err4:
429 device_remove_file(priv->dev, &dev_attr_reg_br);
430out_err3:
431 platform_set_drvdata(pdev, NULL);
432 uio_unregister_device(info);
433out_err2:
434 if (priv->shutdown)
435 priv->shutdown(info, true);
436 iounmap(info->mem[0].internal_addr);
437out_err1:
438 kfree(info->mem[0].name);
439 kfree(info);
440out_err0:
441 kfree(uio_name);
442 kfree(priv);
443 return ret;
444}
445
446static int uio_fsl_elbc_gpcm_remove(struct platform_device *pdev)
447{
448 struct uio_info *info = platform_get_drvdata(pdev);
449 struct fsl_elbc_gpcm *priv = info->priv;
450
451 device_remove_file(priv->dev, &dev_attr_reg_or);
452 device_remove_file(priv->dev, &dev_attr_reg_br);
453 platform_set_drvdata(pdev, NULL);
454 uio_unregister_device(info);
455 if (priv->shutdown)
456 priv->shutdown(info, false);
457 iounmap(info->mem[0].internal_addr);
458 kfree(info->mem[0].name);
459 kfree(info->name);
460 kfree(info);
461 kfree(priv);
462
463 return 0;
464
465}
466
467static const struct of_device_id uio_fsl_elbc_gpcm_match[] = {
468 { .compatible = "fsl,elbc-gpcm-uio", },
469 {}
470};
471MODULE_DEVICE_TABLE(of, uio_fsl_elbc_gpcm_match);
472
473static struct platform_driver uio_fsl_elbc_gpcm_driver = {
474 .driver = {
475 .name = "fsl,elbc-gpcm-uio",
476 .of_match_table = uio_fsl_elbc_gpcm_match,
477 },
478 .probe = uio_fsl_elbc_gpcm_probe,
479 .remove = uio_fsl_elbc_gpcm_remove,
480};
481module_platform_driver(uio_fsl_elbc_gpcm_driver);
482
483MODULE_LICENSE("GPL");
484MODULE_AUTHOR("John Ogness <john.ogness@linutronix.de>");
485MODULE_DESCRIPTION("Freescale Enhanced Local Bus Controller GPCM driver");
486