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