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