linux/drivers/vme/vme.c
<<
>>
Prefs
   1/*
   2 * VME Bridge Framework
   3 *
   4 * Author: Martyn Welch <martyn.welch@ge.com>
   5 * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc.
   6 *
   7 * Based on work by Tom Armistead and Ajit Prem
   8 * Copyright 2004 Motorola Inc.
   9 *
  10 * This program is free software; you can redistribute  it and/or modify it
  11 * under  the terms of  the GNU General  Public License as published by the
  12 * Free Software Foundation;  either version 2 of the  License, or (at your
  13 * option) any later version.
  14 */
  15
  16#include <linux/init.h>
  17#include <linux/export.h>
  18#include <linux/mm.h>
  19#include <linux/types.h>
  20#include <linux/kernel.h>
  21#include <linux/errno.h>
  22#include <linux/pci.h>
  23#include <linux/poll.h>
  24#include <linux/highmem.h>
  25#include <linux/interrupt.h>
  26#include <linux/pagemap.h>
  27#include <linux/device.h>
  28#include <linux/dma-mapping.h>
  29#include <linux/syscalls.h>
  30#include <linux/mutex.h>
  31#include <linux/spinlock.h>
  32#include <linux/slab.h>
  33#include <linux/vme.h>
  34
  35#include "vme_bridge.h"
  36
  37/* Bitmask and list of registered buses both protected by common mutex */
  38static unsigned int vme_bus_numbers;
  39static LIST_HEAD(vme_bus_list);
  40static DEFINE_MUTEX(vme_buses_lock);
  41
  42static int __init vme_init(void);
  43
  44static struct vme_dev *dev_to_vme_dev(struct device *dev)
  45{
  46        return container_of(dev, struct vme_dev, dev);
  47}
  48
  49/*
  50 * Find the bridge that the resource is associated with.
  51 */
  52static struct vme_bridge *find_bridge(struct vme_resource *resource)
  53{
  54        /* Get list to search */
  55        switch (resource->type) {
  56        case VME_MASTER:
  57                return list_entry(resource->entry, struct vme_master_resource,
  58                        list)->parent;
  59                break;
  60        case VME_SLAVE:
  61                return list_entry(resource->entry, struct vme_slave_resource,
  62                        list)->parent;
  63                break;
  64        case VME_DMA:
  65                return list_entry(resource->entry, struct vme_dma_resource,
  66                        list)->parent;
  67                break;
  68        case VME_LM:
  69                return list_entry(resource->entry, struct vme_lm_resource,
  70                        list)->parent;
  71                break;
  72        default:
  73                printk(KERN_ERR "Unknown resource type\n");
  74                return NULL;
  75                break;
  76        }
  77}
  78
  79/**
  80 * vme_free_consistent - Allocate contiguous memory.
  81 * @resource: Pointer to VME resource.
  82 * @size: Size of allocation required.
  83 * @dma: Pointer to variable to store physical address of allocation.
  84 *
  85 * Allocate a contiguous block of memory for use by the driver. This is used to
  86 * create the buffers for the slave windows.
  87 *
  88 * Return: Virtual address of allocation on success, NULL on failure.
  89 */
  90void *vme_alloc_consistent(struct vme_resource *resource, size_t size,
  91        dma_addr_t *dma)
  92{
  93        struct vme_bridge *bridge;
  94
  95        if (!resource) {
  96                printk(KERN_ERR "No resource\n");
  97                return NULL;
  98        }
  99
 100        bridge = find_bridge(resource);
 101        if (!bridge) {
 102                printk(KERN_ERR "Can't find bridge\n");
 103                return NULL;
 104        }
 105
 106        if (!bridge->parent) {
 107                printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name);
 108                return NULL;
 109        }
 110
 111        if (!bridge->alloc_consistent) {
 112                printk(KERN_ERR "alloc_consistent not supported by bridge %s\n",
 113                       bridge->name);
 114                return NULL;
 115        }
 116
 117        return bridge->alloc_consistent(bridge->parent, size, dma);
 118}
 119EXPORT_SYMBOL(vme_alloc_consistent);
 120
 121/**
 122 * vme_free_consistent - Free previously allocated memory.
 123 * @resource: Pointer to VME resource.
 124 * @size: Size of allocation to free.
 125 * @vaddr: Virtual address of allocation.
 126 * @dma: Physical address of allocation.
 127 *
 128 * Free previously allocated block of contiguous memory.
 129 */
 130void vme_free_consistent(struct vme_resource *resource, size_t size,
 131        void *vaddr, dma_addr_t dma)
 132{
 133        struct vme_bridge *bridge;
 134
 135        if (!resource) {
 136                printk(KERN_ERR "No resource\n");
 137                return;
 138        }
 139
 140        bridge = find_bridge(resource);
 141        if (!bridge) {
 142                printk(KERN_ERR "Can't find bridge\n");
 143                return;
 144        }
 145
 146        if (!bridge->parent) {
 147                printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name);
 148                return;
 149        }
 150
 151        if (!bridge->free_consistent) {
 152                printk(KERN_ERR "free_consistent not supported by bridge %s\n",
 153                       bridge->name);
 154                return;
 155        }
 156
 157        bridge->free_consistent(bridge->parent, size, vaddr, dma);
 158}
 159EXPORT_SYMBOL(vme_free_consistent);
 160
 161/**
 162 * vme_get_size - Helper function returning size of a VME window
 163 * @resource: Pointer to VME slave or master resource.
 164 *
 165 * Determine the size of the VME window provided. This is a helper
 166 * function, wrappering the call to vme_master_get or vme_slave_get
 167 * depending on the type of window resource handed to it.
 168 *
 169 * Return: Size of the window on success, zero on failure.
 170 */
 171size_t vme_get_size(struct vme_resource *resource)
 172{
 173        int enabled, retval;
 174        unsigned long long base, size;
 175        dma_addr_t buf_base;
 176        u32 aspace, cycle, dwidth;
 177
 178        switch (resource->type) {
 179        case VME_MASTER:
 180                retval = vme_master_get(resource, &enabled, &base, &size,
 181                        &aspace, &cycle, &dwidth);
 182                if (retval)
 183                        return 0;
 184
 185                return size;
 186                break;
 187        case VME_SLAVE:
 188                retval = vme_slave_get(resource, &enabled, &base, &size,
 189                        &buf_base, &aspace, &cycle);
 190                if (retval)
 191                        return 0;
 192
 193                return size;
 194                break;
 195        case VME_DMA:
 196                return 0;
 197                break;
 198        default:
 199                printk(KERN_ERR "Unknown resource type\n");
 200                return 0;
 201                break;
 202        }
 203}
 204EXPORT_SYMBOL(vme_get_size);
 205
 206int vme_check_window(u32 aspace, unsigned long long vme_base,
 207                     unsigned long long size)
 208{
 209        int retval = 0;
 210
 211        if (vme_base + size < size)
 212                return -EINVAL;
 213
 214        switch (aspace) {
 215        case VME_A16:
 216                if (vme_base + size > VME_A16_MAX)
 217                        retval = -EFAULT;
 218                break;
 219        case VME_A24:
 220                if (vme_base + size > VME_A24_MAX)
 221                        retval = -EFAULT;
 222                break;
 223        case VME_A32:
 224                if (vme_base + size > VME_A32_MAX)
 225                        retval = -EFAULT;
 226                break;
 227        case VME_A64:
 228                /* The VME_A64_MAX limit is actually U64_MAX + 1 */
 229                break;
 230        case VME_CRCSR:
 231                if (vme_base + size > VME_CRCSR_MAX)
 232                        retval = -EFAULT;
 233                break;
 234        case VME_USER1:
 235        case VME_USER2:
 236        case VME_USER3:
 237        case VME_USER4:
 238                /* User Defined */
 239                break;
 240        default:
 241                printk(KERN_ERR "Invalid address space\n");
 242                retval = -EINVAL;
 243                break;
 244        }
 245
 246        return retval;
 247}
 248EXPORT_SYMBOL(vme_check_window);
 249
 250static u32 vme_get_aspace(int am)
 251{
 252        switch (am) {
 253        case 0x29:
 254        case 0x2D:
 255                return VME_A16;
 256        case 0x38:
 257        case 0x39:
 258        case 0x3A:
 259        case 0x3B:
 260        case 0x3C:
 261        case 0x3D:
 262        case 0x3E:
 263        case 0x3F:
 264                return VME_A24;
 265        case 0x8:
 266        case 0x9:
 267        case 0xA:
 268        case 0xB:
 269        case 0xC:
 270        case 0xD:
 271        case 0xE:
 272        case 0xF:
 273                return VME_A32;
 274        case 0x0:
 275        case 0x1:
 276        case 0x3:
 277                return VME_A64;
 278        }
 279
 280        return 0;
 281}
 282
 283/**
 284 * vme_slave_request - Request a VME slave window resource.
 285 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
 286 * @address: Required VME address space.
 287 * @cycle: Required VME data transfer cycle type.
 288 *
 289 * Request use of a VME window resource capable of being set for the requested
 290 * address space and data transfer cycle.
 291 *
 292 * Return: Pointer to VME resource on success, NULL on failure.
 293 */
 294struct vme_resource *vme_slave_request(struct vme_dev *vdev, u32 address,
 295        u32 cycle)
 296{
 297        struct vme_bridge *bridge;
 298        struct list_head *slave_pos = NULL;
 299        struct vme_slave_resource *allocated_image = NULL;
 300        struct vme_slave_resource *slave_image = NULL;
 301        struct vme_resource *resource = NULL;
 302
 303        bridge = vdev->bridge;
 304        if (!bridge) {
 305                printk(KERN_ERR "Can't find VME bus\n");
 306                goto err_bus;
 307        }
 308
 309        /* Loop through slave resources */
 310        list_for_each(slave_pos, &bridge->slave_resources) {
 311                slave_image = list_entry(slave_pos,
 312                        struct vme_slave_resource, list);
 313
 314                if (!slave_image) {
 315                        printk(KERN_ERR "Registered NULL Slave resource\n");
 316                        continue;
 317                }
 318
 319                /* Find an unlocked and compatible image */
 320                mutex_lock(&slave_image->mtx);
 321                if (((slave_image->address_attr & address) == address) &&
 322                        ((slave_image->cycle_attr & cycle) == cycle) &&
 323                        (slave_image->locked == 0)) {
 324
 325                        slave_image->locked = 1;
 326                        mutex_unlock(&slave_image->mtx);
 327                        allocated_image = slave_image;
 328                        break;
 329                }
 330                mutex_unlock(&slave_image->mtx);
 331        }
 332
 333        /* No free image */
 334        if (!allocated_image)
 335                goto err_image;
 336
 337        resource = kmalloc(sizeof(*resource), GFP_KERNEL);
 338        if (!resource)
 339                goto err_alloc;
 340
 341        resource->type = VME_SLAVE;
 342        resource->entry = &allocated_image->list;
 343
 344        return resource;
 345
 346err_alloc:
 347        /* Unlock image */
 348        mutex_lock(&slave_image->mtx);
 349        slave_image->locked = 0;
 350        mutex_unlock(&slave_image->mtx);
 351err_image:
 352err_bus:
 353        return NULL;
 354}
 355EXPORT_SYMBOL(vme_slave_request);
 356
 357/**
 358 * vme_slave_set - Set VME slave window configuration.
 359 * @resource: Pointer to VME slave resource.
 360 * @enabled: State to which the window should be configured.
 361 * @vme_base: Base address for the window.
 362 * @size: Size of the VME window.
 363 * @buf_base: Based address of buffer used to provide VME slave window storage.
 364 * @aspace: VME address space for the VME window.
 365 * @cycle: VME data transfer cycle type for the VME window.
 366 *
 367 * Set configuration for provided VME slave window.
 368 *
 369 * Return: Zero on success, -EINVAL if operation is not supported on this
 370 *         device, if an invalid resource has been provided or invalid
 371 *         attributes are provided. Hardware specific errors may also be
 372 *         returned.
 373 */
 374int vme_slave_set(struct vme_resource *resource, int enabled,
 375        unsigned long long vme_base, unsigned long long size,
 376        dma_addr_t buf_base, u32 aspace, u32 cycle)
 377{
 378        struct vme_bridge *bridge = find_bridge(resource);
 379        struct vme_slave_resource *image;
 380        int retval;
 381
 382        if (resource->type != VME_SLAVE) {
 383                printk(KERN_ERR "Not a slave resource\n");
 384                return -EINVAL;
 385        }
 386
 387        image = list_entry(resource->entry, struct vme_slave_resource, list);
 388
 389        if (!bridge->slave_set) {
 390                printk(KERN_ERR "Function not supported\n");
 391                return -ENOSYS;
 392        }
 393
 394        if (!(((image->address_attr & aspace) == aspace) &&
 395                ((image->cycle_attr & cycle) == cycle))) {
 396                printk(KERN_ERR "Invalid attributes\n");
 397                return -EINVAL;
 398        }
 399
 400        retval = vme_check_window(aspace, vme_base, size);
 401        if (retval)
 402                return retval;
 403
 404        return bridge->slave_set(image, enabled, vme_base, size, buf_base,
 405                aspace, cycle);
 406}
 407EXPORT_SYMBOL(vme_slave_set);
 408
 409/**
 410 * vme_slave_get - Retrieve VME slave window configuration.
 411 * @resource: Pointer to VME slave resource.
 412 * @enabled: Pointer to variable for storing state.
 413 * @vme_base: Pointer to variable for storing window base address.
 414 * @size: Pointer to variable for storing window size.
 415 * @buf_base: Pointer to variable for storing slave buffer base address.
 416 * @aspace: Pointer to variable for storing VME address space.
 417 * @cycle: Pointer to variable for storing VME data transfer cycle type.
 418 *
 419 * Return configuration for provided VME slave window.
 420 *
 421 * Return: Zero on success, -EINVAL if operation is not supported on this
 422 *         device or if an invalid resource has been provided.
 423 */
 424int vme_slave_get(struct vme_resource *resource, int *enabled,
 425        unsigned long long *vme_base, unsigned long long *size,
 426        dma_addr_t *buf_base, u32 *aspace, u32 *cycle)
 427{
 428        struct vme_bridge *bridge = find_bridge(resource);
 429        struct vme_slave_resource *image;
 430
 431        if (resource->type != VME_SLAVE) {
 432                printk(KERN_ERR "Not a slave resource\n");
 433                return -EINVAL;
 434        }
 435
 436        image = list_entry(resource->entry, struct vme_slave_resource, list);
 437
 438        if (!bridge->slave_get) {
 439                printk(KERN_ERR "vme_slave_get not supported\n");
 440                return -EINVAL;
 441        }
 442
 443        return bridge->slave_get(image, enabled, vme_base, size, buf_base,
 444                aspace, cycle);
 445}
 446EXPORT_SYMBOL(vme_slave_get);
 447
 448/**
 449 * vme_slave_free - Free VME slave window
 450 * @resource: Pointer to VME slave resource.
 451 *
 452 * Free the provided slave resource so that it may be reallocated.
 453 */
 454void vme_slave_free(struct vme_resource *resource)
 455{
 456        struct vme_slave_resource *slave_image;
 457
 458        if (resource->type != VME_SLAVE) {
 459                printk(KERN_ERR "Not a slave resource\n");
 460                return;
 461        }
 462
 463        slave_image = list_entry(resource->entry, struct vme_slave_resource,
 464                list);
 465        if (!slave_image) {
 466                printk(KERN_ERR "Can't find slave resource\n");
 467                return;
 468        }
 469
 470        /* Unlock image */
 471        mutex_lock(&slave_image->mtx);
 472        if (slave_image->locked == 0)
 473                printk(KERN_ERR "Image is already free\n");
 474
 475        slave_image->locked = 0;
 476        mutex_unlock(&slave_image->mtx);
 477
 478        /* Free up resource memory */
 479        kfree(resource);
 480}
 481EXPORT_SYMBOL(vme_slave_free);
 482
 483/**
 484 * vme_master_request - Request a VME master window resource.
 485 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
 486 * @address: Required VME address space.
 487 * @cycle: Required VME data transfer cycle type.
 488 * @dwidth: Required VME data transfer width.
 489 *
 490 * Request use of a VME window resource capable of being set for the requested
 491 * address space, data transfer cycle and width.
 492 *
 493 * Return: Pointer to VME resource on success, NULL on failure.
 494 */
 495struct vme_resource *vme_master_request(struct vme_dev *vdev, u32 address,
 496        u32 cycle, u32 dwidth)
 497{
 498        struct vme_bridge *bridge;
 499        struct list_head *master_pos = NULL;
 500        struct vme_master_resource *allocated_image = NULL;
 501        struct vme_master_resource *master_image = NULL;
 502        struct vme_resource *resource = NULL;
 503
 504        bridge = vdev->bridge;
 505        if (!bridge) {
 506                printk(KERN_ERR "Can't find VME bus\n");
 507                goto err_bus;
 508        }
 509
 510        /* Loop through master resources */
 511        list_for_each(master_pos, &bridge->master_resources) {
 512                master_image = list_entry(master_pos,
 513                        struct vme_master_resource, list);
 514
 515                if (!master_image) {
 516                        printk(KERN_WARNING "Registered NULL master resource\n");
 517                        continue;
 518                }
 519
 520                /* Find an unlocked and compatible image */
 521                spin_lock(&master_image->lock);
 522                if (((master_image->address_attr & address) == address) &&
 523                        ((master_image->cycle_attr & cycle) == cycle) &&
 524                        ((master_image->width_attr & dwidth) == dwidth) &&
 525                        (master_image->locked == 0)) {
 526
 527                        master_image->locked = 1;
 528                        spin_unlock(&master_image->lock);
 529                        allocated_image = master_image;
 530                        break;
 531                }
 532                spin_unlock(&master_image->lock);
 533        }
 534
 535        /* Check to see if we found a resource */
 536        if (!allocated_image) {
 537                printk(KERN_ERR "Can't find a suitable resource\n");
 538                goto err_image;
 539        }
 540
 541        resource = kmalloc(sizeof(*resource), GFP_KERNEL);
 542        if (!resource)
 543                goto err_alloc;
 544
 545        resource->type = VME_MASTER;
 546        resource->entry = &allocated_image->list;
 547
 548        return resource;
 549
 550err_alloc:
 551        /* Unlock image */
 552        spin_lock(&master_image->lock);
 553        master_image->locked = 0;
 554        spin_unlock(&master_image->lock);
 555err_image:
 556err_bus:
 557        return NULL;
 558}
 559EXPORT_SYMBOL(vme_master_request);
 560
 561/**
 562 * vme_master_set - Set VME master window configuration.
 563 * @resource: Pointer to VME master resource.
 564 * @enabled: State to which the window should be configured.
 565 * @vme_base: Base address for the window.
 566 * @size: Size of the VME window.
 567 * @aspace: VME address space for the VME window.
 568 * @cycle: VME data transfer cycle type for the VME window.
 569 * @dwidth: VME data transfer width for the VME window.
 570 *
 571 * Set configuration for provided VME master window.
 572 *
 573 * Return: Zero on success, -EINVAL if operation is not supported on this
 574 *         device, if an invalid resource has been provided or invalid
 575 *         attributes are provided. Hardware specific errors may also be
 576 *         returned.
 577 */
 578int vme_master_set(struct vme_resource *resource, int enabled,
 579        unsigned long long vme_base, unsigned long long size, u32 aspace,
 580        u32 cycle, u32 dwidth)
 581{
 582        struct vme_bridge *bridge = find_bridge(resource);
 583        struct vme_master_resource *image;
 584        int retval;
 585
 586        if (resource->type != VME_MASTER) {
 587                printk(KERN_ERR "Not a master resource\n");
 588                return -EINVAL;
 589        }
 590
 591        image = list_entry(resource->entry, struct vme_master_resource, list);
 592
 593        if (!bridge->master_set) {
 594                printk(KERN_WARNING "vme_master_set not supported\n");
 595                return -EINVAL;
 596        }
 597
 598        if (!(((image->address_attr & aspace) == aspace) &&
 599                ((image->cycle_attr & cycle) == cycle) &&
 600                ((image->width_attr & dwidth) == dwidth))) {
 601                printk(KERN_WARNING "Invalid attributes\n");
 602                return -EINVAL;
 603        }
 604
 605        retval = vme_check_window(aspace, vme_base, size);
 606        if (retval)
 607                return retval;
 608
 609        return bridge->master_set(image, enabled, vme_base, size, aspace,
 610                cycle, dwidth);
 611}
 612EXPORT_SYMBOL(vme_master_set);
 613
 614/**
 615 * vme_master_get - Retrieve VME master window configuration.
 616 * @resource: Pointer to VME master resource.
 617 * @enabled: Pointer to variable for storing state.
 618 * @vme_base: Pointer to variable for storing window base address.
 619 * @size: Pointer to variable for storing window size.
 620 * @aspace: Pointer to variable for storing VME address space.
 621 * @cycle: Pointer to variable for storing VME data transfer cycle type.
 622 * @dwidth: Pointer to variable for storing VME data transfer width.
 623 *
 624 * Return configuration for provided VME master window.
 625 *
 626 * Return: Zero on success, -EINVAL if operation is not supported on this
 627 *         device or if an invalid resource has been provided.
 628 */
 629int vme_master_get(struct vme_resource *resource, int *enabled,
 630        unsigned long long *vme_base, unsigned long long *size, u32 *aspace,
 631        u32 *cycle, u32 *dwidth)
 632{
 633        struct vme_bridge *bridge = find_bridge(resource);
 634        struct vme_master_resource *image;
 635
 636        if (resource->type != VME_MASTER) {
 637                printk(KERN_ERR "Not a master resource\n");
 638                return -EINVAL;
 639        }
 640
 641        image = list_entry(resource->entry, struct vme_master_resource, list);
 642
 643        if (!bridge->master_get) {
 644                printk(KERN_WARNING "%s not supported\n", __func__);
 645                return -EINVAL;
 646        }
 647
 648        return bridge->master_get(image, enabled, vme_base, size, aspace,
 649                cycle, dwidth);
 650}
 651EXPORT_SYMBOL(vme_master_get);
 652
 653/**
 654 * vme_master_write - Read data from VME space into a buffer.
 655 * @resource: Pointer to VME master resource.
 656 * @buf: Pointer to buffer where data should be transferred.
 657 * @count: Number of bytes to transfer.
 658 * @offset: Offset into VME master window at which to start transfer.
 659 *
 660 * Perform read of count bytes of data from location on VME bus which maps into
 661 * the VME master window at offset to buf.
 662 *
 663 * Return: Number of bytes read, -EINVAL if resource is not a VME master
 664 *         resource or read operation is not supported. -EFAULT returned if
 665 *         invalid offset is provided. Hardware specific errors may also be
 666 *         returned.
 667 */
 668ssize_t vme_master_read(struct vme_resource *resource, void *buf, size_t count,
 669        loff_t offset)
 670{
 671        struct vme_bridge *bridge = find_bridge(resource);
 672        struct vme_master_resource *image;
 673        size_t length;
 674
 675        if (!bridge->master_read) {
 676                printk(KERN_WARNING "Reading from resource not supported\n");
 677                return -EINVAL;
 678        }
 679
 680        if (resource->type != VME_MASTER) {
 681                printk(KERN_ERR "Not a master resource\n");
 682                return -EINVAL;
 683        }
 684
 685        image = list_entry(resource->entry, struct vme_master_resource, list);
 686
 687        length = vme_get_size(resource);
 688
 689        if (offset > length) {
 690                printk(KERN_WARNING "Invalid Offset\n");
 691                return -EFAULT;
 692        }
 693
 694        if ((offset + count) > length)
 695                count = length - offset;
 696
 697        return bridge->master_read(image, buf, count, offset);
 698
 699}
 700EXPORT_SYMBOL(vme_master_read);
 701
 702/**
 703 * vme_master_write - Write data out to VME space from a buffer.
 704 * @resource: Pointer to VME master resource.
 705 * @buf: Pointer to buffer holding data to transfer.
 706 * @count: Number of bytes to transfer.
 707 * @offset: Offset into VME master window at which to start transfer.
 708 *
 709 * Perform write of count bytes of data from buf to location on VME bus which
 710 * maps into the VME master window at offset.
 711 *
 712 * Return: Number of bytes written, -EINVAL if resource is not a VME master
 713 *         resource or write operation is not supported. -EFAULT returned if
 714 *         invalid offset is provided. Hardware specific errors may also be
 715 *         returned.
 716 */
 717ssize_t vme_master_write(struct vme_resource *resource, void *buf,
 718        size_t count, loff_t offset)
 719{
 720        struct vme_bridge *bridge = find_bridge(resource);
 721        struct vme_master_resource *image;
 722        size_t length;
 723
 724        if (!bridge->master_write) {
 725                printk(KERN_WARNING "Writing to resource not supported\n");
 726                return -EINVAL;
 727        }
 728
 729        if (resource->type != VME_MASTER) {
 730                printk(KERN_ERR "Not a master resource\n");
 731                return -EINVAL;
 732        }
 733
 734        image = list_entry(resource->entry, struct vme_master_resource, list);
 735
 736        length = vme_get_size(resource);
 737
 738        if (offset > length) {
 739                printk(KERN_WARNING "Invalid Offset\n");
 740                return -EFAULT;
 741        }
 742
 743        if ((offset + count) > length)
 744                count = length - offset;
 745
 746        return bridge->master_write(image, buf, count, offset);
 747}
 748EXPORT_SYMBOL(vme_master_write);
 749
 750/**
 751 * vme_master_rmw - Perform read-modify-write cycle.
 752 * @resource: Pointer to VME master resource.
 753 * @mask: Bits to be compared and swapped in operation.
 754 * @compare: Bits to be compared with data read from offset.
 755 * @swap: Bits to be swapped in data read from offset.
 756 * @offset: Offset into VME master window at which to perform operation.
 757 *
 758 * Perform read-modify-write cycle on provided location:
 759 * - Location on VME bus is read.
 760 * - Bits selected by mask are compared with compare.
 761 * - Where a selected bit matches that in compare and are selected in swap,
 762 * the bit is swapped.
 763 * - Result written back to location on VME bus.
 764 *
 765 * Return: Bytes written on success, -EINVAL if resource is not a VME master
 766 *         resource or RMW operation is not supported. Hardware specific
 767 *         errors may also be returned.
 768 */
 769unsigned int vme_master_rmw(struct vme_resource *resource, unsigned int mask,
 770        unsigned int compare, unsigned int swap, loff_t offset)
 771{
 772        struct vme_bridge *bridge = find_bridge(resource);
 773        struct vme_master_resource *image;
 774
 775        if (!bridge->master_rmw) {
 776                printk(KERN_WARNING "Writing to resource not supported\n");
 777                return -EINVAL;
 778        }
 779
 780        if (resource->type != VME_MASTER) {
 781                printk(KERN_ERR "Not a master resource\n");
 782                return -EINVAL;
 783        }
 784
 785        image = list_entry(resource->entry, struct vme_master_resource, list);
 786
 787        return bridge->master_rmw(image, mask, compare, swap, offset);
 788}
 789EXPORT_SYMBOL(vme_master_rmw);
 790
 791/**
 792 * vme_master_mmap - Mmap region of VME master window.
 793 * @resource: Pointer to VME master resource.
 794 * @vma: Pointer to definition of user mapping.
 795 *
 796 * Memory map a region of the VME master window into user space.
 797 *
 798 * Return: Zero on success, -EINVAL if resource is not a VME master
 799 *         resource or -EFAULT if map exceeds window size. Other generic mmap
 800 *         errors may also be returned.
 801 */
 802int vme_master_mmap(struct vme_resource *resource, struct vm_area_struct *vma)
 803{
 804        struct vme_master_resource *image;
 805        phys_addr_t phys_addr;
 806        unsigned long vma_size;
 807
 808        if (resource->type != VME_MASTER) {
 809                pr_err("Not a master resource\n");
 810                return -EINVAL;
 811        }
 812
 813        image = list_entry(resource->entry, struct vme_master_resource, list);
 814        phys_addr = image->bus_resource.start + (vma->vm_pgoff << PAGE_SHIFT);
 815        vma_size = vma->vm_end - vma->vm_start;
 816
 817        if (phys_addr + vma_size > image->bus_resource.end + 1) {
 818                pr_err("Map size cannot exceed the window size\n");
 819                return -EFAULT;
 820        }
 821
 822        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 823
 824        return vm_iomap_memory(vma, phys_addr, vma->vm_end - vma->vm_start);
 825}
 826EXPORT_SYMBOL(vme_master_mmap);
 827
 828/**
 829 * vme_master_free - Free VME master window
 830 * @resource: Pointer to VME master resource.
 831 *
 832 * Free the provided master resource so that it may be reallocated.
 833 */
 834void vme_master_free(struct vme_resource *resource)
 835{
 836        struct vme_master_resource *master_image;
 837
 838        if (resource->type != VME_MASTER) {
 839                printk(KERN_ERR "Not a master resource\n");
 840                return;
 841        }
 842
 843        master_image = list_entry(resource->entry, struct vme_master_resource,
 844                list);
 845        if (!master_image) {
 846                printk(KERN_ERR "Can't find master resource\n");
 847                return;
 848        }
 849
 850        /* Unlock image */
 851        spin_lock(&master_image->lock);
 852        if (master_image->locked == 0)
 853                printk(KERN_ERR "Image is already free\n");
 854
 855        master_image->locked = 0;
 856        spin_unlock(&master_image->lock);
 857
 858        /* Free up resource memory */
 859        kfree(resource);
 860}
 861EXPORT_SYMBOL(vme_master_free);
 862
 863/**
 864 * vme_dma_request - Request a DMA controller.
 865 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
 866 * @route: Required src/destination combination.
 867 *
 868 * Request a VME DMA controller with capability to perform transfers bewteen
 869 * requested source/destination combination.
 870 *
 871 * Return: Pointer to VME DMA resource on success, NULL on failure.
 872 */
 873struct vme_resource *vme_dma_request(struct vme_dev *vdev, u32 route)
 874{
 875        struct vme_bridge *bridge;
 876        struct list_head *dma_pos = NULL;
 877        struct vme_dma_resource *allocated_ctrlr = NULL;
 878        struct vme_dma_resource *dma_ctrlr = NULL;
 879        struct vme_resource *resource = NULL;
 880
 881        /* XXX Not checking resource attributes */
 882        printk(KERN_ERR "No VME resource Attribute tests done\n");
 883
 884        bridge = vdev->bridge;
 885        if (!bridge) {
 886                printk(KERN_ERR "Can't find VME bus\n");
 887                goto err_bus;
 888        }
 889
 890        /* Loop through DMA resources */
 891        list_for_each(dma_pos, &bridge->dma_resources) {
 892                dma_ctrlr = list_entry(dma_pos,
 893                        struct vme_dma_resource, list);
 894                if (!dma_ctrlr) {
 895                        printk(KERN_ERR "Registered NULL DMA resource\n");
 896                        continue;
 897                }
 898
 899                /* Find an unlocked and compatible controller */
 900                mutex_lock(&dma_ctrlr->mtx);
 901                if (((dma_ctrlr->route_attr & route) == route) &&
 902                        (dma_ctrlr->locked == 0)) {
 903
 904                        dma_ctrlr->locked = 1;
 905                        mutex_unlock(&dma_ctrlr->mtx);
 906                        allocated_ctrlr = dma_ctrlr;
 907                        break;
 908                }
 909                mutex_unlock(&dma_ctrlr->mtx);
 910        }
 911
 912        /* Check to see if we found a resource */
 913        if (!allocated_ctrlr)
 914                goto err_ctrlr;
 915
 916        resource = kmalloc(sizeof(*resource), GFP_KERNEL);
 917        if (!resource)
 918                goto err_alloc;
 919
 920        resource->type = VME_DMA;
 921        resource->entry = &allocated_ctrlr->list;
 922
 923        return resource;
 924
 925err_alloc:
 926        /* Unlock image */
 927        mutex_lock(&dma_ctrlr->mtx);
 928        dma_ctrlr->locked = 0;
 929        mutex_unlock(&dma_ctrlr->mtx);
 930err_ctrlr:
 931err_bus:
 932        return NULL;
 933}
 934EXPORT_SYMBOL(vme_dma_request);
 935
 936/**
 937 * vme_new_dma_list - Create new VME DMA list.
 938 * @resource: Pointer to VME DMA resource.
 939 *
 940 * Create a new VME DMA list. It is the responsibility of the user to free
 941 * the list once it is no longer required with vme_dma_list_free().
 942 *
 943 * Return: Pointer to new VME DMA list, NULL on allocation failure or invalid
 944 *         VME DMA resource.
 945 */
 946struct vme_dma_list *vme_new_dma_list(struct vme_resource *resource)
 947{
 948        struct vme_dma_list *dma_list;
 949
 950        if (resource->type != VME_DMA) {
 951                printk(KERN_ERR "Not a DMA resource\n");
 952                return NULL;
 953        }
 954
 955        dma_list = kmalloc(sizeof(*dma_list), GFP_KERNEL);
 956        if (!dma_list)
 957                return NULL;
 958
 959        INIT_LIST_HEAD(&dma_list->entries);
 960        dma_list->parent = list_entry(resource->entry,
 961                                      struct vme_dma_resource,
 962                                      list);
 963        mutex_init(&dma_list->mtx);
 964
 965        return dma_list;
 966}
 967EXPORT_SYMBOL(vme_new_dma_list);
 968
 969/**
 970 * vme_dma_pattern_attribute - Create "Pattern" type VME DMA list attribute.
 971 * @pattern: Value to use used as pattern
 972 * @type: Type of pattern to be written.
 973 *
 974 * Create VME DMA list attribute for pattern generation. It is the
 975 * responsibility of the user to free used attributes using
 976 * vme_dma_free_attribute().
 977 *
 978 * Return: Pointer to VME DMA attribute, NULL on failure.
 979 */
 980struct vme_dma_attr *vme_dma_pattern_attribute(u32 pattern, u32 type)
 981{
 982        struct vme_dma_attr *attributes;
 983        struct vme_dma_pattern *pattern_attr;
 984
 985        attributes = kmalloc(sizeof(*attributes), GFP_KERNEL);
 986        if (!attributes)
 987                goto err_attr;
 988
 989        pattern_attr = kmalloc(sizeof(*pattern_attr), GFP_KERNEL);
 990        if (!pattern_attr)
 991                goto err_pat;
 992
 993        attributes->type = VME_DMA_PATTERN;
 994        attributes->private = (void *)pattern_attr;
 995
 996        pattern_attr->pattern = pattern;
 997        pattern_attr->type = type;
 998
 999        return attributes;
1000
1001err_pat:
1002        kfree(attributes);
1003err_attr:
1004        return NULL;
1005}
1006EXPORT_SYMBOL(vme_dma_pattern_attribute);
1007
1008/**
1009 * vme_dma_pci_attribute - Create "PCI" type VME DMA list attribute.
1010 * @address: PCI base address for DMA transfer.
1011 *
1012 * Create VME DMA list attribute pointing to a location on PCI for DMA
1013 * transfers. It is the responsibility of the user to free used attributes
1014 * using vme_dma_free_attribute().
1015 *
1016 * Return: Pointer to VME DMA attribute, NULL on failure.
1017 */
1018struct vme_dma_attr *vme_dma_pci_attribute(dma_addr_t address)
1019{
1020        struct vme_dma_attr *attributes;
1021        struct vme_dma_pci *pci_attr;
1022
1023        /* XXX Run some sanity checks here */
1024
1025        attributes = kmalloc(sizeof(*attributes), GFP_KERNEL);
1026        if (!attributes)
1027                goto err_attr;
1028
1029        pci_attr = kmalloc(sizeof(*pci_attr), GFP_KERNEL);
1030        if (!pci_attr)
1031                goto err_pci;
1032
1033        attributes->type = VME_DMA_PCI;
1034        attributes->private = (void *)pci_attr;
1035
1036        pci_attr->address = address;
1037
1038        return attributes;
1039
1040err_pci:
1041        kfree(attributes);
1042err_attr:
1043        return NULL;
1044}
1045EXPORT_SYMBOL(vme_dma_pci_attribute);
1046
1047/**
1048 * vme_dma_vme_attribute - Create "VME" type VME DMA list attribute.
1049 * @address: VME base address for DMA transfer.
1050 * @aspace: VME address space to use for DMA transfer.
1051 * @cycle: VME bus cycle to use for DMA transfer.
1052 * @dwidth: VME data width to use for DMA transfer.
1053 *
1054 * Create VME DMA list attribute pointing to a location on the VME bus for DMA
1055 * transfers. It is the responsibility of the user to free used attributes
1056 * using vme_dma_free_attribute().
1057 *
1058 * Return: Pointer to VME DMA attribute, NULL on failure.
1059 */
1060struct vme_dma_attr *vme_dma_vme_attribute(unsigned long long address,
1061        u32 aspace, u32 cycle, u32 dwidth)
1062{
1063        struct vme_dma_attr *attributes;
1064        struct vme_dma_vme *vme_attr;
1065
1066        attributes = kmalloc(sizeof(*attributes), GFP_KERNEL);
1067        if (!attributes)
1068                goto err_attr;
1069
1070        vme_attr = kmalloc(sizeof(*vme_attr), GFP_KERNEL);
1071        if (!vme_attr)
1072                goto err_vme;
1073
1074        attributes->type = VME_DMA_VME;
1075        attributes->private = (void *)vme_attr;
1076
1077        vme_attr->address = address;
1078        vme_attr->aspace = aspace;
1079        vme_attr->cycle = cycle;
1080        vme_attr->dwidth = dwidth;
1081
1082        return attributes;
1083
1084err_vme:
1085        kfree(attributes);
1086err_attr:
1087        return NULL;
1088}
1089EXPORT_SYMBOL(vme_dma_vme_attribute);
1090
1091/**
1092 * vme_dma_free_attribute - Free DMA list attribute.
1093 * @attributes: Pointer to DMA list attribute.
1094 *
1095 * Free VME DMA list attribute. VME DMA list attributes can be safely freed
1096 * once vme_dma_list_add() has returned.
1097 */
1098void vme_dma_free_attribute(struct vme_dma_attr *attributes)
1099{
1100        kfree(attributes->private);
1101        kfree(attributes);
1102}
1103EXPORT_SYMBOL(vme_dma_free_attribute);
1104
1105/**
1106 * vme_dma_list_add - Add enty to a VME DMA list.
1107 * @list: Pointer to VME list.
1108 * @src: Pointer to DMA list attribute to use as source.
1109 * @dest: Pointer to DMA list attribute to use as destination.
1110 * @count: Number of bytes to transfer.
1111 *
1112 * Add an entry to the provided VME DMA list. Entry requires pointers to source
1113 * and destination DMA attributes and a count.
1114 *
1115 * Please note, the attributes supported as source and destinations for
1116 * transfers are hardware dependent.
1117 *
1118 * Return: Zero on success, -EINVAL if operation is not supported on this
1119 *         device or if the link list has already been submitted for execution.
1120 *         Hardware specific errors also possible.
1121 */
1122int vme_dma_list_add(struct vme_dma_list *list, struct vme_dma_attr *src,
1123        struct vme_dma_attr *dest, size_t count)
1124{
1125        struct vme_bridge *bridge = list->parent->parent;
1126        int retval;
1127
1128        if (!bridge->dma_list_add) {
1129                printk(KERN_WARNING "Link List DMA generation not supported\n");
1130                return -EINVAL;
1131        }
1132
1133        if (!mutex_trylock(&list->mtx)) {
1134                printk(KERN_ERR "Link List already submitted\n");
1135                return -EINVAL;
1136        }
1137
1138        retval = bridge->dma_list_add(list, src, dest, count);
1139
1140        mutex_unlock(&list->mtx);
1141
1142        return retval;
1143}
1144EXPORT_SYMBOL(vme_dma_list_add);
1145
1146/**
1147 * vme_dma_list_exec - Queue a VME DMA list for execution.
1148 * @list: Pointer to VME list.
1149 *
1150 * Queue the provided VME DMA list for execution. The call will return once the
1151 * list has been executed.
1152 *
1153 * Return: Zero on success, -EINVAL if operation is not supported on this
1154 *         device. Hardware specific errors also possible.
1155 */
1156int vme_dma_list_exec(struct vme_dma_list *list)
1157{
1158        struct vme_bridge *bridge = list->parent->parent;
1159        int retval;
1160
1161        if (!bridge->dma_list_exec) {
1162                printk(KERN_ERR "Link List DMA execution not supported\n");
1163                return -EINVAL;
1164        }
1165
1166        mutex_lock(&list->mtx);
1167
1168        retval = bridge->dma_list_exec(list);
1169
1170        mutex_unlock(&list->mtx);
1171
1172        return retval;
1173}
1174EXPORT_SYMBOL(vme_dma_list_exec);
1175
1176/**
1177 * vme_dma_list_free - Free a VME DMA list.
1178 * @list: Pointer to VME list.
1179 *
1180 * Free the provided DMA list and all its entries.
1181 *
1182 * Return: Zero on success, -EINVAL on invalid VME resource, -EBUSY if resource
1183 *         is still in use. Hardware specific errors also possible.
1184 */
1185int vme_dma_list_free(struct vme_dma_list *list)
1186{
1187        struct vme_bridge *bridge = list->parent->parent;
1188        int retval;
1189
1190        if (!bridge->dma_list_empty) {
1191                printk(KERN_WARNING "Emptying of Link Lists not supported\n");
1192                return -EINVAL;
1193        }
1194
1195        if (!mutex_trylock(&list->mtx)) {
1196                printk(KERN_ERR "Link List in use\n");
1197                return -EBUSY;
1198        }
1199
1200        /*
1201         * Empty out all of the entries from the DMA list. We need to go to the
1202         * low level driver as DMA entries are driver specific.
1203         */
1204        retval = bridge->dma_list_empty(list);
1205        if (retval) {
1206                printk(KERN_ERR "Unable to empty link-list entries\n");
1207                mutex_unlock(&list->mtx);
1208                return retval;
1209        }
1210        mutex_unlock(&list->mtx);
1211        kfree(list);
1212
1213        return retval;
1214}
1215EXPORT_SYMBOL(vme_dma_list_free);
1216
1217/**
1218 * vme_dma_free - Free a VME DMA resource.
1219 * @resource: Pointer to VME DMA resource.
1220 *
1221 * Free the provided DMA resource so that it may be reallocated.
1222 *
1223 * Return: Zero on success, -EINVAL on invalid VME resource, -EBUSY if resource
1224 *         is still active.
1225 */
1226int vme_dma_free(struct vme_resource *resource)
1227{
1228        struct vme_dma_resource *ctrlr;
1229
1230        if (resource->type != VME_DMA) {
1231                printk(KERN_ERR "Not a DMA resource\n");
1232                return -EINVAL;
1233        }
1234
1235        ctrlr = list_entry(resource->entry, struct vme_dma_resource, list);
1236
1237        if (!mutex_trylock(&ctrlr->mtx)) {
1238                printk(KERN_ERR "Resource busy, can't free\n");
1239                return -EBUSY;
1240        }
1241
1242        if (!(list_empty(&ctrlr->pending) && list_empty(&ctrlr->running))) {
1243                printk(KERN_WARNING "Resource still processing transfers\n");
1244                mutex_unlock(&ctrlr->mtx);
1245                return -EBUSY;
1246        }
1247
1248        ctrlr->locked = 0;
1249
1250        mutex_unlock(&ctrlr->mtx);
1251
1252        kfree(resource);
1253
1254        return 0;
1255}
1256EXPORT_SYMBOL(vme_dma_free);
1257
1258void vme_bus_error_handler(struct vme_bridge *bridge,
1259                           unsigned long long address, int am)
1260{
1261        struct list_head *handler_pos = NULL;
1262        struct vme_error_handler *handler;
1263        int handler_triggered = 0;
1264        u32 aspace = vme_get_aspace(am);
1265
1266        list_for_each(handler_pos, &bridge->vme_error_handlers) {
1267                handler = list_entry(handler_pos, struct vme_error_handler,
1268                                     list);
1269                if ((aspace == handler->aspace) &&
1270                    (address >= handler->start) &&
1271                    (address < handler->end)) {
1272                        if (!handler->num_errors)
1273                                handler->first_error = address;
1274                        if (handler->num_errors != UINT_MAX)
1275                                handler->num_errors++;
1276                        handler_triggered = 1;
1277                }
1278        }
1279
1280        if (!handler_triggered)
1281                dev_err(bridge->parent,
1282                        "Unhandled VME access error at address 0x%llx\n",
1283                        address);
1284}
1285EXPORT_SYMBOL(vme_bus_error_handler);
1286
1287struct vme_error_handler *vme_register_error_handler(
1288        struct vme_bridge *bridge, u32 aspace,
1289        unsigned long long address, size_t len)
1290{
1291        struct vme_error_handler *handler;
1292
1293        handler = kmalloc(sizeof(*handler), GFP_ATOMIC);
1294        if (!handler)
1295                return NULL;
1296
1297        handler->aspace = aspace;
1298        handler->start = address;
1299        handler->end = address + len;
1300        handler->num_errors = 0;
1301        handler->first_error = 0;
1302        list_add_tail(&handler->list, &bridge->vme_error_handlers);
1303
1304        return handler;
1305}
1306EXPORT_SYMBOL(vme_register_error_handler);
1307
1308void vme_unregister_error_handler(struct vme_error_handler *handler)
1309{
1310        list_del(&handler->list);
1311        kfree(handler);
1312}
1313EXPORT_SYMBOL(vme_unregister_error_handler);
1314
1315void vme_irq_handler(struct vme_bridge *bridge, int level, int statid)
1316{
1317        void (*call)(int, int, void *);
1318        void *priv_data;
1319
1320        call = bridge->irq[level - 1].callback[statid].func;
1321        priv_data = bridge->irq[level - 1].callback[statid].priv_data;
1322        if (call)
1323                call(level, statid, priv_data);
1324        else
1325                printk(KERN_WARNING "Spurious VME interrupt, level:%x, vector:%x\n",
1326                       level, statid);
1327}
1328EXPORT_SYMBOL(vme_irq_handler);
1329
1330/**
1331 * vme_irq_request - Request a specific VME interrupt.
1332 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1333 * @level: Interrupt priority being requested.
1334 * @statid: Interrupt vector being requested.
1335 * @callback: Pointer to callback function called when VME interrupt/vector
1336 *            received.
1337 * @priv_data: Generic pointer that will be passed to the callback function.
1338 *
1339 * Request callback to be attached as a handler for VME interrupts with provided
1340 * level and statid.
1341 *
1342 * Return: Zero on success, -EINVAL on invalid vme device, level or if the
1343 *         function is not supported, -EBUSY if the level/statid combination is
1344 *         already in use. Hardware specific errors also possible.
1345 */
1346int vme_irq_request(struct vme_dev *vdev, int level, int statid,
1347        void (*callback)(int, int, void *),
1348        void *priv_data)
1349{
1350        struct vme_bridge *bridge;
1351
1352        bridge = vdev->bridge;
1353        if (!bridge) {
1354                printk(KERN_ERR "Can't find VME bus\n");
1355                return -EINVAL;
1356        }
1357
1358        if ((level < 1) || (level > 7)) {
1359                printk(KERN_ERR "Invalid interrupt level\n");
1360                return -EINVAL;
1361        }
1362
1363        if (!bridge->irq_set) {
1364                printk(KERN_ERR "Configuring interrupts not supported\n");
1365                return -EINVAL;
1366        }
1367
1368        mutex_lock(&bridge->irq_mtx);
1369
1370        if (bridge->irq[level - 1].callback[statid].func) {
1371                mutex_unlock(&bridge->irq_mtx);
1372                printk(KERN_WARNING "VME Interrupt already taken\n");
1373                return -EBUSY;
1374        }
1375
1376        bridge->irq[level - 1].count++;
1377        bridge->irq[level - 1].callback[statid].priv_data = priv_data;
1378        bridge->irq[level - 1].callback[statid].func = callback;
1379
1380        /* Enable IRQ level */
1381        bridge->irq_set(bridge, level, 1, 1);
1382
1383        mutex_unlock(&bridge->irq_mtx);
1384
1385        return 0;
1386}
1387EXPORT_SYMBOL(vme_irq_request);
1388
1389/**
1390 * vme_irq_free - Free a VME interrupt.
1391 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1392 * @level: Interrupt priority of interrupt being freed.
1393 * @statid: Interrupt vector of interrupt being freed.
1394 *
1395 * Remove previously attached callback from VME interrupt priority/vector.
1396 */
1397void vme_irq_free(struct vme_dev *vdev, int level, int statid)
1398{
1399        struct vme_bridge *bridge;
1400
1401        bridge = vdev->bridge;
1402        if (!bridge) {
1403                printk(KERN_ERR "Can't find VME bus\n");
1404                return;
1405        }
1406
1407        if ((level < 1) || (level > 7)) {
1408                printk(KERN_ERR "Invalid interrupt level\n");
1409                return;
1410        }
1411
1412        if (!bridge->irq_set) {
1413                printk(KERN_ERR "Configuring interrupts not supported\n");
1414                return;
1415        }
1416
1417        mutex_lock(&bridge->irq_mtx);
1418
1419        bridge->irq[level - 1].count--;
1420
1421        /* Disable IRQ level if no more interrupts attached at this level*/
1422        if (bridge->irq[level - 1].count == 0)
1423                bridge->irq_set(bridge, level, 0, 1);
1424
1425        bridge->irq[level - 1].callback[statid].func = NULL;
1426        bridge->irq[level - 1].callback[statid].priv_data = NULL;
1427
1428        mutex_unlock(&bridge->irq_mtx);
1429}
1430EXPORT_SYMBOL(vme_irq_free);
1431
1432/**
1433 * vme_irq_generate - Generate VME interrupt.
1434 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1435 * @level: Interrupt priority at which to assert the interrupt.
1436 * @statid: Interrupt vector to associate with the interrupt.
1437 *
1438 * Generate a VME interrupt of the provided level and with the provided
1439 * statid.
1440 *
1441 * Return: Zero on success, -EINVAL on invalid vme device, level or if the
1442 *         function is not supported. Hardware specific errors also possible.
1443 */
1444int vme_irq_generate(struct vme_dev *vdev, int level, int statid)
1445{
1446        struct vme_bridge *bridge;
1447
1448        bridge = vdev->bridge;
1449        if (!bridge) {
1450                printk(KERN_ERR "Can't find VME bus\n");
1451                return -EINVAL;
1452        }
1453
1454        if ((level < 1) || (level > 7)) {
1455                printk(KERN_WARNING "Invalid interrupt level\n");
1456                return -EINVAL;
1457        }
1458
1459        if (!bridge->irq_generate) {
1460                printk(KERN_WARNING "Interrupt generation not supported\n");
1461                return -EINVAL;
1462        }
1463
1464        return bridge->irq_generate(bridge, level, statid);
1465}
1466EXPORT_SYMBOL(vme_irq_generate);
1467
1468/**
1469 * vme_lm_request - Request a VME location monitor
1470 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1471 *
1472 * Allocate a location monitor resource to the driver. A location monitor
1473 * allows the driver to monitor accesses to a contiguous number of
1474 * addresses on the VME bus.
1475 *
1476 * Return: Pointer to a VME resource on success or NULL on failure.
1477 */
1478struct vme_resource *vme_lm_request(struct vme_dev *vdev)
1479{
1480        struct vme_bridge *bridge;
1481        struct list_head *lm_pos = NULL;
1482        struct vme_lm_resource *allocated_lm = NULL;
1483        struct vme_lm_resource *lm = NULL;
1484        struct vme_resource *resource = NULL;
1485
1486        bridge = vdev->bridge;
1487        if (!bridge) {
1488                printk(KERN_ERR "Can't find VME bus\n");
1489                goto err_bus;
1490        }
1491
1492        /* Loop through LM resources */
1493        list_for_each(lm_pos, &bridge->lm_resources) {
1494                lm = list_entry(lm_pos,
1495                        struct vme_lm_resource, list);
1496                if (!lm) {
1497                        printk(KERN_ERR "Registered NULL Location Monitor resource\n");
1498                        continue;
1499                }
1500
1501                /* Find an unlocked controller */
1502                mutex_lock(&lm->mtx);
1503                if (lm->locked == 0) {
1504                        lm->locked = 1;
1505                        mutex_unlock(&lm->mtx);
1506                        allocated_lm = lm;
1507                        break;
1508                }
1509                mutex_unlock(&lm->mtx);
1510        }
1511
1512        /* Check to see if we found a resource */
1513        if (!allocated_lm)
1514                goto err_lm;
1515
1516        resource = kmalloc(sizeof(*resource), GFP_KERNEL);
1517        if (!resource)
1518                goto err_alloc;
1519
1520        resource->type = VME_LM;
1521        resource->entry = &allocated_lm->list;
1522
1523        return resource;
1524
1525err_alloc:
1526        /* Unlock image */
1527        mutex_lock(&lm->mtx);
1528        lm->locked = 0;
1529        mutex_unlock(&lm->mtx);
1530err_lm:
1531err_bus:
1532        return NULL;
1533}
1534EXPORT_SYMBOL(vme_lm_request);
1535
1536/**
1537 * vme_lm_count - Determine number of VME Addresses monitored
1538 * @resource: Pointer to VME location monitor resource.
1539 *
1540 * The number of contiguous addresses monitored is hardware dependent.
1541 * Return the number of contiguous addresses monitored by the
1542 * location monitor.
1543 *
1544 * Return: Count of addresses monitored or -EINVAL when provided with an
1545 *         invalid location monitor resource.
1546 */
1547int vme_lm_count(struct vme_resource *resource)
1548{
1549        struct vme_lm_resource *lm;
1550
1551        if (resource->type != VME_LM) {
1552                printk(KERN_ERR "Not a Location Monitor resource\n");
1553                return -EINVAL;
1554        }
1555
1556        lm = list_entry(resource->entry, struct vme_lm_resource, list);
1557
1558        return lm->monitors;
1559}
1560EXPORT_SYMBOL(vme_lm_count);
1561
1562/**
1563 * vme_lm_set - Configure location monitor
1564 * @resource: Pointer to VME location monitor resource.
1565 * @lm_base: Base address to monitor.
1566 * @aspace: VME address space to monitor.
1567 * @cycle: VME bus cycle type to monitor.
1568 *
1569 * Set the base address, address space and cycle type of accesses to be
1570 * monitored by the location monitor.
1571 *
1572 * Return: Zero on success, -EINVAL when provided with an invalid location
1573 *         monitor resource or function is not supported. Hardware specific
1574 *         errors may also be returned.
1575 */
1576int vme_lm_set(struct vme_resource *resource, unsigned long long lm_base,
1577        u32 aspace, u32 cycle)
1578{
1579        struct vme_bridge *bridge = find_bridge(resource);
1580        struct vme_lm_resource *lm;
1581
1582        if (resource->type != VME_LM) {
1583                printk(KERN_ERR "Not a Location Monitor resource\n");
1584                return -EINVAL;
1585        }
1586
1587        lm = list_entry(resource->entry, struct vme_lm_resource, list);
1588
1589        if (!bridge->lm_set) {
1590                printk(KERN_ERR "vme_lm_set not supported\n");
1591                return -EINVAL;
1592        }
1593
1594        return bridge->lm_set(lm, lm_base, aspace, cycle);
1595}
1596EXPORT_SYMBOL(vme_lm_set);
1597
1598/**
1599 * vme_lm_get - Retrieve location monitor settings
1600 * @resource: Pointer to VME location monitor resource.
1601 * @lm_base: Pointer used to output the base address monitored.
1602 * @aspace: Pointer used to output the address space monitored.
1603 * @cycle: Pointer used to output the VME bus cycle type monitored.
1604 *
1605 * Retrieve the base address, address space and cycle type of accesses to
1606 * be monitored by the location monitor.
1607 *
1608 * Return: Zero on success, -EINVAL when provided with an invalid location
1609 *         monitor resource or function is not supported. Hardware specific
1610 *         errors may also be returned.
1611 */
1612int vme_lm_get(struct vme_resource *resource, unsigned long long *lm_base,
1613        u32 *aspace, u32 *cycle)
1614{
1615        struct vme_bridge *bridge = find_bridge(resource);
1616        struct vme_lm_resource *lm;
1617
1618        if (resource->type != VME_LM) {
1619                printk(KERN_ERR "Not a Location Monitor resource\n");
1620                return -EINVAL;
1621        }
1622
1623        lm = list_entry(resource->entry, struct vme_lm_resource, list);
1624
1625        if (!bridge->lm_get) {
1626                printk(KERN_ERR "vme_lm_get not supported\n");
1627                return -EINVAL;
1628        }
1629
1630        return bridge->lm_get(lm, lm_base, aspace, cycle);
1631}
1632EXPORT_SYMBOL(vme_lm_get);
1633
1634/**
1635 * vme_lm_attach - Provide callback for location monitor address
1636 * @resource: Pointer to VME location monitor resource.
1637 * @monitor: Offset to which callback should be attached.
1638 * @callback: Pointer to callback function called when triggered.
1639 * @data: Generic pointer that will be passed to the callback function.
1640 *
1641 * Attach a callback to the specificed offset into the location monitors
1642 * monitored addresses. A generic pointer is provided to allow data to be
1643 * passed to the callback when called.
1644 *
1645 * Return: Zero on success, -EINVAL when provided with an invalid location
1646 *         monitor resource or function is not supported. Hardware specific
1647 *         errors may also be returned.
1648 */
1649int vme_lm_attach(struct vme_resource *resource, int monitor,
1650        void (*callback)(void *), void *data)
1651{
1652        struct vme_bridge *bridge = find_bridge(resource);
1653        struct vme_lm_resource *lm;
1654
1655        if (resource->type != VME_LM) {
1656                printk(KERN_ERR "Not a Location Monitor resource\n");
1657                return -EINVAL;
1658        }
1659
1660        lm = list_entry(resource->entry, struct vme_lm_resource, list);
1661
1662        if (!bridge->lm_attach) {
1663                printk(KERN_ERR "vme_lm_attach not supported\n");
1664                return -EINVAL;
1665        }
1666
1667        return bridge->lm_attach(lm, monitor, callback, data);
1668}
1669EXPORT_SYMBOL(vme_lm_attach);
1670
1671/**
1672 * vme_lm_detach - Remove callback for location monitor address
1673 * @resource: Pointer to VME location monitor resource.
1674 * @monitor: Offset to which callback should be removed.
1675 *
1676 * Remove the callback associated with the specificed offset into the
1677 * location monitors monitored addresses.
1678 *
1679 * Return: Zero on success, -EINVAL when provided with an invalid location
1680 *         monitor resource or function is not supported. Hardware specific
1681 *         errors may also be returned.
1682 */
1683int vme_lm_detach(struct vme_resource *resource, int monitor)
1684{
1685        struct vme_bridge *bridge = find_bridge(resource);
1686        struct vme_lm_resource *lm;
1687
1688        if (resource->type != VME_LM) {
1689                printk(KERN_ERR "Not a Location Monitor resource\n");
1690                return -EINVAL;
1691        }
1692
1693        lm = list_entry(resource->entry, struct vme_lm_resource, list);
1694
1695        if (!bridge->lm_detach) {
1696                printk(KERN_ERR "vme_lm_detach not supported\n");
1697                return -EINVAL;
1698        }
1699
1700        return bridge->lm_detach(lm, monitor);
1701}
1702EXPORT_SYMBOL(vme_lm_detach);
1703
1704/**
1705 * vme_lm_free - Free allocated VME location monitor
1706 * @resource: Pointer to VME location monitor resource.
1707 *
1708 * Free allocation of a VME location monitor.
1709 *
1710 * WARNING: This function currently expects that any callbacks that have
1711 *          been attached to the location monitor have been removed.
1712 *
1713 * Return: Zero on success, -EINVAL when provided with an invalid location
1714 *         monitor resource.
1715 */
1716void vme_lm_free(struct vme_resource *resource)
1717{
1718        struct vme_lm_resource *lm;
1719
1720        if (resource->type != VME_LM) {
1721                printk(KERN_ERR "Not a Location Monitor resource\n");
1722                return;
1723        }
1724
1725        lm = list_entry(resource->entry, struct vme_lm_resource, list);
1726
1727        mutex_lock(&lm->mtx);
1728
1729        /* XXX
1730         * Check to see that there aren't any callbacks still attached, if
1731         * there are we should probably be detaching them!
1732         */
1733
1734        lm->locked = 0;
1735
1736        mutex_unlock(&lm->mtx);
1737
1738        kfree(resource);
1739}
1740EXPORT_SYMBOL(vme_lm_free);
1741
1742/**
1743 * vme_slot_num - Retrieve slot ID
1744 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1745 *
1746 * Retrieve the slot ID associated with the provided VME device.
1747 *
1748 * Return: The slot ID on success, -EINVAL if VME bridge cannot be determined
1749 *         or the function is not supported. Hardware specific errors may also
1750 *         be returned.
1751 */
1752int vme_slot_num(struct vme_dev *vdev)
1753{
1754        struct vme_bridge *bridge;
1755
1756        bridge = vdev->bridge;
1757        if (!bridge) {
1758                printk(KERN_ERR "Can't find VME bus\n");
1759                return -EINVAL;
1760        }
1761
1762        if (!bridge->slot_get) {
1763                printk(KERN_WARNING "vme_slot_num not supported\n");
1764                return -EINVAL;
1765        }
1766
1767        return bridge->slot_get(bridge);
1768}
1769EXPORT_SYMBOL(vme_slot_num);
1770
1771/**
1772 * vme_bus_num - Retrieve bus number
1773 * @vdev: Pointer to VME device struct vme_dev assigned to driver instance.
1774 *
1775 * Retrieve the bus enumeration associated with the provided VME device.
1776 *
1777 * Return: The bus number on success, -EINVAL if VME bridge cannot be
1778 *         determined.
1779 */
1780int vme_bus_num(struct vme_dev *vdev)
1781{
1782        struct vme_bridge *bridge;
1783
1784        bridge = vdev->bridge;
1785        if (!bridge) {
1786                pr_err("Can't find VME bus\n");
1787                return -EINVAL;
1788        }
1789
1790        return bridge->num;
1791}
1792EXPORT_SYMBOL(vme_bus_num);
1793
1794/* - Bridge Registration --------------------------------------------------- */
1795
1796static void vme_dev_release(struct device *dev)
1797{
1798        kfree(dev_to_vme_dev(dev));
1799}
1800
1801/* Common bridge initialization */
1802struct vme_bridge *vme_init_bridge(struct vme_bridge *bridge)
1803{
1804        INIT_LIST_HEAD(&bridge->vme_error_handlers);
1805        INIT_LIST_HEAD(&bridge->master_resources);
1806        INIT_LIST_HEAD(&bridge->slave_resources);
1807        INIT_LIST_HEAD(&bridge->dma_resources);
1808        INIT_LIST_HEAD(&bridge->lm_resources);
1809        mutex_init(&bridge->irq_mtx);
1810
1811        return bridge;
1812}
1813EXPORT_SYMBOL(vme_init_bridge);
1814
1815int vme_register_bridge(struct vme_bridge *bridge)
1816{
1817        int i;
1818        int ret = -1;
1819
1820        mutex_lock(&vme_buses_lock);
1821        for (i = 0; i < sizeof(vme_bus_numbers) * 8; i++) {
1822                if ((vme_bus_numbers & (1 << i)) == 0) {
1823                        vme_bus_numbers |= (1 << i);
1824                        bridge->num = i;
1825                        INIT_LIST_HEAD(&bridge->devices);
1826                        list_add_tail(&bridge->bus_list, &vme_bus_list);
1827                        ret = 0;
1828                        break;
1829                }
1830        }
1831        mutex_unlock(&vme_buses_lock);
1832
1833        return ret;
1834}
1835EXPORT_SYMBOL(vme_register_bridge);
1836
1837void vme_unregister_bridge(struct vme_bridge *bridge)
1838{
1839        struct vme_dev *vdev;
1840        struct vme_dev *tmp;
1841
1842        mutex_lock(&vme_buses_lock);
1843        vme_bus_numbers &= ~(1 << bridge->num);
1844        list_for_each_entry_safe(vdev, tmp, &bridge->devices, bridge_list) {
1845                list_del(&vdev->drv_list);
1846                list_del(&vdev->bridge_list);
1847                device_unregister(&vdev->dev);
1848        }
1849        list_del(&bridge->bus_list);
1850        mutex_unlock(&vme_buses_lock);
1851}
1852EXPORT_SYMBOL(vme_unregister_bridge);
1853
1854/* - Driver Registration --------------------------------------------------- */
1855
1856static int __vme_register_driver_bus(struct vme_driver *drv,
1857        struct vme_bridge *bridge, unsigned int ndevs)
1858{
1859        int err;
1860        unsigned int i;
1861        struct vme_dev *vdev;
1862        struct vme_dev *tmp;
1863
1864        for (i = 0; i < ndevs; i++) {
1865                vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
1866                if (!vdev) {
1867                        err = -ENOMEM;
1868                        goto err_devalloc;
1869                }
1870                vdev->num = i;
1871                vdev->bridge = bridge;
1872                vdev->dev.platform_data = drv;
1873                vdev->dev.release = vme_dev_release;
1874                vdev->dev.parent = bridge->parent;
1875                vdev->dev.bus = &vme_bus_type;
1876                dev_set_name(&vdev->dev, "%s.%u-%u", drv->name, bridge->num,
1877                        vdev->num);
1878
1879                err = device_register(&vdev->dev);
1880                if (err)
1881                        goto err_reg;
1882
1883                if (vdev->dev.platform_data) {
1884                        list_add_tail(&vdev->drv_list, &drv->devices);
1885                        list_add_tail(&vdev->bridge_list, &bridge->devices);
1886                } else
1887                        device_unregister(&vdev->dev);
1888        }
1889        return 0;
1890
1891err_reg:
1892        put_device(&vdev->dev);
1893err_devalloc:
1894        list_for_each_entry_safe(vdev, tmp, &drv->devices, drv_list) {
1895                list_del(&vdev->drv_list);
1896                list_del(&vdev->bridge_list);
1897                device_unregister(&vdev->dev);
1898        }
1899        return err;
1900}
1901
1902static int __vme_register_driver(struct vme_driver *drv, unsigned int ndevs)
1903{
1904        struct vme_bridge *bridge;
1905        int err = 0;
1906
1907        mutex_lock(&vme_buses_lock);
1908        list_for_each_entry(bridge, &vme_bus_list, bus_list) {
1909                /*
1910                 * This cannot cause trouble as we already have vme_buses_lock
1911                 * and if the bridge is removed, it will have to go through
1912                 * vme_unregister_bridge() to do it (which calls remove() on
1913                 * the bridge which in turn tries to acquire vme_buses_lock and
1914                 * will have to wait).
1915                 */
1916                err = __vme_register_driver_bus(drv, bridge, ndevs);
1917                if (err)
1918                        break;
1919        }
1920        mutex_unlock(&vme_buses_lock);
1921        return err;
1922}
1923
1924/**
1925 * vme_register_driver - Register a VME driver
1926 * @drv: Pointer to VME driver structure to register.
1927 * @ndevs: Maximum number of devices to allow to be enumerated.
1928 *
1929 * Register a VME device driver with the VME subsystem.
1930 *
1931 * Return: Zero on success, error value on registration failure.
1932 */
1933int vme_register_driver(struct vme_driver *drv, unsigned int ndevs)
1934{
1935        int err;
1936
1937        drv->driver.name = drv->name;
1938        drv->driver.bus = &vme_bus_type;
1939        INIT_LIST_HEAD(&drv->devices);
1940
1941        err = driver_register(&drv->driver);
1942        if (err)
1943                return err;
1944
1945        err = __vme_register_driver(drv, ndevs);
1946        if (err)
1947                driver_unregister(&drv->driver);
1948
1949        return err;
1950}
1951EXPORT_SYMBOL(vme_register_driver);
1952
1953/**
1954 * vme_unregister_driver - Unregister a VME driver
1955 * @drv: Pointer to VME driver structure to unregister.
1956 *
1957 * Unregister a VME device driver from the VME subsystem.
1958 */
1959void vme_unregister_driver(struct vme_driver *drv)
1960{
1961        struct vme_dev *dev, *dev_tmp;
1962
1963        mutex_lock(&vme_buses_lock);
1964        list_for_each_entry_safe(dev, dev_tmp, &drv->devices, drv_list) {
1965                list_del(&dev->drv_list);
1966                list_del(&dev->bridge_list);
1967                device_unregister(&dev->dev);
1968        }
1969        mutex_unlock(&vme_buses_lock);
1970
1971        driver_unregister(&drv->driver);
1972}
1973EXPORT_SYMBOL(vme_unregister_driver);
1974
1975/* - Bus Registration ------------------------------------------------------ */
1976
1977static int vme_bus_match(struct device *dev, struct device_driver *drv)
1978{
1979        struct vme_driver *vme_drv;
1980
1981        vme_drv = container_of(drv, struct vme_driver, driver);
1982
1983        if (dev->platform_data == vme_drv) {
1984                struct vme_dev *vdev = dev_to_vme_dev(dev);
1985
1986                if (vme_drv->match && vme_drv->match(vdev))
1987                        return 1;
1988
1989                dev->platform_data = NULL;
1990        }
1991        return 0;
1992}
1993
1994static int vme_bus_probe(struct device *dev)
1995{
1996        struct vme_driver *driver;
1997        struct vme_dev *vdev = dev_to_vme_dev(dev);
1998
1999        driver = dev->platform_data;
2000        if (driver->probe)
2001                return driver->probe(vdev);
2002
2003        return -ENODEV;
2004}
2005
2006static int vme_bus_remove(struct device *dev)
2007{
2008        struct vme_driver *driver;
2009        struct vme_dev *vdev = dev_to_vme_dev(dev);
2010
2011        driver = dev->platform_data;
2012        if (driver->remove)
2013                return driver->remove(vdev);
2014
2015        return -ENODEV;
2016}
2017
2018struct bus_type vme_bus_type = {
2019        .name = "vme",
2020        .match = vme_bus_match,
2021        .probe = vme_bus_probe,
2022        .remove = vme_bus_remove,
2023};
2024EXPORT_SYMBOL(vme_bus_type);
2025
2026static int __init vme_init(void)
2027{
2028        return bus_register(&vme_bus_type);
2029}
2030subsys_initcall(vme_init);
2031