2 * This file is subject to the terms and conditions of the GNU General Public
3 * License. See the file "COPYING" in the main directory of this archive
6 * Copyright (C) 2001-2006 Silicon Graphics, Inc. All rights reserved.
9 #include <linux/types.h>
10 #include <asm/sn/sn_sal.h>
11 #include <asm/sn/pcibr_provider.h>
12 #include <asm/sn/pcibus_provider_defs.h>
13 #include <asm/sn/pcidev.h>
15 int pcibr_invalidate_ate; /* by default don't invalidate ATE on free */
18 * mark_ate: Mark the ate as either free or inuse.
20 static void mark_ate(struct ate_resource *ate_resource, int start, int number,
23 u64 *ate = ate_resource->ate;
27 for (index = start; length < number; index++, length++)
32 * find_free_ate: Find the first free ate index starting from the given
33 * index for the desired consecutive count.
35 static int find_free_ate(struct ate_resource *ate_resource, int start,
38 u64 *ate = ate_resource->ate;
42 for (index = start; index < ate_resource->num_ate;) {
47 start_free = index; /* Found start free ate */
48 for (i = start_free; i < ate_resource->num_ate; i++) {
49 if (!ate[i]) { /* This is free */
57 if (i >= ate_resource->num_ate)
60 index++; /* Try next ate */
67 * free_ate_resource: Free the requested number of ATEs.
69 static inline void free_ate_resource(struct ate_resource *ate_resource,
72 mark_ate(ate_resource, start, ate_resource->ate[start], 0);
73 if ((ate_resource->lowest_free_index > start) ||
74 (ate_resource->lowest_free_index < 0))
75 ate_resource->lowest_free_index = start;
79 * alloc_ate_resource: Allocate the requested number of ATEs.
81 static inline int alloc_ate_resource(struct ate_resource *ate_resource,
87 * Check for ate exhaustion.
89 if (ate_resource->lowest_free_index < 0)
93 * Find the required number of free consecutive ates.
96 find_free_ate(ate_resource, ate_resource->lowest_free_index,
99 mark_ate(ate_resource, start_index, ate_needed, ate_needed);
101 ate_resource->lowest_free_index =
102 find_free_ate(ate_resource, ate_resource->lowest_free_index, 1);
108 * Allocate "count" contiguous Bridge Address Translation Entries
109 * on the specified bridge to be used for PCI to XTALK mappings.
110 * Indices in rm map range from 1..num_entries. Indices returned
111 * to caller range from 0..num_entries-1.
113 * Return the start index on success, -1 on failure.
115 int pcibr_ate_alloc(struct pcibus_info *pcibus_info, int count)
120 spin_lock_irqsave(&pcibus_info->pbi_lock, flags);
121 status = alloc_ate_resource(&pcibus_info->pbi_int_ate_resource, count);
122 spin_unlock_irqrestore(&pcibus_info->pbi_lock, flags);
128 * Setup an Address Translation Entry as specified. Use either the Bridge
129 * internal maps or the external map RAM, as appropriate.
131 static inline u64 __iomem *pcibr_ate_addr(struct pcibus_info *pcibus_info,
134 if (ate_index < pcibus_info->pbi_int_ate_size) {
135 return pcireg_int_ate_addr(pcibus_info, ate_index);
137 panic("pcibr_ate_addr: invalid ate_index 0x%x", ate_index);
144 ate_write(struct pcibus_info *pcibus_info, int ate_index, int count,
147 while (count-- > 0) {
148 if (ate_index < pcibus_info->pbi_int_ate_size) {
149 pcireg_int_ate_set(pcibus_info, ate_index, ate);
151 panic("ate_write: invalid ate_index 0x%x", ate_index);
157 pcireg_tflush_get(pcibus_info); /* wait until Bridge PIO complete */
160 void pcibr_ate_free(struct pcibus_info *pcibus_info, int index)
167 if (pcibr_invalidate_ate) {
168 /* For debugging purposes, clear the valid bit in the ATE */
169 ate = *pcibr_ate_addr(pcibus_info, index);
170 count = pcibus_info->pbi_int_ate_resource.ate[index];
171 ate_write(pcibus_info, index, count, (ate & ~PCI32_ATE_V));
174 spin_lock_irqsave(&pcibus_info->pbi_lock, flags);
175 free_ate_resource(&pcibus_info->pbi_int_ate_resource, index);
176 spin_unlock_irqrestore(&pcibus_info->pbi_lock, flags);