]> git.karo-electronics.de Git - karo-tx-linux.git/blob - drivers/edac/edac_pci.c
Replace <asm/uaccess.h> with <linux/uaccess.h> globally
[karo-tx-linux.git] / drivers / edac / edac_pci.c
1 /*
2  * EDAC PCI component
3  *
4  * Author: Dave Jiang <djiang@mvista.com>
5  *
6  * 2007 (c) MontaVista Software, Inc. This file is licensed under
7  * the terms of the GNU General Public License version 2. This program
8  * is licensed "as is" without any warranty of any kind, whether express
9  * or implied.
10  *
11  */
12 #include <asm/page.h>
13 #include <linux/uaccess.h>
14 #include <linux/ctype.h>
15 #include <linux/highmem.h>
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/smp.h>
20 #include <linux/spinlock.h>
21 #include <linux/sysctl.h>
22 #include <linux/timer.h>
23
24 #include "edac_pci.h"
25 #include "edac_module.h"
26
27 static DEFINE_MUTEX(edac_pci_ctls_mutex);
28 static LIST_HEAD(edac_pci_list);
29 static atomic_t pci_indexes = ATOMIC_INIT(0);
30
31 struct edac_pci_ctl_info *edac_pci_alloc_ctl_info(unsigned int sz_pvt,
32                                                 const char *edac_pci_name)
33 {
34         struct edac_pci_ctl_info *pci;
35         void *p = NULL, *pvt;
36         unsigned int size;
37
38         edac_dbg(1, "\n");
39
40         pci = edac_align_ptr(&p, sizeof(*pci), 1);
41         pvt = edac_align_ptr(&p, 1, sz_pvt);
42         size = ((unsigned long)pvt) + sz_pvt;
43
44         /* Alloc the needed control struct memory */
45         pci = kzalloc(size, GFP_KERNEL);
46         if (pci  == NULL)
47                 return NULL;
48
49         /* Now much private space */
50         pvt = sz_pvt ? ((char *)pci) + ((unsigned long)pvt) : NULL;
51
52         pci->pvt_info = pvt;
53         pci->op_state = OP_ALLOC;
54
55         snprintf(pci->name, strlen(edac_pci_name) + 1, "%s", edac_pci_name);
56
57         return pci;
58 }
59 EXPORT_SYMBOL_GPL(edac_pci_alloc_ctl_info);
60
61 void edac_pci_free_ctl_info(struct edac_pci_ctl_info *pci)
62 {
63         edac_dbg(1, "\n");
64
65         edac_pci_remove_sysfs(pci);
66 }
67 EXPORT_SYMBOL_GPL(edac_pci_free_ctl_info);
68
69 /*
70  * find_edac_pci_by_dev()
71  *      scans the edac_pci list for a specific 'struct device *'
72  *
73  *      return NULL if not found, or return control struct pointer
74  */
75 static struct edac_pci_ctl_info *find_edac_pci_by_dev(struct device *dev)
76 {
77         struct edac_pci_ctl_info *pci;
78         struct list_head *item;
79
80         edac_dbg(1, "\n");
81
82         list_for_each(item, &edac_pci_list) {
83                 pci = list_entry(item, struct edac_pci_ctl_info, link);
84
85                 if (pci->dev == dev)
86                         return pci;
87         }
88
89         return NULL;
90 }
91
92 /*
93  * add_edac_pci_to_global_list
94  *      Before calling this function, caller must assign a unique value to
95  *      edac_dev->pci_idx.
96  *      Return:
97  *              0 on success
98  *              1 on failure
99  */
100 static int add_edac_pci_to_global_list(struct edac_pci_ctl_info *pci)
101 {
102         struct list_head *item, *insert_before;
103         struct edac_pci_ctl_info *rover;
104
105         edac_dbg(1, "\n");
106
107         insert_before = &edac_pci_list;
108
109         /* Determine if already on the list */
110         rover = find_edac_pci_by_dev(pci->dev);
111         if (unlikely(rover != NULL))
112                 goto fail0;
113
114         /* Insert in ascending order by 'pci_idx', so find position */
115         list_for_each(item, &edac_pci_list) {
116                 rover = list_entry(item, struct edac_pci_ctl_info, link);
117
118                 if (rover->pci_idx >= pci->pci_idx) {
119                         if (unlikely(rover->pci_idx == pci->pci_idx))
120                                 goto fail1;
121
122                         insert_before = item;
123                         break;
124                 }
125         }
126
127         list_add_tail_rcu(&pci->link, insert_before);
128         return 0;
129
130 fail0:
131         edac_printk(KERN_WARNING, EDAC_PCI,
132                 "%s (%s) %s %s already assigned %d\n",
133                 dev_name(rover->dev), edac_dev_name(rover),
134                 rover->mod_name, rover->ctl_name, rover->pci_idx);
135         return 1;
136
137 fail1:
138         edac_printk(KERN_WARNING, EDAC_PCI,
139                 "but in low-level driver: attempt to assign\n"
140                 "\tduplicate pci_idx %d in %s()\n", rover->pci_idx,
141                 __func__);
142         return 1;
143 }
144
145 /*
146  * del_edac_pci_from_global_list
147  *
148  *      remove the PCI control struct from the global list
149  */
150 static void del_edac_pci_from_global_list(struct edac_pci_ctl_info *pci)
151 {
152         list_del_rcu(&pci->link);
153
154         /* these are for safe removal of devices from global list while
155          * NMI handlers may be traversing list
156          */
157         synchronize_rcu();
158         INIT_LIST_HEAD(&pci->link);
159 }
160
161 /*
162  * edac_pci_workq_function()
163  *
164  *      periodic function that performs the operation
165  *      scheduled by a workq request, for a given PCI control struct
166  */
167 static void edac_pci_workq_function(struct work_struct *work_req)
168 {
169         struct delayed_work *d_work = to_delayed_work(work_req);
170         struct edac_pci_ctl_info *pci = to_edac_pci_ctl_work(d_work);
171         int msec;
172         unsigned long delay;
173
174         edac_dbg(3, "checking\n");
175
176         mutex_lock(&edac_pci_ctls_mutex);
177
178         if (pci->op_state != OP_RUNNING_POLL) {
179                 mutex_unlock(&edac_pci_ctls_mutex);
180                 return;
181         }
182
183         if (edac_pci_get_check_errors())
184                 pci->edac_check(pci);
185
186         /* if we are on a one second period, then use round */
187         msec = edac_pci_get_poll_msec();
188         if (msec == 1000)
189                 delay = round_jiffies_relative(msecs_to_jiffies(msec));
190         else
191                 delay = msecs_to_jiffies(msec);
192
193         edac_queue_work(&pci->work, delay);
194
195         mutex_unlock(&edac_pci_ctls_mutex);
196 }
197
198 int edac_pci_alloc_index(void)
199 {
200         return atomic_inc_return(&pci_indexes) - 1;
201 }
202 EXPORT_SYMBOL_GPL(edac_pci_alloc_index);
203
204 int edac_pci_add_device(struct edac_pci_ctl_info *pci, int edac_idx)
205 {
206         edac_dbg(0, "\n");
207
208         pci->pci_idx = edac_idx;
209         pci->start_time = jiffies;
210
211         mutex_lock(&edac_pci_ctls_mutex);
212
213         if (add_edac_pci_to_global_list(pci))
214                 goto fail0;
215
216         if (edac_pci_create_sysfs(pci)) {
217                 edac_pci_printk(pci, KERN_WARNING,
218                                 "failed to create sysfs pci\n");
219                 goto fail1;
220         }
221
222         if (pci->edac_check) {
223                 pci->op_state = OP_RUNNING_POLL;
224
225                 INIT_DELAYED_WORK(&pci->work, edac_pci_workq_function);
226                 edac_queue_work(&pci->work, msecs_to_jiffies(edac_pci_get_poll_msec()));
227
228         } else {
229                 pci->op_state = OP_RUNNING_INTERRUPT;
230         }
231
232         edac_pci_printk(pci, KERN_INFO,
233                 "Giving out device to module %s controller %s: DEV %s (%s)\n",
234                 pci->mod_name, pci->ctl_name, pci->dev_name,
235                 edac_op_state_to_string(pci->op_state));
236
237         mutex_unlock(&edac_pci_ctls_mutex);
238         return 0;
239
240         /* error unwind stack */
241 fail1:
242         del_edac_pci_from_global_list(pci);
243 fail0:
244         mutex_unlock(&edac_pci_ctls_mutex);
245         return 1;
246 }
247 EXPORT_SYMBOL_GPL(edac_pci_add_device);
248
249 struct edac_pci_ctl_info *edac_pci_del_device(struct device *dev)
250 {
251         struct edac_pci_ctl_info *pci;
252
253         edac_dbg(0, "\n");
254
255         mutex_lock(&edac_pci_ctls_mutex);
256
257         /* ensure the control struct is on the global list
258          * if not, then leave
259          */
260         pci = find_edac_pci_by_dev(dev);
261         if (pci  == NULL) {
262                 mutex_unlock(&edac_pci_ctls_mutex);
263                 return NULL;
264         }
265
266         pci->op_state = OP_OFFLINE;
267
268         del_edac_pci_from_global_list(pci);
269
270         mutex_unlock(&edac_pci_ctls_mutex);
271
272         if (pci->edac_check)
273                 edac_stop_work(&pci->work);
274
275         edac_printk(KERN_INFO, EDAC_PCI,
276                 "Removed device %d for %s %s: DEV %s\n",
277                 pci->pci_idx, pci->mod_name, pci->ctl_name, edac_dev_name(pci));
278
279         return pci;
280 }
281 EXPORT_SYMBOL_GPL(edac_pci_del_device);
282
283 /*
284  * edac_pci_generic_check
285  *
286  *      a Generic parity check API
287  */
288 static void edac_pci_generic_check(struct edac_pci_ctl_info *pci)
289 {
290         edac_dbg(4, "\n");
291         edac_pci_do_parity_check();
292 }
293
294 /* free running instance index counter */
295 static int edac_pci_idx;
296 #define EDAC_PCI_GENCTL_NAME    "EDAC PCI controller"
297
298 struct edac_pci_gen_data {
299         int edac_idx;
300 };
301
302 struct edac_pci_ctl_info *edac_pci_create_generic_ctl(struct device *dev,
303                                                 const char *mod_name)
304 {
305         struct edac_pci_ctl_info *pci;
306         struct edac_pci_gen_data *pdata;
307
308         pci = edac_pci_alloc_ctl_info(sizeof(*pdata), EDAC_PCI_GENCTL_NAME);
309         if (!pci)
310                 return NULL;
311
312         pdata = pci->pvt_info;
313         pci->dev = dev;
314         dev_set_drvdata(pci->dev, pci);
315         pci->dev_name = pci_name(to_pci_dev(dev));
316
317         pci->mod_name = mod_name;
318         pci->ctl_name = EDAC_PCI_GENCTL_NAME;
319         if (edac_op_state == EDAC_OPSTATE_POLL)
320                 pci->edac_check = edac_pci_generic_check;
321
322         pdata->edac_idx = edac_pci_idx++;
323
324         if (edac_pci_add_device(pci, pdata->edac_idx) > 0) {
325                 edac_dbg(3, "failed edac_pci_add_device()\n");
326                 edac_pci_free_ctl_info(pci);
327                 return NULL;
328         }
329
330         return pci;
331 }
332 EXPORT_SYMBOL_GPL(edac_pci_create_generic_ctl);
333
334 void edac_pci_release_generic_ctl(struct edac_pci_ctl_info *pci)
335 {
336         edac_dbg(0, "pci mod=%s\n", pci->mod_name);
337
338         edac_pci_del_device(pci->dev);
339         edac_pci_free_ctl_info(pci);
340 }
341 EXPORT_SYMBOL_GPL(edac_pci_release_generic_ctl);