rx.c 17 KB

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