WebSVN – Kolibri OS – Diff – /drivers/video/drm/drm_mm.c

 /**************************************************************************
+ *
  * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA.
  * All Rights Reserved.
+ *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * Finally iteration helpers to walk all nodes and all holes are provided as are
  * some basic allocator dumpers for debugging.
  */
 static struct drm_mm_node *drm_mm_search_free_generic(const struct drm_mm *mm,
-						unsigned long size,
+						u64 size,
 						unsigned alignment,
 						unsigned long color,
 						enum drm_mm_search_flags flags);
 static struct drm_mm_node *drm_mm_search_free_in_range_generic(const struct drm_mm *mm,
-						unsigned long size,
+						u64 size,
 						unsigned alignment,
 						unsigned long color,
-						unsigned long start,
+						u64 start,
-						unsigned long end,
+						u64 end,
 						enum drm_mm_search_flags flags);
 static void drm_mm_insert_helper(struct drm_mm_node *hole_node,
 				 struct drm_mm_node *node,
-				 unsigned long size, unsigned alignment,
+				 u64 size, unsigned alignment,
 				 unsigned long color,
 				 enum drm_mm_allocator_flags flags)
 {
 	struct drm_mm *mm = hole_node->mm;
-	unsigned long hole_start = drm_mm_hole_node_start(hole_node);
+	u64 hole_start = drm_mm_hole_node_start(hole_node);
-	unsigned long hole_end = drm_mm_hole_node_end(hole_node);
+	u64 hole_end = drm_mm_hole_node_end(hole_node);
-	unsigned long adj_start = hole_start;
+	u64 adj_start = hole_start;
-	unsigned long adj_end = hole_end;
+	u64 adj_end = hole_end;
 	BUG_ON(node->allocated);
 	if (mm->color_adjust)
+		mm->color_adjust(hole_node, color, &adj_start, &adj_end);
+	if (flags & DRM_MM_CREATE_TOP)
-		mm->color_adjust(hole_node, color, &adj_start, &adj_end);
+		adj_start = adj_end - size;
-	if (flags & DRM_MM_CREATE_TOP)
+	if (alignment) {
-		adj_start = adj_end - size;
+		u64 tmp = adj_start;
 		unsigned rem;
-	if (alignment) {
-		unsigned tmp = adj_start % alignment;
+		rem = do_div(tmp, alignment);
-		if (tmp) {
+		if (rem) {
 			if (flags & DRM_MM_CREATE_TOP)
-				adj_start -= tmp;
+				adj_start -= rem;
  * 0 on success, -ENOSPC if there's no hole where @node is.
  */
 int drm_mm_reserve_node(struct drm_mm *mm, struct drm_mm_node *node)
+{
 	struct drm_mm_node *hole;
-	unsigned long end = node->start + node->size;
+	u64 end = node->start + node->size;
-	unsigned long hole_start;
+	u64 hole_start;
-	unsigned long hole_end;
+	u64 hole_end;
 	BUG_ON(node == NULL);
+ *
  * Returns:
  * 0 on success, -ENOSPC if there's no suitable hole.
  */
 int drm_mm_insert_node_generic(struct drm_mm *mm, struct drm_mm_node *node,
-			       unsigned long size, unsigned alignment,
+			       u64 size, unsigned alignment,
 			       unsigned long color,
 			       enum drm_mm_search_flags sflags,
 			       enum drm_mm_allocator_flags aflags)
+{
 	struct drm_mm_node *hole_node;
+}
 EXPORT_SYMBOL(drm_mm_insert_node_generic);
 static void drm_mm_insert_helper_range(struct drm_mm_node *hole_node,
 				       struct drm_mm_node *node,
-				       unsigned long size, unsigned alignment,
+				       u64 size, unsigned alignment,
 				       unsigned long color,
-				       unsigned long start, unsigned long end,
+				       u64 start, u64 end,
 				       enum drm_mm_allocator_flags flags)
+{
 	struct drm_mm *mm = hole_node->mm;
-	unsigned long hole_start = drm_mm_hole_node_start(hole_node);
+	u64 hole_start = drm_mm_hole_node_start(hole_node);
-	unsigned long hole_end = drm_mm_hole_node_end(hole_node);
+	u64 hole_end = drm_mm_hole_node_end(hole_node);
-	unsigned long adj_start = hole_start;
+	u64 adj_start = hole_start;
-	unsigned long adj_end = hole_end;
+	u64 adj_end = hole_end;
 	BUG_ON(!hole_node->hole_follows || node->allocated);
 	if (adj_start < start)
-		adj_start = start;
-	if (adj_end > end)
-		adj_end = end;
 		adj_start = start;
-	if (flags & DRM_MM_CREATE_TOP)
+	if (adj_end > end)
+		adj_end = end;
+	if (mm->color_adjust)
-		adj_start = adj_end - size;
+		mm->color_adjust(hole_node, color, &adj_start, &adj_end);
+	if (flags & DRM_MM_CREATE_TOP)
+		adj_start = adj_end - size;
-	if (mm->color_adjust)
+	if (alignment) {
-		mm->color_adjust(hole_node, color, &adj_start, &adj_end);
+		u64 tmp = adj_start;
+		unsigned rem;
 	if (alignment) {
-		unsigned tmp = adj_start % alignment;
+		rem = do_div(tmp, alignment);
-		if (tmp) {
+		if (rem) {
 			if (flags & DRM_MM_CREATE_TOP)
-				adj_start -= tmp;
+				adj_start -= rem;
 			else
+ *
  * Returns:
  * 0 on success, -ENOSPC if there's no suitable hole.
  */
 int drm_mm_insert_node_in_range_generic(struct drm_mm *mm, struct drm_mm_node *node,
-					unsigned long size, unsigned alignment,
+					u64 size, unsigned alignment,
 					unsigned long color,
-					unsigned long start, unsigned long end,
+					u64 start, u64 end,
 					enum drm_mm_search_flags sflags,
 					enum drm_mm_allocator_flags aflags)
+{
 	struct drm_mm_node *hole_node;
 	list_del(&node->node_list);
 	node->allocated = 0;
+}
 EXPORT_SYMBOL(drm_mm_remove_node);
-static int check_free_hole(unsigned long start, unsigned long end,
-			   unsigned long size, unsigned alignment)
+static int check_free_hole(u64 start, u64 end, u64 size, unsigned alignment)
+{
 	if (end - start < size)
 		return 0;
+	if (alignment) {
+		u64 tmp = start;
+		unsigned rem;
-	if (alignment) {
-		unsigned tmp = start % alignment;
+		rem = do_div(tmp, alignment);
-		if (tmp)
+		if (rem)
-			start += alignment - tmp;
+			start += alignment - rem;
+	}
 	return end >= start + size;
+}
 static struct drm_mm_node *drm_mm_search_free_generic(const struct drm_mm *mm,
-				       unsigned long size,
+						      u64 size,
-					       unsigned alignment,
+						      unsigned alignment,
-					       unsigned long color,
+						      unsigned long color,
 						      enum drm_mm_search_flags flags)
 {
 	struct drm_mm_node *entry;
 	struct drm_mm_node *best;
-	unsigned long adj_start;
+	u64 adj_start;
-	unsigned long adj_end;
+	u64 adj_end;
-	unsigned long best_size;
+	u64 best_size;
 	BUG_ON(mm->scanned_blocks);
 	best = NULL;
 	best_size = ~0UL;
 	return best;
+}
 static struct drm_mm_node *drm_mm_search_free_in_range_generic(const struct drm_mm *mm,
-						unsigned long size,
+							u64 size,
-						unsigned alignment,
+							unsigned alignment,
 							unsigned long color,
-						unsigned long start,
+							u64 start,
-						unsigned long end,
+							u64 end,
 							enum drm_mm_search_flags flags)
+{
 	struct drm_mm_node *entry;
 	struct drm_mm_node *best;
-	unsigned long adj_start;
+	u64 adj_start;
-	unsigned long adj_end;
+	u64 adj_end;
-	unsigned long best_size;
+	u64 best_size;
 	BUG_ON(mm->scanned_blocks);
 	best = NULL;
 	best_size = ~0UL;
 	__drm_mm_for_each_hole(entry, mm, adj_start, adj_end,
 			       flags & DRM_MM_SEARCH_BELOW) {
  * Warning:
  * As long as the scan list is non-empty, no other operations than
  * adding/removing nodes to/from the scan list are allowed.
  */
 void drm_mm_init_scan(struct drm_mm *mm,
-		      unsigned long size,
+		      u64 size,
 		      unsigned alignment,
 		      unsigned long color)
+{
 	mm->scan_color = color;
 	mm->scan_alignment = alignment;
  * Warning:
  * As long as the scan list is non-empty, no other operations than
  * adding/removing nodes to/from the scan list are allowed.
  */
 void drm_mm_init_scan_with_range(struct drm_mm *mm,
-				 unsigned long size,
+				 u64 size,
 				 unsigned alignment,
 				 unsigned long color,
-				 unsigned long start,
+				 u64 start,
-				 unsigned long end)
+				 u64 end)
+{
 	mm->scan_color = color;
 	mm->scan_alignment = alignment;
 	mm->scan_size = size;
 	mm->scanned_blocks = 0;
  */
 bool drm_mm_scan_add_block(struct drm_mm_node *node)
+{
 	struct drm_mm *mm = node->mm;
 	struct drm_mm_node *prev_node;
-	unsigned long hole_start, hole_end;
+	u64 hole_start, hole_end;
-	unsigned long adj_start, adj_end;
+	u64 adj_start, adj_end;
 	mm->scanned_blocks++;
  * @start: start of the range managed by @mm
  * @size: end of the range managed by @mm
+ *
  * Note that @mm must be cleared to 0 before calling this function.
  */
-void drm_mm_init(struct drm_mm * mm, unsigned long start, unsigned long size)
+void drm_mm_init(struct drm_mm * mm, u64 start, u64 size)
+{
 	INIT_LIST_HEAD(&mm->hole_stack);
 	mm->scanned_blocks = 0;
 	WARN(!list_empty(&mm->head_node.node_list),
 	     "Memory manager not clean during takedown.\n");
+}
 EXPORT_SYMBOL(drm_mm_takedown);
-static unsigned long drm_mm_debug_hole(struct drm_mm_node *entry,
+static u64 drm_mm_debug_hole(struct drm_mm_node *entry,
-				       const char *prefix)
+				     const char *prefix)
 {
-	unsigned long hole_start, hole_end, hole_size;
+	u64 hole_start, hole_end, hole_size;
 	if (entry->hole_follows) {
 		hole_start = drm_mm_hole_node_start(entry);
 		hole_end = drm_mm_hole_node_end(entry);
-	hole_size = hole_end - hole_start;
-		printk(KERN_DEBUG "%s 0x%08lx-0x%08lx: %8lu: free\n",
+		hole_size = hole_end - hole_start;
-			prefix, hole_start, hole_end,
+		pr_debug("%s %#llx-%#llx: %llu: free\n", prefix, hole_start,
-			hole_size);
+			 hole_end, hole_size);
 		return hole_size;
+	}
  * @prefix: prefix to use for dumping to dmesg
  */
 void drm_mm_debug_table(struct drm_mm *mm, const char *prefix)
+{
 	struct drm_mm_node *entry;
-	unsigned long total_used = 0, total_free = 0, total = 0;
+	u64 total_used = 0, total_free = 0, total = 0;
 	total_free += drm_mm_debug_hole(&mm->head_node, prefix);
 	drm_mm_for_each_node(entry, mm) {
-		printk(KERN_DEBUG "%s 0x%08lx-0x%08lx: %8lu: used\n",
-			prefix, entry->start, entry->start + entry->size,
+		pr_debug("%s %#llx-%#llx: %llu: used\n", prefix, entry->start,
-			entry->size);
+			 entry->start + entry->size, entry->size);
 		total_used += entry->size;
 		total_free += drm_mm_debug_hole(entry, prefix);
-		}
+	}
 	total = total_free + total_used;
-	printk(KERN_DEBUG "%s total: %lu, used %lu free %lu\n", prefix, total,
+	pr_debug("%s total: %llu, used %llu free %llu\n", prefix, total,
-		total_used, total_free);
+		 total_used, total_free);
 }
 EXPORT_SYMBOL(drm_mm_debug_table);
 #if defined(CONFIG_DEBUG_FS)
-static unsigned long drm_mm_dump_hole(struct seq_file *m, struct drm_mm_node *entry)
+static u64 drm_mm_dump_hole(struct seq_file *m, struct drm_mm_node *entry)
+{
-	unsigned long hole_start, hole_end, hole_size;
+	u64 hole_start, hole_end, hole_size;
 	if (entry->hole_follows) {
 		hole_start = drm_mm_hole_node_start(entry);
 		hole_end = drm_mm_hole_node_end(entry);
-	hole_size = hole_end - hole_start;
+		hole_size = hole_end - hole_start;
-		seq_printf(m, "0x%08lx-0x%08lx: 0x%08lx: free\n",
+		seq_printf(m, "%#018llx-%#018llx: %llu: free\n", hole_start,
  * @mm: drm_mm allocator to dump
  */
 int drm_mm_dump_table(struct seq_file *m, struct drm_mm *mm)
+{
 	struct drm_mm_node *entry;
-	unsigned long total_used = 0, total_free = 0, total = 0;
+	u64 total_used = 0, total_free = 0, total = 0;
 	total_free += drm_mm_dump_hole(m, &mm->head_node);
 	drm_mm_for_each_node(entry, mm) {
-		seq_printf(m, "0x%08lx-0x%08lx: 0x%08lx: used\n",
-				entry->start, entry->start + entry->size,
+		seq_printf(m, "%#018llx-%#018llx: %llu: used\n", entry->start,
-				entry->size);
+			   entry->start + entry->size, entry->size);
 		total_used += entry->size;
 		total_free += drm_mm_dump_hole(m, entry);
-		}
+	}
+	total = total_free + total_used;
 	total = total_free + total_used;
 	seq_printf(m, "total: %llu, used %llu free %llu\n", total,
-	seq_printf(m, "total: %lu, used %lu free %lu\n", total, total_used, total_free);
+		   total_used, total_free);
 	return 0;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/drm_mm.c @ 1233 – Rev 5060 → 6084