1/* 2 * AGPGART driver frontend 3 * Copyright (C) 2004 Silicon Graphics, Inc. 4 * Copyright (C) 2002-2003 Dave Jones 5 * Copyright (C) 1999 Jeff Hartmann 6 * Copyright (C) 1999 Precision Insight, Inc. 7 * Copyright (C) 1999 Xi Graphics, Inc. 8 * 9 * Permission is hereby granted, free of charge, to any person obtaining a 10 * copy of this software and associated documentation files (the "Software"), 11 * to deal in the Software without restriction, including without limitation 12 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 13 * and/or sell copies of the Software, and to permit persons to whom the 14 * Software is furnished to do so, subject to the following conditions: 15 * 16 * The above copyright notice and this permission notice shall be included 17 * in all copies or substantial portions of the Software. 18 * 19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 22 * JEFF HARTMANN, OR ANY OTHER CONTRIBUTORS BE LIABLE FOR ANY CLAIM, 23 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR 24 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE 25 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 26 * 27 */ 28 29#include <linux/types.h> 30#include <linux/kernel.h> 31#include <linux/module.h> 32#include <linux/mman.h> 33#include <linux/pci.h> 34#include <linux/init.h> 35#include <linux/miscdevice.h> 36#include <linux/agp_backend.h> 37#include <linux/agpgart.h> 38#include <linux/slab.h> 39#include <linux/mm.h> 40#include <linux/sched.h> 41#include <asm/uaccess.h> 42#include <asm/pgtable.h> 43#include "agp.h" 44 45struct agp_front_data agp_fe; 46 47struct agp_memory *agp_find_mem_by_key(int key) 48{ 49 struct agp_memory *curr; 50 51 if (agp_fe.current_controller == NULL) 52 return NULL; 53 54 curr = agp_fe.current_controller->pool; 55 56 while (curr != NULL) { 57 if (curr->key == key) 58 break; 59 curr = curr->next; 60 } 61 62 DBG("key=%d -> mem=%p", key, curr); 63 return curr; 64} 65 66static void agp_remove_from_pool(struct agp_memory *temp) 67{ 68 struct agp_memory *prev; 69 struct agp_memory *next; 70 71 /* Check to see if this is even in the memory pool */ 72 73 DBG("mem=%p", temp); 74 if (agp_find_mem_by_key(temp->key) != NULL) { 75 next = temp->next; 76 prev = temp->prev; 77 78 if (prev != NULL) { 79 prev->next = next; 80 if (next != NULL) 81 next->prev = prev; 82 83 } else { 84 /* This is the first item on the list */ 85 if (next != NULL) 86 next->prev = NULL; 87 88 agp_fe.current_controller->pool = next; 89 } 90 } 91} 92 93/* 94 * Routines for managing each client's segment list - 95 * These routines handle adding and removing segments 96 * to each auth'ed client. 97 */ 98 99static struct 100agp_segment_priv *agp_find_seg_in_client(const struct agp_client *client, 101 unsigned long offset, 102 int size, pgprot_t page_prot) 103{ 104 struct agp_segment_priv *seg; 105 int num_segments, i; 106 off_t pg_start; 107 size_t pg_count; 108 109 pg_start = offset / 4096; 110 pg_count = size / 4096; 111 seg = *(client->segments); 112 num_segments = client->num_segments; 113 114 for (i = 0; i < client->num_segments; i++) { 115 if ((seg[i].pg_start == pg_start) && 116 (seg[i].pg_count == pg_count) && 117 (pgprot_val(seg[i].prot) == pgprot_val(page_prot))) { 118 return seg + i; 119 } 120 } 121 122 return NULL; 123} 124 125static void agp_remove_seg_from_client(struct agp_client *client) 126{ 127 DBG("client=%p", client); 128 129 if (client->segments != NULL) { 130 if (*(client->segments) != NULL) { 131 DBG("Freeing %p from client %p", *(client->segments), client); 132 kfree(*(client->segments)); 133 } 134 DBG("Freeing %p from client %p", client->segments, client); 135 kfree(client->segments); 136 client->segments = NULL; 137 } 138} 139 140static void agp_add_seg_to_client(struct agp_client *client, 141 struct agp_segment_priv ** seg, int num_segments) 142{ 143 struct agp_segment_priv **prev_seg; 144 145 prev_seg = client->segments; 146 147 if (prev_seg != NULL) 148 agp_remove_seg_from_client(client); 149 150 DBG("Adding seg %p (%d segments) to client %p", seg, num_segments, client); 151 client->num_segments = num_segments; 152 client->segments = seg; 153} 154 155static pgprot_t agp_convert_mmap_flags(int prot) 156{ 157 unsigned long prot_bits; 158 159 prot_bits = calc_vm_prot_bits(prot) | VM_SHARED; 160 return vm_get_page_prot(prot_bits); 161} 162 163int agp_create_segment(struct agp_client *client, struct agp_region *region) 164{ 165 struct agp_segment_priv **ret_seg; 166 struct agp_segment_priv *seg; 167 struct agp_segment *user_seg; 168 size_t i; 169 170 seg = kzalloc((sizeof(struct agp_segment_priv) * region->seg_count), GFP_KERNEL); 171 if (seg == NULL) { 172 kfree(region->seg_list); 173 region->seg_list = NULL; 174 return -ENOMEM; 175 } 176 user_seg = region->seg_list; 177 178 for (i = 0; i < region->seg_count; i++) { 179 seg[i].pg_start = user_seg[i].pg_start; 180 seg[i].pg_count = user_seg[i].pg_count; 181 seg[i].prot = agp_convert_mmap_flags(user_seg[i].prot); 182 } 183 kfree(region->seg_list); 184 region->seg_list = NULL; 185 186 ret_seg = kmalloc(sizeof(void *), GFP_KERNEL); 187 if (ret_seg == NULL) { 188 kfree(seg); 189 return -ENOMEM; 190 } 191 *ret_seg = seg; 192 agp_add_seg_to_client(client, ret_seg, region->seg_count); 193 return 0; 194} 195 196/* End - Routines for managing each client's segment list */ 197 198/* This function must only be called when current_controller != NULL */ 199static void agp_insert_into_pool(struct agp_memory * temp) 200{ 201 struct agp_memory *prev; 202 203 prev = agp_fe.current_controller->pool; 204 205 if (prev != NULL) { 206 prev->prev = temp; 207 temp->next = prev; 208 } 209 agp_fe.current_controller->pool = temp; 210} 211 212 213/* File private list routines */ 214 215struct agp_file_private *agp_find_private(pid_t pid) 216{ 217 struct agp_file_private *curr; 218 219 curr = agp_fe.file_priv_list; 220 221 while (curr != NULL) { 222 if (curr->my_pid == pid) 223 return curr; 224 curr = curr->next; 225 } 226 227 return NULL; 228} 229 230static void agp_insert_file_private(struct agp_file_private * priv) 231{ 232 struct agp_file_private *prev; 233 234 prev = agp_fe.file_priv_list; 235 236 if (prev != NULL) 237 prev->prev = priv; 238 priv->next = prev; 239 agp_fe.file_priv_list = priv; 240} 241 242static void agp_remove_file_private(struct agp_file_private * priv) 243{ 244 struct agp_file_private *next; 245 struct agp_file_private *prev; 246 247 next = priv->next; 248 prev = priv->prev; 249 250 if (prev != NULL) { 251 prev->next = next; 252 253 if (next != NULL) 254 next->prev = prev; 255 256 } else { 257 if (next != NULL) 258 next->prev = NULL; 259 260 agp_fe.file_priv_list = next; 261 } 262} 263 264/* End - File flag list routines */ 265 266/* 267 * Wrappers for agp_free_memory & agp_allocate_memory 268 * These make sure that internal lists are kept updated. 269 */ 270void agp_free_memory_wrap(struct agp_memory *memory) 271{ 272 agp_remove_from_pool(memory); 273 agp_free_memory(memory); 274} 275 276struct agp_memory *agp_allocate_memory_wrap(size_t pg_count, u32 type) 277{ 278 struct agp_memory *memory; 279 280 memory = agp_allocate_memory(agp_bridge, pg_count, type); 281 if (memory == NULL) 282 return NULL; 283 284 agp_insert_into_pool(memory); 285 return memory; 286} 287 288/* Routines for managing the list of controllers - 289 * These routines manage the current controller, and the list of 290 * controllers 291 */ 292 293static struct agp_controller *agp_find_controller_by_pid(pid_t id) 294{ 295 struct agp_controller *controller; 296 297 controller = agp_fe.controllers; 298 299 while (controller != NULL) { 300 if (controller->pid == id) 301 return controller; 302 controller = controller->next; 303 } 304 305 return NULL; 306} 307 308static struct agp_controller *agp_create_controller(pid_t id) 309{ 310 struct agp_controller *controller; 311 312 controller = kzalloc(sizeof(struct agp_controller), GFP_KERNEL); 313 if (controller == NULL) 314 return NULL; 315 316 controller->pid = id; 317 return controller; 318} 319 320static int agp_insert_controller(struct agp_controller *controller) 321{ 322 struct agp_controller *prev_controller; 323 324 prev_controller = agp_fe.controllers; 325 controller->next = prev_controller; 326 327 if (prev_controller != NULL) 328 prev_controller->prev = controller; 329 330 agp_fe.controllers = controller; 331 332 return 0; 333} 334 335static void agp_remove_all_clients(struct agp_controller *controller) 336{ 337 struct agp_client *client; 338 struct agp_client *temp; 339 340 client = controller->clients; 341 342 while (client) { 343 struct agp_file_private *priv; 344 345 temp = client; 346 agp_remove_seg_from_client(temp); 347 priv = agp_find_private(temp->pid); 348 349 if (priv != NULL) { 350 clear_bit(AGP_FF_IS_VALID, &priv->access_flags); 351 clear_bit(AGP_FF_IS_CLIENT, &priv->access_flags); 352 } 353 client = client->next; 354 kfree(temp); 355 } 356} 357 358static void agp_remove_all_memory(struct agp_controller *controller) 359{ 360 struct agp_memory *memory; 361 struct agp_memory *temp; 362 363 memory = controller->pool; 364 365 while (memory) { 366 temp = memory; 367 memory = memory->next; 368 agp_free_memory_wrap(temp); 369 } 370} 371 372static int agp_remove_controller(struct agp_controller *controller) 373{ 374 struct agp_controller *prev_controller; 375 struct agp_controller *next_controller; 376 377 prev_controller = controller->prev; 378 next_controller = controller->next; 379 380 if (prev_controller != NULL) { 381 prev_controller->next = next_controller; 382 if (next_controller != NULL) 383 next_controller->prev = prev_controller; 384 385 } else { 386 if (next_controller != NULL) 387 next_controller->prev = NULL; 388 389 agp_fe.controllers = next_controller; 390 } 391 392 agp_remove_all_memory(controller); 393 agp_remove_all_clients(controller); 394 395 if (agp_fe.current_controller == controller) { 396 agp_fe.current_controller = NULL; 397 agp_fe.backend_acquired = FALSE; 398 agp_backend_release(agp_bridge); 399 } 400 kfree(controller); 401 return 0; 402} 403 404static void agp_controller_make_current(struct agp_controller *controller) 405{ 406 struct agp_client *clients; 407 408 clients = controller->clients; 409 410 while (clients != NULL) { 411 struct agp_file_private *priv; 412 413 priv = agp_find_private(clients->pid); 414 415 if (priv != NULL) { 416 set_bit(AGP_FF_IS_VALID, &priv->access_flags); 417 set_bit(AGP_FF_IS_CLIENT, &priv->access_flags); 418 } 419 clients = clients->next; 420 } 421 422 agp_fe.current_controller = controller; 423} 424 425static void agp_controller_release_current(struct agp_controller *controller, 426 struct agp_file_private *controller_priv) 427{ 428 struct agp_client *clients; 429 430 clear_bit(AGP_FF_IS_VALID, &controller_priv->access_flags); 431 clients = controller->clients; 432 433 while (clients != NULL) { 434 struct agp_file_private *priv; 435 436 priv = agp_find_private(clients->pid); 437 438 if (priv != NULL) 439 clear_bit(AGP_FF_IS_VALID, &priv->access_flags); 440 441 clients = clients->next; 442 } 443 444 agp_fe.current_controller = NULL; 445 agp_fe.used_by_controller = FALSE; 446 agp_backend_release(agp_bridge); 447} 448 449/* 450 * Routines for managing client lists - 451 * These routines are for managing the list of auth'ed clients. 452 */ 453 454static struct agp_client 455*agp_find_client_in_controller(struct agp_controller *controller, pid_t id) 456{ 457 struct agp_client *client; 458 459 if (controller == NULL) 460 return NULL; 461 462 client = controller->clients; 463 464 while (client != NULL) { 465 if (client->pid == id) 466 return client; 467 client = client->next; 468 } 469 470 return NULL; 471} 472 473static struct agp_controller *agp_find_controller_for_client(pid_t id) 474{ 475 struct agp_controller *controller; 476 477 controller = agp_fe.controllers; 478 479 while (controller != NULL) { 480 if ((agp_find_client_in_controller(controller, id)) != NULL) 481 return controller; 482 controller = controller->next; 483 } 484 485 return NULL; 486} 487 488struct agp_client *agp_find_client_by_pid(pid_t id) 489{ 490 struct agp_client *temp; 491 492 if (agp_fe.current_controller == NULL) 493 return NULL; 494 495 temp = agp_find_client_in_controller(agp_fe.current_controller, id); 496 return temp; 497} 498 499static void agp_insert_client(struct agp_client *client) 500{ 501 struct agp_client *prev_client; 502 503 prev_client = agp_fe.current_controller->clients; 504 client->next = prev_client; 505 506 if (prev_client != NULL) 507 prev_client->prev = client; 508 509 agp_fe.current_controller->clients = client; 510 agp_fe.current_controller->num_clients++; 511} 512 513struct agp_client *agp_create_client(pid_t id) 514{ 515 struct agp_client *new_client; 516 517 new_client = kzalloc(sizeof(struct agp_client), GFP_KERNEL); 518 if (new_client == NULL) 519 return NULL; 520 521 new_client->pid = id; 522 agp_insert_client(new_client); 523 return new_client; 524} 525 526int agp_remove_client(pid_t id) 527{ 528 struct agp_client *client; 529 struct agp_client *prev_client; 530 struct agp_client *next_client; 531 struct agp_controller *controller; 532 533 controller = agp_find_controller_for_client(id); 534 if (controller == NULL) 535 return -EINVAL; 536 537 client = agp_find_client_in_controller(controller, id); 538 if (client == NULL) 539 return -EINVAL; 540 541 prev_client = client->prev; 542 next_client = client->next; 543 544 if (prev_client != NULL) { 545 prev_client->next = next_client; 546 if (next_client != NULL) 547 next_client->prev = prev_client; 548 549 } else { 550 if (next_client != NULL) 551 next_client->prev = NULL; 552 controller->clients = next_client; 553 } 554 555 controller->num_clients--; 556 agp_remove_seg_from_client(client); 557 kfree(client); 558 return 0; 559} 560 561/* End - Routines for managing client lists */ 562 563/* File Operations */ 564 565static int agp_mmap(struct file *file, struct vm_area_struct *vma) 566{ 567 unsigned int size, current_size; 568 unsigned long offset; 569 struct agp_client *client; 570 struct agp_file_private *priv = file->private_data; 571 struct agp_kern_info kerninfo; 572 573 mutex_lock(&(agp_fe.agp_mutex)); 574 575 if (agp_fe.backend_acquired != TRUE) 576 goto out_eperm; 577 578 if (!(test_bit(AGP_FF_IS_VALID, &priv->access_flags))) 579 goto out_eperm; 580 581 agp_copy_info(agp_bridge, &kerninfo); 582 size = vma->vm_end - vma->vm_start; 583 current_size = kerninfo.aper_size; 584 current_size = current_size * 0x100000; 585 offset = vma->vm_pgoff << PAGE_SHIFT; 586 DBG("%lx:%lx", offset, offset+size); 587 588 if (test_bit(AGP_FF_IS_CLIENT, &priv->access_flags)) { 589 if ((size + offset) > current_size) 590 goto out_inval; 591 592 client = agp_find_client_by_pid(current->pid); 593 594 if (client == NULL) 595 goto out_eperm; 596 597 if (!agp_find_seg_in_client(client, offset, size, vma->vm_page_prot)) 598 goto out_inval; 599 600 DBG("client vm_ops=%p", kerninfo.vm_ops); 601 if (kerninfo.vm_ops) { 602 vma->vm_ops = kerninfo.vm_ops; 603 } else if (io_remap_pfn_range(vma, vma->vm_start, 604 (kerninfo.aper_base + offset) >> PAGE_SHIFT, 605 size, vma->vm_page_prot)) { 606 goto out_again; 607 } 608 mutex_unlock(&(agp_fe.agp_mutex)); 609 return 0; 610 } 611 612 if (test_bit(AGP_FF_IS_CONTROLLER, &priv->access_flags)) { 613 if (size != current_size) 614 goto out_inval; 615 616 DBG("controller vm_ops=%p", kerninfo.vm_ops); 617 if (kerninfo.vm_ops) { 618 vma->vm_ops = kerninfo.vm_ops; 619 } else if (io_remap_pfn_range(vma, vma->vm_start, 620 kerninfo.aper_base >> PAGE_SHIFT, 621 size, vma->vm_page_prot)) { 622 goto out_again; 623 } 624 mutex_unlock(&(agp_fe.agp_mutex)); 625 return 0; 626 } 627 628out_eperm: 629 mutex_unlock(&(agp_fe.agp_mutex)); 630 return -EPERM; 631 632out_inval: 633 mutex_unlock(&(agp_fe.agp_mutex)); 634 return -EINVAL; 635 636out_again: 637 mutex_unlock(&(agp_fe.agp_mutex)); 638 return -EAGAIN; 639} 640 641static int agp_release(struct inode *inode, struct file *file) 642{ 643 struct agp_file_private *priv = file->private_data; 644 645 mutex_lock(&(agp_fe.agp_mutex)); 646 647 DBG("priv=%p", priv); 648 649 if (test_bit(AGP_FF_IS_CONTROLLER, &priv->access_flags)) { 650 struct agp_controller *controller; 651 652 controller = agp_find_controller_by_pid(priv->my_pid); 653 654 if (controller != NULL) { 655 if (controller == agp_fe.current_controller) 656 agp_controller_release_current(controller, priv); 657 agp_remove_controller(controller); 658 controller = NULL; 659 } 660 } 661 662 if (test_bit(AGP_FF_IS_CLIENT, &priv->access_flags)) 663 agp_remove_client(priv->my_pid); 664 665 agp_remove_file_private(priv); 666 kfree(priv); 667 file->private_data = NULL; 668 mutex_unlock(&(agp_fe.agp_mutex)); 669 return 0; 670} 671 672static int agp_open(struct inode *inode, struct file *file) 673{ 674 int minor = iminor(inode); 675 struct agp_file_private *priv; 676 struct agp_client *client; 677 int rc = -ENXIO; 678 679 mutex_lock(&(agp_fe.agp_mutex)); 680 681 if (minor != AGPGART_MINOR) 682 goto err_out; 683 684 priv = kzalloc(sizeof(struct agp_file_private), GFP_KERNEL); 685 if (priv == NULL) 686 goto err_out_nomem; 687 688 set_bit(AGP_FF_ALLOW_CLIENT, &priv->access_flags); 689 priv->my_pid = current->pid; 690 691 if ((current->uid == 0) || (current->suid == 0)) { 692 /* Root priv, can be controller */ 693 set_bit(AGP_FF_ALLOW_CONTROLLER, &priv->access_flags); 694 } 695 client = agp_find_client_by_pid(current->pid); 696 697 if (client != NULL) { 698 set_bit(AGP_FF_IS_CLIENT, &priv->access_flags); 699 set_bit(AGP_FF_IS_VALID, &priv->access_flags); 700 } 701 file->private_data = (void *) priv; 702 agp_insert_file_private(priv); 703 DBG("private=%p, client=%p", priv, client); 704 mutex_unlock(&(agp_fe.agp_mutex)); 705 return 0; 706 707err_out_nomem: 708 rc = -ENOMEM; 709err_out: 710 mutex_unlock(&(agp_fe.agp_mutex)); 711 return rc; 712} 713 714 715static ssize_t agp_read(struct file *file, char __user *buf, 716 size_t count, loff_t * ppos) 717{ 718 return -EINVAL; 719} 720 721static ssize_t agp_write(struct file *file, const char __user *buf, 722 size_t count, loff_t * ppos) 723{ 724 return -EINVAL; 725} 726 727static int agpioc_info_wrap(struct agp_file_private *priv, void __user *arg) 728{ 729 struct agp_info userinfo; 730 struct agp_kern_info kerninfo; 731 732 agp_copy_info(agp_bridge, &kerninfo); 733 734 userinfo.version.major = kerninfo.version.major; 735 userinfo.version.minor = kerninfo.version.minor; 736 userinfo.bridge_id = kerninfo.device->vendor | 737 (kerninfo.device->device << 16); 738 userinfo.agp_mode = kerninfo.mode; 739 userinfo.aper_base = kerninfo.aper_base; 740 userinfo.aper_size = kerninfo.aper_size; 741 userinfo.pg_total = userinfo.pg_system = kerninfo.max_memory; 742 userinfo.pg_used = kerninfo.current_memory; 743 744 if (copy_to_user(arg, &userinfo, sizeof(struct agp_info))) 745 return -EFAULT; 746 747 return 0; 748} 749 750int agpioc_acquire_wrap(struct agp_file_private *priv) 751{ 752 struct agp_controller *controller; 753 754 DBG(""); 755 756 if (!(test_bit(AGP_FF_ALLOW_CONTROLLER, &priv->access_flags))) 757 return -EPERM; 758 759 if (agp_fe.current_controller != NULL) 760 return -EBUSY; 761 762 if (!agp_bridge) 763 return -ENODEV; 764 765 if (atomic_read(&agp_bridge->agp_in_use)) 766 return -EBUSY; 767 768 atomic_inc(&agp_bridge->agp_in_use); 769 770 agp_fe.backend_acquired = TRUE; 771 772 controller = agp_find_controller_by_pid(priv->my_pid); 773 774 if (controller != NULL) { 775 agp_controller_make_current(controller); 776 } else { 777 controller = agp_create_controller(priv->my_pid); 778 779 if (controller == NULL) { 780 agp_fe.backend_acquired = FALSE; 781 agp_backend_release(agp_bridge); 782 return -ENOMEM; 783 } 784 agp_insert_controller(controller); 785 agp_controller_make_current(controller); 786 } 787 788 set_bit(AGP_FF_IS_CONTROLLER, &priv->access_flags); 789 set_bit(AGP_FF_IS_VALID, &priv->access_flags); 790 return 0; 791} 792 793int agpioc_release_wrap(struct agp_file_private *priv) 794{ 795 DBG(""); 796 agp_controller_release_current(agp_fe.current_controller, priv); 797 return 0; 798} 799 800int agpioc_setup_wrap(struct agp_file_private *priv, void __user *arg) 801{ 802 struct agp_setup mode; 803 804 DBG(""); 805 if (copy_from_user(&mode, arg, sizeof(struct agp_setup))) 806 return -EFAULT; 807 808 agp_enable(agp_bridge, mode.agp_mode); 809 return 0; 810} 811 812static int agpioc_reserve_wrap(struct agp_file_private *priv, void __user *arg) 813{ 814 struct agp_region reserve; 815 struct agp_client *client; 816 struct agp_file_private *client_priv; 817 818 DBG(""); 819 if (copy_from_user(&reserve, arg, sizeof(struct agp_region))) 820 return -EFAULT; 821 822 if ((unsigned) reserve.seg_count >= ~0U/sizeof(struct agp_segment)) 823 return -EFAULT; 824 825 client = agp_find_client_by_pid(reserve.pid); 826 827 if (reserve.seg_count == 0) { 828 /* remove a client */ 829 client_priv = agp_find_private(reserve.pid); 830 831 if (client_priv != NULL) { 832 set_bit(AGP_FF_IS_CLIENT, &client_priv->access_flags); 833 set_bit(AGP_FF_IS_VALID, &client_priv->access_flags); 834 } 835 if (client == NULL) { 836 /* client is already removed */ 837 return 0; 838 } 839 return agp_remove_client(reserve.pid); 840 } else { 841 struct agp_segment *segment; 842 843 if (reserve.seg_count >= 16384) 844 return -EINVAL; 845 846 segment = kmalloc((sizeof(struct agp_segment) * reserve.seg_count), 847 GFP_KERNEL); 848 849 if (segment == NULL) 850 return -ENOMEM; 851 852 if (copy_from_user(segment, (void __user *) reserve.seg_list, 853 sizeof(struct agp_segment) * reserve.seg_count)) { 854 kfree(segment); 855 return -EFAULT; 856 } 857 reserve.seg_list = segment; 858 859 if (client == NULL) { 860 /* Create the client and add the segment */ 861 client = agp_create_client(reserve.pid); 862 863 if (client == NULL) { 864 kfree(segment); 865 return -ENOMEM; 866 } 867 client_priv = agp_find_private(reserve.pid); 868 869 if (client_priv != NULL) { 870 set_bit(AGP_FF_IS_CLIENT, &client_priv->access_flags); 871 set_bit(AGP_FF_IS_VALID, &client_priv->access_flags); 872 } 873 } 874 return agp_create_segment(client, &reserve); 875 } 876 /* Will never really happen */ 877 return -EINVAL; 878} 879 880int agpioc_protect_wrap(struct agp_file_private *priv) 881{ 882 DBG(""); 883 /* This function is not currently implemented */ 884 return -EINVAL; 885} 886 887static int agpioc_allocate_wrap(struct agp_file_private *priv, void __user *arg) 888{ 889 struct agp_memory *memory; 890 struct agp_allocate alloc; 891 892 DBG(""); 893 if (copy_from_user(&alloc, arg, sizeof(struct agp_allocate))) 894 return -EFAULT; 895 896 if (alloc.type >= AGP_USER_TYPES) 897 return -EINVAL; 898 899 memory = agp_allocate_memory_wrap(alloc.pg_count, alloc.type); 900 901 if (memory == NULL) 902 return -ENOMEM; 903 904 alloc.key = memory->key; 905 alloc.physical = memory->physical; 906 907 if (copy_to_user(arg, &alloc, sizeof(struct agp_allocate))) { 908 agp_free_memory_wrap(memory); 909 return -EFAULT; 910 } 911 return 0; 912} 913 914int agpioc_deallocate_wrap(struct agp_file_private *priv, int arg) 915{ 916 struct agp_memory *memory; 917 918 DBG(""); 919 memory = agp_find_mem_by_key(arg); 920 921 if (memory == NULL) 922 return -EINVAL; 923 924 agp_free_memory_wrap(memory); 925 return 0; 926} 927 928static int agpioc_bind_wrap(struct agp_file_private *priv, void __user *arg) 929{ 930 struct agp_bind bind_info; 931 struct agp_memory *memory; 932 933 DBG(""); 934 if (copy_from_user(&bind_info, arg, sizeof(struct agp_bind))) 935 return -EFAULT; 936 937 memory = agp_find_mem_by_key(bind_info.key); 938 939 if (memory == NULL) 940 return -EINVAL; 941 942 return agp_bind_memory(memory, bind_info.pg_start); 943} 944 945static int agpioc_unbind_wrap(struct agp_file_private *priv, void __user *arg) 946{ 947 struct agp_memory *memory; 948 struct agp_unbind unbind; 949 950 DBG(""); 951 if (copy_from_user(&unbind, arg, sizeof(struct agp_unbind))) 952 return -EFAULT; 953 954 memory = agp_find_mem_by_key(unbind.key); 955 956 if (memory == NULL) 957 return -EINVAL; 958 959 return agp_unbind_memory(memory); 960} 961 962static int agp_ioctl(struct inode *inode, struct file *file, 963 unsigned int cmd, unsigned long arg) 964{ 965 struct agp_file_private *curr_priv = file->private_data; 966 int ret_val = -ENOTTY; 967 968 DBG("priv=%p, cmd=%x", curr_priv, cmd); 969 mutex_lock(&(agp_fe.agp_mutex)); 970 971 if ((agp_fe.current_controller == NULL) && 972 (cmd != AGPIOC_ACQUIRE)) { 973 ret_val = -EINVAL; 974 goto ioctl_out; 975 } 976 if ((agp_fe.backend_acquired != TRUE) && 977 (cmd != AGPIOC_ACQUIRE)) { 978 ret_val = -EBUSY; 979 goto ioctl_out; 980 } 981 if (cmd != AGPIOC_ACQUIRE) { 982 if (!(test_bit(AGP_FF_IS_CONTROLLER, &curr_priv->access_flags))) { 983 ret_val = -EPERM; 984 goto ioctl_out; 985 } 986 /* Use the original pid of the controller, 987 * in case it's threaded */ 988 989 if (agp_fe.current_controller->pid != curr_priv->my_pid) { 990 ret_val = -EBUSY; 991 goto ioctl_out; 992 } 993 } 994 995 switch (cmd) { 996 case AGPIOC_INFO: 997 ret_val = agpioc_info_wrap(curr_priv, (void __user *) arg); 998 break; 999 1000 case AGPIOC_ACQUIRE: 1001 ret_val = agpioc_acquire_wrap(curr_priv); 1002 break; 1003 1004 case AGPIOC_RELEASE: 1005 ret_val = agpioc_release_wrap(curr_priv); 1006 break; 1007 1008 case AGPIOC_SETUP: 1009 ret_val = agpioc_setup_wrap(curr_priv, (void __user *) arg); 1010 break; 1011 1012 case AGPIOC_RESERVE: 1013 ret_val = agpioc_reserve_wrap(curr_priv, (void __user *) arg); 1014 break; 1015 1016 case AGPIOC_PROTECT: 1017 ret_val = agpioc_protect_wrap(curr_priv); 1018 break; 1019 1020 case AGPIOC_ALLOCATE: 1021 ret_val = agpioc_allocate_wrap(curr_priv, (void __user *) arg); 1022 break; 1023 1024 case AGPIOC_DEALLOCATE: 1025 ret_val = agpioc_deallocate_wrap(curr_priv, (int) arg); 1026 break; 1027 1028 case AGPIOC_BIND: 1029 ret_val = agpioc_bind_wrap(curr_priv, (void __user *) arg); 1030 break; 1031 1032 case AGPIOC_UNBIND: 1033 ret_val = agpioc_unbind_wrap(curr_priv, (void __user *) arg); 1034 break; 1035 } 1036 1037ioctl_out: 1038 DBG("ioctl returns %d\n", ret_val); 1039 mutex_unlock(&(agp_fe.agp_mutex)); 1040 return ret_val; 1041} 1042 1043static const struct file_operations agp_fops = 1044{ 1045 .owner = THIS_MODULE, 1046 .llseek = no_llseek, 1047 .read = agp_read, 1048 .write = agp_write, 1049 .ioctl = agp_ioctl, 1050#ifdef CONFIG_COMPAT 1051 .compat_ioctl = compat_agp_ioctl, 1052#endif 1053 .mmap = agp_mmap, 1054 .open = agp_open, 1055 .release = agp_release, 1056}; 1057 1058static struct miscdevice agp_miscdev = 1059{ 1060 .minor = AGPGART_MINOR, 1061 .name = "agpgart", 1062 .fops = &agp_fops 1063}; 1064 1065int agp_frontend_initialize(void) 1066{ 1067 memset(&agp_fe, 0, sizeof(struct agp_front_data)); 1068 mutex_init(&(agp_fe.agp_mutex)); 1069 1070 if (misc_register(&agp_miscdev)) { 1071 printk(KERN_ERR PFX "unable to get minor: %d\n", AGPGART_MINOR); 1072 return -EIO; 1073 } 1074 return 0; 1075} 1076 1077void agp_frontend_cleanup(void) 1078{ 1079 misc_deregister(&agp_miscdev); 1080} 1081