1 // SPDX-License-Identifier: GPL-2.0-or-later 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. 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 33 #include "vme.h" 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 */ 43 struct fake_slave_window { 44 int enabled; 45 unsigned long long vme_base; 46 unsigned long long size; 47 void *buf_base; 48 u32 aspace; 49 u32 cycle; 50 }; 51 52 struct 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 */ 62 struct 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 */ 82 static int geoid; 83 84 static const char driver_name[] = "vme_fake"; 85 86 static struct vme_bridge *exit_pointer; 87 88 static struct device *vme_root; 89 90 /* 91 * Calling VME bus interrupt callback if provided. 92 */ 93 static 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 */ 107 static void fake_irq_set(struct vme_bridge *fake_bridge, int level, 108 int state, int sync) 109 { 110 /* Nothing to do */ 111 } 112 113 static void *fake_pci_to_ptr(dma_addr_t addr) 114 { 115 return (void *)(uintptr_t)addr; 116 } 117 118 static dma_addr_t fake_ptr_to_pci(void *addr) 119 { 120 return (dma_addr_t)(uintptr_t)addr; 121 } 122 123 /* 124 * Generate a VME bus interrupt at the requested level & vector. Wait for 125 * interrupt to be acked. 126 */ 127 static 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 */ 154 static 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; 211 bridge->slaves[i].buf_base = fake_pci_to_ptr(buf_base); 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 */ 223 static 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; 239 *buf_base = fake_ptr_to_pci(bridge->slaves[i].buf_base); 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 */ 251 static 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) { 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: 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: 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 328 err_aspace: 329 err_dwidth: 330 err_window: 331 return retval; 332 333 } 334 335 /* 336 * Set the attributes of an outbound window. 337 */ 338 static 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 360 static 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 377 static void fake_lm_check(struct fake_driver *bridge, unsigned long long addr, 378 u32 aspace, u32 cycle) 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)) { 408 if (bridge->lm_callback[i]) 409 bridge->lm_callback[i]( 410 bridge->lm_data[i]); 411 } 412 } 413 } 414 } 415 } 416 417 static noinline_for_stack u8 fake_vmeread8(struct fake_driver *bridge, 418 unsigned long long addr, 419 u32 aspace, u32 cycle) 420 { 421 u8 retval = 0xff; 422 int i; 423 unsigned long long start, end, offset; 424 u8 *loc; 425 426 for (i = 0; i < FAKE_MAX_SLAVE; i++) { 427 start = bridge->slaves[i].vme_base; 428 end = bridge->slaves[i].vme_base + bridge->slaves[i].size; 429 430 if (aspace != bridge->slaves[i].aspace) 431 continue; 432 433 if (cycle != bridge->slaves[i].cycle) 434 continue; 435 436 if ((addr >= start) && (addr < end)) { 437 offset = addr - bridge->slaves[i].vme_base; 438 loc = (u8 *)(bridge->slaves[i].buf_base + offset); 439 retval = *loc; 440 441 break; 442 } 443 } 444 445 fake_lm_check(bridge, addr, aspace, cycle); 446 447 return retval; 448 } 449 450 static noinline_for_stack u16 fake_vmeread16(struct fake_driver *bridge, 451 unsigned long long addr, 452 u32 aspace, u32 cycle) 453 { 454 u16 retval = 0xffff; 455 int i; 456 unsigned long long start, end, offset; 457 u16 *loc; 458 459 for (i = 0; i < FAKE_MAX_SLAVE; i++) { 460 if (aspace != bridge->slaves[i].aspace) 461 continue; 462 463 if (cycle != bridge->slaves[i].cycle) 464 continue; 465 466 start = bridge->slaves[i].vme_base; 467 end = bridge->slaves[i].vme_base + bridge->slaves[i].size; 468 469 if ((addr >= start) && ((addr + 1) < end)) { 470 offset = addr - bridge->slaves[i].vme_base; 471 loc = (u16 *)(bridge->slaves[i].buf_base + offset); 472 retval = *loc; 473 474 break; 475 } 476 } 477 478 fake_lm_check(bridge, addr, aspace, cycle); 479 480 return retval; 481 } 482 483 static noinline_for_stack u32 fake_vmeread32(struct fake_driver *bridge, 484 unsigned long long addr, 485 u32 aspace, u32 cycle) 486 { 487 u32 retval = 0xffffffff; 488 int i; 489 unsigned long long start, end, offset; 490 u32 *loc; 491 492 for (i = 0; i < FAKE_MAX_SLAVE; i++) { 493 if (aspace != bridge->slaves[i].aspace) 494 continue; 495 496 if (cycle != bridge->slaves[i].cycle) 497 continue; 498 499 start = bridge->slaves[i].vme_base; 500 end = bridge->slaves[i].vme_base + bridge->slaves[i].size; 501 502 if ((addr >= start) && ((addr + 3) < end)) { 503 offset = addr - bridge->slaves[i].vme_base; 504 loc = (u32 *)(bridge->slaves[i].buf_base + offset); 505 retval = *loc; 506 507 break; 508 } 509 } 510 511 fake_lm_check(bridge, addr, aspace, cycle); 512 513 return retval; 514 } 515 516 static ssize_t fake_master_read(struct vme_master_resource *image, void *buf, 517 size_t count, loff_t offset) 518 { 519 int retval; 520 u32 aspace, cycle, dwidth; 521 struct vme_bridge *fake_bridge; 522 struct fake_driver *priv; 523 int i; 524 unsigned long long addr; 525 unsigned int done = 0; 526 unsigned int count32; 527 528 fake_bridge = image->parent; 529 530 priv = fake_bridge->driver_priv; 531 532 i = image->number; 533 534 addr = (unsigned long long)priv->masters[i].vme_base + offset; 535 aspace = priv->masters[i].aspace; 536 cycle = priv->masters[i].cycle; 537 dwidth = priv->masters[i].dwidth; 538 539 spin_lock(&image->lock); 540 541 /* The following code handles VME address alignment. We cannot use 542 * memcpy_xxx here because it may cut data transfers in to 8-bit 543 * cycles when D16 or D32 cycles are required on the VME bus. 544 * On the other hand, the bridge itself assures that the maximum data 545 * cycle configured for the transfer is used and splits it 546 * automatically for non-aligned addresses, so we don't want the 547 * overhead of needlessly forcing small transfers for the entire cycle. 548 */ 549 if (addr & 0x1) { 550 *(u8 *)buf = fake_vmeread8(priv, addr, aspace, cycle); 551 done += 1; 552 if (done == count) 553 goto out; 554 } 555 if ((dwidth == VME_D16) || (dwidth == VME_D32)) { 556 if ((addr + done) & 0x2) { 557 if ((count - done) < 2) { 558 *(u8 *)(buf + done) = fake_vmeread8(priv, 559 addr + done, aspace, cycle); 560 done += 1; 561 goto out; 562 } else { 563 *(u16 *)(buf + done) = fake_vmeread16(priv, 564 addr + done, aspace, cycle); 565 done += 2; 566 } 567 } 568 } 569 570 if (dwidth == VME_D32) { 571 count32 = (count - done) & ~0x3; 572 while (done < count32) { 573 *(u32 *)(buf + done) = fake_vmeread32(priv, addr + done, 574 aspace, cycle); 575 done += 4; 576 } 577 } else if (dwidth == VME_D16) { 578 count32 = (count - done) & ~0x3; 579 while (done < count32) { 580 *(u16 *)(buf + done) = fake_vmeread16(priv, addr + done, 581 aspace, cycle); 582 done += 2; 583 } 584 } else if (dwidth == VME_D8) { 585 count32 = (count - done); 586 while (done < count32) { 587 *(u8 *)(buf + done) = fake_vmeread8(priv, addr + done, 588 aspace, cycle); 589 done += 1; 590 } 591 592 } 593 594 if ((dwidth == VME_D16) || (dwidth == VME_D32)) { 595 if ((count - done) & 0x2) { 596 *(u16 *)(buf + done) = fake_vmeread16(priv, addr + done, 597 aspace, cycle); 598 done += 2; 599 } 600 } 601 if ((count - done) & 0x1) { 602 *(u8 *)(buf + done) = fake_vmeread8(priv, addr + done, aspace, 603 cycle); 604 done += 1; 605 } 606 607 out: 608 retval = count; 609 610 spin_unlock(&image->lock); 611 612 return retval; 613 } 614 615 static noinline_for_stack void fake_vmewrite8(struct fake_driver *bridge, 616 u8 *buf, unsigned long long addr, 617 u32 aspace, u32 cycle) 618 { 619 int i; 620 unsigned long long start, end, offset; 621 u8 *loc; 622 623 for (i = 0; i < FAKE_MAX_SLAVE; i++) { 624 if (aspace != bridge->slaves[i].aspace) 625 continue; 626 627 if (cycle != bridge->slaves[i].cycle) 628 continue; 629 630 start = bridge->slaves[i].vme_base; 631 end = bridge->slaves[i].vme_base + bridge->slaves[i].size; 632 633 if ((addr >= start) && (addr < end)) { 634 offset = addr - bridge->slaves[i].vme_base; 635 loc = (u8 *)((void *)bridge->slaves[i].buf_base + offset); 636 *loc = *buf; 637 638 break; 639 } 640 } 641 642 fake_lm_check(bridge, addr, aspace, cycle); 643 644 } 645 646 static noinline_for_stack void fake_vmewrite16(struct fake_driver *bridge, 647 u16 *buf, unsigned long long addr, 648 u32 aspace, u32 cycle) 649 { 650 int i; 651 unsigned long long start, end, offset; 652 u16 *loc; 653 654 for (i = 0; i < FAKE_MAX_SLAVE; i++) { 655 if (aspace != bridge->slaves[i].aspace) 656 continue; 657 658 if (cycle != bridge->slaves[i].cycle) 659 continue; 660 661 start = bridge->slaves[i].vme_base; 662 end = bridge->slaves[i].vme_base + bridge->slaves[i].size; 663 664 if ((addr >= start) && ((addr + 1) < end)) { 665 offset = addr - bridge->slaves[i].vme_base; 666 loc = (u16 *)((void *)bridge->slaves[i].buf_base + offset); 667 *loc = *buf; 668 669 break; 670 } 671 } 672 673 fake_lm_check(bridge, addr, aspace, cycle); 674 675 } 676 677 static noinline_for_stack void fake_vmewrite32(struct fake_driver *bridge, 678 u32 *buf, unsigned long long addr, 679 u32 aspace, u32 cycle) 680 { 681 int i; 682 unsigned long long start, end, offset; 683 u32 *loc; 684 685 for (i = 0; i < FAKE_MAX_SLAVE; i++) { 686 if (aspace != bridge->slaves[i].aspace) 687 continue; 688 689 if (cycle != bridge->slaves[i].cycle) 690 continue; 691 692 start = bridge->slaves[i].vme_base; 693 end = bridge->slaves[i].vme_base + bridge->slaves[i].size; 694 695 if ((addr >= start) && ((addr + 3) < end)) { 696 offset = addr - bridge->slaves[i].vme_base; 697 loc = (u32 *)((void *)bridge->slaves[i].buf_base + offset); 698 *loc = *buf; 699 700 break; 701 } 702 } 703 704 fake_lm_check(bridge, addr, aspace, cycle); 705 706 } 707 708 static ssize_t fake_master_write(struct vme_master_resource *image, void *buf, 709 size_t count, loff_t offset) 710 { 711 int retval = 0; 712 u32 aspace, cycle, dwidth; 713 unsigned long long addr; 714 int i; 715 unsigned int done = 0; 716 unsigned int count32; 717 718 struct vme_bridge *fake_bridge; 719 struct fake_driver *bridge; 720 721 fake_bridge = image->parent; 722 723 bridge = fake_bridge->driver_priv; 724 725 i = image->number; 726 727 addr = bridge->masters[i].vme_base + offset; 728 aspace = bridge->masters[i].aspace; 729 cycle = bridge->masters[i].cycle; 730 dwidth = bridge->masters[i].dwidth; 731 732 spin_lock(&image->lock); 733 734 /* Here we apply for the same strategy we do in master_read 735 * function in order to assure the correct cycles. 736 */ 737 if (addr & 0x1) { 738 fake_vmewrite8(bridge, (u8 *)buf, addr, aspace, cycle); 739 done += 1; 740 if (done == count) 741 goto out; 742 } 743 744 if ((dwidth == VME_D16) || (dwidth == VME_D32)) { 745 if ((addr + done) & 0x2) { 746 if ((count - done) < 2) { 747 fake_vmewrite8(bridge, (u8 *)(buf + done), 748 addr + done, aspace, cycle); 749 done += 1; 750 goto out; 751 } else { 752 fake_vmewrite16(bridge, (u16 *)(buf + done), 753 addr + done, aspace, cycle); 754 done += 2; 755 } 756 } 757 } 758 759 if (dwidth == VME_D32) { 760 count32 = (count - done) & ~0x3; 761 while (done < count32) { 762 fake_vmewrite32(bridge, (u32 *)(buf + done), 763 addr + done, aspace, cycle); 764 done += 4; 765 } 766 } else if (dwidth == VME_D16) { 767 count32 = (count - done) & ~0x3; 768 while (done < count32) { 769 fake_vmewrite16(bridge, (u16 *)(buf + done), 770 addr + done, aspace, cycle); 771 done += 2; 772 } 773 } else if (dwidth == VME_D8) { 774 count32 = (count - done); 775 while (done < count32) { 776 fake_vmewrite8(bridge, (u8 *)(buf + done), addr + done, 777 aspace, cycle); 778 done += 1; 779 } 780 781 } 782 783 if ((dwidth == VME_D16) || (dwidth == VME_D32)) { 784 if ((count - done) & 0x2) { 785 fake_vmewrite16(bridge, (u16 *)(buf + done), 786 addr + done, aspace, cycle); 787 done += 2; 788 } 789 } 790 791 if ((count - done) & 0x1) { 792 fake_vmewrite8(bridge, (u8 *)(buf + done), addr + done, aspace, 793 cycle); 794 done += 1; 795 } 796 797 out: 798 retval = count; 799 800 spin_unlock(&image->lock); 801 802 return retval; 803 } 804 805 /* 806 * Perform an RMW cycle on the VME bus. 807 * 808 * Requires a previously configured master window, returns final value. 809 */ 810 static unsigned int fake_master_rmw(struct vme_master_resource *image, 811 unsigned int mask, unsigned int compare, unsigned int swap, 812 loff_t offset) 813 { 814 u32 tmp, base; 815 u32 aspace, cycle; 816 int i; 817 struct fake_driver *bridge; 818 819 bridge = image->parent->driver_priv; 820 821 /* Find the PCI address that maps to the desired VME address */ 822 i = image->number; 823 824 base = bridge->masters[i].vme_base; 825 aspace = bridge->masters[i].aspace; 826 cycle = bridge->masters[i].cycle; 827 828 /* Lock image */ 829 spin_lock(&image->lock); 830 831 /* Read existing value */ 832 tmp = fake_vmeread32(bridge, base + offset, aspace, cycle); 833 834 /* Perform check */ 835 if ((tmp && mask) == (compare && mask)) { 836 tmp = tmp | (mask | swap); 837 tmp = tmp & (~mask | swap); 838 839 /* Write back */ 840 fake_vmewrite32(bridge, &tmp, base + offset, aspace, cycle); 841 } 842 843 /* Unlock image */ 844 spin_unlock(&image->lock); 845 846 return tmp; 847 } 848 849 /* 850 * All 4 location monitors reside at the same base - this is therefore a 851 * system wide configuration. 852 * 853 * This does not enable the LM monitor - that should be done when the first 854 * callback is attached and disabled when the last callback is removed. 855 */ 856 static int fake_lm_set(struct vme_lm_resource *lm, unsigned long long lm_base, 857 u32 aspace, u32 cycle) 858 { 859 int i; 860 struct vme_bridge *fake_bridge; 861 struct fake_driver *bridge; 862 863 fake_bridge = lm->parent; 864 865 bridge = fake_bridge->driver_priv; 866 867 mutex_lock(&lm->mtx); 868 869 /* If we already have a callback attached, we can't move it! */ 870 for (i = 0; i < lm->monitors; i++) { 871 if (bridge->lm_callback[i]) { 872 mutex_unlock(&lm->mtx); 873 pr_err("Location monitor callback attached, can't reset\n"); 874 return -EBUSY; 875 } 876 } 877 878 switch (aspace) { 879 case VME_A16: 880 case VME_A24: 881 case VME_A32: 882 case VME_A64: 883 break; 884 default: 885 mutex_unlock(&lm->mtx); 886 pr_err("Invalid address space\n"); 887 return -EINVAL; 888 } 889 890 bridge->lm_base = lm_base; 891 bridge->lm_aspace = aspace; 892 bridge->lm_cycle = cycle; 893 894 mutex_unlock(&lm->mtx); 895 896 return 0; 897 } 898 899 /* Get configuration of the callback monitor and return whether it is enabled 900 * or disabled. 901 */ 902 static int fake_lm_get(struct vme_lm_resource *lm, 903 unsigned long long *lm_base, u32 *aspace, u32 *cycle) 904 { 905 struct fake_driver *bridge; 906 907 bridge = lm->parent->driver_priv; 908 909 mutex_lock(&lm->mtx); 910 911 *lm_base = bridge->lm_base; 912 *aspace = bridge->lm_aspace; 913 *cycle = bridge->lm_cycle; 914 915 mutex_unlock(&lm->mtx); 916 917 return bridge->lm_enabled; 918 } 919 920 /* 921 * Attach a callback to a specific location monitor. 922 * 923 * Callback will be passed the monitor triggered. 924 */ 925 static int fake_lm_attach(struct vme_lm_resource *lm, int monitor, 926 void (*callback)(void *), void *data) 927 { 928 struct vme_bridge *fake_bridge; 929 struct fake_driver *bridge; 930 931 fake_bridge = lm->parent; 932 933 bridge = fake_bridge->driver_priv; 934 935 mutex_lock(&lm->mtx); 936 937 /* Ensure that the location monitor is configured - need PGM or DATA */ 938 if (bridge->lm_cycle == 0) { 939 mutex_unlock(&lm->mtx); 940 pr_err("Location monitor not properly configured\n"); 941 return -EINVAL; 942 } 943 944 /* Check that a callback isn't already attached */ 945 if (bridge->lm_callback[monitor]) { 946 mutex_unlock(&lm->mtx); 947 pr_err("Existing callback attached\n"); 948 return -EBUSY; 949 } 950 951 /* Attach callback */ 952 bridge->lm_callback[monitor] = callback; 953 bridge->lm_data[monitor] = data; 954 955 /* Ensure that global Location Monitor Enable set */ 956 bridge->lm_enabled = 1; 957 958 mutex_unlock(&lm->mtx); 959 960 return 0; 961 } 962 963 /* 964 * Detach a callback function forn a specific location monitor. 965 */ 966 static int fake_lm_detach(struct vme_lm_resource *lm, int monitor) 967 { 968 u32 tmp; 969 int i; 970 struct fake_driver *bridge; 971 972 bridge = lm->parent->driver_priv; 973 974 mutex_lock(&lm->mtx); 975 976 /* Detach callback */ 977 bridge->lm_callback[monitor] = NULL; 978 bridge->lm_data[monitor] = NULL; 979 980 /* If all location monitors disabled, disable global Location Monitor */ 981 tmp = 0; 982 for (i = 0; i < lm->monitors; i++) { 983 if (bridge->lm_callback[i]) 984 tmp = 1; 985 } 986 987 if (tmp == 0) 988 bridge->lm_enabled = 0; 989 990 mutex_unlock(&lm->mtx); 991 992 return 0; 993 } 994 995 /* 996 * Determine Geographical Addressing 997 */ 998 static int fake_slot_get(struct vme_bridge *fake_bridge) 999 { 1000 return geoid; 1001 } 1002 1003 static void *fake_alloc_consistent(struct device *parent, size_t size, 1004 dma_addr_t *dma) 1005 { 1006 void *alloc = kmalloc(size, GFP_KERNEL); 1007 1008 if (alloc) 1009 *dma = fake_ptr_to_pci(alloc); 1010 1011 return alloc; 1012 } 1013 1014 static void fake_free_consistent(struct device *parent, size_t size, 1015 void *vaddr, dma_addr_t dma) 1016 { 1017 kfree(vaddr); 1018 /* 1019 dma_free_coherent(parent, size, vaddr, dma); 1020 */ 1021 } 1022 1023 /* 1024 * Configure CR/CSR space 1025 * 1026 * Access to the CR/CSR can be configured at power-up. The location of the 1027 * CR/CSR registers in the CR/CSR address space is determined by the boards 1028 * Geographic address. 1029 * 1030 * Each board has a 512kB window, with the highest 4kB being used for the 1031 * boards registers, this means there is a fix length 508kB window which must 1032 * be mapped onto PCI memory. 1033 */ 1034 static int fake_crcsr_init(struct vme_bridge *fake_bridge) 1035 { 1036 u32 vstat; 1037 struct fake_driver *bridge; 1038 1039 bridge = fake_bridge->driver_priv; 1040 1041 /* Allocate mem for CR/CSR image */ 1042 bridge->crcsr_kernel = kzalloc(VME_CRCSR_BUF_SIZE, GFP_KERNEL); 1043 bridge->crcsr_bus = fake_ptr_to_pci(bridge->crcsr_kernel); 1044 if (!bridge->crcsr_kernel) 1045 return -ENOMEM; 1046 1047 vstat = fake_slot_get(fake_bridge); 1048 1049 pr_info("CR/CSR Offset: %d\n", vstat); 1050 1051 return 0; 1052 } 1053 1054 static void fake_crcsr_exit(struct vme_bridge *fake_bridge) 1055 { 1056 struct fake_driver *bridge; 1057 1058 bridge = fake_bridge->driver_priv; 1059 1060 kfree(bridge->crcsr_kernel); 1061 } 1062 1063 1064 static int __init fake_init(void) 1065 { 1066 int retval, i; 1067 struct list_head *pos = NULL, *n; 1068 struct vme_bridge *fake_bridge; 1069 struct fake_driver *fake_device; 1070 struct vme_master_resource *master_image; 1071 struct vme_slave_resource *slave_image; 1072 struct vme_lm_resource *lm; 1073 1074 /* We need a fake parent device */ 1075 vme_root = __root_device_register("vme", THIS_MODULE); 1076 1077 /* If we want to support more than one bridge at some point, we need to 1078 * dynamically allocate this so we get one per device. 1079 */ 1080 fake_bridge = kzalloc(sizeof(*fake_bridge), GFP_KERNEL); 1081 if (!fake_bridge) { 1082 retval = -ENOMEM; 1083 goto err_struct; 1084 } 1085 1086 fake_device = kzalloc(sizeof(*fake_device), GFP_KERNEL); 1087 if (!fake_device) { 1088 retval = -ENOMEM; 1089 goto err_driver; 1090 } 1091 1092 fake_bridge->driver_priv = fake_device; 1093 1094 fake_bridge->parent = vme_root; 1095 1096 fake_device->parent = fake_bridge; 1097 1098 /* Initialize wait queues & mutual exclusion flags */ 1099 mutex_init(&fake_device->vme_int); 1100 mutex_init(&fake_bridge->irq_mtx); 1101 tasklet_init(&fake_device->int_tasklet, fake_VIRQ_tasklet, 1102 (unsigned long) fake_bridge); 1103 1104 strcpy(fake_bridge->name, driver_name); 1105 1106 /* Add master windows to list */ 1107 INIT_LIST_HEAD(&fake_bridge->master_resources); 1108 for (i = 0; i < FAKE_MAX_MASTER; i++) { 1109 master_image = kmalloc(sizeof(*master_image), GFP_KERNEL); 1110 if (!master_image) { 1111 retval = -ENOMEM; 1112 goto err_master; 1113 } 1114 master_image->parent = fake_bridge; 1115 spin_lock_init(&master_image->lock); 1116 master_image->locked = 0; 1117 master_image->number = i; 1118 master_image->address_attr = VME_A16 | VME_A24 | VME_A32 | 1119 VME_A64; 1120 master_image->cycle_attr = VME_SCT | VME_BLT | VME_MBLT | 1121 VME_2eVME | VME_2eSST | VME_2eSSTB | VME_2eSST160 | 1122 VME_2eSST267 | VME_2eSST320 | VME_SUPER | VME_USER | 1123 VME_PROG | VME_DATA; 1124 master_image->width_attr = VME_D16 | VME_D32; 1125 memset(&master_image->bus_resource, 0, 1126 sizeof(struct resource)); 1127 master_image->kern_base = NULL; 1128 list_add_tail(&master_image->list, 1129 &fake_bridge->master_resources); 1130 } 1131 1132 /* Add slave windows to list */ 1133 INIT_LIST_HEAD(&fake_bridge->slave_resources); 1134 for (i = 0; i < FAKE_MAX_SLAVE; i++) { 1135 slave_image = kmalloc(sizeof(*slave_image), GFP_KERNEL); 1136 if (!slave_image) { 1137 retval = -ENOMEM; 1138 goto err_slave; 1139 } 1140 slave_image->parent = fake_bridge; 1141 mutex_init(&slave_image->mtx); 1142 slave_image->locked = 0; 1143 slave_image->number = i; 1144 slave_image->address_attr = VME_A16 | VME_A24 | VME_A32 | 1145 VME_A64 | VME_CRCSR | VME_USER1 | VME_USER2 | 1146 VME_USER3 | VME_USER4; 1147 slave_image->cycle_attr = VME_SCT | VME_BLT | VME_MBLT | 1148 VME_2eVME | VME_2eSST | VME_2eSSTB | VME_2eSST160 | 1149 VME_2eSST267 | VME_2eSST320 | VME_SUPER | VME_USER | 1150 VME_PROG | VME_DATA; 1151 list_add_tail(&slave_image->list, 1152 &fake_bridge->slave_resources); 1153 } 1154 1155 /* Add location monitor to list */ 1156 INIT_LIST_HEAD(&fake_bridge->lm_resources); 1157 lm = kmalloc(sizeof(*lm), GFP_KERNEL); 1158 if (!lm) { 1159 retval = -ENOMEM; 1160 goto err_lm; 1161 } 1162 lm->parent = fake_bridge; 1163 mutex_init(&lm->mtx); 1164 lm->locked = 0; 1165 lm->number = 1; 1166 lm->monitors = 4; 1167 list_add_tail(&lm->list, &fake_bridge->lm_resources); 1168 1169 fake_bridge->slave_get = fake_slave_get; 1170 fake_bridge->slave_set = fake_slave_set; 1171 fake_bridge->master_get = fake_master_get; 1172 fake_bridge->master_set = fake_master_set; 1173 fake_bridge->master_read = fake_master_read; 1174 fake_bridge->master_write = fake_master_write; 1175 fake_bridge->master_rmw = fake_master_rmw; 1176 fake_bridge->irq_set = fake_irq_set; 1177 fake_bridge->irq_generate = fake_irq_generate; 1178 fake_bridge->lm_set = fake_lm_set; 1179 fake_bridge->lm_get = fake_lm_get; 1180 fake_bridge->lm_attach = fake_lm_attach; 1181 fake_bridge->lm_detach = fake_lm_detach; 1182 fake_bridge->slot_get = fake_slot_get; 1183 fake_bridge->alloc_consistent = fake_alloc_consistent; 1184 fake_bridge->free_consistent = fake_free_consistent; 1185 1186 pr_info("Board is%s the VME system controller\n", 1187 (geoid == 1) ? "" : " not"); 1188 1189 pr_info("VME geographical address is set to %d\n", geoid); 1190 1191 retval = fake_crcsr_init(fake_bridge); 1192 if (retval) { 1193 pr_err("CR/CSR configuration failed.\n"); 1194 goto err_crcsr; 1195 } 1196 1197 retval = vme_register_bridge(fake_bridge); 1198 if (retval != 0) { 1199 pr_err("Chip Registration failed.\n"); 1200 goto err_reg; 1201 } 1202 1203 exit_pointer = fake_bridge; 1204 1205 return 0; 1206 1207 err_reg: 1208 fake_crcsr_exit(fake_bridge); 1209 err_crcsr: 1210 err_lm: 1211 /* resources are stored in link list */ 1212 list_for_each_safe(pos, n, &fake_bridge->lm_resources) { 1213 lm = list_entry(pos, struct vme_lm_resource, list); 1214 list_del(pos); 1215 kfree(lm); 1216 } 1217 err_slave: 1218 /* resources are stored in link list */ 1219 list_for_each_safe(pos, n, &fake_bridge->slave_resources) { 1220 slave_image = list_entry(pos, struct vme_slave_resource, list); 1221 list_del(pos); 1222 kfree(slave_image); 1223 } 1224 err_master: 1225 /* resources are stored in link list */ 1226 list_for_each_safe(pos, n, &fake_bridge->master_resources) { 1227 master_image = list_entry(pos, struct vme_master_resource, 1228 list); 1229 list_del(pos); 1230 kfree(master_image); 1231 } 1232 1233 kfree(fake_device); 1234 err_driver: 1235 kfree(fake_bridge); 1236 err_struct: 1237 return retval; 1238 1239 } 1240 1241 1242 static void __exit fake_exit(void) 1243 { 1244 struct list_head *pos = NULL; 1245 struct list_head *tmplist; 1246 struct vme_master_resource *master_image; 1247 struct vme_slave_resource *slave_image; 1248 int i; 1249 struct vme_bridge *fake_bridge; 1250 struct fake_driver *bridge; 1251 1252 fake_bridge = exit_pointer; 1253 1254 bridge = fake_bridge->driver_priv; 1255 1256 pr_debug("Driver is being unloaded.\n"); 1257 1258 /* 1259 * Shutdown all inbound and outbound windows. 1260 */ 1261 for (i = 0; i < FAKE_MAX_MASTER; i++) 1262 bridge->masters[i].enabled = 0; 1263 1264 for (i = 0; i < FAKE_MAX_SLAVE; i++) 1265 bridge->slaves[i].enabled = 0; 1266 1267 /* 1268 * Shutdown Location monitor. 1269 */ 1270 bridge->lm_enabled = 0; 1271 1272 vme_unregister_bridge(fake_bridge); 1273 1274 fake_crcsr_exit(fake_bridge); 1275 /* resources are stored in link list */ 1276 list_for_each_safe(pos, tmplist, &fake_bridge->slave_resources) { 1277 slave_image = list_entry(pos, struct vme_slave_resource, list); 1278 list_del(pos); 1279 kfree(slave_image); 1280 } 1281 1282 /* resources are stored in link list */ 1283 list_for_each_safe(pos, tmplist, &fake_bridge->master_resources) { 1284 master_image = list_entry(pos, struct vme_master_resource, 1285 list); 1286 list_del(pos); 1287 kfree(master_image); 1288 } 1289 1290 kfree(fake_bridge->driver_priv); 1291 1292 kfree(fake_bridge); 1293 1294 root_device_unregister(vme_root); 1295 } 1296 1297 1298 MODULE_PARM_DESC(geoid, "Set geographical addressing"); 1299 module_param(geoid, int, 0); 1300 1301 MODULE_DESCRIPTION("Fake VME bridge driver"); 1302 MODULE_LICENSE("GPL"); 1303 1304 module_init(fake_init); 1305 module_exit(fake_exit); 1306