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); 342