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/miscdevice.h> |
35 | #include <linux/agp_backend.h> |
36 | #include <linux/agpgart.h> |
37 | #include <linux/slab.h> |
38 | #include <linux/mm.h> |
39 | #include <linux/fs.h> |
40 | #include <linux/sched.h> |
41 | #include <linux/uaccess.h> |
42 | |
43 | #include "agp.h" |
44 | #include "compat_ioctl.h" |
45 | |
46 | struct agp_front_data agp_fe; |
47 | |
48 | struct agp_memory *agp_find_mem_by_key(int key) |
49 | { |
50 | struct agp_memory *curr; |
51 | |
52 | if (agp_fe.current_controller == NULL) |
53 | return NULL; |
54 | |
55 | curr = agp_fe.current_controller->pool; |
56 | |
57 | while (curr != NULL) { |
58 | if (curr->key == key) |
59 | break; |
60 | curr = curr->next; |
61 | } |
62 | |
63 | DBG("key=%d -> mem=%p" , key, curr); |
64 | return curr; |
65 | } |
66 | |
67 | static void agp_remove_from_pool(struct agp_memory *temp) |
68 | { |
69 | struct agp_memory *prev; |
70 | struct agp_memory *next; |
71 | |
72 | /* Check to see if this is even in the memory pool */ |
73 | |
74 | DBG("mem=%p" , temp); |
75 | if (agp_find_mem_by_key(key: temp->key) != NULL) { |
76 | next = temp->next; |
77 | prev = temp->prev; |
78 | |
79 | if (prev != NULL) { |
80 | prev->next = next; |
81 | if (next != NULL) |
82 | next->prev = prev; |
83 | |
84 | } else { |
85 | /* This is the first item on the list */ |
86 | if (next != NULL) |
87 | next->prev = NULL; |
88 | |
89 | agp_fe.current_controller->pool = next; |
90 | } |
91 | } |
92 | } |
93 | |
94 | /* |
95 | * Routines for managing each client's segment list - |
96 | * These routines handle adding and removing segments |
97 | * to each auth'ed client. |
98 | */ |
99 | |
100 | static struct |
101 | agp_segment_priv *agp_find_seg_in_client(const struct agp_client *client, |
102 | unsigned long offset, |
103 | int size, pgprot_t page_prot) |
104 | { |
105 | struct agp_segment_priv *seg; |
106 | int i; |
107 | off_t pg_start; |
108 | size_t pg_count; |
109 | |
110 | pg_start = offset / 4096; |
111 | pg_count = size / 4096; |
112 | seg = *(client->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 | |
125 | static 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(objp: *(client->segments)); |
133 | } |
134 | DBG("Freeing %p from client %p" , client->segments, client); |
135 | kfree(objp: client->segments); |
136 | client->segments = NULL; |
137 | } |
138 | } |
139 | |
140 | static 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 | |
155 | static pgprot_t agp_convert_mmap_flags(int prot) |
156 | { |
157 | unsigned long prot_bits; |
158 | |
159 | prot_bits = calc_vm_prot_bits(prot, pkey: 0) | VM_SHARED; |
160 | return vm_get_page_prot(vm_flags: prot_bits); |
161 | } |
162 | |
163 | int 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(size: (sizeof(struct agp_segment_priv) * region->seg_count), GFP_KERNEL); |
171 | if (seg == NULL) { |
172 | kfree(objp: 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(prot: user_seg[i].prot); |
182 | } |
183 | kfree(objp: region->seg_list); |
184 | region->seg_list = NULL; |
185 | |
186 | ret_seg = kmalloc(size: sizeof(void *), GFP_KERNEL); |
187 | if (ret_seg == NULL) { |
188 | kfree(objp: seg); |
189 | return -ENOMEM; |
190 | } |
191 | *ret_seg = seg; |
192 | agp_add_seg_to_client(client, seg: ret_seg, num_segments: 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 */ |
199 | static 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 | |
215 | struct 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 | |
230 | static 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 | |
242 | static 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 | */ |
270 | void agp_free_memory_wrap(struct agp_memory *memory) |
271 | { |
272 | agp_remove_from_pool(temp: memory); |
273 | agp_free_memory(memory); |
274 | } |
275 | |
276 | struct 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(temp: 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 | |
293 | static 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 | |
308 | static struct agp_controller *agp_create_controller(pid_t id) |
309 | { |
310 | struct agp_controller *controller; |
311 | |
312 | controller = kzalloc(size: sizeof(struct agp_controller), GFP_KERNEL); |
313 | if (controller == NULL) |
314 | return NULL; |
315 | |
316 | controller->pid = id; |
317 | return controller; |
318 | } |
319 | |
320 | static 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 | |
335 | static 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(client: temp); |
347 | priv = agp_find_private(pid: temp->pid); |
348 | |
349 | if (priv != NULL) { |
350 | clear_bit(AGP_FF_IS_VALID, addr: &priv->access_flags); |
351 | clear_bit(AGP_FF_IS_CLIENT, addr: &priv->access_flags); |
352 | } |
353 | client = client->next; |
354 | kfree(objp: temp); |
355 | } |
356 | } |
357 | |
358 | static 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(memory: temp); |
369 | } |
370 | } |
371 | |
372 | static 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(objp: controller); |
401 | return 0; |
402 | } |
403 | |
404 | static 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(pid: clients->pid); |
414 | |
415 | if (priv != NULL) { |
416 | set_bit(AGP_FF_IS_VALID, addr: &priv->access_flags); |
417 | set_bit(AGP_FF_IS_CLIENT, addr: &priv->access_flags); |
418 | } |
419 | clients = clients->next; |
420 | } |
421 | |
422 | agp_fe.current_controller = controller; |
423 | } |
424 | |
425 | static 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, addr: &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(pid: clients->pid); |
437 | |
438 | if (priv != NULL) |
439 | clear_bit(AGP_FF_IS_VALID, addr: &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 | |
454 | static 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 | |
473 | static 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 | |
488 | struct 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(controller: agp_fe.current_controller, id); |
496 | return temp; |
497 | } |
498 | |
499 | static 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 | |
513 | struct agp_client *agp_create_client(pid_t id) |
514 | { |
515 | struct agp_client *new_client; |
516 | |
517 | new_client = kzalloc(size: sizeof(struct agp_client), GFP_KERNEL); |
518 | if (new_client == NULL) |
519 | return NULL; |
520 | |
521 | new_client->pid = id; |
522 | agp_insert_client(client: new_client); |
523 | return new_client; |
524 | } |
525 | |
526 | int 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(objp: client); |
558 | return 0; |
559 | } |
560 | |
561 | /* End - Routines for managing client lists */ |
562 | |
563 | /* File Operations */ |
564 | |
565 | static 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, page_prot: 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, addr: vma->vm_start, |
604 | pfn: (kerninfo.aper_base + offset) >> PAGE_SHIFT, |
605 | size, |
606 | pgprot_writecombine(prot: vma->vm_page_prot))) { |
607 | goto out_again; |
608 | } |
609 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
610 | return 0; |
611 | } |
612 | |
613 | if (test_bit(AGP_FF_IS_CONTROLLER, &priv->access_flags)) { |
614 | if (size != current_size) |
615 | goto out_inval; |
616 | |
617 | DBG("controller vm_ops=%p" , kerninfo.vm_ops); |
618 | if (kerninfo.vm_ops) { |
619 | vma->vm_ops = kerninfo.vm_ops; |
620 | } else if (io_remap_pfn_range(vma, addr: vma->vm_start, |
621 | pfn: kerninfo.aper_base >> PAGE_SHIFT, |
622 | size, |
623 | pgprot_writecombine(prot: vma->vm_page_prot))) { |
624 | goto out_again; |
625 | } |
626 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
627 | return 0; |
628 | } |
629 | |
630 | out_eperm: |
631 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
632 | return -EPERM; |
633 | |
634 | out_inval: |
635 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
636 | return -EINVAL; |
637 | |
638 | out_again: |
639 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
640 | return -EAGAIN; |
641 | } |
642 | |
643 | static int agp_release(struct inode *inode, struct file *file) |
644 | { |
645 | struct agp_file_private *priv = file->private_data; |
646 | |
647 | mutex_lock(&(agp_fe.agp_mutex)); |
648 | |
649 | DBG("priv=%p" , priv); |
650 | |
651 | if (test_bit(AGP_FF_IS_CONTROLLER, &priv->access_flags)) { |
652 | struct agp_controller *controller; |
653 | |
654 | controller = agp_find_controller_by_pid(id: priv->my_pid); |
655 | |
656 | if (controller != NULL) { |
657 | if (controller == agp_fe.current_controller) |
658 | agp_controller_release_current(controller, controller_priv: priv); |
659 | agp_remove_controller(controller); |
660 | controller = NULL; |
661 | } |
662 | } |
663 | |
664 | if (test_bit(AGP_FF_IS_CLIENT, &priv->access_flags)) |
665 | agp_remove_client(id: priv->my_pid); |
666 | |
667 | agp_remove_file_private(priv); |
668 | kfree(objp: priv); |
669 | file->private_data = NULL; |
670 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
671 | return 0; |
672 | } |
673 | |
674 | static int agp_open(struct inode *inode, struct file *file) |
675 | { |
676 | int minor = iminor(inode); |
677 | struct agp_file_private *priv; |
678 | struct agp_client *client; |
679 | |
680 | if (minor != AGPGART_MINOR) |
681 | return -ENXIO; |
682 | |
683 | mutex_lock(&(agp_fe.agp_mutex)); |
684 | |
685 | priv = kzalloc(size: sizeof(struct agp_file_private), GFP_KERNEL); |
686 | if (priv == NULL) { |
687 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
688 | return -ENOMEM; |
689 | } |
690 | |
691 | set_bit(AGP_FF_ALLOW_CLIENT, addr: &priv->access_flags); |
692 | priv->my_pid = current->pid; |
693 | |
694 | if (capable(CAP_SYS_RAWIO)) |
695 | /* Root priv, can be controller */ |
696 | set_bit(AGP_FF_ALLOW_CONTROLLER, addr: &priv->access_flags); |
697 | |
698 | client = agp_find_client_by_pid(current->pid); |
699 | |
700 | if (client != NULL) { |
701 | set_bit(AGP_FF_IS_CLIENT, addr: &priv->access_flags); |
702 | set_bit(AGP_FF_IS_VALID, addr: &priv->access_flags); |
703 | } |
704 | file->private_data = (void *) priv; |
705 | agp_insert_file_private(priv); |
706 | DBG("private=%p, client=%p" , priv, client); |
707 | |
708 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
709 | |
710 | return 0; |
711 | } |
712 | |
713 | static int agpioc_info_wrap(struct agp_file_private *priv, void __user *arg) |
714 | { |
715 | struct agp_info userinfo; |
716 | struct agp_kern_info kerninfo; |
717 | |
718 | agp_copy_info(agp_bridge, &kerninfo); |
719 | |
720 | memset(&userinfo, 0, sizeof(userinfo)); |
721 | userinfo.version.major = kerninfo.version.major; |
722 | userinfo.version.minor = kerninfo.version.minor; |
723 | userinfo.bridge_id = kerninfo.device->vendor | |
724 | (kerninfo.device->device << 16); |
725 | userinfo.agp_mode = kerninfo.mode; |
726 | userinfo.aper_base = kerninfo.aper_base; |
727 | userinfo.aper_size = kerninfo.aper_size; |
728 | userinfo.pg_total = userinfo.pg_system = kerninfo.max_memory; |
729 | userinfo.pg_used = kerninfo.current_memory; |
730 | |
731 | if (copy_to_user(to: arg, from: &userinfo, n: sizeof(struct agp_info))) |
732 | return -EFAULT; |
733 | |
734 | return 0; |
735 | } |
736 | |
737 | int agpioc_acquire_wrap(struct agp_file_private *priv) |
738 | { |
739 | struct agp_controller *controller; |
740 | |
741 | DBG("" ); |
742 | |
743 | if (!(test_bit(AGP_FF_ALLOW_CONTROLLER, &priv->access_flags))) |
744 | return -EPERM; |
745 | |
746 | if (agp_fe.current_controller != NULL) |
747 | return -EBUSY; |
748 | |
749 | if (!agp_bridge) |
750 | return -ENODEV; |
751 | |
752 | if (atomic_read(v: &agp_bridge->agp_in_use)) |
753 | return -EBUSY; |
754 | |
755 | atomic_inc(v: &agp_bridge->agp_in_use); |
756 | |
757 | agp_fe.backend_acquired = true; |
758 | |
759 | controller = agp_find_controller_by_pid(id: priv->my_pid); |
760 | |
761 | if (controller != NULL) { |
762 | agp_controller_make_current(controller); |
763 | } else { |
764 | controller = agp_create_controller(id: priv->my_pid); |
765 | |
766 | if (controller == NULL) { |
767 | agp_fe.backend_acquired = false; |
768 | agp_backend_release(agp_bridge); |
769 | return -ENOMEM; |
770 | } |
771 | agp_insert_controller(controller); |
772 | agp_controller_make_current(controller); |
773 | } |
774 | |
775 | set_bit(AGP_FF_IS_CONTROLLER, addr: &priv->access_flags); |
776 | set_bit(AGP_FF_IS_VALID, addr: &priv->access_flags); |
777 | return 0; |
778 | } |
779 | |
780 | int agpioc_release_wrap(struct agp_file_private *priv) |
781 | { |
782 | DBG("" ); |
783 | agp_controller_release_current(controller: agp_fe.current_controller, controller_priv: priv); |
784 | return 0; |
785 | } |
786 | |
787 | int agpioc_setup_wrap(struct agp_file_private *priv, void __user *arg) |
788 | { |
789 | struct agp_setup mode; |
790 | |
791 | DBG("" ); |
792 | if (copy_from_user(to: &mode, from: arg, n: sizeof(struct agp_setup))) |
793 | return -EFAULT; |
794 | |
795 | agp_enable(agp_bridge, mode.agp_mode); |
796 | return 0; |
797 | } |
798 | |
799 | static int agpioc_reserve_wrap(struct agp_file_private *priv, void __user *arg) |
800 | { |
801 | struct agp_region reserve; |
802 | struct agp_client *client; |
803 | struct agp_file_private *client_priv; |
804 | |
805 | DBG("" ); |
806 | if (copy_from_user(to: &reserve, from: arg, n: sizeof(struct agp_region))) |
807 | return -EFAULT; |
808 | |
809 | if ((unsigned) reserve.seg_count >= ~0U/sizeof(struct agp_segment)) |
810 | return -EFAULT; |
811 | |
812 | client = agp_find_client_by_pid(id: reserve.pid); |
813 | |
814 | if (reserve.seg_count == 0) { |
815 | /* remove a client */ |
816 | client_priv = agp_find_private(pid: reserve.pid); |
817 | |
818 | if (client_priv != NULL) { |
819 | set_bit(AGP_FF_IS_CLIENT, addr: &client_priv->access_flags); |
820 | set_bit(AGP_FF_IS_VALID, addr: &client_priv->access_flags); |
821 | } |
822 | if (client == NULL) { |
823 | /* client is already removed */ |
824 | return 0; |
825 | } |
826 | return agp_remove_client(id: reserve.pid); |
827 | } else { |
828 | struct agp_segment *segment; |
829 | |
830 | if (reserve.seg_count >= 16384) |
831 | return -EINVAL; |
832 | |
833 | segment = kmalloc(size: (sizeof(struct agp_segment) * reserve.seg_count), |
834 | GFP_KERNEL); |
835 | |
836 | if (segment == NULL) |
837 | return -ENOMEM; |
838 | |
839 | if (copy_from_user(to: segment, from: (void __user *) reserve.seg_list, |
840 | n: sizeof(struct agp_segment) * reserve.seg_count)) { |
841 | kfree(objp: segment); |
842 | return -EFAULT; |
843 | } |
844 | reserve.seg_list = segment; |
845 | |
846 | if (client == NULL) { |
847 | /* Create the client and add the segment */ |
848 | client = agp_create_client(id: reserve.pid); |
849 | |
850 | if (client == NULL) { |
851 | kfree(objp: segment); |
852 | return -ENOMEM; |
853 | } |
854 | client_priv = agp_find_private(pid: reserve.pid); |
855 | |
856 | if (client_priv != NULL) { |
857 | set_bit(AGP_FF_IS_CLIENT, addr: &client_priv->access_flags); |
858 | set_bit(AGP_FF_IS_VALID, addr: &client_priv->access_flags); |
859 | } |
860 | } |
861 | return agp_create_segment(client, region: &reserve); |
862 | } |
863 | /* Will never really happen */ |
864 | return -EINVAL; |
865 | } |
866 | |
867 | int agpioc_protect_wrap(struct agp_file_private *priv) |
868 | { |
869 | DBG("" ); |
870 | /* This function is not currently implemented */ |
871 | return -EINVAL; |
872 | } |
873 | |
874 | static int agpioc_allocate_wrap(struct agp_file_private *priv, void __user *arg) |
875 | { |
876 | struct agp_memory *memory; |
877 | struct agp_allocate alloc; |
878 | |
879 | DBG("" ); |
880 | if (copy_from_user(to: &alloc, from: arg, n: sizeof(struct agp_allocate))) |
881 | return -EFAULT; |
882 | |
883 | if (alloc.type >= AGP_USER_TYPES) |
884 | return -EINVAL; |
885 | |
886 | memory = agp_allocate_memory_wrap(pg_count: alloc.pg_count, type: alloc.type); |
887 | |
888 | if (memory == NULL) |
889 | return -ENOMEM; |
890 | |
891 | alloc.key = memory->key; |
892 | alloc.physical = memory->physical; |
893 | |
894 | if (copy_to_user(to: arg, from: &alloc, n: sizeof(struct agp_allocate))) { |
895 | agp_free_memory_wrap(memory); |
896 | return -EFAULT; |
897 | } |
898 | return 0; |
899 | } |
900 | |
901 | int agpioc_deallocate_wrap(struct agp_file_private *priv, int arg) |
902 | { |
903 | struct agp_memory *memory; |
904 | |
905 | DBG("" ); |
906 | memory = agp_find_mem_by_key(key: arg); |
907 | |
908 | if (memory == NULL) |
909 | return -EINVAL; |
910 | |
911 | agp_free_memory_wrap(memory); |
912 | return 0; |
913 | } |
914 | |
915 | static int agpioc_bind_wrap(struct agp_file_private *priv, void __user *arg) |
916 | { |
917 | struct agp_bind bind_info; |
918 | struct agp_memory *memory; |
919 | |
920 | DBG("" ); |
921 | if (copy_from_user(to: &bind_info, from: arg, n: sizeof(struct agp_bind))) |
922 | return -EFAULT; |
923 | |
924 | memory = agp_find_mem_by_key(key: bind_info.key); |
925 | |
926 | if (memory == NULL) |
927 | return -EINVAL; |
928 | |
929 | return agp_bind_memory(memory, bind_info.pg_start); |
930 | } |
931 | |
932 | static int agpioc_unbind_wrap(struct agp_file_private *priv, void __user *arg) |
933 | { |
934 | struct agp_memory *memory; |
935 | struct agp_unbind unbind; |
936 | |
937 | DBG("" ); |
938 | if (copy_from_user(to: &unbind, from: arg, n: sizeof(struct agp_unbind))) |
939 | return -EFAULT; |
940 | |
941 | memory = agp_find_mem_by_key(key: unbind.key); |
942 | |
943 | if (memory == NULL) |
944 | return -EINVAL; |
945 | |
946 | return agp_unbind_memory(memory); |
947 | } |
948 | |
949 | static long agp_ioctl(struct file *file, |
950 | unsigned int cmd, unsigned long arg) |
951 | { |
952 | struct agp_file_private *curr_priv = file->private_data; |
953 | int ret_val = -ENOTTY; |
954 | |
955 | DBG("priv=%p, cmd=%x" , curr_priv, cmd); |
956 | mutex_lock(&(agp_fe.agp_mutex)); |
957 | |
958 | if ((agp_fe.current_controller == NULL) && |
959 | (cmd != AGPIOC_ACQUIRE)) { |
960 | ret_val = -EINVAL; |
961 | goto ioctl_out; |
962 | } |
963 | if ((agp_fe.backend_acquired != true) && |
964 | (cmd != AGPIOC_ACQUIRE)) { |
965 | ret_val = -EBUSY; |
966 | goto ioctl_out; |
967 | } |
968 | if (cmd != AGPIOC_ACQUIRE) { |
969 | if (!(test_bit(AGP_FF_IS_CONTROLLER, &curr_priv->access_flags))) { |
970 | ret_val = -EPERM; |
971 | goto ioctl_out; |
972 | } |
973 | /* Use the original pid of the controller, |
974 | * in case it's threaded */ |
975 | |
976 | if (agp_fe.current_controller->pid != curr_priv->my_pid) { |
977 | ret_val = -EBUSY; |
978 | goto ioctl_out; |
979 | } |
980 | } |
981 | |
982 | switch (cmd) { |
983 | case AGPIOC_INFO: |
984 | ret_val = agpioc_info_wrap(priv: curr_priv, arg: (void __user *) arg); |
985 | break; |
986 | |
987 | case AGPIOC_ACQUIRE: |
988 | ret_val = agpioc_acquire_wrap(priv: curr_priv); |
989 | break; |
990 | |
991 | case AGPIOC_RELEASE: |
992 | ret_val = agpioc_release_wrap(priv: curr_priv); |
993 | break; |
994 | |
995 | case AGPIOC_SETUP: |
996 | ret_val = agpioc_setup_wrap(priv: curr_priv, arg: (void __user *) arg); |
997 | break; |
998 | |
999 | case AGPIOC_RESERVE: |
1000 | ret_val = agpioc_reserve_wrap(priv: curr_priv, arg: (void __user *) arg); |
1001 | break; |
1002 | |
1003 | case AGPIOC_PROTECT: |
1004 | ret_val = agpioc_protect_wrap(priv: curr_priv); |
1005 | break; |
1006 | |
1007 | case AGPIOC_ALLOCATE: |
1008 | ret_val = agpioc_allocate_wrap(priv: curr_priv, arg: (void __user *) arg); |
1009 | break; |
1010 | |
1011 | case AGPIOC_DEALLOCATE: |
1012 | ret_val = agpioc_deallocate_wrap(priv: curr_priv, arg: (int) arg); |
1013 | break; |
1014 | |
1015 | case AGPIOC_BIND: |
1016 | ret_val = agpioc_bind_wrap(priv: curr_priv, arg: (void __user *) arg); |
1017 | break; |
1018 | |
1019 | case AGPIOC_UNBIND: |
1020 | ret_val = agpioc_unbind_wrap(priv: curr_priv, arg: (void __user *) arg); |
1021 | break; |
1022 | |
1023 | case AGPIOC_CHIPSET_FLUSH: |
1024 | break; |
1025 | } |
1026 | |
1027 | ioctl_out: |
1028 | DBG("ioctl returns %d\n" , ret_val); |
1029 | mutex_unlock(lock: &(agp_fe.agp_mutex)); |
1030 | return ret_val; |
1031 | } |
1032 | |
1033 | static const struct file_operations agp_fops = |
1034 | { |
1035 | .owner = THIS_MODULE, |
1036 | .llseek = no_llseek, |
1037 | .unlocked_ioctl = agp_ioctl, |
1038 | #ifdef CONFIG_COMPAT |
1039 | .compat_ioctl = compat_agp_ioctl, |
1040 | #endif |
1041 | .mmap = agp_mmap, |
1042 | .open = agp_open, |
1043 | .release = agp_release, |
1044 | }; |
1045 | |
1046 | static struct miscdevice agp_miscdev = |
1047 | { |
1048 | .minor = AGPGART_MINOR, |
1049 | .name = "agpgart" , |
1050 | .fops = &agp_fops |
1051 | }; |
1052 | |
1053 | int agp_frontend_initialize(void) |
1054 | { |
1055 | memset(&agp_fe, 0, sizeof(struct agp_front_data)); |
1056 | mutex_init(&(agp_fe.agp_mutex)); |
1057 | |
1058 | if (misc_register(misc: &agp_miscdev)) { |
1059 | printk(KERN_ERR PFX "unable to get minor: %d\n" , AGPGART_MINOR); |
1060 | return -EIO; |
1061 | } |
1062 | return 0; |
1063 | } |
1064 | |
1065 | void agp_frontend_cleanup(void) |
1066 | { |
1067 | misc_deregister(misc: &agp_miscdev); |
1068 | } |
1069 | |