1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Adaptec AAC series RAID controller driver 4 * (c) Copyright 2001 Red Hat Inc. 5 * 6 * based on the old aacraid driver that is.. 7 * Adaptec aacraid device driver for Linux. 8 * 9 * Copyright (c) 2000-2010 Adaptec, Inc. 10 * 2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com) 11 * 2016-2017 Microsemi Corp. (aacraid@microsemi.com) 12 * 13 * Module Name: 14 * rx.c 15 * 16 * Abstract: Hardware miniport for Drawbridge specific hardware functions. 17 */ 18 19 #include <linux/kernel.h> 20 #include <linux/init.h> 21 #include <linux/types.h> 22 #include <linux/pci.h> 23 #include <linux/spinlock.h> 24 #include <linux/blkdev.h> 25 #include <linux/delay.h> 26 #include <linux/completion.h> 27 #include <linux/time.h> 28 #include <linux/interrupt.h> 29 30 #include <scsi/scsi_host.h> 31 32 #include "aacraid.h" 33 34 static irqreturn_t aac_rx_intr_producer(int irq, void *dev_id) 35 { 36 struct aac_dev *dev = dev_id; 37 unsigned long bellbits; 38 u8 intstat = rx_readb(dev, MUnit.OISR); 39 40 /* 41 * Read mask and invert because drawbridge is reversed. 42 * This allows us to only service interrupts that have 43 * been enabled. 44 * Check to see if this is our interrupt. If it isn't just return 45 */ 46 if (likely(intstat & ~(dev->OIMR))) { 47 bellbits = rx_readl(dev, OutboundDoorbellReg); 48 if (unlikely(bellbits & DoorBellPrintfReady)) { 49 aac_printf(dev, readl (&dev->IndexRegs->Mailbox[5])); 50 rx_writel(dev, MUnit.ODR,DoorBellPrintfReady); 51 rx_writel(dev, InboundDoorbellReg,DoorBellPrintfDone); 52 } 53 else if (unlikely(bellbits & DoorBellAdapterNormCmdReady)) { 54 rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady); 55 aac_command_normal(&dev->queues->queue[HostNormCmdQueue]); 56 } 57 else if (likely(bellbits & DoorBellAdapterNormRespReady)) { 58 rx_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady); 59 aac_response_normal(&dev->queues->queue[HostNormRespQueue]); 60 } 61 else if (unlikely(bellbits & DoorBellAdapterNormCmdNotFull)) { 62 rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull); 63 } 64 else if (unlikely(bellbits & DoorBellAdapterNormRespNotFull)) { 65 rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull); 66 rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull); 67 } 68 return IRQ_HANDLED; 69 } 70 return IRQ_NONE; 71 } 72 73 static irqreturn_t aac_rx_intr_message(int irq, void *dev_id) 74 { 75 int isAif, isFastResponse, isSpecial; 76 struct aac_dev *dev = dev_id; 77 u32 Index = rx_readl(dev, MUnit.OutboundQueue); 78 if (unlikely(Index == 0xFFFFFFFFL)) 79 Index = rx_readl(dev, MUnit.OutboundQueue); 80 if (likely(Index != 0xFFFFFFFFL)) { 81 do { 82 isAif = isFastResponse = isSpecial = 0; 83 if (Index & 0x00000002L) { 84 isAif = 1; 85 if (Index == 0xFFFFFFFEL) 86 isSpecial = 1; 87 Index &= ~0x00000002L; 88 } else { 89 if (Index & 0x00000001L) 90 isFastResponse = 1; 91 Index >>= 2; 92 } 93 if (!isSpecial) { 94 if (unlikely(aac_intr_normal(dev, 95 Index, isAif, 96 isFastResponse, NULL))) { 97 rx_writel(dev, 98 MUnit.OutboundQueue, 99 Index); 100 rx_writel(dev, 101 MUnit.ODR, 102 DoorBellAdapterNormRespReady); 103 } 104 } 105 Index = rx_readl(dev, MUnit.OutboundQueue); 106 } while (Index != 0xFFFFFFFFL); 107 return IRQ_HANDLED; 108 } 109 return IRQ_NONE; 110 } 111 112 /** 113 * aac_rx_disable_interrupt - Disable interrupts 114 * @dev: Adapter 115 */ 116 117 static void aac_rx_disable_interrupt(struct aac_dev *dev) 118 { 119 rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff); 120 } 121 122 /** 123 * aac_rx_enable_interrupt_producer - Enable interrupts 124 * @dev: Adapter 125 */ 126 127 static void aac_rx_enable_interrupt_producer(struct aac_dev *dev) 128 { 129 rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb); 130 } 131 132 /** 133 * aac_rx_enable_interrupt_message - Enable interrupts 134 * @dev: Adapter 135 */ 136 137 static void aac_rx_enable_interrupt_message(struct aac_dev *dev) 138 { 139 rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7); 140 } 141 142 /** 143 * rx_sync_cmd - send a command and wait 144 * @dev: Adapter 145 * @command: Command to execute 146 * @p1: first parameter 147 * @p2: second parameter 148 * @p3: third parameter 149 * @p4: forth parameter 150 * @p5: fifth parameter 151 * @p6: sixth parameter 152 * @status: adapter status 153 * @r1: first return value 154 * @r2: second return value 155 * @r3: third return value 156 * @r4: forth return value 157 * 158 * This routine will send a synchronous command to the adapter and wait 159 * for its completion. 160 */ 161 162 static int rx_sync_cmd(struct aac_dev *dev, u32 command, 163 u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6, 164 u32 *status, u32 * r1, u32 * r2, u32 * r3, u32 * r4) 165 { 166 unsigned long start; 167 int ok; 168 /* 169 * Write the command into Mailbox 0 170 */ 171 writel(command, &dev->IndexRegs->Mailbox[0]); 172 /* 173 * Write the parameters into Mailboxes 1 - 6 174 */ 175 writel(p1, &dev->IndexRegs->Mailbox[1]); 176 writel(p2, &dev->IndexRegs->Mailbox[2]); 177 writel(p3, &dev->IndexRegs->Mailbox[3]); 178 writel(p4, &dev->IndexRegs->Mailbox[4]); 179 /* 180 * Clear the synch command doorbell to start on a clean slate. 181 */ 182 rx_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0); 183 /* 184 * Disable doorbell interrupts 185 */ 186 rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff); 187 /* 188 * Force the completion of the mask register write before issuing 189 * the interrupt. 190 */ 191 rx_readb (dev, MUnit.OIMR); 192 /* 193 * Signal that there is a new synch command 194 */ 195 rx_writel(dev, InboundDoorbellReg, INBOUNDDOORBELL_0); 196 197 ok = 0; 198 start = jiffies; 199 200 /* 201 * Wait up to 30 seconds 202 */ 203 while (time_before(jiffies, start+30*HZ)) 204 { 205 udelay(5); /* Delay 5 microseconds to let Mon960 get info. */ 206 /* 207 * Mon960 will set doorbell0 bit when it has completed the command. 208 */ 209 if (rx_readl(dev, OutboundDoorbellReg) & OUTBOUNDDOORBELL_0) { 210 /* 211 * Clear the doorbell. 212 */ 213 rx_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0); 214 ok = 1; 215 break; 216 } 217 /* 218 * Yield the processor in case we are slow 219 */ 220 msleep(1); 221 } 222 if (unlikely(ok != 1)) { 223 /* 224 * Restore interrupt mask even though we timed out 225 */ 226 aac_adapter_enable_int(dev); 227 return -ETIMEDOUT; 228 } 229 /* 230 * Pull the synch status from Mailbox 0. 231 */ 232 if (status) 233 *status = readl(&dev->IndexRegs->Mailbox[0]); 234 if (r1) 235 *r1 = readl(&dev->IndexRegs->Mailbox[1]); 236 if (r2) 237 *r2 = readl(&dev->IndexRegs->Mailbox[2]); 238 if (r3) 239 *r3 = readl(&dev->IndexRegs->Mailbox[3]); 240 if (r4) 241 *r4 = readl(&dev->IndexRegs->Mailbox[4]); 242 /* 243 * Clear the synch command doorbell. 244 */ 245 rx_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0); 246 /* 247 * Restore interrupt mask 248 */ 249 aac_adapter_enable_int(dev); 250 return 0; 251 252 } 253 254 /** 255 * aac_rx_interrupt_adapter - interrupt adapter 256 * @dev: Adapter 257 * 258 * Send an interrupt to the i960 and breakpoint it. 259 */ 260 261 static void aac_rx_interrupt_adapter(struct aac_dev *dev) 262 { 263 rx_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL); 264 } 265 266 /** 267 * aac_rx_notify_adapter - send an event to the adapter 268 * @dev: Adapter 269 * @event: Event to send 270 * 271 * Notify the i960 that something it probably cares about has 272 * happened. 273 */ 274 275 static void aac_rx_notify_adapter(struct aac_dev *dev, u32 event) 276 { 277 switch (event) { 278 279 case AdapNormCmdQue: 280 rx_writel(dev, MUnit.IDR,INBOUNDDOORBELL_1); 281 break; 282 case HostNormRespNotFull: 283 rx_writel(dev, MUnit.IDR,INBOUNDDOORBELL_4); 284 break; 285 case AdapNormRespQue: 286 rx_writel(dev, MUnit.IDR,INBOUNDDOORBELL_2); 287 break; 288 case HostNormCmdNotFull: 289 rx_writel(dev, MUnit.IDR,INBOUNDDOORBELL_3); 290 break; 291 case HostShutdown: 292 break; 293 case FastIo: 294 rx_writel(dev, MUnit.IDR,INBOUNDDOORBELL_6); 295 break; 296 case AdapPrintfDone: 297 rx_writel(dev, MUnit.IDR,INBOUNDDOORBELL_5); 298 break; 299 default: 300 BUG(); 301 break; 302 } 303 } 304 305 /** 306 * aac_rx_start_adapter - activate adapter 307 * @dev: Adapter 308 * 309 * Start up processing on an i960 based AAC adapter 310 */ 311 312 static void aac_rx_start_adapter(struct aac_dev *dev) 313 { 314 union aac_init *init; 315 316 init = dev->init; 317 init->r7.host_elapsed_seconds = cpu_to_le32(ktime_get_real_seconds()); 318 // We can only use a 32 bit address here 319 rx_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa, 320 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL); 321 } 322 323 /** 324 * aac_rx_check_health 325 * @dev: device to check if healthy 326 * 327 * Will attempt to determine if the specified adapter is alive and 328 * capable of handling requests, returning 0 if alive. 329 */ 330 static int aac_rx_check_health(struct aac_dev *dev) 331 { 332 u32 status = rx_readl(dev, MUnit.OMRx[0]); 333 334 /* 335 * Check to see if the board failed any self tests. 336 */ 337 if (unlikely(status & SELF_TEST_FAILED)) 338 return -1; 339 /* 340 * Check to see if the board panic'd. 341 */ 342 if (unlikely(status & KERNEL_PANIC)) { 343 char * buffer; 344 struct POSTSTATUS { 345 __le32 Post_Command; 346 __le32 Post_Address; 347 } * post; 348 dma_addr_t paddr, baddr; 349 int ret; 350 351 if (likely((status & 0xFF000000L) == 0xBC000000L)) 352 return (status >> 16) & 0xFF; 353 buffer = dma_alloc_coherent(&dev->pdev->dev, 512, &baddr, 354 GFP_KERNEL); 355 ret = -2; 356 if (unlikely(buffer == NULL)) 357 return ret; 358 post = dma_alloc_coherent(&dev->pdev->dev, 359 sizeof(struct POSTSTATUS), &paddr, 360 GFP_KERNEL); 361 if (unlikely(post == NULL)) { 362 dma_free_coherent(&dev->pdev->dev, 512, buffer, baddr); 363 return ret; 364 } 365 memset(buffer, 0, 512); 366 post->Post_Command = cpu_to_le32(COMMAND_POST_RESULTS); 367 post->Post_Address = cpu_to_le32(baddr); 368 rx_writel(dev, MUnit.IMRx[0], paddr); 369 rx_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, 0, 0, 0, 0, 0, 370 NULL, NULL, NULL, NULL, NULL); 371 dma_free_coherent(&dev->pdev->dev, sizeof(struct POSTSTATUS), 372 post, paddr); 373 if (likely((buffer[0] == '0') && ((buffer[1] == 'x') || (buffer[1] == 'X')))) { 374 ret = (hex_to_bin(buffer[2]) << 4) + 375 hex_to_bin(buffer[3]); 376 } 377 dma_free_coherent(&dev->pdev->dev, 512, buffer, baddr); 378 return ret; 379 } 380 /* 381 * Wait for the adapter to be up and running. 382 */ 383 if (unlikely(!(status & KERNEL_UP_AND_RUNNING))) 384 return -3; 385 /* 386 * Everything is OK 387 */ 388 return 0; 389 } 390 391 /** 392 * aac_rx_deliver_producer 393 * @fib: fib to issue 394 * 395 * Will send a fib, returning 0 if successful. 396 */ 397 int aac_rx_deliver_producer(struct fib * fib) 398 { 399 struct aac_dev *dev = fib->dev; 400 struct aac_queue *q = &dev->queues->queue[AdapNormCmdQueue]; 401 u32 Index; 402 unsigned long nointr = 0; 403 404 aac_queue_get( dev, &Index, AdapNormCmdQueue, fib->hw_fib_va, 1, fib, &nointr); 405 406 atomic_inc(&q->numpending); 407 *(q->headers.producer) = cpu_to_le32(Index + 1); 408 if (!(nointr & aac_config.irq_mod)) 409 aac_adapter_notify(dev, AdapNormCmdQueue); 410 411 return 0; 412 } 413 414 /** 415 * aac_rx_deliver_message 416 * @fib: fib to issue 417 * 418 * Will send a fib, returning 0 if successful. 419 */ 420 static int aac_rx_deliver_message(struct fib * fib) 421 { 422 struct aac_dev *dev = fib->dev; 423 struct aac_queue *q = &dev->queues->queue[AdapNormCmdQueue]; 424 u32 Index; 425 u64 addr; 426 volatile void __iomem *device; 427 428 unsigned long count = 10000000L; /* 50 seconds */ 429 atomic_inc(&q->numpending); 430 for(;;) { 431 Index = rx_readl(dev, MUnit.InboundQueue); 432 if (unlikely(Index == 0xFFFFFFFFL)) 433 Index = rx_readl(dev, MUnit.InboundQueue); 434 if (likely(Index != 0xFFFFFFFFL)) 435 break; 436 if (--count == 0) { 437 atomic_dec(&q->numpending); 438 return -ETIMEDOUT; 439 } 440 udelay(5); 441 } 442 device = dev->base + Index; 443 addr = fib->hw_fib_pa; 444 writel((u32)(addr & 0xffffffff), device); 445 device += sizeof(u32); 446 writel((u32)(addr >> 32), device); 447 device += sizeof(u32); 448 writel(le16_to_cpu(fib->hw_fib_va->header.Size), device); 449 rx_writel(dev, MUnit.InboundQueue, Index); 450 return 0; 451 } 452 453 /** 454 * aac_rx_ioremap 455 * @dev: adapter 456 * @size: mapping resize request 457 * 458 */ 459 static int aac_rx_ioremap(struct aac_dev * dev, u32 size) 460 { 461 if (!size) { 462 iounmap(dev->regs.rx); 463 return 0; 464 } 465 dev->base = dev->regs.rx = ioremap(dev->base_start, size); 466 if (dev->base == NULL) 467 return -1; 468 dev->IndexRegs = &dev->regs.rx->IndexRegs; 469 return 0; 470 } 471 472 static int aac_rx_restart_adapter(struct aac_dev *dev, int bled, u8 reset_type) 473 { 474 u32 var = 0; 475 476 if (!(dev->supplement_adapter_info.supported_options2 & 477 AAC_OPTION_MU_RESET) || (bled >= 0) || (bled == -2)) { 478 if (bled) 479 printk(KERN_ERR "%s%d: adapter kernel panic'd %x.\n", 480 dev->name, dev->id, bled); 481 else { 482 bled = aac_adapter_sync_cmd(dev, IOP_RESET_ALWAYS, 483 0, 0, 0, 0, 0, 0, &var, NULL, NULL, NULL, NULL); 484 if (!bled && (var != 0x00000001) && (var != 0x3803000F)) 485 bled = -EINVAL; 486 } 487 if (bled && (bled != -ETIMEDOUT)) 488 bled = aac_adapter_sync_cmd(dev, IOP_RESET, 489 0, 0, 0, 0, 0, 0, &var, NULL, NULL, NULL, NULL); 490 491 if (bled && (bled != -ETIMEDOUT)) 492 return -EINVAL; 493 } 494 if (bled && (var == 0x3803000F)) { /* USE_OTHER_METHOD */ 495 rx_writel(dev, MUnit.reserved2, 3); 496 msleep(5000); /* Delay 5 seconds */ 497 var = 0x00000001; 498 } 499 if (bled && (var != 0x00000001)) 500 return -EINVAL; 501 ssleep(5); 502 if (rx_readl(dev, MUnit.OMRx[0]) & KERNEL_PANIC) 503 return -ENODEV; 504 if (startup_timeout < 300) 505 startup_timeout = 300; 506 return 0; 507 } 508 509 /** 510 * aac_rx_select_comm - Select communications method 511 * @dev: Adapter 512 * @comm: communications method 513 */ 514 515 int aac_rx_select_comm(struct aac_dev *dev, int comm) 516 { 517 switch (comm) { 518 case AAC_COMM_PRODUCER: 519 dev->a_ops.adapter_enable_int = aac_rx_enable_interrupt_producer; 520 dev->a_ops.adapter_intr = aac_rx_intr_producer; 521 dev->a_ops.adapter_deliver = aac_rx_deliver_producer; 522 break; 523 case AAC_COMM_MESSAGE: 524 dev->a_ops.adapter_enable_int = aac_rx_enable_interrupt_message; 525 dev->a_ops.adapter_intr = aac_rx_intr_message; 526 dev->a_ops.adapter_deliver = aac_rx_deliver_message; 527 break; 528 default: 529 return 1; 530 } 531 return 0; 532 } 533 534 /** 535 * _aac_rx_init - initialize an i960 based AAC card 536 * @dev: device to configure 537 * 538 * Allocate and set up resources for the i960 based AAC variants. The 539 * device_interface in the commregion will be allocated and linked 540 * to the comm region. 541 */ 542 543 int _aac_rx_init(struct aac_dev *dev) 544 { 545 unsigned long start; 546 unsigned long status; 547 int restart = 0; 548 int instance = dev->id; 549 const char * name = dev->name; 550 551 if (aac_adapter_ioremap(dev, dev->base_size)) { 552 printk(KERN_WARNING "%s: unable to map adapter.\n", name); 553 goto error_iounmap; 554 } 555 556 /* Failure to reset here is an option ... */ 557 dev->a_ops.adapter_sync_cmd = rx_sync_cmd; 558 dev->a_ops.adapter_enable_int = aac_rx_disable_interrupt; 559 dev->OIMR = status = rx_readb (dev, MUnit.OIMR); 560 561 if (((status & 0x0c) != 0x0c) || dev->init_reset) { 562 dev->init_reset = false; 563 if (!aac_rx_restart_adapter(dev, 0, IOP_HWSOFT_RESET)) { 564 /* Make sure the Hardware FIFO is empty */ 565 while ((++restart < 512) && 566 (rx_readl(dev, MUnit.OutboundQueue) != 0xFFFFFFFFL)); 567 } 568 } 569 570 /* 571 * Check to see if the board panic'd while booting. 572 */ 573 status = rx_readl(dev, MUnit.OMRx[0]); 574 if (status & KERNEL_PANIC) { 575 if (aac_rx_restart_adapter(dev, 576 aac_rx_check_health(dev), IOP_HWSOFT_RESET)) 577 goto error_iounmap; 578 ++restart; 579 } 580 /* 581 * Check to see if the board failed any self tests. 582 */ 583 status = rx_readl(dev, MUnit.OMRx[0]); 584 if (status & SELF_TEST_FAILED) { 585 printk(KERN_ERR "%s%d: adapter self-test failed.\n", dev->name, instance); 586 goto error_iounmap; 587 } 588 /* 589 * Check to see if the monitor panic'd while booting. 590 */ 591 if (status & MONITOR_PANIC) { 592 printk(KERN_ERR "%s%d: adapter monitor panic.\n", dev->name, instance); 593 goto error_iounmap; 594 } 595 start = jiffies; 596 /* 597 * Wait for the adapter to be up and running. Wait up to 3 minutes 598 */ 599 while (!((status = rx_readl(dev, MUnit.OMRx[0])) & KERNEL_UP_AND_RUNNING)) 600 { 601 if ((restart && 602 (status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC))) || 603 time_after(jiffies, start+HZ*startup_timeout)) { 604 printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n", 605 dev->name, instance, status); 606 goto error_iounmap; 607 } 608 if (!restart && 609 ((status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC)) || 610 time_after(jiffies, start + HZ * 611 ((startup_timeout > 60) 612 ? (startup_timeout - 60) 613 : (startup_timeout / 2))))) { 614 if (likely(!aac_rx_restart_adapter(dev, 615 aac_rx_check_health(dev), IOP_HWSOFT_RESET))) 616 start = jiffies; 617 ++restart; 618 } 619 msleep(1); 620 } 621 if (restart && aac_commit) 622 aac_commit = 1; 623 /* 624 * Fill in the common function dispatch table. 625 */ 626 dev->a_ops.adapter_interrupt = aac_rx_interrupt_adapter; 627 dev->a_ops.adapter_disable_int = aac_rx_disable_interrupt; 628 dev->a_ops.adapter_notify = aac_rx_notify_adapter; 629 dev->a_ops.adapter_sync_cmd = rx_sync_cmd; 630 dev->a_ops.adapter_check_health = aac_rx_check_health; 631 dev->a_ops.adapter_restart = aac_rx_restart_adapter; 632 dev->a_ops.adapter_start = aac_rx_start_adapter; 633 634 /* 635 * First clear out all interrupts. Then enable the one's that we 636 * can handle. 637 */ 638 aac_adapter_comm(dev, AAC_COMM_PRODUCER); 639 aac_adapter_disable_int(dev); 640 rx_writel(dev, MUnit.ODR, 0xffffffff); 641 aac_adapter_enable_int(dev); 642 643 if (aac_init_adapter(dev) == NULL) 644 goto error_iounmap; 645 aac_adapter_comm(dev, dev->comm_interface); 646 dev->sync_mode = 0; /* sync. mode not supported */ 647 dev->msi = aac_msi && !pci_enable_msi(dev->pdev); 648 if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr, 649 IRQF_SHARED, "aacraid", dev) < 0) { 650 if (dev->msi) 651 pci_disable_msi(dev->pdev); 652 printk(KERN_ERR "%s%d: Interrupt unavailable.\n", 653 name, instance); 654 goto error_iounmap; 655 } 656 dev->dbg_base = dev->base_start; 657 dev->dbg_base_mapped = dev->base; 658 dev->dbg_size = dev->base_size; 659 660 aac_adapter_enable_int(dev); 661 /* 662 * Tell the adapter that all is configured, and it can 663 * start accepting requests 664 */ 665 aac_rx_start_adapter(dev); 666 667 return 0; 668 669 error_iounmap: 670 671 return -1; 672 } 673 674 int aac_rx_init(struct aac_dev *dev) 675 { 676 /* 677 * Fill in the function dispatch table. 678 */ 679 dev->a_ops.adapter_ioremap = aac_rx_ioremap; 680 dev->a_ops.adapter_comm = aac_rx_select_comm; 681 682 return _aac_rx_init(dev); 683 } 684