projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 152
[linux-2.6-block.git] / drivers / vme / bridges / vme_fake.c
CommitLineData
2874c5fd 1// SPDX-License-Identifier: GPL-2.0-or-later
658bcdae
MW		 2/*
3 * Fake VME bridge support.
4 *
5 * This drive provides a fake VME bridge chip, this enables debugging of the
6 * VME framework in the absence of a VME system.
7 *
8 * This driver has to do a number of things in software that would be driven
9 * by hardware if it was available, it will also result in extra overhead at
10 * times when compared with driving actual hardware.
11 *
12 * Author: Martyn Welch <martyn@welches.me.uk>
13 * Copyright (c) 2014 Martyn Welch
14 *
15 * Based on vme_tsi148.c:
16 *
17 * Author: Martyn Welch <martyn.welch@ge.com>
18 * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc.
19 *
20 * Based on work by Tom Armistead and Ajit Prem
21 * Copyright 2004 Motorola Inc.
658bcdae
MW		 22 */
23
24#include <linux/device.h>
25#include <linux/errno.h>
26#include <linux/interrupt.h>
27#include <linux/module.h>
28#include <linux/moduleparam.h>
29#include <linux/slab.h>
30#include <linux/spinlock.h>
31#include <linux/types.h>
32#include <linux/vme.h>
33
34#include "../vme_bridge.h"
35
36/*
37 * Define the number of each that the fake driver supports.
38 */
39#define FAKE_MAX_MASTER 8 /* Max Master Windows */
40#define FAKE_MAX_SLAVE 8 /* Max Slave Windows */
41
42/* Structures to hold information normally held in device registers */
43struct fake_slave_window {
44 int enabled;
45 unsigned long long vme_base;
46 unsigned long long size;
4b7b948b 47 void *buf_base;
658bcdae
MW		 48 u32 aspace;
49 u32 cycle;
50};
51
52struct fake_master_window {
53 int enabled;
54 unsigned long long vme_base;
55 unsigned long long size;
56 u32 aspace;
57 u32 cycle;
58 u32 dwidth;
59};
60
61/* Structure used to hold driver specific information */
62struct fake_driver {
63 struct vme_bridge *parent;
64 struct fake_slave_window slaves[FAKE_MAX_SLAVE];
65 struct fake_master_window masters[FAKE_MAX_MASTER];
66 u32 lm_enabled;
67 unsigned long long lm_base;
68 u32 lm_aspace;
69 u32 lm_cycle;
70 void (*lm_callback[4])(void *);
71 void *lm_data[4];
72 struct tasklet_struct int_tasklet;
73 int int_level;
74 int int_statid;
75 void *crcsr_kernel;
76 dma_addr_t crcsr_bus;
77 /* Only one VME interrupt can be generated at a time, provide locking */
78 struct mutex vme_int;
79};
80
81/* Module parameter */
82static int geoid;
83
84static const char driver_name[] = "vme_fake";
85
86static struct vme_bridge *exit_pointer;
87
88static struct device *vme_root;
89
90/*
91 * Calling VME bus interrupt callback if provided.
92 */
93static void fake_VIRQ_tasklet(unsigned long data)
94{
95 struct vme_bridge *fake_bridge;
96 struct fake_driver *bridge;
97
98 fake_bridge = (struct vme_bridge *) data;
99 bridge = fake_bridge->driver_priv;
100
101 vme_irq_handler(fake_bridge, bridge->int_level, bridge->int_statid);
102}
103
104/*
105 * Configure VME interrupt
106 */
107static void fake_irq_set(struct vme_bridge *fake_bridge, int level,
108 int state, int sync)
109{
110 /* Nothing to do */
111}
112
4b7b948b
AB		 113static void *fake_pci_to_ptr(dma_addr_t addr)
114{
115 return (void *)(uintptr_t)addr;
116}
117
118static dma_addr_t fake_ptr_to_pci(void *addr)
119{
120 return (dma_addr_t)(uintptr_t)addr;
121}
122
658bcdae
MW		 123/*
124 * Generate a VME bus interrupt at the requested level & vector. Wait for
125 * interrupt to be acked.
126 */
127static int fake_irq_generate(struct vme_bridge *fake_bridge, int level,
128 int statid)
129{
130 struct fake_driver *bridge;
131
132 bridge = fake_bridge->driver_priv;
133
134 mutex_lock(&bridge->vme_int);
135
136 bridge->int_level = level;
137
138 bridge->int_statid = statid;
139
140 /*
141 * Schedule tasklet to run VME handler to emulate normal VME interrupt
142 * handler behaviour.
143 */
144 tasklet_schedule(&bridge->int_tasklet);
145
146 mutex_unlock(&bridge->vme_int);
147
148 return 0;
149}
150
151/*
152 * Initialize a slave window with the requested attributes.
153 */
154static int fake_slave_set(struct vme_slave_resource *image, int enabled,
155 unsigned long long vme_base, unsigned long long size,
156 dma_addr_t buf_base, u32 aspace, u32 cycle)
157{
158 unsigned int i, granularity = 0;
159 unsigned long long vme_bound;
160 struct vme_bridge *fake_bridge;
161 struct fake_driver *bridge;
162
163 fake_bridge = image->parent;
164 bridge = fake_bridge->driver_priv;
165
166 i = image->number;
167
168 switch (aspace) {
169 case VME_A16:
170 granularity = 0x10;
171 break;
172 case VME_A24:
173 granularity = 0x1000;
174 break;
175 case VME_A32:
176 granularity = 0x10000;
177 break;
178 case VME_A64:
179 granularity = 0x10000;
180 break;
181 case VME_CRCSR:
182 case VME_USER1:
183 case VME_USER2:
184 case VME_USER3:
185 case VME_USER4:
186 default:
187 pr_err("Invalid address space\n");
188 return -EINVAL;
189 }
190
191 /*
192 * Bound address is a valid address for the window, adjust
193 * accordingly
194 */
195 vme_bound = vme_base + size - granularity;
196
197 if (vme_base & (granularity - 1)) {
198 pr_err("Invalid VME base alignment\n");
199 return -EINVAL;
200 }
201 if (vme_bound & (granularity - 1)) {
202 pr_err("Invalid VME bound alignment\n");
203 return -EINVAL;
204 }
205
206 mutex_lock(&image->mtx);
207
208 bridge->slaves[i].enabled = enabled;
209 bridge->slaves[i].vme_base = vme_base;
210 bridge->slaves[i].size = size;
4b7b948b 211 bridge->slaves[i].buf_base = fake_pci_to_ptr(buf_base);
658bcdae
MW		 212 bridge->slaves[i].aspace = aspace;
213 bridge->slaves[i].cycle = cycle;
214
215 mutex_unlock(&image->mtx);
216
217 return 0;
218}
219
220/*
221 * Get slave window configuration.
222 */
223static int fake_slave_get(struct vme_slave_resource *image, int *enabled,
224 unsigned long long *vme_base, unsigned long long *size,
225 dma_addr_t *buf_base, u32 *aspace, u32 *cycle)
226{
227 unsigned int i;
228 struct fake_driver *bridge;
229
230 bridge = image->parent->driver_priv;
231
232 i = image->number;
233
234 mutex_lock(&image->mtx);
235
236 *enabled = bridge->slaves[i].enabled;
237 *vme_base = bridge->slaves[i].vme_base;
238 *size = bridge->slaves[i].size;
4b7b948b 239 *buf_base = fake_ptr_to_pci(bridge->slaves[i].buf_base);
658bcdae
MW		 240 *aspace = bridge->slaves[i].aspace;
241 *cycle = bridge->slaves[i].cycle;
242
243 mutex_unlock(&image->mtx);
244
245 return 0;
246}
247
248/*
249 * Set the attributes of an outbound window.
250 */
251static int fake_master_set(struct vme_master_resource *image, int enabled,
252 unsigned long long vme_base, unsigned long long size,
253 u32 aspace, u32 cycle, u32 dwidth)
254{
255 int retval = 0;
256 unsigned int i;
257 struct vme_bridge *fake_bridge;
258 struct fake_driver *bridge;
259
260 fake_bridge = image->parent;
261
262 bridge = fake_bridge->driver_priv;
263
264 /* Verify input data */
265 if (vme_base & 0xFFFF) {
266 pr_err("Invalid VME Window alignment\n");
267 retval = -EINVAL;
268 goto err_window;
269 }
270
271 if (size & 0xFFFF) {
658bcdae
MW		 272 pr_err("Invalid size alignment\n");
273 retval = -EINVAL;
274 goto err_window;
275 }
276
277 if ((size == 0) && (enabled != 0)) {
278 pr_err("Size must be non-zero for enabled windows\n");
279 retval = -EINVAL;
280 goto err_window;
281 }
282
283 /* Setup data width */
284 switch (dwidth) {
285 case VME_D8:
286 case VME_D16:
287 case VME_D32:
288 break;
289 default:
658bcdae
MW		 290 pr_err("Invalid data width\n");
291 retval = -EINVAL;
292 goto err_dwidth;
293 }
294
295 /* Setup address space */
296 switch (aspace) {
297 case VME_A16:
298 case VME_A24:
299 case VME_A32:
300 case VME_A64:
301 case VME_CRCSR:
302 case VME_USER1:
303 case VME_USER2:
304 case VME_USER3:
305 case VME_USER4:
306 break;
307 default:
658bcdae
MW		 308 pr_err("Invalid address space\n");
309 retval = -EINVAL;
310 goto err_aspace;
311 }
312
313 spin_lock(&image->lock);
314
315 i = image->number;
316
317 bridge->masters[i].enabled = enabled;
318 bridge->masters[i].vme_base = vme_base;
319 bridge->masters[i].size = size;
320 bridge->masters[i].aspace = aspace;
321 bridge->masters[i].cycle = cycle;
322 bridge->masters[i].dwidth = dwidth;
323
324 spin_unlock(&image->lock);
325
326 return 0;
327
328err_aspace:
329err_dwidth:
330err_window:
331 return retval;
332
333}
334
335/*
336 * Set the attributes of an outbound window.
337 */
338static int __fake_master_get(struct vme_master_resource *image, int *enabled,
339 unsigned long long *vme_base, unsigned long long *size,
340 u32 *aspace, u32 *cycle, u32 *dwidth)
341{
342 unsigned int i;
343 struct fake_driver *bridge;
344
345 bridge = image->parent->driver_priv;
346
347 i = image->number;
348
349 *enabled = bridge->masters[i].enabled;
350 *vme_base = bridge->masters[i].vme_base;
351 *size = bridge->masters[i].size;
352 *aspace = bridge->masters[i].aspace;
353 *cycle = bridge->masters[i].cycle;
354 *dwidth = bridge->masters[i].dwidth;
355
356 return 0;
357}
358
359
360static int fake_master_get(struct vme_master_resource *image, int *enabled,
361 unsigned long long *vme_base, unsigned long long *size,
362 u32 *aspace, u32 *cycle, u32 *dwidth)
363{
364 int retval;
365
366 spin_lock(&image->lock);
367
368 retval = __fake_master_get(image, enabled, vme_base, size, aspace,
369 cycle, dwidth);
370
371 spin_unlock(&image->lock);
372
373 return retval;
374}
375
376
58ccaae3
BX		 377static void fake_lm_check(struct fake_driver *bridge, unsigned long long addr,
378 u32 aspace, u32 cycle)
658bcdae
MW		 379{
380 struct vme_bridge *fake_bridge;
381 unsigned long long lm_base;
382 u32 lm_aspace, lm_cycle;
383 int i;
384 struct vme_lm_resource *lm;
385 struct list_head *pos = NULL, *n;
386
387 /* Get vme_bridge */
388 fake_bridge = bridge->parent;
389
390 /* Loop through each location monitor resource */
391 list_for_each_safe(pos, n, &fake_bridge->lm_resources) {
392 lm = list_entry(pos, struct vme_lm_resource, list);
393
394 /* If disabled, we're done */
395 if (bridge->lm_enabled == 0)
396 return;
397
398 lm_base = bridge->lm_base;
399 lm_aspace = bridge->lm_aspace;
400 lm_cycle = bridge->lm_cycle;
401
402 /* First make sure that the cycle and address space match */
403 if ((lm_aspace == aspace) && (lm_cycle == cycle)) {
404 for (i = 0; i < lm->monitors; i++) {
405 /* Each location monitor covers 8 bytes */
406 if (((lm_base + (8 * i)) <= addr) &&
407 ((lm_base + (8 * i) + 8) > addr)) {
2444d37f 408 if (bridge->lm_callback[i])
658bcdae
MW		 409 bridge->lm_callback[i](
410 bridge->lm_data[i]);
411 }
412 }
413 }
414 }
415}
416
417static u8 fake_vmeread8(struct fake_driver *bridge, unsigned long long addr,
418 u32 aspace, u32 cycle)
419{
420 u8 retval = 0xff;
421 int i;
422 unsigned long long start, end, offset;
423 u8 *loc;
424
425 for (i = 0; i < FAKE_MAX_SLAVE; i++) {
426 start = bridge->slaves[i].vme_base;
427 end = bridge->slaves[i].vme_base + bridge->slaves[i].size;
428
429 if (aspace != bridge->slaves[i].aspace)
430 continue;
431
432 if (cycle != bridge->slaves[i].cycle)
433 continue;
434
435 if ((addr >= start) && (addr < end)) {
436 offset = addr - bridge->slaves[i].vme_base;
4b7b948b 437 loc = (u8 *)(bridge->slaves[i].buf_base + offset);
658bcdae
MW		 438 retval = *loc;
439
440 break;
441 }
442 }
443
444 fake_lm_check(bridge, addr, aspace, cycle);
445
446 return retval;
447}
448
449static u16 fake_vmeread16(struct fake_driver *bridge, unsigned long long addr,
450 u32 aspace, u32 cycle)
451{
452 u16 retval = 0xffff;
453 int i;
454 unsigned long long start, end, offset;
455 u16 *loc;
456
457 for (i = 0; i < FAKE_MAX_SLAVE; i++) {
458 if (aspace != bridge->slaves[i].aspace)
459 continue;
460
461 if (cycle != bridge->slaves[i].cycle)
462 continue;
463
464 start = bridge->slaves[i].vme_base;
465 end = bridge->slaves[i].vme_base + bridge->slaves[i].size;
466
467 if ((addr >= start) && ((addr + 1) < end)) {
468 offset = addr - bridge->slaves[i].vme_base;
4b7b948b 469 loc = (u16 *)(bridge->slaves[i].buf_base + offset);
658bcdae
MW		 470 retval = *loc;
471
472 break;
473 }
474 }
475
476 fake_lm_check(bridge, addr, aspace, cycle);
477
478 return retval;
479}
480
481static u32 fake_vmeread32(struct fake_driver *bridge, unsigned long long addr,
482 u32 aspace, u32 cycle)
483{
484 u32 retval = 0xffffffff;
485 int i;
486 unsigned long long start, end, offset;
487 u32 *loc;
488
489 for (i = 0; i < FAKE_MAX_SLAVE; i++) {
490 if (aspace != bridge->slaves[i].aspace)
491 continue;
492
493 if (cycle != bridge->slaves[i].cycle)
494 continue;
495
496 start = bridge->slaves[i].vme_base;
497 end = bridge->slaves[i].vme_base + bridge->slaves[i].size;
498
499 if ((addr >= start) && ((addr + 3) < end)) {
500 offset = addr - bridge->slaves[i].vme_base;
4b7b948b 501 loc = (u32 *)(bridge->slaves[i].buf_base + offset);
658bcdae
MW		 502 retval = *loc;
503
504 break;
505 }
506 }
507
508 fake_lm_check(bridge, addr, aspace, cycle);
509
510 return retval;
511}
512
513static ssize_t fake_master_read(struct vme_master_resource *image, void *buf,
514 size_t count, loff_t offset)
515{
516 int retval;
517 u32 aspace, cycle, dwidth;
518 struct vme_bridge *fake_bridge;
519 struct fake_driver *priv;
520 int i;
521 unsigned long long addr;
522 unsigned int done = 0;
523 unsigned int count32;
524
525 fake_bridge = image->parent;
526
527 priv = fake_bridge->driver_priv;
528
529 i = image->number;
530
531 addr = (unsigned long long)priv->masters[i].vme_base + offset;
532 aspace = priv->masters[i].aspace;
533 cycle = priv->masters[i].cycle;
534 dwidth = priv->masters[i].dwidth;
535
536 spin_lock(&image->lock);
537
538 /* The following code handles VME address alignment. We cannot use
539 * memcpy_xxx here because it may cut data transfers in to 8-bit
540 * cycles when D16 or D32 cycles are required on the VME bus.
541 * On the other hand, the bridge itself assures that the maximum data
542 * cycle configured for the transfer is used and splits it
543 * automatically for non-aligned addresses, so we don't want the
544 * overhead of needlessly forcing small transfers for the entire cycle.
545 */
546 if (addr & 0x1) {
547 *(u8 *)buf = fake_vmeread8(priv, addr, aspace, cycle);
548 done += 1;
549 if (done == count)
550 goto out;
551 }
552 if ((dwidth == VME_D16) || (dwidth == VME_D32)) {
553 if ((addr + done) & 0x2) {
554 if ((count - done) < 2) {
555 *(u8 *)(buf + done) = fake_vmeread8(priv,
556 addr + done, aspace, cycle);
557 done += 1;
558 goto out;
559 } else {
560 *(u16 *)(buf + done) = fake_vmeread16(priv,
561 addr + done, aspace, cycle);
562 done += 2;
563 }
564 }
565 }
566
567 if (dwidth == VME_D32) {
568 count32 = (count - done) & ~0x3;
569 while (done < count32) {
570 *(u32 *)(buf + done) = fake_vmeread32(priv, addr + done,
571 aspace, cycle);
572 done += 4;
573 }
574 } else if (dwidth == VME_D16) {
575 count32 = (count - done) & ~0x3;
576 while (done < count32) {
577 *(u16 *)(buf + done) = fake_vmeread16(priv, addr + done,
578 aspace, cycle);
579 done += 2;
580 }
581 } else if (dwidth == VME_D8) {
582 count32 = (count - done);
583 while (done < count32) {
584 *(u8 *)(buf + done) = fake_vmeread8(priv, addr + done,
585 aspace, cycle);
586 done += 1;
587 }
588
589 }
590
591 if ((dwidth == VME_D16) || (dwidth == VME_D32)) {
592 if ((count - done) & 0x2) {
593 *(u16 *)(buf + done) = fake_vmeread16(priv, addr + done,
594 aspace, cycle);
595 done += 2;
596 }
597 }
598 if ((count - done) & 0x1) {
599 *(u8 *)(buf + done) = fake_vmeread8(priv, addr + done, aspace,
600 cycle);
601 done += 1;
602 }
603
604out:
605 retval = count;
606
607 spin_unlock(&image->lock);
608
609 return retval;
610}
611
58ccaae3
BX		 612static void fake_vmewrite8(struct fake_driver *bridge, u8 *buf,
613 unsigned long long addr, u32 aspace, u32 cycle)
658bcdae
MW		 614{
615 int i;
616 unsigned long long start, end, offset;
617 u8 *loc;
618
619 for (i = 0; i < FAKE_MAX_SLAVE; i++) {
620 if (aspace != bridge->slaves[i].aspace)
621 continue;
622
623 if (cycle != bridge->slaves[i].cycle)
624 continue;
625
626 start = bridge->slaves[i].vme_base;
627 end = bridge->slaves[i].vme_base + bridge->slaves[i].size;
628
629 if ((addr >= start) && (addr < end)) {
630 offset = addr - bridge->slaves[i].vme_base;
631 loc = (u8 *)((void *)bridge->slaves[i].buf_base + offset);
632 *loc = *buf;
633
634 break;
635 }
636 }
637
638 fake_lm_check(bridge, addr, aspace, cycle);
639
640}
641
58ccaae3
BX		 642static void fake_vmewrite16(struct fake_driver *bridge, u16 *buf,
643 unsigned long long addr, u32 aspace, u32 cycle)
658bcdae
MW		 644{
645 int i;
646 unsigned long long start, end, offset;
647 u16 *loc;
648
649 for (i = 0; i < FAKE_MAX_SLAVE; i++) {
650 if (aspace != bridge->slaves[i].aspace)
651 continue;
652
653 if (cycle != bridge->slaves[i].cycle)
654 continue;
655
656 start = bridge->slaves[i].vme_base;
657 end = bridge->slaves[i].vme_base + bridge->slaves[i].size;
658
659 if ((addr >= start) && ((addr + 1) < end)) {
660 offset = addr - bridge->slaves[i].vme_base;
661 loc = (u16 *)((void *)bridge->slaves[i].buf_base + offset);
662 *loc = *buf;
663
664 break;
665 }
666 }
667
668 fake_lm_check(bridge, addr, aspace, cycle);
669
670}
671
58ccaae3
BX		 672static void fake_vmewrite32(struct fake_driver *bridge, u32 *buf,
673 unsigned long long addr, u32 aspace, u32 cycle)
658bcdae
MW		 674{
675 int i;
676 unsigned long long start, end, offset;
677 u32 *loc;
678
679 for (i = 0; i < FAKE_MAX_SLAVE; i++) {
680 if (aspace != bridge->slaves[i].aspace)
681 continue;
682
683 if (cycle != bridge->slaves[i].cycle)
684 continue;
685
686 start = bridge->slaves[i].vme_base;
687 end = bridge->slaves[i].vme_base + bridge->slaves[i].size;
688
689 if ((addr >= start) && ((addr + 3) < end)) {
690 offset = addr - bridge->slaves[i].vme_base;
691 loc = (u32 *)((void *)bridge->slaves[i].buf_base + offset);
692 *loc = *buf;
693
694 break;
695 }
696 }
697
698 fake_lm_check(bridge, addr, aspace, cycle);
699
700}
701
702static ssize_t fake_master_write(struct vme_master_resource *image, void *buf,
703 size_t count, loff_t offset)
704{
705 int retval = 0;
706 u32 aspace, cycle, dwidth;
707 unsigned long long addr;
708 int i;
709 unsigned int done = 0;
710 unsigned int count32;
711
712 struct vme_bridge *fake_bridge;
713 struct fake_driver *bridge;
714
715 fake_bridge = image->parent;
716
717 bridge = fake_bridge->driver_priv;
718
719 i = image->number;
720
721 addr = bridge->masters[i].vme_base + offset;
722 aspace = bridge->masters[i].aspace;
723 cycle = bridge->masters[i].cycle;
724 dwidth = bridge->masters[i].dwidth;
725
726 spin_lock(&image->lock);
727
728 /* Here we apply for the same strategy we do in master_read
729 * function in order to assure the correct cycles.
730 */
731 if (addr & 0x1) {
732 fake_vmewrite8(bridge, (u8 *)buf, addr, aspace, cycle);
733 done += 1;
734 if (done == count)
735 goto out;
736 }
737
738 if ((dwidth == VME_D16) || (dwidth == VME_D32)) {
739 if ((addr + done) & 0x2) {
740 if ((count - done) < 2) {
741 fake_vmewrite8(bridge, (u8 *)(buf + done),
742 addr + done, aspace, cycle);
743 done += 1;
744 goto out;
745 } else {
746 fake_vmewrite16(bridge, (u16 *)(buf + done),
747 addr + done, aspace, cycle);
748 done += 2;
749 }
750 }
751 }
752
753 if (dwidth == VME_D32) {
754 count32 = (count - done) & ~0x3;
755 while (done < count32) {
756 fake_vmewrite32(bridge, (u32 *)(buf + done),
757 addr + done, aspace, cycle);
758 done += 4;
759 }
760 } else if (dwidth == VME_D16) {
761 count32 = (count - done) & ~0x3;
762 while (done < count32) {
763 fake_vmewrite16(bridge, (u16 *)(buf + done),
764 addr + done, aspace, cycle);
765 done += 2;
766 }
767 } else if (dwidth == VME_D8) {
768 count32 = (count - done);
769 while (done < count32) {
770 fake_vmewrite8(bridge, (u8 *)(buf + done), addr + done,
771 aspace, cycle);
772 done += 1;
773 }
774
775 }
776
777 if ((dwidth == VME_D16) || (dwidth == VME_D32)) {
778 if ((count - done) & 0x2) {
779 fake_vmewrite16(bridge, (u16 *)(buf + done),
780 addr + done, aspace, cycle);
781 done += 2;
782 }
783 }
784
785 if ((count - done) & 0x1) {
786 fake_vmewrite8(bridge, (u8 *)(buf + done), addr + done, aspace,
787 cycle);
788 done += 1;
789 }
790
791out:
792 retval = count;
793
794 spin_unlock(&image->lock);
795
796 return retval;
797}
798
799/*
800 * Perform an RMW cycle on the VME bus.
801 *
802 * Requires a previously configured master window, returns final value.
803 */
804static unsigned int fake_master_rmw(struct vme_master_resource *image,
805 unsigned int mask, unsigned int compare, unsigned int swap,
806 loff_t offset)
807{
808 u32 tmp, base;
809 u32 aspace, cycle;
810 int i;
811 struct fake_driver *bridge;
812
813 bridge = image->parent->driver_priv;
814
815 /* Find the PCI address that maps to the desired VME address */
816 i = image->number;
817
818 base = bridge->masters[i].vme_base;
819 aspace = bridge->masters[i].aspace;
820 cycle = bridge->masters[i].cycle;
821
822 /* Lock image */
823 spin_lock(&image->lock);
824
825 /* Read existing value */
826 tmp = fake_vmeread32(bridge, base + offset, aspace, cycle);
827
828 /* Perform check */
829 if ((tmp && mask) == (compare && mask)) {
830 tmp = tmp | (mask | swap);
831 tmp = tmp & (~mask | swap);
832
833 /* Write back */
834 fake_vmewrite32(bridge, &tmp, base + offset, aspace, cycle);
835 }
836
837 /* Unlock image */
838 spin_unlock(&image->lock);
839
840 return tmp;
841}
842
843/*
844 * All 4 location monitors reside at the same base - this is therefore a
845 * system wide configuration.
846 *
847 * This does not enable the LM monitor - that should be done when the first
848 * callback is attached and disabled when the last callback is removed.
849 */
850static int fake_lm_set(struct vme_lm_resource *lm, unsigned long long lm_base,
851 u32 aspace, u32 cycle)
852{
853 int i;
854 struct vme_bridge *fake_bridge;
855 struct fake_driver *bridge;
856
857 fake_bridge = lm->parent;
858
859 bridge = fake_bridge->driver_priv;
860
861 mutex_lock(&lm->mtx);
862
863 /* If we already have a callback attached, we can't move it! */
864 for (i = 0; i < lm->monitors; i++) {
2444d37f 865 if (bridge->lm_callback[i]) {
658bcdae
MW		 866 mutex_unlock(&lm->mtx);
867 pr_err("Location monitor callback attached, can't reset\n");
868 return -EBUSY;
869 }
870 }
871
872 switch (aspace) {
873 case VME_A16:
874 case VME_A24:
875 case VME_A32:
876 case VME_A64:
877 break;
878 default:
879 mutex_unlock(&lm->mtx);
880 pr_err("Invalid address space\n");
881 return -EINVAL;
882 }
883
884 bridge->lm_base = lm_base;
885 bridge->lm_aspace = aspace;
886 bridge->lm_cycle = cycle;
887
888 mutex_unlock(&lm->mtx);
889
890 return 0;
891}
892
893/* Get configuration of the callback monitor and return whether it is enabled
894 * or disabled.
895 */
896static int fake_lm_get(struct vme_lm_resource *lm,
897 unsigned long long *lm_base, u32 *aspace, u32 *cycle)
898{
899 struct fake_driver *bridge;
900
901 bridge = lm->parent->driver_priv;
902
903 mutex_lock(&lm->mtx);
904
905 *lm_base = bridge->lm_base;
906 *aspace = bridge->lm_aspace;
907 *cycle = bridge->lm_cycle;
908
909 mutex_unlock(&lm->mtx);
910
911 return bridge->lm_enabled;
912}
913
914/*
915 * Attach a callback to a specific location monitor.
916 *
917 * Callback will be passed the monitor triggered.
918 */
919static int fake_lm_attach(struct vme_lm_resource *lm, int monitor,
920 void (*callback)(void *), void *data)
921{
922 struct vme_bridge *fake_bridge;
923 struct fake_driver *bridge;
924
925 fake_bridge = lm->parent;
926
927 bridge = fake_bridge->driver_priv;
928
929 mutex_lock(&lm->mtx);
930
931 /* Ensure that the location monitor is configured - need PGM or DATA */
932 if (bridge->lm_cycle == 0) {
933 mutex_unlock(&lm->mtx);
934 pr_err("Location monitor not properly configured\n");
935 return -EINVAL;
936 }
937
938 /* Check that a callback isn't already attached */
2444d37f 939 if (bridge->lm_callback[monitor]) {
658bcdae
MW		 940 mutex_unlock(&lm->mtx);
941 pr_err("Existing callback attached\n");
942 return -EBUSY;
943 }
944
945 /* Attach callback */
946 bridge->lm_callback[monitor] = callback;
947 bridge->lm_data[monitor] = data;
948
949 /* Ensure that global Location Monitor Enable set */
950 bridge->lm_enabled = 1;
951
952 mutex_unlock(&lm->mtx);
953
954 return 0;
955}
956
957/*
958 * Detach a callback function forn a specific location monitor.
959 */
960static int fake_lm_detach(struct vme_lm_resource *lm, int monitor)
961{
962 u32 tmp;
963 int i;
964 struct fake_driver *bridge;
965
966 bridge = lm->parent->driver_priv;
967
968 mutex_lock(&lm->mtx);
969
970 /* Detach callback */
971 bridge->lm_callback[monitor] = NULL;
972 bridge->lm_data[monitor] = NULL;
973
974 /* If all location monitors disabled, disable global Location Monitor */
975 tmp = 0;
976 for (i = 0; i < lm->monitors; i++) {
2444d37f 977 if (bridge->lm_callback[i])
658bcdae
MW		 978 tmp = 1;
979 }
980
981 if (tmp == 0)
982 bridge->lm_enabled = 0;
983
984 mutex_unlock(&lm->mtx);
985
986 return 0;
987}
988
989/*
990 * Determine Geographical Addressing
991 */
992static int fake_slot_get(struct vme_bridge *fake_bridge)
993{
994 return geoid;
995}
996
997static void *fake_alloc_consistent(struct device *parent, size_t size,
998 dma_addr_t *dma)
999{
1000 void *alloc = kmalloc(size, GFP_KERNEL);
1001
2444d37f 1002 if (alloc)
4b7b948b 1003 *dma = fake_ptr_to_pci(alloc);
658bcdae
MW		 1004
1005 return alloc;
1006}
1007
1008static void fake_free_consistent(struct device *parent, size_t size,
1009 void *vaddr, dma_addr_t dma)
1010{
1011 kfree(vaddr);
1012/*
1013 dma_free_coherent(parent, size, vaddr, dma);
1014*/
1015}
1016
1017/*
1018 * Configure CR/CSR space
1019 *
1020 * Access to the CR/CSR can be configured at power-up. The location of the
1021 * CR/CSR registers in the CR/CSR address space is determined by the boards
1022 * Geographic address.
1023 *
1024 * Each board has a 512kB window, with the highest 4kB being used for the
1025 * boards registers, this means there is a fix length 508kB window which must
1026 * be mapped onto PCI memory.
1027 */
1028static int fake_crcsr_init(struct vme_bridge *fake_bridge)
1029{
1030 u32 vstat;
1031 struct fake_driver *bridge;
1032
1033 bridge = fake_bridge->driver_priv;
1034
1035 /* Allocate mem for CR/CSR image */
1036 bridge->crcsr_kernel = kzalloc(VME_CRCSR_BUF_SIZE, GFP_KERNEL);
4b7b948b 1037 bridge->crcsr_bus = fake_ptr_to_pci(bridge->crcsr_kernel);
2444d37f 1038 if (!bridge->crcsr_kernel)
658bcdae
MW		 1039 return -ENOMEM;
1040
1041 vstat = fake_slot_get(fake_bridge);
1042
1043 pr_info("CR/CSR Offset: %d\n", vstat);
1044
1045 return 0;
1046}
1047
1048static void fake_crcsr_exit(struct vme_bridge *fake_bridge)
1049{
1050 struct fake_driver *bridge;
1051
1052 bridge = fake_bridge->driver_priv;
1053
1054 kfree(bridge->crcsr_kernel);
1055}
1056
1057
1058static int __init fake_init(void)
1059{
1060 int retval, i;
1061 struct list_head *pos = NULL, *n;
1062 struct vme_bridge *fake_bridge;
1063 struct fake_driver *fake_device;
1064 struct vme_master_resource *master_image;
1065 struct vme_slave_resource *slave_image;
1066 struct vme_lm_resource *lm;
1067
1068 /* We need a fake parent device */
1069 vme_root = __root_device_register("vme", THIS_MODULE);
1070
1071 /* If we want to support more than one bridge at some point, we need to
1072 * dynamically allocate this so we get one per device.
1073 */
24674065 1074 fake_bridge = kzalloc(sizeof(*fake_bridge), GFP_KERNEL);
2444d37f 1075 if (!fake_bridge) {
658bcdae
MW		 1076 retval = -ENOMEM;
1077 goto err_struct;
1078 }
1079
24674065 1080 fake_device = kzalloc(sizeof(*fake_device), GFP_KERNEL);
2444d37f 1081 if (!fake_device) {
658bcdae
MW		 1082 retval = -ENOMEM;
1083 goto err_driver;
1084 }
1085
1086 fake_bridge->driver_priv = fake_device;
1087
1088 fake_bridge->parent = vme_root;
1089
1090 fake_device->parent = fake_bridge;
1091
1092 /* Initialize wait queues & mutual exclusion flags */
1093 mutex_init(&fake_device->vme_int);
1094 mutex_init(&fake_bridge->irq_mtx);
1095 tasklet_init(&fake_device->int_tasklet, fake_VIRQ_tasklet,
1096 (unsigned long) fake_bridge);
1097
1098 strcpy(fake_bridge->name, driver_name);
1099
1100 /* Add master windows to list */
1101 INIT_LIST_HEAD(&fake_bridge->master_resources);
1102 for (i = 0; i < FAKE_MAX_MASTER; i++) {
24674065 1103 master_image = kmalloc(sizeof(*master_image), GFP_KERNEL);
2444d37f 1104 if (!master_image) {
658bcdae
MW		 1105 retval = -ENOMEM;
1106 goto err_master;
1107 }
1108 master_image->parent = fake_bridge;
1109 spin_lock_init(&master_image->lock);
1110 master_image->locked = 0;
1111 master_image->number = i;
1112 master_image->address_attr = VME_A16 | VME_A24 | VME_A32 |
1113 VME_A64;
1114 master_image->cycle_attr = VME_SCT | VME_BLT | VME_MBLT |
1115 VME_2eVME | VME_2eSST | VME_2eSSTB | VME_2eSST160 |
1116 VME_2eSST267 | VME_2eSST320 | VME_SUPER | VME_USER |
1117 VME_PROG | VME_DATA;
1118 master_image->width_attr = VME_D16 | VME_D32;
1119 memset(&master_image->bus_resource, 0,
1120 sizeof(struct resource));
1121 master_image->kern_base = NULL;
1122 list_add_tail(&master_image->list,
1123 &fake_bridge->master_resources);
1124 }
1125
1126 /* Add slave windows to list */
1127 INIT_LIST_HEAD(&fake_bridge->slave_resources);
1128 for (i = 0; i < FAKE_MAX_SLAVE; i++) {
24674065 1129 slave_image = kmalloc(sizeof(*slave_image), GFP_KERNEL);
2444d37f 1130 if (!slave_image) {
658bcdae
MW		 1131 retval = -ENOMEM;
1132 goto err_slave;
1133 }
1134 slave_image->parent = fake_bridge;
1135 mutex_init(&slave_image->mtx);
1136 slave_image->locked = 0;
1137 slave_image->number = i;
1138 slave_image->address_attr = VME_A16 | VME_A24 | VME_A32 |
1139 VME_A64 | VME_CRCSR | VME_USER1 | VME_USER2 |
1140 VME_USER3 | VME_USER4;
1141 slave_image->cycle_attr = VME_SCT | VME_BLT | VME_MBLT |
1142 VME_2eVME | VME_2eSST | VME_2eSSTB | VME_2eSST160 |
1143 VME_2eSST267 | VME_2eSST320 | VME_SUPER | VME_USER |
1144 VME_PROG | VME_DATA;
1145 list_add_tail(&slave_image->list,
1146 &fake_bridge->slave_resources);
1147 }
1148
1149 /* Add location monitor to list */
1150 INIT_LIST_HEAD(&fake_bridge->lm_resources);
24674065 1151 lm = kmalloc(sizeof(*lm), GFP_KERNEL);
2444d37f 1152 if (!lm) {
658bcdae
MW		 1153 retval = -ENOMEM;
1154 goto err_lm;
1155 }
1156 lm->parent = fake_bridge;
1157 mutex_init(&lm->mtx);
1158 lm->locked = 0;
1159 lm->number = 1;
1160 lm->monitors = 4;
1161 list_add_tail(&lm->list, &fake_bridge->lm_resources);
1162
1163 fake_bridge->slave_get = fake_slave_get;
1164 fake_bridge->slave_set = fake_slave_set;
1165 fake_bridge->master_get = fake_master_get;
1166 fake_bridge->master_set = fake_master_set;
1167 fake_bridge->master_read = fake_master_read;
1168 fake_bridge->master_write = fake_master_write;
1169 fake_bridge->master_rmw = fake_master_rmw;
1170 fake_bridge->irq_set = fake_irq_set;
1171 fake_bridge->irq_generate = fake_irq_generate;
1172 fake_bridge->lm_set = fake_lm_set;
1173 fake_bridge->lm_get = fake_lm_get;
1174 fake_bridge->lm_attach = fake_lm_attach;
1175 fake_bridge->lm_detach = fake_lm_detach;
1176 fake_bridge->slot_get = fake_slot_get;
1177 fake_bridge->alloc_consistent = fake_alloc_consistent;
1178 fake_bridge->free_consistent = fake_free_consistent;
1179
1180 pr_info("Board is%s the VME system controller\n",
1181 (geoid == 1) ? "" : " not");
1182
1183 pr_info("VME geographical address is set to %d\n", geoid);
1184
1185 retval = fake_crcsr_init(fake_bridge);
1186 if (retval) {
1187 pr_err("CR/CSR configuration failed.\n");
1188 goto err_crcsr;
1189 }
1190
1191 retval = vme_register_bridge(fake_bridge);
1192 if (retval != 0) {
1193 pr_err("Chip Registration failed.\n");
1194 goto err_reg;
1195 }
1196
1197 exit_pointer = fake_bridge;
1198
1199 return 0;
1200
1201err_reg:
1202 fake_crcsr_exit(fake_bridge);
1203err_crcsr:
1204err_lm:
1205 /* resources are stored in link list */
1206 list_for_each_safe(pos, n, &fake_bridge->lm_resources) {
1207 lm = list_entry(pos, struct vme_lm_resource, list);
1208 list_del(pos);
1209 kfree(lm);
1210 }
1211err_slave:
1212 /* resources are stored in link list */
1213 list_for_each_safe(pos, n, &fake_bridge->slave_resources) {
1214 slave_image = list_entry(pos, struct vme_slave_resource, list);
1215 list_del(pos);
1216 kfree(slave_image);
1217 }
1218err_master:
1219 /* resources are stored in link list */
1220 list_for_each_safe(pos, n, &fake_bridge->master_resources) {
1221 master_image = list_entry(pos, struct vme_master_resource,
1222 list);
1223 list_del(pos);
1224 kfree(master_image);
1225 }
1226
1227 kfree(fake_device);
1228err_driver:
1229 kfree(fake_bridge);
1230err_struct:
1231 return retval;
1232
1233}
1234
1235
1236static void __exit fake_exit(void)
1237{
1238 struct list_head *pos = NULL;
1239 struct list_head *tmplist;
1240 struct vme_master_resource *master_image;
1241 struct vme_slave_resource *slave_image;
1242 int i;
1243 struct vme_bridge *fake_bridge;
1244 struct fake_driver *bridge;
1245
1246 fake_bridge = exit_pointer;
1247
1248 bridge = fake_bridge->driver_priv;
1249
1250 pr_debug("Driver is being unloaded.\n");
1251
1252 /*
1253 * Shutdown all inbound and outbound windows.
1254 */
1255 for (i = 0; i < FAKE_MAX_MASTER; i++)
1256 bridge->masters[i].enabled = 0;
1257
1258 for (i = 0; i < FAKE_MAX_SLAVE; i++)
1259 bridge->slaves[i].enabled = 0;
1260
1261 /*
1262 * Shutdown Location monitor.
1263 */
1264 bridge->lm_enabled = 0;
1265
1266 vme_unregister_bridge(fake_bridge);
1267
1268 fake_crcsr_exit(fake_bridge);
1269 /* resources are stored in link list */
1270 list_for_each_safe(pos, tmplist, &fake_bridge->slave_resources) {
1271 slave_image = list_entry(pos, struct vme_slave_resource, list);
1272 list_del(pos);
1273 kfree(slave_image);
1274 }
1275
1276 /* resources are stored in link list */
1277 list_for_each_safe(pos, tmplist, &fake_bridge->master_resources) {
1278 master_image = list_entry(pos, struct vme_master_resource,
1279 list);
1280 list_del(pos);
1281 kfree(master_image);
1282 }
1283
1284 kfree(fake_bridge->driver_priv);
1285
1286 kfree(fake_bridge);
1287
1288 root_device_unregister(vme_root);
1289}
1290
1291
1292MODULE_PARM_DESC(geoid, "Set geographical addressing");
1293module_param(geoid, int, 0);
1294
1295MODULE_DESCRIPTION("Fake VME bridge driver");
1296MODULE_LICENSE("GPL");
1297
1298module_init(fake_init);
1299module_exit(fake_exit);
Linux 6.x block layer and io_uring tree(s)