Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/cmarinas...
[linux-2.6.git] / drivers / gpu / drm / drm_mm.c
1 /**************************************************************************
2  *
3  * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
4  * All Rights Reserved.
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the
8  * "Software"), to deal in the Software without restriction, including
9  * without limitation the rights to use, copy, modify, merge, publish,
10  * distribute, sub license, and/or sell copies of the Software, and to
11  * permit persons to whom the Software is furnished to do so, subject to
12  * the following conditions:
13  *
14  * The above copyright notice and this permission notice (including the
15  * next paragraph) shall be included in all copies or substantial portions
16  * of the Software.
17  *
18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
25  *
26  *
27  **************************************************************************/
28
29 /*
30  * Generic simple memory manager implementation. Intended to be used as a base
31  * class implementation for more advanced memory managers.
32  *
33  * Note that the algorithm used is quite simple and there might be substantial
34  * performance gains if a smarter free list is implemented. Currently it is just an
35  * unordered stack of free regions. This could easily be improved if an RB-tree
36  * is used instead. At least if we expect heavy fragmentation.
37  *
38  * Aligned allocations can also see improvement.
39  *
40  * Authors:
41  * Thomas Hellström <thomas-at-tungstengraphics-dot-com>
42  */
43
44 #include "drmP.h"
45 #include "drm_mm.h"
46 #include <linux/slab.h>
47 #include <linux/seq_file.h>
48
49 #define MM_UNUSED_TARGET 4
50
51 static struct drm_mm_node *drm_mm_kmalloc(struct drm_mm *mm, int atomic)
52 {
53         struct drm_mm_node *child;
54
55         if (atomic)
56                 child = kzalloc(sizeof(*child), GFP_ATOMIC);
57         else
58                 child = kzalloc(sizeof(*child), GFP_KERNEL);
59
60         if (unlikely(child == NULL)) {
61                 spin_lock(&mm->unused_lock);
62                 if (list_empty(&mm->unused_nodes))
63                         child = NULL;
64                 else {
65                         child =
66                             list_entry(mm->unused_nodes.next,
67                                        struct drm_mm_node, node_list);
68                         list_del(&child->node_list);
69                         --mm->num_unused;
70                 }
71                 spin_unlock(&mm->unused_lock);
72         }
73         return child;
74 }
75
76 /* drm_mm_pre_get() - pre allocate drm_mm_node structure
77  * drm_mm:      memory manager struct we are pre-allocating for
78  *
79  * Returns 0 on success or -ENOMEM if allocation fails.
80  */
81 int drm_mm_pre_get(struct drm_mm *mm)
82 {
83         struct drm_mm_node *node;
84
85         spin_lock(&mm->unused_lock);
86         while (mm->num_unused < MM_UNUSED_TARGET) {
87                 spin_unlock(&mm->unused_lock);
88                 node = kzalloc(sizeof(*node), GFP_KERNEL);
89                 spin_lock(&mm->unused_lock);
90
91                 if (unlikely(node == NULL)) {
92                         int ret = (mm->num_unused < 2) ? -ENOMEM : 0;
93                         spin_unlock(&mm->unused_lock);
94                         return ret;
95                 }
96                 ++mm->num_unused;
97                 list_add_tail(&node->node_list, &mm->unused_nodes);
98         }
99         spin_unlock(&mm->unused_lock);
100         return 0;
101 }
102 EXPORT_SYMBOL(drm_mm_pre_get);
103
104 static inline unsigned long drm_mm_hole_node_start(struct drm_mm_node *hole_node)
105 {
106         return hole_node->start + hole_node->size;
107 }
108
109 static inline unsigned long drm_mm_hole_node_end(struct drm_mm_node *hole_node)
110 {
111         struct drm_mm_node *next_node =
112                 list_entry(hole_node->node_list.next, struct drm_mm_node,
113                            node_list);
114
115         return next_node->start;
116 }
117
118 static void drm_mm_insert_helper(struct drm_mm_node *hole_node,
119                                  struct drm_mm_node *node,
120                                  unsigned long size, unsigned alignment)
121 {
122         struct drm_mm *mm = hole_node->mm;
123         unsigned long tmp = 0, wasted = 0;
124         unsigned long hole_start = drm_mm_hole_node_start(hole_node);
125         unsigned long hole_end = drm_mm_hole_node_end(hole_node);
126
127         BUG_ON(!hole_node->hole_follows || node->allocated);
128
129         if (alignment)
130                 tmp = hole_start % alignment;
131
132         if (!tmp) {
133                 hole_node->hole_follows = 0;
134                 list_del_init(&hole_node->hole_stack);
135         } else
136                 wasted = alignment - tmp;
137
138         node->start = hole_start + wasted;
139         node->size = size;
140         node->mm = mm;
141         node->allocated = 1;
142
143         INIT_LIST_HEAD(&node->hole_stack);
144         list_add(&node->node_list, &hole_node->node_list);
145
146         BUG_ON(node->start + node->size > hole_end);
147
148         if (node->start + node->size < hole_end) {
149                 list_add(&node->hole_stack, &mm->hole_stack);
150                 node->hole_follows = 1;
151         } else {
152                 node->hole_follows = 0;
153         }
154 }
155
156 struct drm_mm_node *drm_mm_get_block_generic(struct drm_mm_node *hole_node,
157                                              unsigned long size,
158                                              unsigned alignment,
159                                              int atomic)
160 {
161         struct drm_mm_node *node;
162
163         node = drm_mm_kmalloc(hole_node->mm, atomic);
164         if (unlikely(node == NULL))
165                 return NULL;
166
167         drm_mm_insert_helper(hole_node, node, size, alignment);
168
169         return node;
170 }
171 EXPORT_SYMBOL(drm_mm_get_block_generic);
172
173 /**
174  * Search for free space and insert a preallocated memory node. Returns
175  * -ENOSPC if no suitable free area is available. The preallocated memory node
176  * must be cleared.
177  */
178 int drm_mm_insert_node(struct drm_mm *mm, struct drm_mm_node *node,
179                        unsigned long size, unsigned alignment)
180 {
181         struct drm_mm_node *hole_node;
182
183         hole_node = drm_mm_search_free(mm, size, alignment, 0);
184         if (!hole_node)
185                 return -ENOSPC;
186
187         drm_mm_insert_helper(hole_node, node, size, alignment);
188
189         return 0;
190 }
191 EXPORT_SYMBOL(drm_mm_insert_node);
192
193 static void drm_mm_insert_helper_range(struct drm_mm_node *hole_node,
194                                        struct drm_mm_node *node,
195                                        unsigned long size, unsigned alignment,
196                                        unsigned long start, unsigned long end)
197 {
198         struct drm_mm *mm = hole_node->mm;
199         unsigned long tmp = 0, wasted = 0;
200         unsigned long hole_start = drm_mm_hole_node_start(hole_node);
201         unsigned long hole_end = drm_mm_hole_node_end(hole_node);
202
203         BUG_ON(!hole_node->hole_follows || node->allocated);
204
205         if (hole_start < start)
206                 wasted += start - hole_start;
207         if (alignment)
208                 tmp = (hole_start + wasted) % alignment;
209
210         if (tmp)
211                 wasted += alignment - tmp;
212
213         if (!wasted) {
214                 hole_node->hole_follows = 0;
215                 list_del_init(&hole_node->hole_stack);
216         }
217
218         node->start = hole_start + wasted;
219         node->size = size;
220         node->mm = mm;
221         node->allocated = 1;
222
223         INIT_LIST_HEAD(&node->hole_stack);
224         list_add(&node->node_list, &hole_node->node_list);
225
226         BUG_ON(node->start + node->size > hole_end);
227         BUG_ON(node->start + node->size > end);
228
229         if (node->start + node->size < hole_end) {
230                 list_add(&node->hole_stack, &mm->hole_stack);
231                 node->hole_follows = 1;
232         } else {
233                 node->hole_follows = 0;
234         }
235 }
236
237 struct drm_mm_node *drm_mm_get_block_range_generic(struct drm_mm_node *hole_node,
238                                                 unsigned long size,
239                                                 unsigned alignment,
240                                                 unsigned long start,
241                                                 unsigned long end,
242                                                 int atomic)
243 {
244         struct drm_mm_node *node;
245
246         node = drm_mm_kmalloc(hole_node->mm, atomic);
247         if (unlikely(node == NULL))
248                 return NULL;
249
250         drm_mm_insert_helper_range(hole_node, node, size, alignment,
251                                    start, end);
252
253         return node;
254 }
255 EXPORT_SYMBOL(drm_mm_get_block_range_generic);
256
257 /**
258  * Search for free space and insert a preallocated memory node. Returns
259  * -ENOSPC if no suitable free area is available. This is for range
260  * restricted allocations. The preallocated memory node must be cleared.
261  */
262 int drm_mm_insert_node_in_range(struct drm_mm *mm, struct drm_mm_node *node,
263                                 unsigned long size, unsigned alignment,
264                                 unsigned long start, unsigned long end)
265 {
266         struct drm_mm_node *hole_node;
267
268         hole_node = drm_mm_search_free_in_range(mm, size, alignment,
269                                                 start, end, 0);
270         if (!hole_node)
271                 return -ENOSPC;
272
273         drm_mm_insert_helper_range(hole_node, node, size, alignment,
274                                    start, end);
275
276         return 0;
277 }
278 EXPORT_SYMBOL(drm_mm_insert_node_in_range);
279
280 /**
281  * Remove a memory node from the allocator.
282  */
283 void drm_mm_remove_node(struct drm_mm_node *node)
284 {
285         struct drm_mm *mm = node->mm;
286         struct drm_mm_node *prev_node;
287
288         BUG_ON(node->scanned_block || node->scanned_prev_free
289                                    || node->scanned_next_free);
290
291         prev_node =
292             list_entry(node->node_list.prev, struct drm_mm_node, node_list);
293
294         if (node->hole_follows) {
295                 BUG_ON(drm_mm_hole_node_start(node)
296                                 == drm_mm_hole_node_end(node));
297                 list_del(&node->hole_stack);
298         } else
299                 BUG_ON(drm_mm_hole_node_start(node)
300                                 != drm_mm_hole_node_end(node));
301
302         if (!prev_node->hole_follows) {
303                 prev_node->hole_follows = 1;
304                 list_add(&prev_node->hole_stack, &mm->hole_stack);
305         } else
306                 list_move(&prev_node->hole_stack, &mm->hole_stack);
307
308         list_del(&node->node_list);
309         node->allocated = 0;
310 }
311 EXPORT_SYMBOL(drm_mm_remove_node);
312
313 /*
314  * Remove a memory node from the allocator and free the allocated struct
315  * drm_mm_node. Only to be used on a struct drm_mm_node obtained by one of the
316  * drm_mm_get_block functions.
317  */
318 void drm_mm_put_block(struct drm_mm_node *node)
319 {
320
321         struct drm_mm *mm = node->mm;
322
323         drm_mm_remove_node(node);
324
325         spin_lock(&mm->unused_lock);
326         if (mm->num_unused < MM_UNUSED_TARGET) {
327                 list_add(&node->node_list, &mm->unused_nodes);
328                 ++mm->num_unused;
329         } else
330                 kfree(node);
331         spin_unlock(&mm->unused_lock);
332 }
333 EXPORT_SYMBOL(drm_mm_put_block);
334
335 static int check_free_hole(unsigned long start, unsigned long end,
336                            unsigned long size, unsigned alignment)
337 {
338         unsigned wasted = 0;
339
340         if (end - start < size)
341                 return 0;
342
343         if (alignment) {
344                 unsigned tmp = start % alignment;
345                 if (tmp)
346                         wasted = alignment - tmp;
347         }
348
349         if (end >= start + size + wasted) {
350                 return 1;
351         }
352
353         return 0;
354 }
355
356 struct drm_mm_node *drm_mm_search_free(const struct drm_mm *mm,
357                                        unsigned long size,
358                                        unsigned alignment, int best_match)
359 {
360         struct drm_mm_node *entry;
361         struct drm_mm_node *best;
362         unsigned long best_size;
363
364         BUG_ON(mm->scanned_blocks);
365
366         best = NULL;
367         best_size = ~0UL;
368
369         list_for_each_entry(entry, &mm->hole_stack, hole_stack) {
370                 BUG_ON(!entry->hole_follows);
371                 if (!check_free_hole(drm_mm_hole_node_start(entry),
372                                      drm_mm_hole_node_end(entry),
373                                      size, alignment))
374                         continue;
375
376                 if (!best_match)
377                         return entry;
378
379                 if (entry->size < best_size) {
380                         best = entry;
381                         best_size = entry->size;
382                 }
383         }
384
385         return best;
386 }
387 EXPORT_SYMBOL(drm_mm_search_free);
388
389 struct drm_mm_node *drm_mm_search_free_in_range(const struct drm_mm *mm,
390                                                 unsigned long size,
391                                                 unsigned alignment,
392                                                 unsigned long start,
393                                                 unsigned long end,
394                                                 int best_match)
395 {
396         struct drm_mm_node *entry;
397         struct drm_mm_node *best;
398         unsigned long best_size;
399
400         BUG_ON(mm->scanned_blocks);
401
402         best = NULL;
403         best_size = ~0UL;
404
405         list_for_each_entry(entry, &mm->hole_stack, hole_stack) {
406                 unsigned long adj_start = drm_mm_hole_node_start(entry) < start ?
407                         start : drm_mm_hole_node_start(entry);
408                 unsigned long adj_end = drm_mm_hole_node_end(entry) > end ?
409                         end : drm_mm_hole_node_end(entry);
410
411                 BUG_ON(!entry->hole_follows);
412                 if (!check_free_hole(adj_start, adj_end, size, alignment))
413                         continue;
414
415                 if (!best_match)
416                         return entry;
417
418                 if (entry->size < best_size) {
419                         best = entry;
420                         best_size = entry->size;
421                 }
422         }
423
424         return best;
425 }
426 EXPORT_SYMBOL(drm_mm_search_free_in_range);
427
428 /**
429  * Moves an allocation. To be used with embedded struct drm_mm_node.
430  */
431 void drm_mm_replace_node(struct drm_mm_node *old, struct drm_mm_node *new)
432 {
433         list_replace(&old->node_list, &new->node_list);
434         list_replace(&old->hole_stack, &new->hole_stack);
435         new->hole_follows = old->hole_follows;
436         new->mm = old->mm;
437         new->start = old->start;
438         new->size = old->size;
439
440         old->allocated = 0;
441         new->allocated = 1;
442 }
443 EXPORT_SYMBOL(drm_mm_replace_node);
444
445 /**
446  * Initializa lru scanning.
447  *
448  * This simply sets up the scanning routines with the parameters for the desired
449  * hole.
450  *
451  * Warning: As long as the scan list is non-empty, no other operations than
452  * adding/removing nodes to/from the scan list are allowed.
453  */
454 void drm_mm_init_scan(struct drm_mm *mm, unsigned long size,
455                       unsigned alignment)
456 {
457         mm->scan_alignment = alignment;
458         mm->scan_size = size;
459         mm->scanned_blocks = 0;
460         mm->scan_hit_start = 0;
461         mm->scan_hit_size = 0;
462         mm->scan_check_range = 0;
463         mm->prev_scanned_node = NULL;
464 }
465 EXPORT_SYMBOL(drm_mm_init_scan);
466
467 /**
468  * Initializa lru scanning.
469  *
470  * This simply sets up the scanning routines with the parameters for the desired
471  * hole. This version is for range-restricted scans.
472  *
473  * Warning: As long as the scan list is non-empty, no other operations than
474  * adding/removing nodes to/from the scan list are allowed.
475  */
476 void drm_mm_init_scan_with_range(struct drm_mm *mm, unsigned long size,
477                                  unsigned alignment,
478                                  unsigned long start,
479                                  unsigned long end)
480 {
481         mm->scan_alignment = alignment;
482         mm->scan_size = size;
483         mm->scanned_blocks = 0;
484         mm->scan_hit_start = 0;
485         mm->scan_hit_size = 0;
486         mm->scan_start = start;
487         mm->scan_end = end;
488         mm->scan_check_range = 1;
489         mm->prev_scanned_node = NULL;
490 }
491 EXPORT_SYMBOL(drm_mm_init_scan_with_range);
492
493 /**
494  * Add a node to the scan list that might be freed to make space for the desired
495  * hole.
496  *
497  * Returns non-zero, if a hole has been found, zero otherwise.
498  */
499 int drm_mm_scan_add_block(struct drm_mm_node *node)
500 {
501         struct drm_mm *mm = node->mm;
502         struct drm_mm_node *prev_node;
503         unsigned long hole_start, hole_end;
504         unsigned long adj_start;
505         unsigned long adj_end;
506
507         mm->scanned_blocks++;
508
509         BUG_ON(node->scanned_block);
510         node->scanned_block = 1;
511
512         prev_node = list_entry(node->node_list.prev, struct drm_mm_node,
513                                node_list);
514
515         node->scanned_preceeds_hole = prev_node->hole_follows;
516         prev_node->hole_follows = 1;
517         list_del(&node->node_list);
518         node->node_list.prev = &prev_node->node_list;
519         node->node_list.next = &mm->prev_scanned_node->node_list;
520         mm->prev_scanned_node = node;
521
522         hole_start = drm_mm_hole_node_start(prev_node);
523         hole_end = drm_mm_hole_node_end(prev_node);
524         if (mm->scan_check_range) {
525                 adj_start = hole_start < mm->scan_start ?
526                         mm->scan_start : hole_start;
527                 adj_end = hole_end > mm->scan_end ?
528                         mm->scan_end : hole_end;
529         } else {
530                 adj_start = hole_start;
531                 adj_end = hole_end;
532         }
533
534         if (check_free_hole(adj_start , adj_end,
535                             mm->scan_size, mm->scan_alignment)) {
536                 mm->scan_hit_start = hole_start;
537                 mm->scan_hit_size = hole_end;
538
539                 return 1;
540         }
541
542         return 0;
543 }
544 EXPORT_SYMBOL(drm_mm_scan_add_block);
545
546 /**
547  * Remove a node from the scan list.
548  *
549  * Nodes _must_ be removed in the exact same order from the scan list as they
550  * have been added, otherwise the internal state of the memory manager will be
551  * corrupted.
552  *
553  * When the scan list is empty, the selected memory nodes can be freed. An
554  * immediately following drm_mm_search_free with best_match = 0 will then return
555  * the just freed block (because its at the top of the free_stack list).
556  *
557  * Returns one if this block should be evicted, zero otherwise. Will always
558  * return zero when no hole has been found.
559  */
560 int drm_mm_scan_remove_block(struct drm_mm_node *node)
561 {
562         struct drm_mm *mm = node->mm;
563         struct drm_mm_node *prev_node;
564
565         mm->scanned_blocks--;
566
567         BUG_ON(!node->scanned_block);
568         node->scanned_block = 0;
569
570         prev_node = list_entry(node->node_list.prev, struct drm_mm_node,
571                                node_list);
572
573         prev_node->hole_follows = node->scanned_preceeds_hole;
574         INIT_LIST_HEAD(&node->node_list);
575         list_add(&node->node_list, &prev_node->node_list);
576
577         /* Only need to check for containement because start&size for the
578          * complete resulting free block (not just the desired part) is
579          * stored. */
580         if (node->start >= mm->scan_hit_start &&
581             node->start + node->size
582                         <= mm->scan_hit_start + mm->scan_hit_size) {
583                 return 1;
584         }
585
586         return 0;
587 }
588 EXPORT_SYMBOL(drm_mm_scan_remove_block);
589
590 int drm_mm_clean(struct drm_mm * mm)
591 {
592         struct list_head *head = &mm->head_node.node_list;
593
594         return (head->next->next == head);
595 }
596 EXPORT_SYMBOL(drm_mm_clean);
597
598 int drm_mm_init(struct drm_mm * mm, unsigned long start, unsigned long size)
599 {
600         INIT_LIST_HEAD(&mm->hole_stack);
601         INIT_LIST_HEAD(&mm->unused_nodes);
602         mm->num_unused = 0;
603         mm->scanned_blocks = 0;
604         spin_lock_init(&mm->unused_lock);
605
606         /* Clever trick to avoid a special case in the free hole tracking. */
607         INIT_LIST_HEAD(&mm->head_node.node_list);
608         INIT_LIST_HEAD(&mm->head_node.hole_stack);
609         mm->head_node.hole_follows = 1;
610         mm->head_node.scanned_block = 0;
611         mm->head_node.scanned_prev_free = 0;
612         mm->head_node.scanned_next_free = 0;
613         mm->head_node.mm = mm;
614         mm->head_node.start = start + size;
615         mm->head_node.size = start - mm->head_node.start;
616         list_add_tail(&mm->head_node.hole_stack, &mm->hole_stack);
617
618         return 0;
619 }
620 EXPORT_SYMBOL(drm_mm_init);
621
622 void drm_mm_takedown(struct drm_mm * mm)
623 {
624         struct drm_mm_node *entry, *next;
625
626         if (!list_empty(&mm->head_node.node_list)) {
627                 DRM_ERROR("Memory manager not clean. Delaying takedown\n");
628                 return;
629         }
630
631         spin_lock(&mm->unused_lock);
632         list_for_each_entry_safe(entry, next, &mm->unused_nodes, node_list) {
633                 list_del(&entry->node_list);
634                 kfree(entry);
635                 --mm->num_unused;
636         }
637         spin_unlock(&mm->unused_lock);
638
639         BUG_ON(mm->num_unused != 0);
640 }
641 EXPORT_SYMBOL(drm_mm_takedown);
642
643 void drm_mm_debug_table(struct drm_mm *mm, const char *prefix)
644 {
645         struct drm_mm_node *entry;
646         unsigned long total_used = 0, total_free = 0, total = 0;
647         unsigned long hole_start, hole_end, hole_size;
648
649         hole_start = drm_mm_hole_node_start(&mm->head_node);
650         hole_end = drm_mm_hole_node_end(&mm->head_node);
651         hole_size = hole_end - hole_start;
652         if (hole_size)
653                 printk(KERN_DEBUG "%s 0x%08lx-0x%08lx: %8lu: free\n",
654                         prefix, hole_start, hole_end,
655                         hole_size);
656         total_free += hole_size;
657
658         drm_mm_for_each_node(entry, mm) {
659                 printk(KERN_DEBUG "%s 0x%08lx-0x%08lx: %8lu: used\n",
660                         prefix, entry->start, entry->start + entry->size,
661                         entry->size);
662                 total_used += entry->size;
663
664                 if (entry->hole_follows) {
665                         hole_start = drm_mm_hole_node_start(entry);
666                         hole_end = drm_mm_hole_node_end(entry);
667                         hole_size = hole_end - hole_start;
668                         printk(KERN_DEBUG "%s 0x%08lx-0x%08lx: %8lu: free\n",
669                                 prefix, hole_start, hole_end,
670                                 hole_size);
671                         total_free += hole_size;
672                 }
673         }
674         total = total_free + total_used;
675
676         printk(KERN_DEBUG "%s total: %lu, used %lu free %lu\n", prefix, total,
677                 total_used, total_free);
678 }
679 EXPORT_SYMBOL(drm_mm_debug_table);
680
681 #if defined(CONFIG_DEBUG_FS)
682 int drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm)
683 {
684         struct drm_mm_node *entry;
685         unsigned long total_used = 0, total_free = 0, total = 0;
686         unsigned long hole_start, hole_end, hole_size;
687
688         hole_start = drm_mm_hole_node_start(&mm->head_node);
689         hole_end = drm_mm_hole_node_end(&mm->head_node);
690         hole_size = hole_end - hole_start;
691         if (hole_size)
692                 seq_printf(m, "0x%08lx-0x%08lx: 0x%08lx: free\n",
693                                 hole_start, hole_end, hole_size);
694         total_free += hole_size;
695
696         drm_mm_for_each_node(entry, mm) {
697                 seq_printf(m, "0x%08lx-0x%08lx: 0x%08lx: used\n",
698                                 entry->start, entry->start + entry->size,
699                                 entry->size);
700                 total_used += entry->size;
701                 if (entry->hole_follows) {
702                         hole_start = drm_mm_hole_node_start(entry);
703                         hole_end = drm_mm_hole_node_end(entry);
704                         hole_size = hole_end - hole_start;
705                         seq_printf(m, "0x%08lx-0x%08lx: 0x%08lx: free\n",
706                                         hole_start, hole_end, hole_size);
707                         total_free += hole_size;
708                 }
709         }
710         total = total_free + total_used;
711
712         seq_printf(m, "total: %lu, used %lu free %lu\n", total, total_used, total_free);
713         return 0;
714 }
715 EXPORT_SYMBOL(drm_mm_dump_table);
716 #endif