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/module.h> 17#include <linux/moduleparam.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 void __exit vme_exit(void); 43static int __init vme_init(void); 44 45static struct vme_dev *dev_to_vme_dev(struct device *dev) 46{ 47 return container_of(dev, struct vme_dev, dev); 48} 49 50/* 51 * Find the bridge that the resource is associated with. 52 */ 53static struct vme_bridge *find_bridge(struct vme_resource *resource) 54{ 55 /* Get list to search */ 56 switch (resource->type) { 57 case VME_MASTER: 58 return list_entry(resource->entry, struct vme_master_resource, 59 list)->parent; 60 break; 61 case VME_SLAVE: 62 return list_entry(resource->entry, struct vme_slave_resource, 63 list)->parent; 64 break; 65 case VME_DMA: 66 return list_entry(resource->entry, struct vme_dma_resource, 67 list)->parent; 68 break; 69 case VME_LM: 70 return list_entry(resource->entry, struct vme_lm_resource, 71 list)->parent; 72 break; 73 default: 74 printk(KERN_ERR "Unknown resource type\n"); 75 return NULL; 76 break; 77 } 78} 79 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 */ 84void *vme_alloc_consistent(struct vme_resource *resource, size_t size, 85 dma_addr_t *dma) 86{ 87 struct vme_bridge *bridge; 88 89 if (resource == NULL) { 90 printk(KERN_ERR "No resource\n"); 91 return NULL; 92 } 93 94 bridge = find_bridge(resource); 95 if (bridge == NULL) { 96 printk(KERN_ERR "Can't find bridge\n"); 97 return NULL; 98 } 99 100 if (bridge->parent == NULL) { 101 printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name); 102 return NULL; 103 } 104 105 if (bridge->alloc_consistent == NULL) { 106 printk(KERN_ERR "alloc_consistent not supported by bridge %s\n", 107 bridge->name); 108 return NULL; 109 } 110 111 return bridge->alloc_consistent(bridge->parent, size, dma); 112} 113EXPORT_SYMBOL(vme_alloc_consistent); 114 115/* 116 * Free previously allocated contiguous block of memory. 117 */ 118void vme_free_consistent(struct vme_resource *resource, size_t size, 119 void *vaddr, dma_addr_t dma) 120{ 121 struct vme_bridge *bridge; 122 123 if (resource == NULL) { 124 printk(KERN_ERR "No resource\n"); 125 return; 126 } 127 128 bridge = find_bridge(resource); 129 if (bridge == NULL) { 130 printk(KERN_ERR "Can't find bridge\n"); 131 return; 132 } 133 134 if (bridge->parent == NULL) { 135 printk(KERN_ERR "Dev entry NULL for bridge %s\n", bridge->name); 136 return; 137 } 138 139 if (bridge->free_consistent == NULL) { 140 printk(KERN_ERR "free_consistent not supported by bridge %s\n", 141 bridge->name); 142 return; 143 } 144 145 bridge->free_consistent(bridge->parent, size, vaddr, dma); 146} 147EXPORT_SYMBOL(vme_free_consistent); 148 149size_t vme_get_size(struct vme_resource *resource) 150{ 151 int enabled, retval; 152 unsigned long long base, size; 153 dma_addr_t buf_base; 154 u32 aspace, cycle, dwidth; 155 156 switch (resource->type) { 157 case VME_MASTER: 158 retval = vme_master_get(resource, &enabled, &base, &size, 159 &aspace, &cycle, &dwidth); 160 161 return size; 162 break; 163 case VME_SLAVE: 164 retval = vme_slave_get(resource, &enabled, &base, &size, 165 &buf_base, &aspace, &cycle); 166 167 return size; 168 break; 169 case VME_DMA: 170 return 0; 171 break; 172 default: 173 printk(KERN_ERR "Unknown resource type\n"); 174 return 0; 175 break; 176 } 177} 178EXPORT_SYMBOL(vme_get_size); 179 180int vme_check_window(u32 aspace, unsigned long long vme_base, 181 unsigned long long size) 182{ 183 int retval = 0; 184 185 switch (aspace) { 186 case VME_A16: 187 if (((vme_base + size) > VME_A16_MAX) || 188 (vme_base > VME_A16_MAX)) 189 retval = -EFAULT; 190 break; 191 case VME_A24: 192 if (((vme_base + size) > VME_A24_MAX) || 193 (vme_base > VME_A24_MAX)) 194 retval = -EFAULT; 195 break; 196 case VME_A32: 197 if (((vme_base + size) > VME_A32_MAX) || 198 (vme_base > VME_A32_MAX)) 199 retval = -EFAULT; 200 break; 201 case VME_A64: 202 if ((size != 0) && (vme_base > U64_MAX + 1 - size)) 203 retval = -EFAULT; 204 break; 205 case VME_CRCSR: 206 if (((vme_base + size) > VME_CRCSR_MAX) || 207 (vme_base > VME_CRCSR_MAX)) 208 retval = -EFAULT; 209 break; 210 case VME_USER1: 211 case VME_USER2: 212 case VME_USER3: 213 case VME_USER4: 214 /* User Defined */ 215 break; 216 default: 217 printk(KERN_ERR "Invalid address space\n"); 218 retval = -EINVAL; 219 break; 220 } 221 222 return retval; 223} 224EXPORT_SYMBOL(vme_check_window); 225 226static u32 vme_get_aspace(int am) 227{ 228 switch (am) { 229 case 0x29: 230 case 0x2D: 231 return VME_A16; 232 case 0x38: 233 case 0x39: 234 case 0x3A: 235 case 0x3B: 236 case 0x3C: 237 case 0x3D: 238 case 0x3E: 239 case 0x3F: 240 return VME_A24; 241 case 0x8: 242 case 0x9: 243 case 0xA: 244 case 0xB: 245 case 0xC: 246 case 0xD: 247 case 0xE: 248 case 0xF: 249 return VME_A32; 250 case 0x0: 251 case 0x1: 252 case 0x3: 253 return VME_A64; 254 } 255 256 return 0; 257} 258 259/* 260 * Request a slave image with specific attributes, return some unique 261 * identifier. 262 */ 263struct vme_resource *vme_slave_request(struct vme_dev *vdev, u32 address, 264 u32 cycle) 265{ 266 struct vme_bridge *bridge; 267 struct list_head *slave_pos = NULL; 268 struct vme_slave_resource *allocated_image = NULL; 269 struct vme_slave_resource *slave_image = NULL; 270 struct vme_resource *resource = NULL; 271 272 bridge = vdev->bridge; 273 if (bridge == NULL) { 274 printk(KERN_ERR "Can't find VME bus\n"); 275 goto err_bus; 276 } 277 278 /* Loop through slave resources */ 279 list_for_each(slave_pos, &bridge->slave_resources) { 280 slave_image = list_entry(slave_pos, 281 struct vme_slave_resource, list); 282 283 if (slave_image == NULL) { 284 printk(KERN_ERR "Registered NULL Slave resource\n"); 285 continue; 286 } 287 288 /* Find an unlocked and compatible image */ 289 mutex_lock(&slave_image->mtx); 290 if (((slave_image->address_attr & address) == address) && 291 ((slave_image->cycle_attr & cycle) == cycle) && 292 (slave_image->locked == 0)) { 293 294 slave_image->locked = 1; 295 mutex_unlock(&slave_image->mtx); 296 allocated_image = slave_image; 297 break; 298 } 299 mutex_unlock(&slave_image->mtx); 300 } 301 302 /* No free image */ 303 if (allocated_image == NULL) 304 goto err_image; 305 306 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL); 307 if (resource == NULL) { 308 printk(KERN_WARNING "Unable to allocate resource structure\n"); 309 goto err_alloc; 310 } 311 resource->type = VME_SLAVE; 312 resource->entry = &allocated_image->list; 313 314 return resource; 315 316err_alloc: 317 /* Unlock image */ 318 mutex_lock(&slave_image->mtx); 319 slave_image->locked = 0; 320 mutex_unlock(&slave_image->mtx); 321err_image: 322err_bus: 323 return NULL; 324} 325EXPORT_SYMBOL(vme_slave_request); 326 327int vme_slave_set(struct vme_resource *resource, int enabled, 328 unsigned long long vme_base, unsigned long long size, 329 dma_addr_t buf_base, u32 aspace, u32 cycle) 330{ 331 struct vme_bridge *bridge = find_bridge(resource); 332 struct vme_slave_resource *image; 333 int retval; 334 335 if (resource->type != VME_SLAVE) { 336 printk(KERN_ERR "Not a slave resource\n"); 337 return -EINVAL; 338 } 339 340 image = list_entry(resource->entry, struct vme_slave_resource, list); 341 342 if (bridge->slave_set == NULL) { 343 printk(KERN_ERR "Function not supported\n"); 344 return -ENOSYS; 345 } 346 347 if (!(((image->address_attr & aspace) == aspace) && 348 ((image->cycle_attr & cycle) == cycle))) { 349 printk(KERN_ERR "Invalid attributes\n"); 350 return -EINVAL; 351 } 352 353 retval = vme_check_window(aspace, vme_base, size); 354 if (retval) 355 return retval; 356 357 return bridge->slave_set(image, enabled, vme_base, size, buf_base, 358 aspace, cycle); 359} 360EXPORT_SYMBOL(vme_slave_set); 361 362int vme_slave_get(struct vme_resource *resource, int *enabled, 363 unsigned long long *vme_base, unsigned long long *size, 364 dma_addr_t *buf_base, u32 *aspace, u32 *cycle) 365{ 366 struct vme_bridge *bridge = find_bridge(resource); 367 struct vme_slave_resource *image; 368 369 if (resource->type != VME_SLAVE) { 370 printk(KERN_ERR "Not a slave resource\n"); 371 return -EINVAL; 372 } 373 374 image = list_entry(resource->entry, struct vme_slave_resource, list); 375 376 if (bridge->slave_get == NULL) { 377 printk(KERN_ERR "vme_slave_get not supported\n"); 378 return -EINVAL; 379 } 380 381 return bridge->slave_get(image, enabled, vme_base, size, buf_base, 382 aspace, cycle); 383} 384EXPORT_SYMBOL(vme_slave_get); 385 386void vme_slave_free(struct vme_resource *resource) 387{ 388 struct vme_slave_resource *slave_image; 389 390 if (resource->type != VME_SLAVE) { 391 printk(KERN_ERR "Not a slave resource\n"); 392 return; 393 } 394 395 slave_image = list_entry(resource->entry, struct vme_slave_resource, 396 list); 397 if (slave_image == NULL) { 398 printk(KERN_ERR "Can't find slave resource\n"); 399 return; 400 } 401 402 /* Unlock image */ 403 mutex_lock(&slave_image->mtx); 404 if (slave_image->locked == 0) 405 printk(KERN_ERR "Image is already free\n"); 406 407 slave_image->locked = 0; 408 mutex_unlock(&slave_image->mtx); 409 410 /* Free up resource memory */ 411 kfree(resource); 412} 413EXPORT_SYMBOL(vme_slave_free); 414 415/* 416 * Request a master image with specific attributes, return some unique 417 * identifier. 418 */ 419struct vme_resource *vme_master_request(struct vme_dev *vdev, u32 address, 420 u32 cycle, u32 dwidth) 421{ 422 struct vme_bridge *bridge; 423 struct list_head *master_pos = NULL; 424 struct vme_master_resource *allocated_image = NULL; 425 struct vme_master_resource *master_image = NULL; 426 struct vme_resource *resource = NULL; 427 428 bridge = vdev->bridge; 429 if (bridge == NULL) { 430 printk(KERN_ERR "Can't find VME bus\n"); 431 goto err_bus; 432 } 433 434 /* Loop through master resources */ 435 list_for_each(master_pos, &bridge->master_resources) { 436 master_image = list_entry(master_pos, 437 struct vme_master_resource, list); 438 439 if (master_image == NULL) { 440 printk(KERN_WARNING "Registered NULL master resource\n"); 441 continue; 442 } 443 444 /* Find an unlocked and compatible image */ 445 spin_lock(&master_image->lock); 446 if (((master_image->address_attr & address) == address) && 447 ((master_image->cycle_attr & cycle) == cycle) && 448 ((master_image->width_attr & dwidth) == dwidth) && 449 (master_image->locked == 0)) { 450 451 master_image->locked = 1; 452 spin_unlock(&master_image->lock); 453 allocated_image = master_image; 454 break; 455 } 456 spin_unlock(&master_image->lock); 457 } 458 459 /* Check to see if we found a resource */ 460 if (allocated_image == NULL) { 461 printk(KERN_ERR "Can't find a suitable resource\n"); 462 goto err_image; 463 } 464 465 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL); 466 if (resource == NULL) { 467 printk(KERN_ERR "Unable to allocate resource structure\n"); 468 goto err_alloc; 469 } 470 resource->type = VME_MASTER; 471 resource->entry = &allocated_image->list; 472 473 return resource; 474 475err_alloc: 476 /* Unlock image */ 477 spin_lock(&master_image->lock); 478 master_image->locked = 0; 479 spin_unlock(&master_image->lock); 480err_image: 481err_bus: 482 return NULL; 483} 484EXPORT_SYMBOL(vme_master_request); 485 486int vme_master_set(struct vme_resource *resource, int enabled, 487 unsigned long long vme_base, unsigned long long size, u32 aspace, 488 u32 cycle, u32 dwidth) 489{ 490 struct vme_bridge *bridge = find_bridge(resource); 491 struct vme_master_resource *image; 492 int retval; 493 494 if (resource->type != VME_MASTER) { 495 printk(KERN_ERR "Not a master resource\n"); 496 return -EINVAL; 497 } 498 499 image = list_entry(resource->entry, struct vme_master_resource, list); 500 501 if (bridge->master_set == NULL) { 502 printk(KERN_WARNING "vme_master_set not supported\n"); 503 return -EINVAL; 504 } 505 506 if (!(((image->address_attr & aspace) == aspace) && 507 ((image->cycle_attr & cycle) == cycle) && 508 ((image->width_attr & dwidth) == dwidth))) { 509 printk(KERN_WARNING "Invalid attributes\n"); 510 return -EINVAL; 511 } 512 513 retval = vme_check_window(aspace, vme_base, size); 514 if (retval) 515 return retval; 516 517 return bridge->master_set(image, enabled, vme_base, size, aspace, 518 cycle, dwidth); 519} 520EXPORT_SYMBOL(vme_master_set); 521 522int vme_master_get(struct vme_resource *resource, int *enabled, 523 unsigned long long *vme_base, unsigned long long *size, u32 *aspace, 524 u32 *cycle, u32 *dwidth) 525{ 526 struct vme_bridge *bridge = find_bridge(resource); 527 struct vme_master_resource *image; 528 529 if (resource->type != VME_MASTER) { 530 printk(KERN_ERR "Not a master resource\n"); 531 return -EINVAL; 532 } 533 534 image = list_entry(resource->entry, struct vme_master_resource, list); 535 536 if (bridge->master_get == NULL) { 537 printk(KERN_WARNING "%s not supported\n", __func__); 538 return -EINVAL; 539 } 540 541 return bridge->master_get(image, enabled, vme_base, size, aspace, 542 cycle, dwidth); 543} 544EXPORT_SYMBOL(vme_master_get); 545 546/* 547 * Read data out of VME space into a buffer. 548 */ 549ssize_t vme_master_read(struct vme_resource *resource, void *buf, size_t count, 550 loff_t offset) 551{ 552 struct vme_bridge *bridge = find_bridge(resource); 553 struct vme_master_resource *image; 554 size_t length; 555 556 if (bridge->master_read == NULL) { 557 printk(KERN_WARNING "Reading from resource not supported\n"); 558 return -EINVAL; 559 } 560 561 if (resource->type != VME_MASTER) { 562 printk(KERN_ERR "Not a master resource\n"); 563 return -EINVAL; 564 } 565 566 image = list_entry(resource->entry, struct vme_master_resource, list); 567 568 length = vme_get_size(resource); 569 570 if (offset > length) { 571 printk(KERN_WARNING "Invalid Offset\n"); 572 return -EFAULT; 573 } 574 575 if ((offset + count) > length) 576 count = length - offset; 577 578 return bridge->master_read(image, buf, count, offset); 579 580} 581EXPORT_SYMBOL(vme_master_read); 582 583/* 584 * Write data out to VME space from a buffer. 585 */ 586ssize_t vme_master_write(struct vme_resource *resource, void *buf, 587 size_t count, loff_t offset) 588{ 589 struct vme_bridge *bridge = find_bridge(resource); 590 struct vme_master_resource *image; 591 size_t length; 592 593 if (bridge->master_write == NULL) { 594 printk(KERN_WARNING "Writing to resource not supported\n"); 595 return -EINVAL; 596 } 597 598 if (resource->type != VME_MASTER) { 599 printk(KERN_ERR "Not a master resource\n"); 600 return -EINVAL; 601 } 602 603 image = list_entry(resource->entry, struct vme_master_resource, list); 604 605 length = vme_get_size(resource); 606 607 if (offset > length) { 608 printk(KERN_WARNING "Invalid Offset\n"); 609 return -EFAULT; 610 } 611 612 if ((offset + count) > length) 613 count = length - offset; 614 615 return bridge->master_write(image, buf, count, offset); 616} 617EXPORT_SYMBOL(vme_master_write); 618 619/* 620 * Perform RMW cycle to provided location. 621 */ 622unsigned int vme_master_rmw(struct vme_resource *resource, unsigned int mask, 623 unsigned int compare, unsigned int swap, loff_t offset) 624{ 625 struct vme_bridge *bridge = find_bridge(resource); 626 struct vme_master_resource *image; 627 628 if (bridge->master_rmw == NULL) { 629 printk(KERN_WARNING "Writing to resource not supported\n"); 630 return -EINVAL; 631 } 632 633 if (resource->type != VME_MASTER) { 634 printk(KERN_ERR "Not a master resource\n"); 635 return -EINVAL; 636 } 637 638 image = list_entry(resource->entry, struct vme_master_resource, list); 639 640 return bridge->master_rmw(image, mask, compare, swap, offset); 641} 642EXPORT_SYMBOL(vme_master_rmw); 643 644int vme_master_mmap(struct vme_resource *resource, struct vm_area_struct *vma) 645{ 646 struct vme_master_resource *image; 647 phys_addr_t phys_addr; 648 unsigned long vma_size; 649 650 if (resource->type != VME_MASTER) { 651 pr_err("Not a master resource\n"); 652 return -EINVAL; 653 } 654 655 image = list_entry(resource->entry, struct vme_master_resource, list); 656 phys_addr = image->bus_resource.start + (vma->vm_pgoff << PAGE_SHIFT); 657 vma_size = vma->vm_end - vma->vm_start; 658 659 if (phys_addr + vma_size > image->bus_resource.end + 1) { 660 pr_err("Map size cannot exceed the window size\n"); 661 return -EFAULT; 662 } 663 664 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 665 666 return vm_iomap_memory(vma, phys_addr, vma->vm_end - vma->vm_start); 667} 668EXPORT_SYMBOL(vme_master_mmap); 669 670void vme_master_free(struct vme_resource *resource) 671{ 672 struct vme_master_resource *master_image; 673 674 if (resource->type != VME_MASTER) { 675 printk(KERN_ERR "Not a master resource\n"); 676 return; 677 } 678 679 master_image = list_entry(resource->entry, struct vme_master_resource, 680 list); 681 if (master_image == NULL) { 682 printk(KERN_ERR "Can't find master resource\n"); 683 return; 684 } 685 686 /* Unlock image */ 687 spin_lock(&master_image->lock); 688 if (master_image->locked == 0) 689 printk(KERN_ERR "Image is already free\n"); 690 691 master_image->locked = 0; 692 spin_unlock(&master_image->lock); 693 694 /* Free up resource memory */ 695 kfree(resource); 696} 697EXPORT_SYMBOL(vme_master_free); 698 699/* 700 * Request a DMA controller with specific attributes, return some unique 701 * identifier. 702 */ 703struct vme_resource *vme_dma_request(struct vme_dev *vdev, u32 route) 704{ 705 struct vme_bridge *bridge; 706 struct list_head *dma_pos = NULL; 707 struct vme_dma_resource *allocated_ctrlr = NULL; 708 struct vme_dma_resource *dma_ctrlr = NULL; 709 struct vme_resource *resource = NULL; 710 711 /* XXX Not checking resource attributes */ 712 printk(KERN_ERR "No VME resource Attribute tests done\n"); 713 714 bridge = vdev->bridge; 715 if (bridge == NULL) { 716 printk(KERN_ERR "Can't find VME bus\n"); 717 goto err_bus; 718 } 719 720 /* Loop through DMA resources */ 721 list_for_each(dma_pos, &bridge->dma_resources) { 722 dma_ctrlr = list_entry(dma_pos, 723 struct vme_dma_resource, list); 724 725 if (dma_ctrlr == NULL) { 726 printk(KERN_ERR "Registered NULL DMA resource\n"); 727 continue; 728 } 729 730 /* Find an unlocked and compatible controller */ 731 mutex_lock(&dma_ctrlr->mtx); 732 if (((dma_ctrlr->route_attr & route) == route) && 733 (dma_ctrlr->locked == 0)) { 734 735 dma_ctrlr->locked = 1; 736 mutex_unlock(&dma_ctrlr->mtx); 737 allocated_ctrlr = dma_ctrlr; 738 break; 739 } 740 mutex_unlock(&dma_ctrlr->mtx); 741 } 742 743 /* Check to see if we found a resource */ 744 if (allocated_ctrlr == NULL) 745 goto err_ctrlr; 746 747 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL); 748 if (resource == NULL) { 749 printk(KERN_WARNING "Unable to allocate resource structure\n"); 750 goto err_alloc; 751 } 752 resource->type = VME_DMA; 753 resource->entry = &allocated_ctrlr->list; 754 755 return resource; 756 757err_alloc: 758 /* Unlock image */ 759 mutex_lock(&dma_ctrlr->mtx); 760 dma_ctrlr->locked = 0; 761 mutex_unlock(&dma_ctrlr->mtx); 762err_ctrlr: 763err_bus: 764 return NULL; 765} 766EXPORT_SYMBOL(vme_dma_request); 767 768/* 769 * Start new list 770 */ 771struct vme_dma_list *vme_new_dma_list(struct vme_resource *resource) 772{ 773 struct vme_dma_resource *ctrlr; 774 struct vme_dma_list *dma_list; 775 776 if (resource->type != VME_DMA) { 777 printk(KERN_ERR "Not a DMA resource\n"); 778 return NULL; 779 } 780 781 ctrlr = list_entry(resource->entry, struct vme_dma_resource, list); 782 783 dma_list = kmalloc(sizeof(struct vme_dma_list), GFP_KERNEL); 784 if (dma_list == NULL) { 785 printk(KERN_ERR "Unable to allocate memory for new dma list\n"); 786 return NULL; 787 } 788 INIT_LIST_HEAD(&dma_list->entries); 789 dma_list->parent = ctrlr; 790 mutex_init(&dma_list->mtx); 791 792 return dma_list; 793} 794EXPORT_SYMBOL(vme_new_dma_list); 795 796/* 797 * Create "Pattern" type attributes 798 */ 799struct vme_dma_attr *vme_dma_pattern_attribute(u32 pattern, u32 type) 800{ 801 struct vme_dma_attr *attributes; 802 struct vme_dma_pattern *pattern_attr; 803 804 attributes = kmalloc(sizeof(struct vme_dma_attr), GFP_KERNEL); 805 if (attributes == NULL) { 806 printk(KERN_ERR "Unable to allocate memory for attributes structure\n"); 807 goto err_attr; 808 } 809 810 pattern_attr = kmalloc(sizeof(struct vme_dma_pattern), GFP_KERNEL); 811 if (pattern_attr == NULL) { 812 printk(KERN_ERR "Unable to allocate memory for pattern attributes\n"); 813 goto err_pat; 814 } 815 816 attributes->type = VME_DMA_PATTERN; 817 attributes->private = (void *)pattern_attr; 818 819 pattern_attr->pattern = pattern; 820 pattern_attr->type = type; 821 822 return attributes; 823 824err_pat: 825 kfree(attributes); 826err_attr: 827 return NULL; 828} 829EXPORT_SYMBOL(vme_dma_pattern_attribute); 830 831/* 832 * Create "PCI" type attributes 833 */ 834struct vme_dma_attr *vme_dma_pci_attribute(dma_addr_t address) 835{ 836 struct vme_dma_attr *attributes; 837 struct vme_dma_pci *pci_attr; 838 839 /* XXX Run some sanity checks here */ 840 841 attributes = kmalloc(sizeof(struct vme_dma_attr), GFP_KERNEL); 842 if (attributes == NULL) { 843 printk(KERN_ERR "Unable to allocate memory for attributes structure\n"); 844 goto err_attr; 845 } 846 847 pci_attr = kmalloc(sizeof(struct vme_dma_pci), GFP_KERNEL); 848 if (pci_attr == NULL) { 849 printk(KERN_ERR "Unable to allocate memory for pci attributes\n"); 850 goto err_pci; 851 } 852 853 854 855 attributes->type = VME_DMA_PCI; 856 attributes->private = (void *)pci_attr; 857 858 pci_attr->address = address; 859 860 return attributes; 861 862err_pci: 863 kfree(attributes); 864err_attr: 865 return NULL; 866} 867EXPORT_SYMBOL(vme_dma_pci_attribute); 868 869/* 870 * Create "VME" type attributes 871 */ 872struct vme_dma_attr *vme_dma_vme_attribute(unsigned long long address, 873 u32 aspace, u32 cycle, u32 dwidth) 874{ 875 struct vme_dma_attr *attributes; 876 struct vme_dma_vme *vme_attr; 877 878 attributes = kmalloc( 879 sizeof(struct vme_dma_attr), GFP_KERNEL); 880 if (attributes == NULL) { 881 printk(KERN_ERR "Unable to allocate memory for attributes structure\n"); 882 goto err_attr; 883 } 884 885 vme_attr = kmalloc(sizeof(struct vme_dma_vme), GFP_KERNEL); 886 if (vme_attr == NULL) { 887 printk(KERN_ERR "Unable to allocate memory for vme attributes\n"); 888 goto err_vme; 889 } 890 891 attributes->type = VME_DMA_VME; 892 attributes->private = (void *)vme_attr; 893 894 vme_attr->address = address; 895 vme_attr->aspace = aspace; 896 vme_attr->cycle = cycle; 897 vme_attr->dwidth = dwidth; 898 899 return attributes; 900 901err_vme: 902 kfree(attributes); 903err_attr: 904 return NULL; 905} 906EXPORT_SYMBOL(vme_dma_vme_attribute); 907 908/* 909 * Free attribute 910 */ 911void vme_dma_free_attribute(struct vme_dma_attr *attributes) 912{ 913 kfree(attributes->private); 914 kfree(attributes); 915} 916EXPORT_SYMBOL(vme_dma_free_attribute); 917 918int vme_dma_list_add(struct vme_dma_list *list, struct vme_dma_attr *src, 919 struct vme_dma_attr *dest, size_t count) 920{ 921 struct vme_bridge *bridge = list->parent->parent; 922 int retval; 923 924 if (bridge->dma_list_add == NULL) { 925 printk(KERN_WARNING "Link List DMA generation not supported\n"); 926 return -EINVAL; 927 } 928 929 if (!mutex_trylock(&list->mtx)) { 930 printk(KERN_ERR "Link List already submitted\n"); 931 return -EINVAL; 932 } 933 934 retval = bridge->dma_list_add(list, src, dest, count); 935 936 mutex_unlock(&list->mtx); 937 938 return retval; 939} 940EXPORT_SYMBOL(vme_dma_list_add); 941 942int vme_dma_list_exec(struct vme_dma_list *list) 943{ 944 struct vme_bridge *bridge = list->parent->parent; 945 int retval; 946 947 if (bridge->dma_list_exec == NULL) { 948 printk(KERN_ERR "Link List DMA execution not supported\n"); 949 return -EINVAL; 950 } 951 952 mutex_lock(&list->mtx); 953 954 retval = bridge->dma_list_exec(list); 955 956 mutex_unlock(&list->mtx); 957 958 return retval; 959} 960EXPORT_SYMBOL(vme_dma_list_exec); 961 962int vme_dma_list_free(struct vme_dma_list *list) 963{ 964 struct vme_bridge *bridge = list->parent->parent; 965 int retval; 966 967 if (bridge->dma_list_empty == NULL) { 968 printk(KERN_WARNING "Emptying of Link Lists not supported\n"); 969 return -EINVAL; 970 } 971 972 if (!mutex_trylock(&list->mtx)) { 973 printk(KERN_ERR "Link List in use\n"); 974 return -EINVAL; 975 } 976 977 /* 978 * Empty out all of the entries from the dma list. We need to go to the 979 * low level driver as dma entries are driver specific. 980 */ 981 retval = bridge->dma_list_empty(list); 982 if (retval) { 983 printk(KERN_ERR "Unable to empty link-list entries\n"); 984 mutex_unlock(&list->mtx); 985 return retval; 986 } 987 mutex_unlock(&list->mtx); 988 kfree(list); 989 990 return retval; 991} 992EXPORT_SYMBOL(vme_dma_list_free); 993 994int vme_dma_free(struct vme_resource *resource) 995{ 996 struct vme_dma_resource *ctrlr; 997 998 if (resource->type != VME_DMA) { 999 printk(KERN_ERR "Not a DMA resource\n"); 1000 return -EINVAL; 1001 } 1002 1003 ctrlr = list_entry(resource->entry, struct vme_dma_resource, list); 1004 1005 if (!mutex_trylock(&ctrlr->mtx)) { 1006 printk(KERN_ERR "Resource busy, can't free\n"); 1007 return -EBUSY; 1008 } 1009 1010 if (!(list_empty(&ctrlr->pending) && list_empty(&ctrlr->running))) { 1011 printk(KERN_WARNING "Resource still processing transfers\n"); 1012 mutex_unlock(&ctrlr->mtx); 1013 return -EBUSY; 1014 } 1015 1016 ctrlr->locked = 0; 1017 1018 mutex_unlock(&ctrlr->mtx); 1019 1020 kfree(resource); 1021 1022 return 0; 1023} 1024EXPORT_SYMBOL(vme_dma_free); 1025 1026void vme_bus_error_handler(struct vme_bridge *bridge, 1027 unsigned long long address, int am) 1028{ 1029 struct list_head *handler_pos = NULL; 1030 struct vme_error_handler *handler; 1031 int handler_triggered = 0; 1032 u32 aspace = vme_get_aspace(am); 1033 1034 list_for_each(handler_pos, &bridge->vme_error_handlers) { 1035 handler = list_entry(handler_pos, struct vme_error_handler, 1036 list); 1037 if ((aspace == handler->aspace) && 1038 (address >= handler->start) && 1039 (address < handler->end)) { 1040 if (!handler->num_errors) 1041 handler->first_error = address; 1042 if (handler->num_errors != UINT_MAX) 1043 handler->num_errors++; 1044 handler_triggered = 1; 1045 } 1046 } 1047 1048 if (!handler_triggered) 1049 dev_err(bridge->parent, 1050 "Unhandled VME access error at address 0x%llx\n", 1051 address); 1052} 1053EXPORT_SYMBOL(vme_bus_error_handler); 1054 1055struct vme_error_handler *vme_register_error_handler( 1056 struct vme_bridge *bridge, u32 aspace, 1057 unsigned long long address, size_t len) 1058{ 1059 struct vme_error_handler *handler; 1060 1061 handler = kmalloc(sizeof(*handler), GFP_KERNEL); 1062 if (!handler) 1063 return NULL; 1064 1065 handler->aspace = aspace; 1066 handler->start = address; 1067 handler->end = address + len; 1068 handler->num_errors = 0; 1069 handler->first_error = 0; 1070 list_add_tail(&handler->list, &bridge->vme_error_handlers); 1071 1072 return handler; 1073} 1074EXPORT_SYMBOL(vme_register_error_handler); 1075 1076void vme_unregister_error_handler(struct vme_error_handler *handler) 1077{ 1078 list_del(&handler->list); 1079 kfree(handler); 1080} 1081EXPORT_SYMBOL(vme_unregister_error_handler); 1082 1083void vme_irq_handler(struct vme_bridge *bridge, int level, int statid) 1084{ 1085 void (*call)(int, int, void *); 1086 void *priv_data; 1087 1088 call = bridge->irq[level - 1].callback[statid].func; 1089 priv_data = bridge->irq[level - 1].callback[statid].priv_data; 1090 1091 if (call != NULL) 1092 call(level, statid, priv_data); 1093 else 1094 printk(KERN_WARNING "Spurilous VME interrupt, level:%x, vector:%x\n", 1095 level, statid); 1096} 1097EXPORT_SYMBOL(vme_irq_handler); 1098 1099int vme_irq_request(struct vme_dev *vdev, int level, int statid, 1100 void (*callback)(int, int, void *), 1101 void *priv_data) 1102{ 1103 struct vme_bridge *bridge; 1104 1105 bridge = vdev->bridge; 1106 if (bridge == NULL) { 1107 printk(KERN_ERR "Can't find VME bus\n"); 1108 return -EINVAL; 1109 } 1110 1111 if ((level < 1) || (level > 7)) { 1112 printk(KERN_ERR "Invalid interrupt level\n"); 1113 return -EINVAL; 1114 } 1115 1116 if (bridge->irq_set == NULL) { 1117 printk(KERN_ERR "Configuring interrupts not supported\n"); 1118 return -EINVAL; 1119 } 1120 1121 mutex_lock(&bridge->irq_mtx); 1122 1123 if (bridge->irq[level - 1].callback[statid].func) { 1124 mutex_unlock(&bridge->irq_mtx); 1125 printk(KERN_WARNING "VME Interrupt already taken\n"); 1126 return -EBUSY; 1127 } 1128 1129 bridge->irq[level - 1].count++; 1130 bridge->irq[level - 1].callback[statid].priv_data = priv_data; 1131 bridge->irq[level - 1].callback[statid].func = callback; 1132 1133 /* Enable IRQ level */ 1134 bridge->irq_set(bridge, level, 1, 1); 1135 1136 mutex_unlock(&bridge->irq_mtx); 1137 1138 return 0; 1139} 1140EXPORT_SYMBOL(vme_irq_request); 1141 1142void vme_irq_free(struct vme_dev *vdev, int level, int statid) 1143{ 1144 struct vme_bridge *bridge; 1145 1146 bridge = vdev->bridge; 1147 if (bridge == NULL) { 1148 printk(KERN_ERR "Can't find VME bus\n"); 1149 return; 1150 } 1151 1152 if ((level < 1) || (level > 7)) { 1153 printk(KERN_ERR "Invalid interrupt level\n"); 1154 return; 1155 } 1156 1157 if (bridge->irq_set == NULL) { 1158 printk(KERN_ERR "Configuring interrupts not supported\n"); 1159 return; 1160 } 1161 1162 mutex_lock(&bridge->irq_mtx); 1163 1164 bridge->irq[level - 1].count--; 1165 1166 /* Disable IRQ level if no more interrupts attached at this level*/ 1167 if (bridge->irq[level - 1].count == 0) 1168 bridge->irq_set(bridge, level, 0, 1); 1169 1170 bridge->irq[level - 1].callback[statid].func = NULL; 1171 bridge->irq[level - 1].callback[statid].priv_data = NULL; 1172 1173 mutex_unlock(&bridge->irq_mtx); 1174} 1175EXPORT_SYMBOL(vme_irq_free); 1176 1177int vme_irq_generate(struct vme_dev *vdev, int level, int statid) 1178{ 1179 struct vme_bridge *bridge; 1180 1181 bridge = vdev->bridge; 1182 if (bridge == NULL) { 1183 printk(KERN_ERR "Can't find VME bus\n"); 1184 return -EINVAL; 1185 } 1186 1187 if ((level < 1) || (level > 7)) { 1188 printk(KERN_WARNING "Invalid interrupt level\n"); 1189 return -EINVAL; 1190 } 1191 1192 if (bridge->irq_generate == NULL) { 1193 printk(KERN_WARNING "Interrupt generation not supported\n"); 1194 return -EINVAL; 1195 } 1196 1197 return bridge->irq_generate(bridge, level, statid); 1198} 1199EXPORT_SYMBOL(vme_irq_generate); 1200 1201/* 1202 * Request the location monitor, return resource or NULL 1203 */ 1204struct vme_resource *vme_lm_request(struct vme_dev *vdev) 1205{ 1206 struct vme_bridge *bridge; 1207 struct list_head *lm_pos = NULL; 1208 struct vme_lm_resource *allocated_lm = NULL; 1209 struct vme_lm_resource *lm = NULL; 1210 struct vme_resource *resource = NULL; 1211 1212 bridge = vdev->bridge; 1213 if (bridge == NULL) { 1214 printk(KERN_ERR "Can't find VME bus\n"); 1215 goto err_bus; 1216 } 1217 1218 /* Loop through DMA resources */ 1219 list_for_each(lm_pos, &bridge->lm_resources) { 1220 lm = list_entry(lm_pos, 1221 struct vme_lm_resource, list); 1222 1223 if (lm == NULL) { 1224 printk(KERN_ERR "Registered NULL Location Monitor resource\n"); 1225 continue; 1226 } 1227 1228 /* Find an unlocked controller */ 1229 mutex_lock(&lm->mtx); 1230 if (lm->locked == 0) { 1231 lm->locked = 1; 1232 mutex_unlock(&lm->mtx); 1233 allocated_lm = lm; 1234 break; 1235 } 1236 mutex_unlock(&lm->mtx); 1237 } 1238 1239 /* Check to see if we found a resource */ 1240 if (allocated_lm == NULL) 1241 goto err_lm; 1242 1243 resource = kmalloc(sizeof(struct vme_resource), GFP_KERNEL); 1244 if (resource == NULL) { 1245 printk(KERN_ERR "Unable to allocate resource structure\n"); 1246 goto err_alloc; 1247 } 1248 resource->type = VME_LM; 1249 resource->entry = &allocated_lm->list; 1250 1251 return resource; 1252 1253err_alloc: 1254 /* Unlock image */ 1255 mutex_lock(&lm->mtx); 1256 lm->locked = 0; 1257 mutex_unlock(&lm->mtx); 1258err_lm: 1259err_bus: 1260 return NULL; 1261} 1262EXPORT_SYMBOL(vme_lm_request); 1263 1264int vme_lm_count(struct vme_resource *resource) 1265{ 1266 struct vme_lm_resource *lm; 1267 1268 if (resource->type != VME_LM) { 1269 printk(KERN_ERR "Not a Location Monitor resource\n"); 1270 return -EINVAL; 1271 } 1272 1273 lm = list_entry(resource->entry, struct vme_lm_resource, list); 1274 1275 return lm->monitors; 1276} 1277EXPORT_SYMBOL(vme_lm_count); 1278 1279int vme_lm_set(struct vme_resource *resource, unsigned long long lm_base, 1280 u32 aspace, u32 cycle) 1281{ 1282 struct vme_bridge *bridge = find_bridge(resource); 1283 struct vme_lm_resource *lm; 1284 1285 if (resource->type != VME_LM) { 1286 printk(KERN_ERR "Not a Location Monitor resource\n"); 1287 return -EINVAL; 1288 } 1289 1290 lm = list_entry(resource->entry, struct vme_lm_resource, list); 1291 1292 if (bridge->lm_set == NULL) { 1293 printk(KERN_ERR "vme_lm_set not supported\n"); 1294 return -EINVAL; 1295 } 1296 1297 return bridge->lm_set(lm, lm_base, aspace, cycle); 1298} 1299EXPORT_SYMBOL(vme_lm_set); 1300 1301int vme_lm_get(struct vme_resource *resource, unsigned long long *lm_base, 1302 u32 *aspace, u32 *cycle) 1303{ 1304 struct vme_bridge *bridge = find_bridge(resource); 1305 struct vme_lm_resource *lm; 1306 1307 if (resource->type != VME_LM) { 1308 printk(KERN_ERR "Not a Location Monitor resource\n"); 1309 return -EINVAL; 1310 } 1311 1312 lm = list_entry(resource->entry, struct vme_lm_resource, list); 1313 1314 if (bridge->lm_get == NULL) { 1315 printk(KERN_ERR "vme_lm_get not supported\n"); 1316 return -EINVAL; 1317 } 1318 1319 return bridge->lm_get(lm, lm_base, aspace, cycle); 1320} 1321EXPORT_SYMBOL(vme_lm_get); 1322 1323int vme_lm_attach(struct vme_resource *resource, int monitor, 1324 void (*callback)(int)) 1325{ 1326 struct vme_bridge *bridge = find_bridge(resource); 1327 struct vme_lm_resource *lm; 1328 1329 if (resource->type != VME_LM) { 1330 printk(KERN_ERR "Not a Location Monitor resource\n"); 1331 return -EINVAL; 1332 } 1333 1334 lm = list_entry(resource->entry, struct vme_lm_resource, list); 1335 1336 if (bridge->lm_attach == NULL) { 1337 printk(KERN_ERR "vme_lm_attach not supported\n"); 1338 return -EINVAL; 1339 } 1340 1341 return bridge->lm_attach(lm, monitor, callback); 1342} 1343EXPORT_SYMBOL(vme_lm_attach); 1344 1345int vme_lm_detach(struct vme_resource *resource, int monitor) 1346{ 1347 struct vme_bridge *bridge = find_bridge(resource); 1348 struct vme_lm_resource *lm; 1349 1350 if (resource->type != VME_LM) { 1351 printk(KERN_ERR "Not a Location Monitor resource\n"); 1352 return -EINVAL; 1353 } 1354 1355 lm = list_entry(resource->entry, struct vme_lm_resource, list); 1356 1357 if (bridge->lm_detach == NULL) { 1358 printk(KERN_ERR "vme_lm_detach not supported\n"); 1359 return -EINVAL; 1360 } 1361 1362 return bridge->lm_detach(lm, monitor); 1363} 1364EXPORT_SYMBOL(vme_lm_detach); 1365 1366void vme_lm_free(struct vme_resource *resource) 1367{ 1368 struct vme_lm_resource *lm; 1369 1370 if (resource->type != VME_LM) { 1371 printk(KERN_ERR "Not a Location Monitor resource\n"); 1372 return; 1373 } 1374 1375 lm = list_entry(resource->entry, struct vme_lm_resource, list); 1376 1377 mutex_lock(&lm->mtx); 1378 1379 /* XXX 1380 * Check to see that there aren't any callbacks still attached, if 1381 * there are we should probably be detaching them! 1382 */ 1383 1384 lm->locked = 0; 1385 1386 mutex_unlock(&lm->mtx); 1387 1388 kfree(resource); 1389} 1390EXPORT_SYMBOL(vme_lm_free); 1391 1392int vme_slot_num(struct vme_dev *vdev) 1393{ 1394 struct vme_bridge *bridge; 1395 1396 bridge = vdev->bridge; 1397 if (bridge == NULL) { 1398 printk(KERN_ERR "Can't find VME bus\n"); 1399 return -EINVAL; 1400 } 1401 1402 if (bridge->slot_get == NULL) { 1403 printk(KERN_WARNING "vme_slot_num not supported\n"); 1404 return -EINVAL; 1405 } 1406 1407 return bridge->slot_get(bridge); 1408} 1409EXPORT_SYMBOL(vme_slot_num); 1410 1411int vme_bus_num(struct vme_dev *vdev) 1412{ 1413 struct vme_bridge *bridge; 1414 1415 bridge = vdev->bridge; 1416 if (bridge == NULL) { 1417 pr_err("Can't find VME bus\n"); 1418 return -EINVAL; 1419 } 1420 1421 return bridge->num; 1422} 1423EXPORT_SYMBOL(vme_bus_num); 1424 1425/* - Bridge Registration --------------------------------------------------- */ 1426 1427static void vme_dev_release(struct device *dev) 1428{ 1429 kfree(dev_to_vme_dev(dev)); 1430} 1431 1432int vme_register_bridge(struct vme_bridge *bridge) 1433{ 1434 int i; 1435 int ret = -1; 1436 1437 mutex_lock(&vme_buses_lock); 1438 for (i = 0; i < sizeof(vme_bus_numbers) * 8; i++) { 1439 if ((vme_bus_numbers & (1 << i)) == 0) { 1440 vme_bus_numbers |= (1 << i); 1441 bridge->num = i; 1442 INIT_LIST_HEAD(&bridge->devices); 1443 list_add_tail(&bridge->bus_list, &vme_bus_list); 1444 ret = 0; 1445 break; 1446 } 1447 } 1448 mutex_unlock(&vme_buses_lock); 1449 1450 return ret; 1451} 1452EXPORT_SYMBOL(vme_register_bridge); 1453 1454void vme_unregister_bridge(struct vme_bridge *bridge) 1455{ 1456 struct vme_dev *vdev; 1457 struct vme_dev *tmp; 1458 1459 mutex_lock(&vme_buses_lock); 1460 vme_bus_numbers &= ~(1 << bridge->num); 1461 list_for_each_entry_safe(vdev, tmp, &bridge->devices, bridge_list) { 1462 list_del(&vdev->drv_list); 1463 list_del(&vdev->bridge_list); 1464 device_unregister(&vdev->dev); 1465 } 1466 list_del(&bridge->bus_list); 1467 mutex_unlock(&vme_buses_lock); 1468} 1469EXPORT_SYMBOL(vme_unregister_bridge); 1470 1471/* - Driver Registration --------------------------------------------------- */ 1472 1473static int __vme_register_driver_bus(struct vme_driver *drv, 1474 struct vme_bridge *bridge, unsigned int ndevs) 1475{ 1476 int err; 1477 unsigned int i; 1478 struct vme_dev *vdev; 1479 struct vme_dev *tmp; 1480 1481 for (i = 0; i < ndevs; i++) { 1482 vdev = kzalloc(sizeof(struct vme_dev), GFP_KERNEL); 1483 if (!vdev) { 1484 err = -ENOMEM; 1485 goto err_devalloc; 1486 } 1487 vdev->num = i; 1488 vdev->bridge = bridge; 1489 vdev->dev.platform_data = drv; 1490 vdev->dev.release = vme_dev_release; 1491 vdev->dev.parent = bridge->parent; 1492 vdev->dev.bus = &vme_bus_type; 1493 dev_set_name(&vdev->dev, "%s.%u-%u", drv->name, bridge->num, 1494 vdev->num); 1495 1496 err = device_register(&vdev->dev); 1497 if (err) 1498 goto err_reg; 1499 1500 if (vdev->dev.platform_data) { 1501 list_add_tail(&vdev->drv_list, &drv->devices); 1502 list_add_tail(&vdev->bridge_list, &bridge->devices); 1503 } else 1504 device_unregister(&vdev->dev); 1505 } 1506 return 0; 1507 1508err_reg: 1509 put_device(&vdev->dev); 1510 kfree(vdev); 1511err_devalloc: 1512 list_for_each_entry_safe(vdev, tmp, &drv->devices, drv_list) { 1513 list_del(&vdev->drv_list); 1514 list_del(&vdev->bridge_list); 1515 device_unregister(&vdev->dev); 1516 } 1517 return err; 1518} 1519 1520static int __vme_register_driver(struct vme_driver *drv, unsigned int ndevs) 1521{ 1522 struct vme_bridge *bridge; 1523 int err = 0; 1524 1525 mutex_lock(&vme_buses_lock); 1526 list_for_each_entry(bridge, &vme_bus_list, bus_list) { 1527 /* 1528 * This cannot cause trouble as we already have vme_buses_lock 1529 * and if the bridge is removed, it will have to go through 1530 * vme_unregister_bridge() to do it (which calls remove() on 1531 * the bridge which in turn tries to acquire vme_buses_lock and 1532 * will have to wait). 1533 */ 1534 err = __vme_register_driver_bus(drv, bridge, ndevs); 1535 if (err) 1536 break; 1537 } 1538 mutex_unlock(&vme_buses_lock); 1539 return err; 1540} 1541 1542int vme_register_driver(struct vme_driver *drv, unsigned int ndevs) 1543{ 1544 int err; 1545 1546 drv->driver.name = drv->name; 1547 drv->driver.bus = &vme_bus_type; 1548 INIT_LIST_HEAD(&drv->devices); 1549 1550 err = driver_register(&drv->driver); 1551 if (err) 1552 return err; 1553 1554 err = __vme_register_driver(drv, ndevs); 1555 if (err) 1556 driver_unregister(&drv->driver); 1557 1558 return err; 1559} 1560EXPORT_SYMBOL(vme_register_driver); 1561 1562void vme_unregister_driver(struct vme_driver *drv) 1563{ 1564 struct vme_dev *dev, *dev_tmp; 1565 1566 mutex_lock(&vme_buses_lock); 1567 list_for_each_entry_safe(dev, dev_tmp, &drv->devices, drv_list) { 1568 list_del(&dev->drv_list); 1569 list_del(&dev->bridge_list); 1570 device_unregister(&dev->dev); 1571 } 1572 mutex_unlock(&vme_buses_lock); 1573 1574 driver_unregister(&drv->driver); 1575} 1576EXPORT_SYMBOL(vme_unregister_driver); 1577 1578/* - Bus Registration ------------------------------------------------------ */ 1579 1580static int vme_bus_match(struct device *dev, struct device_driver *drv) 1581{ 1582 struct vme_driver *vme_drv; 1583 1584 vme_drv = container_of(drv, struct vme_driver, driver); 1585 1586 if (dev->platform_data == vme_drv) { 1587 struct vme_dev *vdev = dev_to_vme_dev(dev); 1588 1589 if (vme_drv->match && vme_drv->match(vdev)) 1590 return 1; 1591 1592 dev->platform_data = NULL; 1593 } 1594 return 0; 1595} 1596 1597static int vme_bus_probe(struct device *dev) 1598{ 1599 int retval = -ENODEV; 1600 struct vme_driver *driver; 1601 struct vme_dev *vdev = dev_to_vme_dev(dev); 1602 1603 driver = dev->platform_data; 1604 1605 if (driver->probe != NULL) 1606 retval = driver->probe(vdev); 1607 1608 return retval; 1609} 1610 1611static int vme_bus_remove(struct device *dev) 1612{ 1613 int retval = -ENODEV; 1614 struct vme_driver *driver; 1615 struct vme_dev *vdev = dev_to_vme_dev(dev); 1616 1617 driver = dev->platform_data; 1618 1619 if (driver->remove != NULL) 1620 retval = driver->remove(vdev); 1621 1622 return retval; 1623} 1624 1625struct bus_type vme_bus_type = { 1626 .name = "vme", 1627 .match = vme_bus_match, 1628 .probe = vme_bus_probe, 1629 .remove = vme_bus_remove, 1630}; 1631EXPORT_SYMBOL(vme_bus_type); 1632 1633static int __init vme_init(void) 1634{ 1635 return bus_register(&vme_bus_type); 1636} 1637 1638static void __exit vme_exit(void) 1639{ 1640 bus_unregister(&vme_bus_type); 1641} 1642 1643subsys_initcall(vme_init); 1644module_exit(vme_exit); 1645