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