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