1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * IBM Accelerator Family 'GenWQE' 4 * 5 * (C) Copyright IBM Corp. 2013 6 * 7 * Author: Frank Haverkamp <haver@linux.vnet.ibm.com> 8 * Author: Joerg-Stephan Vogt <jsvogt@de.ibm.com> 9 * Author: Michael Jung <mijung@gmx.net> 10 * Author: Michael Ruettger <michael@ibmra.de> 11 */ 12 13 /* 14 * Module initialization and PCIe setup. Card health monitoring and 15 * recovery functionality. Character device creation and deletion are 16 * controlled from here. 17 */ 18 19 #include <linux/types.h> 20 #include <linux/pci.h> 21 #include <linux/err.h> 22 #include <linux/aer.h> 23 #include <linux/string.h> 24 #include <linux/sched.h> 25 #include <linux/wait.h> 26 #include <linux/delay.h> 27 #include <linux/dma-mapping.h> 28 #include <linux/module.h> 29 #include <linux/notifier.h> 30 #include <linux/device.h> 31 #include <linux/log2.h> 32 33 #include "card_base.h" 34 #include "card_ddcb.h" 35 36 MODULE_AUTHOR("Frank Haverkamp <haver@linux.vnet.ibm.com>"); 37 MODULE_AUTHOR("Michael Ruettger <michael@ibmra.de>"); 38 MODULE_AUTHOR("Joerg-Stephan Vogt <jsvogt@de.ibm.com>"); 39 MODULE_AUTHOR("Michael Jung <mijung@gmx.net>"); 40 41 MODULE_DESCRIPTION("GenWQE Card"); 42 MODULE_VERSION(DRV_VERSION); 43 MODULE_LICENSE("GPL"); 44 45 static char genwqe_driver_name[] = GENWQE_DEVNAME; 46 static struct class *class_genwqe; 47 static struct dentry *debugfs_genwqe; 48 static struct genwqe_dev *genwqe_devices[GENWQE_CARD_NO_MAX]; 49 50 /* PCI structure for identifying device by PCI vendor and device ID */ 51 static const struct pci_device_id genwqe_device_table[] = { 52 { .vendor = PCI_VENDOR_ID_IBM, 53 .device = PCI_DEVICE_GENWQE, 54 .subvendor = PCI_SUBVENDOR_ID_IBM, 55 .subdevice = PCI_SUBSYSTEM_ID_GENWQE5, 56 .class = (PCI_CLASSCODE_GENWQE5 << 8), 57 .class_mask = ~0, 58 .driver_data = 0 }, 59 60 /* Initial SR-IOV bring-up image */ 61 { .vendor = PCI_VENDOR_ID_IBM, 62 .device = PCI_DEVICE_GENWQE, 63 .subvendor = PCI_SUBVENDOR_ID_IBM_SRIOV, 64 .subdevice = PCI_SUBSYSTEM_ID_GENWQE5_SRIOV, 65 .class = (PCI_CLASSCODE_GENWQE5_SRIOV << 8), 66 .class_mask = ~0, 67 .driver_data = 0 }, 68 69 { .vendor = PCI_VENDOR_ID_IBM, /* VF Vendor ID */ 70 .device = 0x0000, /* VF Device ID */ 71 .subvendor = PCI_SUBVENDOR_ID_IBM_SRIOV, 72 .subdevice = PCI_SUBSYSTEM_ID_GENWQE5_SRIOV, 73 .class = (PCI_CLASSCODE_GENWQE5_SRIOV << 8), 74 .class_mask = ~0, 75 .driver_data = 0 }, 76 77 /* Fixed up image */ 78 { .vendor = PCI_VENDOR_ID_IBM, 79 .device = PCI_DEVICE_GENWQE, 80 .subvendor = PCI_SUBVENDOR_ID_IBM_SRIOV, 81 .subdevice = PCI_SUBSYSTEM_ID_GENWQE5, 82 .class = (PCI_CLASSCODE_GENWQE5_SRIOV << 8), 83 .class_mask = ~0, 84 .driver_data = 0 }, 85 86 { .vendor = PCI_VENDOR_ID_IBM, /* VF Vendor ID */ 87 .device = 0x0000, /* VF Device ID */ 88 .subvendor = PCI_SUBVENDOR_ID_IBM_SRIOV, 89 .subdevice = PCI_SUBSYSTEM_ID_GENWQE5, 90 .class = (PCI_CLASSCODE_GENWQE5_SRIOV << 8), 91 .class_mask = ~0, 92 .driver_data = 0 }, 93 94 /* Even one more ... */ 95 { .vendor = PCI_VENDOR_ID_IBM, 96 .device = PCI_DEVICE_GENWQE, 97 .subvendor = PCI_SUBVENDOR_ID_IBM, 98 .subdevice = PCI_SUBSYSTEM_ID_GENWQE5_NEW, 99 .class = (PCI_CLASSCODE_GENWQE5 << 8), 100 .class_mask = ~0, 101 .driver_data = 0 }, 102 103 { 0, } /* 0 terminated list. */ 104 }; 105 106 MODULE_DEVICE_TABLE(pci, genwqe_device_table); 107 108 /** 109 * genwqe_dev_alloc() - Create and prepare a new card descriptor 110 * 111 * Return: Pointer to card descriptor, or ERR_PTR(err) on error 112 */ 113 static struct genwqe_dev *genwqe_dev_alloc(void) 114 { 115 unsigned int i = 0, j; 116 struct genwqe_dev *cd; 117 118 for (i = 0; i < GENWQE_CARD_NO_MAX; i++) { 119 if (genwqe_devices[i] == NULL) 120 break; 121 } 122 if (i >= GENWQE_CARD_NO_MAX) 123 return ERR_PTR(-ENODEV); 124 125 cd = kzalloc(sizeof(struct genwqe_dev), GFP_KERNEL); 126 if (!cd) 127 return ERR_PTR(-ENOMEM); 128 129 cd->card_idx = i; 130 cd->class_genwqe = class_genwqe; 131 cd->debugfs_genwqe = debugfs_genwqe; 132 133 /* 134 * This comes from kernel config option and can be overritten via 135 * debugfs. 136 */ 137 cd->use_platform_recovery = CONFIG_GENWQE_PLATFORM_ERROR_RECOVERY; 138 139 init_waitqueue_head(&cd->queue_waitq); 140 141 spin_lock_init(&cd->file_lock); 142 INIT_LIST_HEAD(&cd->file_list); 143 144 cd->card_state = GENWQE_CARD_UNUSED; 145 spin_lock_init(&cd->print_lock); 146 147 cd->ddcb_software_timeout = GENWQE_DDCB_SOFTWARE_TIMEOUT; 148 cd->kill_timeout = GENWQE_KILL_TIMEOUT; 149 150 for (j = 0; j < GENWQE_MAX_VFS; j++) 151 cd->vf_jobtimeout_msec[j] = GENWQE_VF_JOBTIMEOUT_MSEC; 152 153 genwqe_devices[i] = cd; 154 return cd; 155 } 156 157 static void genwqe_dev_free(struct genwqe_dev *cd) 158 { 159 if (!cd) 160 return; 161 162 genwqe_devices[cd->card_idx] = NULL; 163 kfree(cd); 164 } 165 166 /** 167 * genwqe_bus_reset() - Card recovery 168 * @cd: GenWQE device information 169 * 170 * pci_reset_function() will recover the device and ensure that the 171 * registers are accessible again when it completes with success. If 172 * not, the card will stay dead and registers will be unaccessible 173 * still. 174 */ 175 static int genwqe_bus_reset(struct genwqe_dev *cd) 176 { 177 int rc = 0; 178 struct pci_dev *pci_dev = cd->pci_dev; 179 void __iomem *mmio; 180 181 if (cd->err_inject & GENWQE_INJECT_BUS_RESET_FAILURE) 182 return -EIO; 183 184 mmio = cd->mmio; 185 cd->mmio = NULL; 186 pci_iounmap(pci_dev, mmio); 187 188 pci_release_mem_regions(pci_dev); 189 190 /* 191 * Firmware/BIOS might change memory mapping during bus reset. 192 * Settings like enable bus-mastering, ... are backuped and 193 * restored by the pci_reset_function(). 194 */ 195 dev_dbg(&pci_dev->dev, "[%s] pci_reset function ...\n", __func__); 196 rc = pci_reset_function(pci_dev); 197 if (rc) { 198 dev_err(&pci_dev->dev, 199 "[%s] err: failed reset func (rc %d)\n", __func__, rc); 200 return rc; 201 } 202 dev_dbg(&pci_dev->dev, "[%s] done with rc=%d\n", __func__, rc); 203 204 /* 205 * Here is the right spot to clear the register read 206 * failure. pci_bus_reset() does this job in real systems. 207 */ 208 cd->err_inject &= ~(GENWQE_INJECT_HARDWARE_FAILURE | 209 GENWQE_INJECT_GFIR_FATAL | 210 GENWQE_INJECT_GFIR_INFO); 211 212 rc = pci_request_mem_regions(pci_dev, genwqe_driver_name); 213 if (rc) { 214 dev_err(&pci_dev->dev, 215 "[%s] err: request bars failed (%d)\n", __func__, rc); 216 return -EIO; 217 } 218 219 cd->mmio = pci_iomap(pci_dev, 0, 0); 220 if (cd->mmio == NULL) { 221 dev_err(&pci_dev->dev, 222 "[%s] err: mapping BAR0 failed\n", __func__); 223 return -ENOMEM; 224 } 225 return 0; 226 } 227 228 /* 229 * Hardware circumvention section. Certain bitstreams in our test-lab 230 * had different kinds of problems. Here is where we adjust those 231 * bitstreams to function will with this version of our device driver. 232 * 233 * Thise circumventions are applied to the physical function only. 234 * The magical numbers below are identifying development/manufacturing 235 * versions of the bitstream used on the card. 236 * 237 * Turn off error reporting for old/manufacturing images. 238 */ 239 240 bool genwqe_need_err_masking(struct genwqe_dev *cd) 241 { 242 return (cd->slu_unitcfg & 0xFFFF0ull) < 0x32170ull; 243 } 244 245 static void genwqe_tweak_hardware(struct genwqe_dev *cd) 246 { 247 struct pci_dev *pci_dev = cd->pci_dev; 248 249 /* Mask FIRs for development images */ 250 if (((cd->slu_unitcfg & 0xFFFF0ull) >= 0x32000ull) && 251 ((cd->slu_unitcfg & 0xFFFF0ull) <= 0x33250ull)) { 252 dev_warn(&pci_dev->dev, 253 "FIRs masked due to bitstream %016llx.%016llx\n", 254 cd->slu_unitcfg, cd->app_unitcfg); 255 256 __genwqe_writeq(cd, IO_APP_SEC_LEM_DEBUG_OVR, 257 0xFFFFFFFFFFFFFFFFull); 258 259 __genwqe_writeq(cd, IO_APP_ERR_ACT_MASK, 260 0x0000000000000000ull); 261 } 262 } 263 264 /** 265 * genwqe_recovery_on_fatal_gfir_required() - Version depended actions 266 * @cd: GenWQE device information 267 * 268 * Bitstreams older than 2013-02-17 have a bug where fatal GFIRs must 269 * be ignored. This is e.g. true for the bitstream we gave to the card 270 * manufacturer, but also for some old bitstreams we released to our 271 * test-lab. 272 */ 273 int genwqe_recovery_on_fatal_gfir_required(struct genwqe_dev *cd) 274 { 275 return (cd->slu_unitcfg & 0xFFFF0ull) >= 0x32170ull; 276 } 277 278 int genwqe_flash_readback_fails(struct genwqe_dev *cd) 279 { 280 return (cd->slu_unitcfg & 0xFFFF0ull) < 0x32170ull; 281 } 282 283 /** 284 * genwqe_T_psec() - Calculate PF/VF timeout register content 285 * @cd: GenWQE device information 286 * 287 * Note: From a design perspective it turned out to be a bad idea to 288 * use codes here to specifiy the frequency/speed values. An old 289 * driver cannot understand new codes and is therefore always a 290 * problem. Better is to measure out the value or put the 291 * speed/frequency directly into a register which is always a valid 292 * value for old as well as for new software. 293 */ 294 /* T = 1/f */ 295 static int genwqe_T_psec(struct genwqe_dev *cd) 296 { 297 u16 speed; /* 1/f -> 250, 200, 166, 175 */ 298 static const int T[] = { 4000, 5000, 6000, 5714 }; 299 300 speed = (u16)((cd->slu_unitcfg >> 28) & 0x0full); 301 if (speed >= ARRAY_SIZE(T)) 302 return -1; /* illegal value */ 303 304 return T[speed]; 305 } 306 307 /** 308 * genwqe_setup_pf_jtimer() - Setup PF hardware timeouts for DDCB execution 309 * @cd: GenWQE device information 310 * 311 * Do this _after_ card_reset() is called. Otherwise the values will 312 * vanish. The settings need to be done when the queues are inactive. 313 * 314 * The max. timeout value is 2^(10+x) * T (6ns for 166MHz) * 15/16. 315 * The min. timeout value is 2^(10+x) * T (6ns for 166MHz) * 14/16. 316 */ 317 static bool genwqe_setup_pf_jtimer(struct genwqe_dev *cd) 318 { 319 u32 T = genwqe_T_psec(cd); 320 u64 x; 321 322 if (GENWQE_PF_JOBTIMEOUT_MSEC == 0) 323 return false; 324 325 /* PF: large value needed, flash update 2sec per block */ 326 x = ilog2(GENWQE_PF_JOBTIMEOUT_MSEC * 327 16000000000uL/(T * 15)) - 10; 328 329 genwqe_write_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT, 330 0xff00 | (x & 0xff), 0); 331 return true; 332 } 333 334 /** 335 * genwqe_setup_vf_jtimer() - Setup VF hardware timeouts for DDCB execution 336 * @cd: GenWQE device information 337 */ 338 static bool genwqe_setup_vf_jtimer(struct genwqe_dev *cd) 339 { 340 struct pci_dev *pci_dev = cd->pci_dev; 341 unsigned int vf; 342 u32 T = genwqe_T_psec(cd); 343 u64 x; 344 int totalvfs; 345 346 totalvfs = pci_sriov_get_totalvfs(pci_dev); 347 if (totalvfs <= 0) 348 return false; 349 350 for (vf = 0; vf < totalvfs; vf++) { 351 352 if (cd->vf_jobtimeout_msec[vf] == 0) 353 continue; 354 355 x = ilog2(cd->vf_jobtimeout_msec[vf] * 356 16000000000uL/(T * 15)) - 10; 357 358 genwqe_write_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT, 359 0xff00 | (x & 0xff), vf + 1); 360 } 361 return true; 362 } 363 364 static int genwqe_ffdc_buffs_alloc(struct genwqe_dev *cd) 365 { 366 unsigned int type, e = 0; 367 368 for (type = 0; type < GENWQE_DBG_UNITS; type++) { 369 switch (type) { 370 case GENWQE_DBG_UNIT0: 371 e = genwqe_ffdc_buff_size(cd, 0); 372 break; 373 case GENWQE_DBG_UNIT1: 374 e = genwqe_ffdc_buff_size(cd, 1); 375 break; 376 case GENWQE_DBG_UNIT2: 377 e = genwqe_ffdc_buff_size(cd, 2); 378 break; 379 case GENWQE_DBG_REGS: 380 e = GENWQE_FFDC_REGS; 381 break; 382 } 383 384 /* currently support only the debug units mentioned here */ 385 cd->ffdc[type].entries = e; 386 cd->ffdc[type].regs = 387 kmalloc_array(e, sizeof(struct genwqe_reg), 388 GFP_KERNEL); 389 /* 390 * regs == NULL is ok, the using code treats this as no regs, 391 * Printing warning is ok in this case. 392 */ 393 } 394 return 0; 395 } 396 397 static void genwqe_ffdc_buffs_free(struct genwqe_dev *cd) 398 { 399 unsigned int type; 400 401 for (type = 0; type < GENWQE_DBG_UNITS; type++) { 402 kfree(cd->ffdc[type].regs); 403 cd->ffdc[type].regs = NULL; 404 } 405 } 406 407 static int genwqe_read_ids(struct genwqe_dev *cd) 408 { 409 int err = 0; 410 int slu_id; 411 struct pci_dev *pci_dev = cd->pci_dev; 412 413 cd->slu_unitcfg = __genwqe_readq(cd, IO_SLU_UNITCFG); 414 if (cd->slu_unitcfg == IO_ILLEGAL_VALUE) { 415 dev_err(&pci_dev->dev, 416 "err: SLUID=%016llx\n", cd->slu_unitcfg); 417 err = -EIO; 418 goto out_err; 419 } 420 421 slu_id = genwqe_get_slu_id(cd); 422 if (slu_id < GENWQE_SLU_ARCH_REQ || slu_id == 0xff) { 423 dev_err(&pci_dev->dev, 424 "err: incompatible SLU Architecture %u\n", slu_id); 425 err = -ENOENT; 426 goto out_err; 427 } 428 429 cd->app_unitcfg = __genwqe_readq(cd, IO_APP_UNITCFG); 430 if (cd->app_unitcfg == IO_ILLEGAL_VALUE) { 431 dev_err(&pci_dev->dev, 432 "err: APPID=%016llx\n", cd->app_unitcfg); 433 err = -EIO; 434 goto out_err; 435 } 436 genwqe_read_app_id(cd, cd->app_name, sizeof(cd->app_name)); 437 438 /* 439 * Is access to all registers possible? If we are a VF the 440 * answer is obvious. If we run fully virtualized, we need to 441 * check if we can access all registers. If we do not have 442 * full access we will cause an UR and some informational FIRs 443 * in the PF, but that should not harm. 444 */ 445 if (pci_dev->is_virtfn) 446 cd->is_privileged = 0; 447 else 448 cd->is_privileged = (__genwqe_readq(cd, IO_SLU_BITSTREAM) 449 != IO_ILLEGAL_VALUE); 450 451 out_err: 452 return err; 453 } 454 455 static int genwqe_start(struct genwqe_dev *cd) 456 { 457 int err; 458 struct pci_dev *pci_dev = cd->pci_dev; 459 460 err = genwqe_read_ids(cd); 461 if (err) 462 return err; 463 464 if (genwqe_is_privileged(cd)) { 465 /* do this after the tweaks. alloc fail is acceptable */ 466 genwqe_ffdc_buffs_alloc(cd); 467 genwqe_stop_traps(cd); 468 469 /* Collect registers e.g. FIRs, UNITIDs, traces ... */ 470 genwqe_read_ffdc_regs(cd, cd->ffdc[GENWQE_DBG_REGS].regs, 471 cd->ffdc[GENWQE_DBG_REGS].entries, 0); 472 473 genwqe_ffdc_buff_read(cd, GENWQE_DBG_UNIT0, 474 cd->ffdc[GENWQE_DBG_UNIT0].regs, 475 cd->ffdc[GENWQE_DBG_UNIT0].entries); 476 477 genwqe_ffdc_buff_read(cd, GENWQE_DBG_UNIT1, 478 cd->ffdc[GENWQE_DBG_UNIT1].regs, 479 cd->ffdc[GENWQE_DBG_UNIT1].entries); 480 481 genwqe_ffdc_buff_read(cd, GENWQE_DBG_UNIT2, 482 cd->ffdc[GENWQE_DBG_UNIT2].regs, 483 cd->ffdc[GENWQE_DBG_UNIT2].entries); 484 485 genwqe_start_traps(cd); 486 487 if (cd->card_state == GENWQE_CARD_FATAL_ERROR) { 488 dev_warn(&pci_dev->dev, 489 "[%s] chip reload/recovery!\n", __func__); 490 491 /* 492 * Stealth Mode: Reload chip on either hot 493 * reset or PERST. 494 */ 495 cd->softreset = 0x7Cull; 496 __genwqe_writeq(cd, IO_SLC_CFGREG_SOFTRESET, 497 cd->softreset); 498 499 err = genwqe_bus_reset(cd); 500 if (err != 0) { 501 dev_err(&pci_dev->dev, 502 "[%s] err: bus reset failed!\n", 503 __func__); 504 goto out; 505 } 506 507 /* 508 * Re-read the IDs because 509 * it could happen that the bitstream load 510 * failed! 511 */ 512 err = genwqe_read_ids(cd); 513 if (err) 514 goto out; 515 } 516 } 517 518 err = genwqe_setup_service_layer(cd); /* does a reset to the card */ 519 if (err != 0) { 520 dev_err(&pci_dev->dev, 521 "[%s] err: could not setup servicelayer!\n", __func__); 522 err = -ENODEV; 523 goto out; 524 } 525 526 if (genwqe_is_privileged(cd)) { /* code is running _after_ reset */ 527 genwqe_tweak_hardware(cd); 528 529 genwqe_setup_pf_jtimer(cd); 530 genwqe_setup_vf_jtimer(cd); 531 } 532 533 err = genwqe_device_create(cd); 534 if (err < 0) { 535 dev_err(&pci_dev->dev, 536 "err: chdev init failed! (err=%d)\n", err); 537 goto out_release_service_layer; 538 } 539 return 0; 540 541 out_release_service_layer: 542 genwqe_release_service_layer(cd); 543 out: 544 if (genwqe_is_privileged(cd)) 545 genwqe_ffdc_buffs_free(cd); 546 return -EIO; 547 } 548 549 /** 550 * genwqe_stop() - Stop card operation 551 * @cd: GenWQE device information 552 * 553 * Recovery notes: 554 * As long as genwqe_thread runs we might access registers during 555 * error data capture. Same is with the genwqe_health_thread. 556 * When genwqe_bus_reset() fails this function might called two times: 557 * first by the genwqe_health_thread() and later by genwqe_remove() to 558 * unbind the device. We must be able to survive that. 559 * 560 * This function must be robust enough to be called twice. 561 */ 562 static int genwqe_stop(struct genwqe_dev *cd) 563 { 564 genwqe_finish_queue(cd); /* no register access */ 565 genwqe_device_remove(cd); /* device removed, procs killed */ 566 genwqe_release_service_layer(cd); /* here genwqe_thread is stopped */ 567 568 if (genwqe_is_privileged(cd)) { 569 pci_disable_sriov(cd->pci_dev); /* access pci config space */ 570 genwqe_ffdc_buffs_free(cd); 571 } 572 573 return 0; 574 } 575 576 /** 577 * genwqe_recover_card() - Try to recover the card if it is possible 578 * @cd: GenWQE device information 579 * @fatal_err: Indicate whether to attempt soft reset 580 * 581 * If fatal_err is set no register access is possible anymore. It is 582 * likely that genwqe_start fails in that situation. Proper error 583 * handling is required in this case. 584 * 585 * genwqe_bus_reset() will cause the pci code to call genwqe_remove() 586 * and later genwqe_probe() for all virtual functions. 587 */ 588 static int genwqe_recover_card(struct genwqe_dev *cd, int fatal_err) 589 { 590 int rc; 591 struct pci_dev *pci_dev = cd->pci_dev; 592 593 genwqe_stop(cd); 594 595 /* 596 * Make sure chip is not reloaded to maintain FFDC. Write SLU 597 * Reset Register, CPLDReset field to 0. 598 */ 599 if (!fatal_err) { 600 cd->softreset = 0x70ull; 601 __genwqe_writeq(cd, IO_SLC_CFGREG_SOFTRESET, cd->softreset); 602 } 603 604 rc = genwqe_bus_reset(cd); 605 if (rc != 0) { 606 dev_err(&pci_dev->dev, 607 "[%s] err: card recovery impossible!\n", __func__); 608 return rc; 609 } 610 611 rc = genwqe_start(cd); 612 if (rc < 0) { 613 dev_err(&pci_dev->dev, 614 "[%s] err: failed to launch device!\n", __func__); 615 return rc; 616 } 617 return 0; 618 } 619 620 static int genwqe_health_check_cond(struct genwqe_dev *cd, u64 *gfir) 621 { 622 *gfir = __genwqe_readq(cd, IO_SLC_CFGREG_GFIR); 623 return (*gfir & GFIR_ERR_TRIGGER) && 624 genwqe_recovery_on_fatal_gfir_required(cd); 625 } 626 627 /** 628 * genwqe_fir_checking() - Check the fault isolation registers of the card 629 * @cd: GenWQE device information 630 * 631 * If this code works ok, can be tried out with help of the genwqe_poke tool: 632 * sudo ./tools/genwqe_poke 0x8 0xfefefefefef 633 * 634 * Now the relevant FIRs/sFIRs should be printed out and the driver should 635 * invoke recovery (devices are removed and readded). 636 */ 637 static u64 genwqe_fir_checking(struct genwqe_dev *cd) 638 { 639 int j, iterations = 0; 640 u64 mask, fir, fec, uid, gfir, gfir_masked, sfir, sfec; 641 u32 fir_addr, fir_clr_addr, fec_addr, sfir_addr, sfec_addr; 642 struct pci_dev *pci_dev = cd->pci_dev; 643 644 healthMonitor: 645 iterations++; 646 if (iterations > 16) { 647 dev_err(&pci_dev->dev, "* exit looping after %d times\n", 648 iterations); 649 goto fatal_error; 650 } 651 652 gfir = __genwqe_readq(cd, IO_SLC_CFGREG_GFIR); 653 if (gfir != 0x0) 654 dev_err(&pci_dev->dev, "* 0x%08x 0x%016llx\n", 655 IO_SLC_CFGREG_GFIR, gfir); 656 if (gfir == IO_ILLEGAL_VALUE) 657 goto fatal_error; 658 659 /* 660 * Avoid printing when to GFIR bit is on prevents contignous 661 * printout e.g. for the following bug: 662 * FIR set without a 2ndary FIR/FIR cannot be cleared 663 * Comment out the following if to get the prints: 664 */ 665 if (gfir == 0) 666 return 0; 667 668 gfir_masked = gfir & GFIR_ERR_TRIGGER; /* fatal errors */ 669 670 for (uid = 0; uid < GENWQE_MAX_UNITS; uid++) { /* 0..2 in zEDC */ 671 672 /* read the primary FIR (pfir) */ 673 fir_addr = (uid << 24) + 0x08; 674 fir = __genwqe_readq(cd, fir_addr); 675 if (fir == 0x0) 676 continue; /* no error in this unit */ 677 678 dev_err(&pci_dev->dev, "* 0x%08x 0x%016llx\n", fir_addr, fir); 679 if (fir == IO_ILLEGAL_VALUE) 680 goto fatal_error; 681 682 /* read primary FEC */ 683 fec_addr = (uid << 24) + 0x18; 684 fec = __genwqe_readq(cd, fec_addr); 685 686 dev_err(&pci_dev->dev, "* 0x%08x 0x%016llx\n", fec_addr, fec); 687 if (fec == IO_ILLEGAL_VALUE) 688 goto fatal_error; 689 690 for (j = 0, mask = 1ULL; j < 64; j++, mask <<= 1) { 691 692 /* secondary fir empty, skip it */ 693 if ((fir & mask) == 0x0) 694 continue; 695 696 sfir_addr = (uid << 24) + 0x100 + 0x08 * j; 697 sfir = __genwqe_readq(cd, sfir_addr); 698 699 if (sfir == IO_ILLEGAL_VALUE) 700 goto fatal_error; 701 dev_err(&pci_dev->dev, 702 "* 0x%08x 0x%016llx\n", sfir_addr, sfir); 703 704 sfec_addr = (uid << 24) + 0x300 + 0x08 * j; 705 sfec = __genwqe_readq(cd, sfec_addr); 706 707 if (sfec == IO_ILLEGAL_VALUE) 708 goto fatal_error; 709 dev_err(&pci_dev->dev, 710 "* 0x%08x 0x%016llx\n", sfec_addr, sfec); 711 712 gfir = __genwqe_readq(cd, IO_SLC_CFGREG_GFIR); 713 if (gfir == IO_ILLEGAL_VALUE) 714 goto fatal_error; 715 716 /* gfir turned on during routine! get out and 717 start over. */ 718 if ((gfir_masked == 0x0) && 719 (gfir & GFIR_ERR_TRIGGER)) { 720 goto healthMonitor; 721 } 722 723 /* do not clear if we entered with a fatal gfir */ 724 if (gfir_masked == 0x0) { 725 726 /* NEW clear by mask the logged bits */ 727 sfir_addr = (uid << 24) + 0x100 + 0x08 * j; 728 __genwqe_writeq(cd, sfir_addr, sfir); 729 730 dev_dbg(&pci_dev->dev, 731 "[HM] Clearing 2ndary FIR 0x%08x with 0x%016llx\n", 732 sfir_addr, sfir); 733 734 /* 735 * note, these cannot be error-Firs 736 * since gfir_masked is 0 after sfir 737 * was read. Also, it is safe to do 738 * this write if sfir=0. Still need to 739 * clear the primary. This just means 740 * there is no secondary FIR. 741 */ 742 743 /* clear by mask the logged bit. */ 744 fir_clr_addr = (uid << 24) + 0x10; 745 __genwqe_writeq(cd, fir_clr_addr, mask); 746 747 dev_dbg(&pci_dev->dev, 748 "[HM] Clearing primary FIR 0x%08x with 0x%016llx\n", 749 fir_clr_addr, mask); 750 } 751 } 752 } 753 gfir = __genwqe_readq(cd, IO_SLC_CFGREG_GFIR); 754 if (gfir == IO_ILLEGAL_VALUE) 755 goto fatal_error; 756 757 if ((gfir_masked == 0x0) && (gfir & GFIR_ERR_TRIGGER)) { 758 /* 759 * Check once more that it didn't go on after all the 760 * FIRS were cleared. 761 */ 762 dev_dbg(&pci_dev->dev, "ACK! Another FIR! Recursing %d!\n", 763 iterations); 764 goto healthMonitor; 765 } 766 return gfir_masked; 767 768 fatal_error: 769 return IO_ILLEGAL_VALUE; 770 } 771 772 /** 773 * genwqe_pci_fundamental_reset() - trigger a PCIe fundamental reset on the slot 774 * @pci_dev: PCI device information struct 775 * 776 * Note: pci_set_pcie_reset_state() is not implemented on all archs, so this 777 * reset method will not work in all cases. 778 * 779 * Return: 0 on success or error code from pci_set_pcie_reset_state() 780 */ 781 static int genwqe_pci_fundamental_reset(struct pci_dev *pci_dev) 782 { 783 int rc; 784 785 /* 786 * lock pci config space access from userspace, 787 * save state and issue PCIe fundamental reset 788 */ 789 pci_cfg_access_lock(pci_dev); 790 pci_save_state(pci_dev); 791 rc = pci_set_pcie_reset_state(pci_dev, pcie_warm_reset); 792 if (!rc) { 793 /* keep PCIe reset asserted for 250ms */ 794 msleep(250); 795 pci_set_pcie_reset_state(pci_dev, pcie_deassert_reset); 796 /* Wait for 2s to reload flash and train the link */ 797 msleep(2000); 798 } 799 pci_restore_state(pci_dev); 800 pci_cfg_access_unlock(pci_dev); 801 return rc; 802 } 803 804 805 static int genwqe_platform_recovery(struct genwqe_dev *cd) 806 { 807 struct pci_dev *pci_dev = cd->pci_dev; 808 int rc; 809 810 dev_info(&pci_dev->dev, 811 "[%s] resetting card for error recovery\n", __func__); 812 813 /* Clear out error injection flags */ 814 cd->err_inject &= ~(GENWQE_INJECT_HARDWARE_FAILURE | 815 GENWQE_INJECT_GFIR_FATAL | 816 GENWQE_INJECT_GFIR_INFO); 817 818 genwqe_stop(cd); 819 820 /* Try recoverying the card with fundamental reset */ 821 rc = genwqe_pci_fundamental_reset(pci_dev); 822 if (!rc) { 823 rc = genwqe_start(cd); 824 if (!rc) 825 dev_info(&pci_dev->dev, 826 "[%s] card recovered\n", __func__); 827 else 828 dev_err(&pci_dev->dev, 829 "[%s] err: cannot start card services! (err=%d)\n", 830 __func__, rc); 831 } else { 832 dev_err(&pci_dev->dev, 833 "[%s] card reset failed\n", __func__); 834 } 835 836 return rc; 837 } 838 839 /** 840 * genwqe_reload_bistream() - reload card bitstream 841 * @cd: GenWQE device information 842 * 843 * Set the appropriate register and call fundamental reset to reaload the card 844 * bitstream. 845 * 846 * Return: 0 on success, error code otherwise 847 */ 848 static int genwqe_reload_bistream(struct genwqe_dev *cd) 849 { 850 struct pci_dev *pci_dev = cd->pci_dev; 851 int rc; 852 853 dev_info(&pci_dev->dev, 854 "[%s] resetting card for bitstream reload\n", 855 __func__); 856 857 genwqe_stop(cd); 858 859 /* 860 * Cause a CPLD reprogram with the 'next_bitstream' 861 * partition on PCIe hot or fundamental reset 862 */ 863 __genwqe_writeq(cd, IO_SLC_CFGREG_SOFTRESET, 864 (cd->softreset & 0xcull) | 0x70ull); 865 866 rc = genwqe_pci_fundamental_reset(pci_dev); 867 if (rc) { 868 /* 869 * A fundamental reset failure can be caused 870 * by lack of support on the arch, so we just 871 * log the error and try to start the card 872 * again. 873 */ 874 dev_err(&pci_dev->dev, 875 "[%s] err: failed to reset card for bitstream reload\n", 876 __func__); 877 } 878 879 rc = genwqe_start(cd); 880 if (rc) { 881 dev_err(&pci_dev->dev, 882 "[%s] err: cannot start card services! (err=%d)\n", 883 __func__, rc); 884 return rc; 885 } 886 dev_info(&pci_dev->dev, 887 "[%s] card reloaded\n", __func__); 888 return 0; 889 } 890 891 892 /** 893 * genwqe_health_thread() - Health checking thread 894 * @data: GenWQE device information 895 * 896 * This thread is only started for the PF of the card. 897 * 898 * This thread monitors the health of the card. A critical situation 899 * is when we read registers which contain -1 (IO_ILLEGAL_VALUE). In 900 * this case we need to be recovered from outside. Writing to 901 * registers will very likely not work either. 902 * 903 * This thread must only exit if kthread_should_stop() becomes true. 904 * 905 * Condition for the health-thread to trigger: 906 * a) when a kthread_stop() request comes in or 907 * b) a critical GFIR occured 908 * 909 * Informational GFIRs are checked and potentially printed in 910 * GENWQE_HEALTH_CHECK_INTERVAL seconds. 911 */ 912 static int genwqe_health_thread(void *data) 913 { 914 int rc, should_stop = 0; 915 struct genwqe_dev *cd = data; 916 struct pci_dev *pci_dev = cd->pci_dev; 917 u64 gfir, gfir_masked, slu_unitcfg, app_unitcfg; 918 919 health_thread_begin: 920 while (!kthread_should_stop()) { 921 rc = wait_event_interruptible_timeout(cd->health_waitq, 922 (genwqe_health_check_cond(cd, &gfir) || 923 (should_stop = kthread_should_stop())), 924 GENWQE_HEALTH_CHECK_INTERVAL * HZ); 925 926 if (should_stop) 927 break; 928 929 if (gfir == IO_ILLEGAL_VALUE) { 930 dev_err(&pci_dev->dev, 931 "[%s] GFIR=%016llx\n", __func__, gfir); 932 goto fatal_error; 933 } 934 935 slu_unitcfg = __genwqe_readq(cd, IO_SLU_UNITCFG); 936 if (slu_unitcfg == IO_ILLEGAL_VALUE) { 937 dev_err(&pci_dev->dev, 938 "[%s] SLU_UNITCFG=%016llx\n", 939 __func__, slu_unitcfg); 940 goto fatal_error; 941 } 942 943 app_unitcfg = __genwqe_readq(cd, IO_APP_UNITCFG); 944 if (app_unitcfg == IO_ILLEGAL_VALUE) { 945 dev_err(&pci_dev->dev, 946 "[%s] APP_UNITCFG=%016llx\n", 947 __func__, app_unitcfg); 948 goto fatal_error; 949 } 950 951 gfir = __genwqe_readq(cd, IO_SLC_CFGREG_GFIR); 952 if (gfir == IO_ILLEGAL_VALUE) { 953 dev_err(&pci_dev->dev, 954 "[%s] %s: GFIR=%016llx\n", __func__, 955 (gfir & GFIR_ERR_TRIGGER) ? "err" : "info", 956 gfir); 957 goto fatal_error; 958 } 959 960 gfir_masked = genwqe_fir_checking(cd); 961 if (gfir_masked == IO_ILLEGAL_VALUE) 962 goto fatal_error; 963 964 /* 965 * GFIR ErrorTrigger bits set => reset the card! 966 * Never do this for old/manufacturing images! 967 */ 968 if ((gfir_masked) && !cd->skip_recovery && 969 genwqe_recovery_on_fatal_gfir_required(cd)) { 970 971 cd->card_state = GENWQE_CARD_FATAL_ERROR; 972 973 rc = genwqe_recover_card(cd, 0); 974 if (rc < 0) { 975 /* FIXME Card is unusable and needs unbind! */ 976 goto fatal_error; 977 } 978 } 979 980 if (cd->card_state == GENWQE_CARD_RELOAD_BITSTREAM) { 981 /* Userspace requested card bitstream reload */ 982 rc = genwqe_reload_bistream(cd); 983 if (rc) 984 goto fatal_error; 985 } 986 987 cd->last_gfir = gfir; 988 cond_resched(); 989 } 990 991 return 0; 992 993 fatal_error: 994 if (cd->use_platform_recovery) { 995 /* 996 * Since we use raw accessors, EEH errors won't be detected 997 * by the platform until we do a non-raw MMIO or config space 998 * read 999 */ 1000 readq(cd->mmio + IO_SLC_CFGREG_GFIR); 1001 1002 /* We do nothing if the card is going over PCI recovery */ 1003 if (pci_channel_offline(pci_dev)) 1004 return -EIO; 1005 1006 /* 1007 * If it's supported by the platform, we try a fundamental reset 1008 * to recover from a fatal error. Otherwise, we continue to wait 1009 * for an external recovery procedure to take care of it. 1010 */ 1011 rc = genwqe_platform_recovery(cd); 1012 if (!rc) 1013 goto health_thread_begin; 1014 } 1015 1016 dev_err(&pci_dev->dev, 1017 "[%s] card unusable. Please trigger unbind!\n", __func__); 1018 1019 /* Bring down logical devices to inform user space via udev remove. */ 1020 cd->card_state = GENWQE_CARD_FATAL_ERROR; 1021 genwqe_stop(cd); 1022 1023 /* genwqe_bus_reset failed(). Now wait for genwqe_remove(). */ 1024 while (!kthread_should_stop()) 1025 cond_resched(); 1026 1027 return -EIO; 1028 } 1029 1030 static int genwqe_health_check_start(struct genwqe_dev *cd) 1031 { 1032 int rc; 1033 1034 if (GENWQE_HEALTH_CHECK_INTERVAL <= 0) 1035 return 0; /* valid for disabling the service */ 1036 1037 /* moved before request_irq() */ 1038 /* init_waitqueue_head(&cd->health_waitq); */ 1039 1040 cd->health_thread = kthread_run(genwqe_health_thread, cd, 1041 GENWQE_DEVNAME "%d_health", 1042 cd->card_idx); 1043 if (IS_ERR(cd->health_thread)) { 1044 rc = PTR_ERR(cd->health_thread); 1045 cd->health_thread = NULL; 1046 return rc; 1047 } 1048 return 0; 1049 } 1050 1051 static int genwqe_health_thread_running(struct genwqe_dev *cd) 1052 { 1053 return cd->health_thread != NULL; 1054 } 1055 1056 static int genwqe_health_check_stop(struct genwqe_dev *cd) 1057 { 1058 if (!genwqe_health_thread_running(cd)) 1059 return -EIO; 1060 1061 kthread_stop(cd->health_thread); 1062 cd->health_thread = NULL; 1063 return 0; 1064 } 1065 1066 /** 1067 * genwqe_pci_setup() - Allocate PCIe related resources for our card 1068 * @cd: GenWQE device information 1069 */ 1070 static int genwqe_pci_setup(struct genwqe_dev *cd) 1071 { 1072 int err; 1073 struct pci_dev *pci_dev = cd->pci_dev; 1074 1075 err = pci_enable_device_mem(pci_dev); 1076 if (err) { 1077 dev_err(&pci_dev->dev, 1078 "err: failed to enable pci memory (err=%d)\n", err); 1079 goto err_out; 1080 } 1081 1082 /* Reserve PCI I/O and memory resources */ 1083 err = pci_request_mem_regions(pci_dev, genwqe_driver_name); 1084 if (err) { 1085 dev_err(&pci_dev->dev, 1086 "[%s] err: request bars failed (%d)\n", __func__, err); 1087 err = -EIO; 1088 goto err_disable_device; 1089 } 1090 1091 /* check for 64-bit DMA address supported (DAC) */ 1092 /* check for 32-bit DMA address supported (SAC) */ 1093 if (dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(64)) && 1094 dma_set_mask_and_coherent(&pci_dev->dev, DMA_BIT_MASK(32))) { 1095 dev_err(&pci_dev->dev, 1096 "err: neither DMA32 nor DMA64 supported\n"); 1097 err = -EIO; 1098 goto out_release_resources; 1099 } 1100 1101 pci_set_master(pci_dev); 1102 pci_enable_pcie_error_reporting(pci_dev); 1103 1104 /* EEH recovery requires PCIe fundamental reset */ 1105 pci_dev->needs_freset = 1; 1106 1107 /* request complete BAR-0 space (length = 0) */ 1108 cd->mmio_len = pci_resource_len(pci_dev, 0); 1109 cd->mmio = pci_iomap(pci_dev, 0, 0); 1110 if (cd->mmio == NULL) { 1111 dev_err(&pci_dev->dev, 1112 "[%s] err: mapping BAR0 failed\n", __func__); 1113 err = -ENOMEM; 1114 goto out_release_resources; 1115 } 1116 1117 cd->num_vfs = pci_sriov_get_totalvfs(pci_dev); 1118 if (cd->num_vfs < 0) 1119 cd->num_vfs = 0; 1120 1121 err = genwqe_read_ids(cd); 1122 if (err) 1123 goto out_iounmap; 1124 1125 return 0; 1126 1127 out_iounmap: 1128 pci_iounmap(pci_dev, cd->mmio); 1129 out_release_resources: 1130 pci_release_mem_regions(pci_dev); 1131 err_disable_device: 1132 pci_disable_device(pci_dev); 1133 err_out: 1134 return err; 1135 } 1136 1137 /** 1138 * genwqe_pci_remove() - Free PCIe related resources for our card 1139 * @cd: GenWQE device information 1140 */ 1141 static void genwqe_pci_remove(struct genwqe_dev *cd) 1142 { 1143 struct pci_dev *pci_dev = cd->pci_dev; 1144 1145 if (cd->mmio) 1146 pci_iounmap(pci_dev, cd->mmio); 1147 1148 pci_release_mem_regions(pci_dev); 1149 pci_disable_device(pci_dev); 1150 } 1151 1152 /** 1153 * genwqe_probe() - Device initialization 1154 * @pci_dev: PCI device information struct 1155 * @id: PCI device ID 1156 * 1157 * Callable for multiple cards. This function is called on bind. 1158 * 1159 * Return: 0 if succeeded, < 0 when failed 1160 */ 1161 static int genwqe_probe(struct pci_dev *pci_dev, 1162 const struct pci_device_id *id) 1163 { 1164 int err; 1165 struct genwqe_dev *cd; 1166 1167 genwqe_init_crc32(); 1168 1169 cd = genwqe_dev_alloc(); 1170 if (IS_ERR(cd)) { 1171 dev_err(&pci_dev->dev, "err: could not alloc mem (err=%d)!\n", 1172 (int)PTR_ERR(cd)); 1173 return PTR_ERR(cd); 1174 } 1175 1176 dev_set_drvdata(&pci_dev->dev, cd); 1177 cd->pci_dev = pci_dev; 1178 1179 err = genwqe_pci_setup(cd); 1180 if (err < 0) { 1181 dev_err(&pci_dev->dev, 1182 "err: problems with PCI setup (err=%d)\n", err); 1183 goto out_free_dev; 1184 } 1185 1186 err = genwqe_start(cd); 1187 if (err < 0) { 1188 dev_err(&pci_dev->dev, 1189 "err: cannot start card services! (err=%d)\n", err); 1190 goto out_pci_remove; 1191 } 1192 1193 if (genwqe_is_privileged(cd)) { 1194 err = genwqe_health_check_start(cd); 1195 if (err < 0) { 1196 dev_err(&pci_dev->dev, 1197 "err: cannot start health checking! (err=%d)\n", 1198 err); 1199 goto out_stop_services; 1200 } 1201 } 1202 return 0; 1203 1204 out_stop_services: 1205 genwqe_stop(cd); 1206 out_pci_remove: 1207 genwqe_pci_remove(cd); 1208 out_free_dev: 1209 genwqe_dev_free(cd); 1210 return err; 1211 } 1212 1213 /** 1214 * genwqe_remove() - Called when device is removed (hot-plugable) 1215 * @pci_dev: PCI device information struct 1216 * 1217 * Or when driver is unloaded respecitively when unbind is done. 1218 */ 1219 static void genwqe_remove(struct pci_dev *pci_dev) 1220 { 1221 struct genwqe_dev *cd = dev_get_drvdata(&pci_dev->dev); 1222 1223 genwqe_health_check_stop(cd); 1224 1225 /* 1226 * genwqe_stop() must survive if it is called twice 1227 * sequentially. This happens when the health thread calls it 1228 * and fails on genwqe_bus_reset(). 1229 */ 1230 genwqe_stop(cd); 1231 genwqe_pci_remove(cd); 1232 genwqe_dev_free(cd); 1233 } 1234 1235 /** 1236 * genwqe_err_error_detected() - Error detection callback 1237 * @pci_dev: PCI device information struct 1238 * @state: PCI channel state 1239 * 1240 * This callback is called by the PCI subsystem whenever a PCI bus 1241 * error is detected. 1242 */ 1243 static pci_ers_result_t genwqe_err_error_detected(struct pci_dev *pci_dev, 1244 pci_channel_state_t state) 1245 { 1246 struct genwqe_dev *cd; 1247 1248 dev_err(&pci_dev->dev, "[%s] state=%d\n", __func__, state); 1249 1250 cd = dev_get_drvdata(&pci_dev->dev); 1251 if (cd == NULL) 1252 return PCI_ERS_RESULT_DISCONNECT; 1253 1254 /* Stop the card */ 1255 genwqe_health_check_stop(cd); 1256 genwqe_stop(cd); 1257 1258 /* 1259 * On permanent failure, the PCI code will call device remove 1260 * after the return of this function. 1261 * genwqe_stop() can be called twice. 1262 */ 1263 if (state == pci_channel_io_perm_failure) { 1264 return PCI_ERS_RESULT_DISCONNECT; 1265 } else { 1266 genwqe_pci_remove(cd); 1267 return PCI_ERS_RESULT_NEED_RESET; 1268 } 1269 } 1270 1271 static pci_ers_result_t genwqe_err_slot_reset(struct pci_dev *pci_dev) 1272 { 1273 int rc; 1274 struct genwqe_dev *cd = dev_get_drvdata(&pci_dev->dev); 1275 1276 rc = genwqe_pci_setup(cd); 1277 if (!rc) { 1278 return PCI_ERS_RESULT_RECOVERED; 1279 } else { 1280 dev_err(&pci_dev->dev, 1281 "err: problems with PCI setup (err=%d)\n", rc); 1282 return PCI_ERS_RESULT_DISCONNECT; 1283 } 1284 } 1285 1286 static pci_ers_result_t genwqe_err_result_none(struct pci_dev *dev) 1287 { 1288 return PCI_ERS_RESULT_NONE; 1289 } 1290 1291 static void genwqe_err_resume(struct pci_dev *pci_dev) 1292 { 1293 int rc; 1294 struct genwqe_dev *cd = dev_get_drvdata(&pci_dev->dev); 1295 1296 rc = genwqe_start(cd); 1297 if (!rc) { 1298 rc = genwqe_health_check_start(cd); 1299 if (rc) 1300 dev_err(&pci_dev->dev, 1301 "err: cannot start health checking! (err=%d)\n", 1302 rc); 1303 } else { 1304 dev_err(&pci_dev->dev, 1305 "err: cannot start card services! (err=%d)\n", rc); 1306 } 1307 } 1308 1309 static int genwqe_sriov_configure(struct pci_dev *dev, int numvfs) 1310 { 1311 int rc; 1312 struct genwqe_dev *cd = dev_get_drvdata(&dev->dev); 1313 1314 if (numvfs > 0) { 1315 genwqe_setup_vf_jtimer(cd); 1316 rc = pci_enable_sriov(dev, numvfs); 1317 if (rc < 0) 1318 return rc; 1319 return numvfs; 1320 } 1321 if (numvfs == 0) { 1322 pci_disable_sriov(dev); 1323 return 0; 1324 } 1325 return 0; 1326 } 1327 1328 static const struct pci_error_handlers genwqe_err_handler = { 1329 .error_detected = genwqe_err_error_detected, 1330 .mmio_enabled = genwqe_err_result_none, 1331 .slot_reset = genwqe_err_slot_reset, 1332 .resume = genwqe_err_resume, 1333 }; 1334 1335 static struct pci_driver genwqe_driver = { 1336 .name = genwqe_driver_name, 1337 .id_table = genwqe_device_table, 1338 .probe = genwqe_probe, 1339 .remove = genwqe_remove, 1340 .sriov_configure = genwqe_sriov_configure, 1341 .err_handler = &genwqe_err_handler, 1342 }; 1343 1344 /** 1345 * genwqe_devnode() - Set default access mode for genwqe devices. 1346 * @dev: Pointer to device (unused) 1347 * @mode: Carrier to pass-back given mode (permissions) 1348 * 1349 * Default mode should be rw for everybody. Do not change default 1350 * device name. 1351 */ 1352 static char *genwqe_devnode(const struct device *dev, umode_t *mode) 1353 { 1354 if (mode) 1355 *mode = 0666; 1356 return NULL; 1357 } 1358 1359 /** 1360 * genwqe_init_module() - Driver registration and initialization 1361 */ 1362 static int __init genwqe_init_module(void) 1363 { 1364 int rc; 1365 1366 class_genwqe = class_create(THIS_MODULE, GENWQE_DEVNAME); 1367 if (IS_ERR(class_genwqe)) { 1368 pr_err("[%s] create class failed\n", __func__); 1369 return -ENOMEM; 1370 } 1371 1372 class_genwqe->devnode = genwqe_devnode; 1373 1374 debugfs_genwqe = debugfs_create_dir(GENWQE_DEVNAME, NULL); 1375 1376 rc = pci_register_driver(&genwqe_driver); 1377 if (rc != 0) { 1378 pr_err("[%s] pci_reg_driver (rc=%d)\n", __func__, rc); 1379 goto err_out0; 1380 } 1381 1382 return rc; 1383 1384 err_out0: 1385 debugfs_remove(debugfs_genwqe); 1386 class_destroy(class_genwqe); 1387 return rc; 1388 } 1389 1390 /** 1391 * genwqe_exit_module() - Driver exit 1392 */ 1393 static void __exit genwqe_exit_module(void) 1394 { 1395 pci_unregister_driver(&genwqe_driver); 1396 debugfs_remove(debugfs_genwqe); 1397 class_destroy(class_genwqe); 1398 } 1399 1400 module_init(genwqe_init_module); 1401 module_exit(genwqe_exit_module); 1402