drivers/vme/bridges/vme

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
fake_VIRQ_tasklet
fake_irq_set
fake_pci_to_ptr
fake_ptr_to_pci
fake_irq_generate
fake_slave_set
fake_slave_get
fake_master_set
__fake_master_get
fake_master_get
fake_lm_check
fake_vmeread8
fake_vmeread16
fake_vmeread32
fake_master_read
fake_vmewrite8
fake_vmewrite16
fake_vmewrite32
fake_master_write
fake_master_rmw
fake_lm_set
fake_lm_get
fake_lm_attach
fake_lm_detach
fake_slot_get
fake_alloc_consistent
fake_free_consistent
fake_crcsr_init
fake_crcsr_exit
fake_init
fake_exit
   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 #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 */
  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);
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/vme/bridges/vme_fake.c

DEFINITIONS
