1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ISM driver for s390. 4 * 5 * Copyright IBM Corp. 2018 6 */ 7 #define pr_fmt(fmt) "ism: " fmt 8 9 #include <linux/export.h> 10 #include <linux/module.h> 11 #include <linux/types.h> 12 #include <linux/interrupt.h> 13 #include <linux/device.h> 14 #include <linux/err.h> 15 #include <linux/ctype.h> 16 #include <linux/processor.h> 17 18 #include "ism.h" 19 20 MODULE_DESCRIPTION("ISM driver for s390"); 21 MODULE_LICENSE("GPL"); 22 23 #define DRV_NAME "ism" 24 25 static const struct pci_device_id ism_device_table[] = { 26 { PCI_VDEVICE(IBM, PCI_DEVICE_ID_IBM_ISM) }, 27 { } 28 }; 29 MODULE_DEVICE_TABLE(pci, ism_device_table); 30 31 static debug_info_t *ism_debug_info; 32 33 static int ism_cmd(struct ism_dev *ism, void *cmd) 34 { 35 struct ism_req_hdr *req = cmd; 36 struct ism_resp_hdr *resp = cmd; 37 38 spin_lock(&ism->cmd_lock); 39 __ism_write_cmd(ism, req + 1, sizeof(*req), req->len - sizeof(*req)); 40 __ism_write_cmd(ism, req, 0, sizeof(*req)); 41 42 WRITE_ONCE(resp->ret, ISM_ERROR); 43 44 __ism_read_cmd(ism, resp, 0, sizeof(*resp)); 45 if (resp->ret) { 46 debug_text_event(ism_debug_info, 0, "cmd failure"); 47 debug_event(ism_debug_info, 0, resp, sizeof(*resp)); 48 goto out; 49 } 50 __ism_read_cmd(ism, resp + 1, sizeof(*resp), resp->len - sizeof(*resp)); 51 out: 52 spin_unlock(&ism->cmd_lock); 53 return resp->ret; 54 } 55 56 static int ism_cmd_simple(struct ism_dev *ism, u32 cmd_code) 57 { 58 union ism_cmd_simple cmd; 59 60 memset(&cmd, 0, sizeof(cmd)); 61 cmd.request.hdr.cmd = cmd_code; 62 cmd.request.hdr.len = sizeof(cmd.request); 63 64 return ism_cmd(ism, &cmd); 65 } 66 67 static int query_info(struct ism_dev *ism) 68 { 69 union ism_qi cmd; 70 71 memset(&cmd, 0, sizeof(cmd)); 72 cmd.request.hdr.cmd = ISM_QUERY_INFO; 73 cmd.request.hdr.len = sizeof(cmd.request); 74 75 if (ism_cmd(ism, &cmd)) 76 goto out; 77 78 debug_text_event(ism_debug_info, 3, "query info"); 79 debug_event(ism_debug_info, 3, &cmd.response, sizeof(cmd.response)); 80 out: 81 return 0; 82 } 83 84 static int register_sba(struct ism_dev *ism) 85 { 86 union ism_reg_sba cmd; 87 dma_addr_t dma_handle; 88 struct ism_sba *sba; 89 90 sba = dma_alloc_coherent(&ism->pdev->dev, PAGE_SIZE, &dma_handle, 91 GFP_KERNEL); 92 if (!sba) 93 return -ENOMEM; 94 95 memset(&cmd, 0, sizeof(cmd)); 96 cmd.request.hdr.cmd = ISM_REG_SBA; 97 cmd.request.hdr.len = sizeof(cmd.request); 98 cmd.request.sba = dma_handle; 99 100 if (ism_cmd(ism, &cmd)) { 101 dma_free_coherent(&ism->pdev->dev, PAGE_SIZE, sba, dma_handle); 102 return -EIO; 103 } 104 105 ism->sba = sba; 106 ism->sba_dma_addr = dma_handle; 107 108 return 0; 109 } 110 111 static int register_ieq(struct ism_dev *ism) 112 { 113 union ism_reg_ieq cmd; 114 dma_addr_t dma_handle; 115 struct ism_eq *ieq; 116 117 ieq = dma_alloc_coherent(&ism->pdev->dev, PAGE_SIZE, &dma_handle, 118 GFP_KERNEL); 119 if (!ieq) 120 return -ENOMEM; 121 122 memset(&cmd, 0, sizeof(cmd)); 123 cmd.request.hdr.cmd = ISM_REG_IEQ; 124 cmd.request.hdr.len = sizeof(cmd.request); 125 cmd.request.ieq = dma_handle; 126 cmd.request.len = sizeof(*ieq); 127 128 if (ism_cmd(ism, &cmd)) { 129 dma_free_coherent(&ism->pdev->dev, PAGE_SIZE, ieq, dma_handle); 130 return -EIO; 131 } 132 133 ism->ieq = ieq; 134 ism->ieq_idx = -1; 135 ism->ieq_dma_addr = dma_handle; 136 137 return 0; 138 } 139 140 static int unregister_sba(struct ism_dev *ism) 141 { 142 int ret; 143 144 if (!ism->sba) 145 return 0; 146 147 ret = ism_cmd_simple(ism, ISM_UNREG_SBA); 148 if (ret && ret != ISM_ERROR) 149 return -EIO; 150 151 return 0; 152 } 153 154 static void ism_free_sba(struct ism_dev *ism) 155 { 156 dma_free_coherent(&ism->pdev->dev, PAGE_SIZE, 157 ism->sba, ism->sba_dma_addr); 158 159 ism->sba = NULL; 160 ism->sba_dma_addr = 0; 161 } 162 163 static int unregister_ieq(struct ism_dev *ism) 164 { 165 int ret; 166 167 if (!ism->ieq) 168 return 0; 169 170 ret = ism_cmd_simple(ism, ISM_UNREG_IEQ); 171 if (ret && ret != ISM_ERROR) 172 return -EIO; 173 174 return 0; 175 } 176 177 static void ism_free_ieq(struct ism_dev *ism) 178 { 179 dma_free_coherent(&ism->pdev->dev, PAGE_SIZE, 180 ism->ieq, ism->ieq_dma_addr); 181 182 ism->ieq = NULL; 183 ism->ieq_dma_addr = 0; 184 } 185 186 static int ism_read_local_gid(struct dibs_dev *dibs) 187 { 188 struct ism_dev *ism = dibs->drv_priv; 189 union ism_read_gid cmd; 190 int ret; 191 192 memset(&cmd, 0, sizeof(cmd)); 193 cmd.request.hdr.cmd = ISM_READ_GID; 194 cmd.request.hdr.len = sizeof(cmd.request); 195 196 ret = ism_cmd(ism, &cmd); 197 if (ret) 198 goto out; 199 200 memset(&dibs->gid, 0, sizeof(dibs->gid)); 201 memcpy(&dibs->gid, &cmd.response.gid, sizeof(cmd.response.gid)); 202 out: 203 return ret; 204 } 205 206 static int ism_query_rgid(struct dibs_dev *dibs, const uuid_t *rgid, 207 u32 vid_valid, u32 vid) 208 { 209 struct ism_dev *ism = dibs->drv_priv; 210 union ism_query_rgid cmd; 211 212 memset(&cmd, 0, sizeof(cmd)); 213 cmd.request.hdr.cmd = ISM_QUERY_RGID; 214 cmd.request.hdr.len = sizeof(cmd.request); 215 216 memcpy(&cmd.request.rgid, rgid, sizeof(cmd.request.rgid)); 217 cmd.request.vlan_valid = vid_valid; 218 cmd.request.vlan_id = vid; 219 220 return ism_cmd(ism, &cmd); 221 } 222 223 static int ism_max_dmbs(void) 224 { 225 return ISM_NR_DMBS; 226 } 227 228 static void ism_free_dmb(struct ism_dev *ism, struct dibs_dmb *dmb) 229 { 230 clear_bit(dmb->idx, ism->sba_bitmap); 231 dma_unmap_page(&ism->pdev->dev, dmb->dma_addr, dmb->dmb_len, 232 DMA_FROM_DEVICE); 233 folio_put(virt_to_folio(dmb->cpu_addr)); 234 dmb->cpu_addr = NULL; 235 } 236 237 static int ism_alloc_dmb(struct ism_dev *ism, struct dibs_dmb *dmb) 238 { 239 struct folio *folio; 240 unsigned long bit; 241 int rc; 242 243 if (PAGE_ALIGN(dmb->dmb_len) > dma_get_max_seg_size(&ism->pdev->dev)) 244 return -EINVAL; 245 246 if (!dmb->idx) { 247 bit = find_next_zero_bit(ism->sba_bitmap, ISM_NR_DMBS, 248 ISM_DMB_BIT_OFFSET); 249 if (bit == ISM_NR_DMBS) 250 return -ENOSPC; 251 252 dmb->idx = bit; 253 } 254 if (dmb->idx < ISM_DMB_BIT_OFFSET || 255 test_and_set_bit(dmb->idx, ism->sba_bitmap)) 256 return -EINVAL; 257 258 folio = folio_alloc(GFP_KERNEL | __GFP_NOWARN | __GFP_NOMEMALLOC | 259 __GFP_NORETRY, get_order(dmb->dmb_len)); 260 261 if (!folio) { 262 rc = -ENOMEM; 263 goto out_bit; 264 } 265 266 dmb->cpu_addr = folio_address(folio); 267 dmb->dma_addr = dma_map_page(&ism->pdev->dev, 268 virt_to_page(dmb->cpu_addr), 0, 269 dmb->dmb_len, DMA_FROM_DEVICE); 270 if (dma_mapping_error(&ism->pdev->dev, dmb->dma_addr)) { 271 rc = -ENOMEM; 272 goto out_free; 273 } 274 275 return 0; 276 277 out_free: 278 folio_put(folio); 279 dmb->cpu_addr = NULL; 280 out_bit: 281 clear_bit(dmb->idx, ism->sba_bitmap); 282 return rc; 283 } 284 285 static int ism_register_dmb(struct dibs_dev *dibs, struct dibs_dmb *dmb, 286 struct dibs_client *client) 287 { 288 struct ism_dev *ism = dibs->drv_priv; 289 union ism_reg_dmb cmd; 290 unsigned long flags; 291 int ret; 292 293 ret = ism_alloc_dmb(ism, dmb); 294 if (ret) 295 goto out; 296 297 memset(&cmd, 0, sizeof(cmd)); 298 cmd.request.hdr.cmd = ISM_REG_DMB; 299 cmd.request.hdr.len = sizeof(cmd.request); 300 301 cmd.request.dmb = dmb->dma_addr; 302 cmd.request.dmb_len = dmb->dmb_len; 303 cmd.request.sba_idx = dmb->idx; 304 cmd.request.vlan_valid = dmb->vlan_valid; 305 cmd.request.vlan_id = dmb->vlan_id; 306 memcpy(&cmd.request.rgid, &dmb->rgid, sizeof(u64)); 307 308 ret = ism_cmd(ism, &cmd); 309 if (ret) { 310 ism_free_dmb(ism, dmb); 311 goto out; 312 } 313 dmb->dmb_tok = cmd.response.dmb_tok; 314 spin_lock_irqsave(&dibs->lock, flags); 315 dibs->dmb_clientid_arr[dmb->idx - ISM_DMB_BIT_OFFSET] = client->id; 316 spin_unlock_irqrestore(&dibs->lock, flags); 317 out: 318 return ret; 319 } 320 321 static int ism_unregister_dmb(struct dibs_dev *dibs, struct dibs_dmb *dmb) 322 { 323 struct ism_dev *ism = dibs->drv_priv; 324 union ism_unreg_dmb cmd; 325 unsigned long flags; 326 int ret; 327 328 memset(&cmd, 0, sizeof(cmd)); 329 cmd.request.hdr.cmd = ISM_UNREG_DMB; 330 cmd.request.hdr.len = sizeof(cmd.request); 331 332 cmd.request.dmb_tok = dmb->dmb_tok; 333 334 spin_lock_irqsave(&dibs->lock, flags); 335 dibs->dmb_clientid_arr[dmb->idx - ISM_DMB_BIT_OFFSET] = NO_DIBS_CLIENT; 336 spin_unlock_irqrestore(&dibs->lock, flags); 337 338 ret = ism_cmd(ism, &cmd); 339 if (ret && ret != ISM_ERROR) 340 goto out; 341 342 ism_free_dmb(ism, dmb); 343 out: 344 return ret; 345 } 346 347 static int ism_add_vlan_id(struct dibs_dev *dibs, u64 vlan_id) 348 { 349 struct ism_dev *ism = dibs->drv_priv; 350 union ism_set_vlan_id cmd; 351 352 memset(&cmd, 0, sizeof(cmd)); 353 cmd.request.hdr.cmd = ISM_ADD_VLAN_ID; 354 cmd.request.hdr.len = sizeof(cmd.request); 355 356 cmd.request.vlan_id = vlan_id; 357 358 return ism_cmd(ism, &cmd); 359 } 360 361 static int ism_del_vlan_id(struct dibs_dev *dibs, u64 vlan_id) 362 { 363 struct ism_dev *ism = dibs->drv_priv; 364 union ism_set_vlan_id cmd; 365 366 memset(&cmd, 0, sizeof(cmd)); 367 cmd.request.hdr.cmd = ISM_DEL_VLAN_ID; 368 cmd.request.hdr.len = sizeof(cmd.request); 369 370 cmd.request.vlan_id = vlan_id; 371 372 return ism_cmd(ism, &cmd); 373 } 374 375 static int ism_signal_ieq(struct dibs_dev *dibs, const uuid_t *rgid, 376 u32 trigger_irq, u32 event_code, u64 info) 377 { 378 struct ism_dev *ism = dibs->drv_priv; 379 union ism_sig_ieq cmd; 380 381 memset(&cmd, 0, sizeof(cmd)); 382 cmd.request.hdr.cmd = ISM_SIGNAL_IEQ; 383 cmd.request.hdr.len = sizeof(cmd.request); 384 385 memcpy(&cmd.request.rgid, rgid, sizeof(cmd.request.rgid)); 386 cmd.request.trigger_irq = trigger_irq; 387 cmd.request.event_code = event_code; 388 cmd.request.info = info; 389 390 return ism_cmd(ism, &cmd); 391 } 392 393 static unsigned int max_bytes(unsigned int start, unsigned int len, 394 unsigned int boundary) 395 { 396 return min(boundary - (start & (boundary - 1)), len); 397 } 398 399 static int ism_move(struct dibs_dev *dibs, u64 dmb_tok, unsigned int idx, 400 bool sf, unsigned int offset, void *data, 401 unsigned int size) 402 { 403 struct ism_dev *ism = dibs->drv_priv; 404 unsigned int bytes; 405 u64 dmb_req; 406 int ret; 407 408 while (size) { 409 bytes = max_bytes(offset, size, PAGE_SIZE); 410 dmb_req = ISM_CREATE_REQ(dmb_tok, idx, size == bytes ? sf : 0, 411 offset); 412 413 ret = __ism_move(ism, dmb_req, data, bytes); 414 if (ret) 415 return ret; 416 417 size -= bytes; 418 data += bytes; 419 offset += bytes; 420 } 421 422 return 0; 423 } 424 425 static u16 ism_get_chid(struct dibs_dev *dibs) 426 { 427 struct ism_dev *ism = dibs->drv_priv; 428 429 if (!ism || !ism->pdev) 430 return 0; 431 432 return to_zpci(ism->pdev)->pchid; 433 } 434 435 static int ism_match_event_type(u32 s390_event_type) 436 { 437 switch (s390_event_type) { 438 case ISM_EVENT_BUF: 439 return DIBS_BUF_EVENT; 440 case ISM_EVENT_DEV: 441 return DIBS_DEV_EVENT; 442 case ISM_EVENT_SWR: 443 return DIBS_SW_EVENT; 444 default: 445 return DIBS_OTHER_TYPE; 446 } 447 } 448 449 static int ism_match_event_subtype(u32 s390_event_subtype) 450 { 451 switch (s390_event_subtype) { 452 case ISM_BUF_DMB_UNREGISTERED: 453 return DIBS_BUF_UNREGISTERED; 454 case ISM_DEV_GID_DISABLED: 455 return DIBS_DEV_DISABLED; 456 case ISM_DEV_GID_ERR_STATE: 457 return DIBS_DEV_ERR_STATE; 458 default: 459 return DIBS_OTHER_SUBTYPE; 460 } 461 } 462 463 static void ism_handle_event(struct ism_dev *ism) 464 { 465 struct dibs_dev *dibs = ism->dibs; 466 struct dibs_event event; 467 struct ism_event *entry; 468 struct dibs_client *clt; 469 int i; 470 471 while ((ism->ieq_idx + 1) != READ_ONCE(ism->ieq->header.idx)) { 472 if (++ism->ieq_idx == ARRAY_SIZE(ism->ieq->entry)) 473 ism->ieq_idx = 0; 474 475 entry = &ism->ieq->entry[ism->ieq_idx]; 476 debug_event(ism_debug_info, 2, entry, sizeof(*entry)); 477 __memset(&event, 0, sizeof(event)); 478 event.type = ism_match_event_type(entry->type); 479 if (event.type == DIBS_SW_EVENT) 480 event.subtype = entry->code; 481 else 482 event.subtype = ism_match_event_subtype(entry->code); 483 event.time = entry->time; 484 event.data = entry->info; 485 switch (event.type) { 486 case DIBS_BUF_EVENT: 487 event.buffer_tok = entry->tok; 488 break; 489 case DIBS_DEV_EVENT: 490 case DIBS_SW_EVENT: 491 memcpy(&event.gid, &entry->tok, sizeof(u64)); 492 } 493 for (i = 0; i < MAX_DIBS_CLIENTS; ++i) { 494 clt = dibs->subs[i]; 495 if (clt) 496 clt->ops->handle_event(dibs, &event); 497 } 498 } 499 } 500 501 static irqreturn_t ism_handle_irq(int irq, void *data) 502 { 503 struct ism_dev *ism = data; 504 unsigned long bit, end; 505 struct dibs_dev *dibs; 506 unsigned long *bv; 507 u16 dmbemask; 508 u8 client_id; 509 510 dibs = ism->dibs; 511 512 bv = (void *) &ism->sba->dmb_bits[ISM_DMB_WORD_OFFSET]; 513 end = sizeof(ism->sba->dmb_bits) * BITS_PER_BYTE - ISM_DMB_BIT_OFFSET; 514 515 spin_lock(&dibs->lock); 516 ism->sba->s = 0; 517 barrier(); 518 for (bit = 0;;) { 519 bit = find_next_bit_inv(bv, end, bit); 520 if (bit >= end) 521 break; 522 523 clear_bit_inv(bit, bv); 524 dmbemask = ism->sba->dmbe_mask[bit + ISM_DMB_BIT_OFFSET]; 525 ism->sba->dmbe_mask[bit + ISM_DMB_BIT_OFFSET] = 0; 526 barrier(); 527 client_id = dibs->dmb_clientid_arr[bit]; 528 if (unlikely(client_id == NO_DIBS_CLIENT || 529 !dibs->subs[client_id])) 530 continue; 531 dibs->subs[client_id]->ops->handle_irq(dibs, 532 bit + ISM_DMB_BIT_OFFSET, 533 dmbemask); 534 } 535 536 if (ism->sba->e) { 537 ism->sba->e = 0; 538 barrier(); 539 ism_handle_event(ism); 540 } 541 spin_unlock(&dibs->lock); 542 return IRQ_HANDLED; 543 } 544 545 static const struct dibs_dev_ops ism_ops = { 546 .get_fabric_id = ism_get_chid, 547 .query_remote_gid = ism_query_rgid, 548 .max_dmbs = ism_max_dmbs, 549 .register_dmb = ism_register_dmb, 550 .unregister_dmb = ism_unregister_dmb, 551 .move_data = ism_move, 552 .add_vlan_id = ism_add_vlan_id, 553 .del_vlan_id = ism_del_vlan_id, 554 .signal_event = ism_signal_ieq, 555 }; 556 557 static int ism_dev_init(struct ism_dev *ism) 558 { 559 struct pci_dev *pdev = ism->pdev; 560 int ret; 561 562 ret = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI); 563 if (ret <= 0) 564 goto out; 565 566 ret = request_irq(pci_irq_vector(pdev, 0), ism_handle_irq, 0, 567 pci_name(pdev), ism); 568 if (ret) 569 goto free_vectors; 570 571 ret = register_sba(ism); 572 if (ret) 573 goto free_irq; 574 575 ret = register_ieq(ism); 576 if (ret) 577 goto unreg_sba; 578 579 query_info(ism); 580 return 0; 581 582 unreg_sba: 583 unregister_sba(ism); 584 ism_free_sba(ism); 585 free_irq: 586 free_irq(pci_irq_vector(pdev, 0), ism); 587 free_vectors: 588 pci_free_irq_vectors(pdev); 589 out: 590 return ret; 591 } 592 593 static void ism_dev_exit(struct ism_dev *ism) 594 { 595 struct pci_dev *pdev = ism->pdev; 596 597 /* ism will only generate new IRQs while ieq & sba are registered */ 598 unregister_ieq(ism); 599 unregister_sba(ism); 600 /* drain ongoing irpt handlers */ 601 free_irq(pci_irq_vector(pdev, 0), ism); 602 ism_free_ieq(ism); 603 ism_free_sba(ism); 604 pci_free_irq_vectors(pdev); 605 } 606 607 static int ism_probe(struct pci_dev *pdev, const struct pci_device_id *id) 608 { 609 struct dibs_dev *dibs; 610 struct zpci_dev *zdev; 611 struct ism_dev *ism; 612 int ret; 613 614 ism = kzalloc_obj(*ism); 615 if (!ism) 616 return -ENOMEM; 617 618 spin_lock_init(&ism->cmd_lock); 619 dev_set_drvdata(&pdev->dev, ism); 620 ism->pdev = pdev; 621 622 ret = pci_enable_device_mem(pdev); 623 if (ret) 624 goto err_dev; 625 626 ret = pci_request_mem_regions(pdev, DRV_NAME); 627 if (ret) 628 goto err_disable; 629 630 ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); 631 if (ret) 632 goto err_resource; 633 634 dma_set_seg_boundary(&pdev->dev, SZ_1M - 1); 635 dma_set_max_seg_size(&pdev->dev, SZ_1M); 636 pci_set_master(pdev); 637 638 dibs = dibs_dev_alloc(); 639 if (!dibs) { 640 ret = -ENOMEM; 641 goto err_resource; 642 } 643 /* set this up before we enable interrupts */ 644 ism->dibs = dibs; 645 dibs->drv_priv = ism; 646 dibs->ops = &ism_ops; 647 648 /* enable ism device, but any interrupts and events will be ignored 649 * before dibs_dev_add() adds it to any clients. 650 */ 651 ret = ism_dev_init(ism); 652 if (ret) 653 goto err_dibs; 654 655 /* after ism_dev_init() we can call ism function to set gid */ 656 ret = ism_read_local_gid(dibs); 657 if (ret) 658 goto err_ism; 659 660 dibs->dev.parent = &pdev->dev; 661 662 zdev = to_zpci(pdev); 663 dev_set_name(&dibs->dev, "ism%x", zdev->uid ? zdev->uid : zdev->fid); 664 665 ret = dibs_dev_add(dibs); 666 if (ret) 667 goto err_ism; 668 669 return 0; 670 671 err_ism: 672 ism_dev_exit(ism); 673 err_dibs: 674 /* pairs with dibs_dev_alloc() */ 675 put_device(&dibs->dev); 676 err_resource: 677 pci_release_mem_regions(pdev); 678 err_disable: 679 pci_disable_device(pdev); 680 err_dev: 681 dev_set_drvdata(&pdev->dev, NULL); 682 kfree(ism); 683 684 return ret; 685 } 686 687 static void ism_remove(struct pci_dev *pdev) 688 { 689 struct ism_dev *ism = dev_get_drvdata(&pdev->dev); 690 struct dibs_dev *dibs = ism->dibs; 691 692 dibs_dev_del(dibs); 693 ism_dev_exit(ism); 694 /* pairs with dibs_dev_alloc() */ 695 put_device(&dibs->dev); 696 697 pci_release_mem_regions(pdev); 698 pci_disable_device(pdev); 699 dev_set_drvdata(&pdev->dev, NULL); 700 kfree(ism); 701 } 702 703 static struct pci_driver ism_driver = { 704 .name = DRV_NAME, 705 .id_table = ism_device_table, 706 .probe = ism_probe, 707 .remove = ism_remove, 708 }; 709 710 static int __init ism_init(void) 711 { 712 int ret; 713 714 ism_debug_info = debug_register("ism", 2, 1, 16); 715 if (!ism_debug_info) 716 return -ENODEV; 717 718 debug_register_view(ism_debug_info, &debug_hex_ascii_view); 719 ret = pci_register_driver(&ism_driver); 720 if (ret) 721 debug_unregister(ism_debug_info); 722 723 return ret; 724 } 725 726 static void __exit ism_exit(void) 727 { 728 pci_unregister_driver(&ism_driver); 729 debug_unregister(ism_debug_info); 730 } 731 732 module_init(ism_init); 733 module_exit(ism_exit); 734