ia64: allocate percpu area for cpu0 like percpu areas for other cpus
[linux-2.6.git] / arch / ia64 / sn / pci / pcibr / pcibr_ate.c
1 /*
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
4  * for more details.
5  *
6  * Copyright (C) 2001-2006 Silicon Graphics, Inc. All rights reserved.
7  */
8
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>
14
15 int pcibr_invalidate_ate;       /* by default don't invalidate ATE on free */
16
17 /*
18  * mark_ate: Mark the ate as either free or inuse.
19  */
20 static void mark_ate(struct ate_resource *ate_resource, int start, int number,
21                      u64 value)
22 {
23         u64 *ate = ate_resource->ate;
24         int index;
25         int length = 0;
26
27         for (index = start; length < number; index++, length++)
28                 ate[index] = value;
29 }
30
31 /*
32  * find_free_ate:  Find the first free ate index starting from the given
33  *                 index for the desired consecutive count.
34  */
35 static int find_free_ate(struct ate_resource *ate_resource, int start,
36                          int count)
37 {
38         u64 *ate = ate_resource->ate;
39         int index;
40         int start_free;
41
42         for (index = start; index < ate_resource->num_ate;) {
43                 if (!ate[index]) {
44                         int i;
45                         int free;
46                         free = 0;
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 */
50                                         if (++free == count)
51                                                 return start_free;
52                                 } else {
53                                         index = i + 1;
54                                         break;
55                                 }
56                         }
57                         if (i >= ate_resource->num_ate)
58                                 return -1;
59                 } else
60                         index++;        /* Try next ate */
61         }
62
63         return -1;
64 }
65
66 /*
67  * free_ate_resource:  Free the requested number of ATEs.
68  */
69 static inline void free_ate_resource(struct ate_resource *ate_resource,
70                                      int start)
71 {
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;
76 }
77
78 /*
79  * alloc_ate_resource:  Allocate the requested number of ATEs.
80  */
81 static inline int alloc_ate_resource(struct ate_resource *ate_resource,
82                                      int ate_needed)
83 {
84         int start_index;
85
86         /*
87          * Check for ate exhaustion.
88          */
89         if (ate_resource->lowest_free_index < 0)
90                 return -1;
91
92         /*
93          * Find the required number of free consecutive ates.
94          */
95         start_index =
96             find_free_ate(ate_resource, ate_resource->lowest_free_index,
97                           ate_needed);
98         if (start_index >= 0)
99                 mark_ate(ate_resource, start_index, ate_needed, ate_needed);
100
101         ate_resource->lowest_free_index =
102             find_free_ate(ate_resource, ate_resource->lowest_free_index, 1);
103
104         return start_index;
105 }
106
107 /*
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.
112  *
113  * Return the start index on success, -1 on failure.
114  */
115 int pcibr_ate_alloc(struct pcibus_info *pcibus_info, int count)
116 {
117         int status;
118         unsigned long flags;
119
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);
123
124         return status;
125 }
126
127 /*
128  * Setup an Address Translation Entry as specified.  Use either the Bridge
129  * internal maps or the external map RAM, as appropriate.
130  */
131 static inline u64 __iomem *pcibr_ate_addr(struct pcibus_info *pcibus_info,
132                                        int ate_index)
133 {
134         if (ate_index < pcibus_info->pbi_int_ate_size) {
135                 return pcireg_int_ate_addr(pcibus_info, ate_index);
136         }
137         panic("pcibr_ate_addr: invalid ate_index 0x%x", ate_index);
138 }
139
140 /*
141  * Update the ate.
142  */
143 void inline
144 ate_write(struct pcibus_info *pcibus_info, int ate_index, int count,
145           volatile u64 ate)
146 {
147         while (count-- > 0) {
148                 if (ate_index < pcibus_info->pbi_int_ate_size) {
149                         pcireg_int_ate_set(pcibus_info, ate_index, ate);
150                 } else {
151                         panic("ate_write: invalid ate_index 0x%x", ate_index);
152                 }
153                 ate_index++;
154                 ate += IOPGSIZE;
155         }
156
157         pcireg_tflush_get(pcibus_info); /* wait until Bridge PIO complete */
158 }
159
160 void pcibr_ate_free(struct pcibus_info *pcibus_info, int index)
161 {
162
163         volatile u64 ate;
164         int count;
165         unsigned long flags;
166
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));
172         }
173
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);
177 }