1c82ee6d3SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2e8b12f0fSMahesh Rajashekhara /*
3e8b12f0fSMahesh Rajashekhara * Adaptec AAC series RAID controller driver
4e8b12f0fSMahesh Rajashekhara * (c) Copyright 2001 Red Hat Inc.
5e8b12f0fSMahesh Rajashekhara *
6e8b12f0fSMahesh Rajashekhara * based on the old aacraid driver that is..
7e8b12f0fSMahesh Rajashekhara * Adaptec aacraid device driver for Linux.
8e8b12f0fSMahesh Rajashekhara *
9e8b12f0fSMahesh Rajashekhara * Copyright (c) 2000-2010 Adaptec, Inc.
10f4babba0SRaghava Aditya Renukunta * 2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
11f4babba0SRaghava Aditya Renukunta * 2016-2017 Microsemi Corp. (aacraid@microsemi.com)
12e8b12f0fSMahesh Rajashekhara *
13e8b12f0fSMahesh Rajashekhara * Module Name:
14e8b12f0fSMahesh Rajashekhara * src.c
15e8b12f0fSMahesh Rajashekhara *
16e8b12f0fSMahesh Rajashekhara * Abstract: Hardware Device Interface for PMC SRC based controllers
17e8b12f0fSMahesh Rajashekhara */
18e8b12f0fSMahesh Rajashekhara
19e8b12f0fSMahesh Rajashekhara #include <linux/kernel.h>
20e8b12f0fSMahesh Rajashekhara #include <linux/init.h>
21e8b12f0fSMahesh Rajashekhara #include <linux/types.h>
22e8b12f0fSMahesh Rajashekhara #include <linux/pci.h>
23e8b12f0fSMahesh Rajashekhara #include <linux/spinlock.h>
24e8b12f0fSMahesh Rajashekhara #include <linux/slab.h>
25e8b12f0fSMahesh Rajashekhara #include <linux/blkdev.h>
26e8b12f0fSMahesh Rajashekhara #include <linux/delay.h>
27e8b12f0fSMahesh Rajashekhara #include <linux/completion.h>
28e8b12f0fSMahesh Rajashekhara #include <linux/time.h>
29e8b12f0fSMahesh Rajashekhara #include <linux/interrupt.h>
30e8b12f0fSMahesh Rajashekhara #include <scsi/scsi_host.h>
31e8b12f0fSMahesh Rajashekhara
32e8b12f0fSMahesh Rajashekhara #include "aacraid.h"
33e8b12f0fSMahesh Rajashekhara
34495c0217SMahesh Rajashekhara static int aac_src_get_sync_status(struct aac_dev *dev);
35495c0217SMahesh Rajashekhara
aac_src_intr_message(int irq,void * dev_id)36305974feSkbuild test robot static irqreturn_t aac_src_intr_message(int irq, void *dev_id)
37e8b12f0fSMahesh Rajashekhara {
38495c0217SMahesh Rajashekhara struct aac_msix_ctx *ctx;
39495c0217SMahesh Rajashekhara struct aac_dev *dev;
40e8b12f0fSMahesh Rajashekhara unsigned long bellbits, bellbits_shifted;
41495c0217SMahesh Rajashekhara int vector_no;
42495c0217SMahesh Rajashekhara int isFastResponse, mode;
43e8b12f0fSMahesh Rajashekhara u32 index, handle;
44e8b12f0fSMahesh Rajashekhara
45495c0217SMahesh Rajashekhara ctx = (struct aac_msix_ctx *)dev_id;
46495c0217SMahesh Rajashekhara dev = ctx->dev;
47495c0217SMahesh Rajashekhara vector_no = ctx->vector_no;
48495c0217SMahesh Rajashekhara
49495c0217SMahesh Rajashekhara if (dev->msi_enabled) {
50495c0217SMahesh Rajashekhara mode = AAC_INT_MODE_MSI;
51495c0217SMahesh Rajashekhara if (vector_no == 0) {
52495c0217SMahesh Rajashekhara bellbits = src_readl(dev, MUnit.ODR_MSI);
53495c0217SMahesh Rajashekhara if (bellbits & 0x40000)
54495c0217SMahesh Rajashekhara mode |= AAC_INT_MODE_AIF;
55495c0217SMahesh Rajashekhara if (bellbits & 0x1000)
56495c0217SMahesh Rajashekhara mode |= AAC_INT_MODE_SYNC;
57495c0217SMahesh Rajashekhara }
58495c0217SMahesh Rajashekhara } else {
59495c0217SMahesh Rajashekhara mode = AAC_INT_MODE_INTX;
60e8b12f0fSMahesh Rajashekhara bellbits = src_readl(dev, MUnit.ODR_R);
61e8b12f0fSMahesh Rajashekhara if (bellbits & PmDoorBellResponseSent) {
62e8b12f0fSMahesh Rajashekhara bellbits = PmDoorBellResponseSent;
6385d22bbfSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C, bellbits);
6485d22bbfSMahesh Rajashekhara src_readl(dev, MUnit.ODR_C);
65e8b12f0fSMahesh Rajashekhara } else {
66e8b12f0fSMahesh Rajashekhara bellbits_shifted = (bellbits >> SRC_ODR_SHIFT);
6785d22bbfSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C, bellbits);
6885d22bbfSMahesh Rajashekhara src_readl(dev, MUnit.ODR_C);
69495c0217SMahesh Rajashekhara
70495c0217SMahesh Rajashekhara if (bellbits_shifted & DoorBellAifPending)
71495c0217SMahesh Rajashekhara mode |= AAC_INT_MODE_AIF;
72495c0217SMahesh Rajashekhara else if (bellbits_shifted & OUTBOUNDDOORBELL_0)
73495c0217SMahesh Rajashekhara mode |= AAC_INT_MODE_SYNC;
74495c0217SMahesh Rajashekhara }
75495c0217SMahesh Rajashekhara }
76495c0217SMahesh Rajashekhara
77495c0217SMahesh Rajashekhara if (mode & AAC_INT_MODE_SYNC) {
7811604612SMahesh Rajashekhara unsigned long sflags;
7911604612SMahesh Rajashekhara struct list_head *entry;
8011604612SMahesh Rajashekhara int send_it = 0;
8185d22bbfSMahesh Rajashekhara extern int aac_sync_mode;
8285d22bbfSMahesh Rajashekhara
83495c0217SMahesh Rajashekhara if (!aac_sync_mode && !dev->msi_enabled) {
84c5bebd82SMahesh Rajashekhara src_writel(dev, MUnit.ODR_C, bellbits);
85c5bebd82SMahesh Rajashekhara src_readl(dev, MUnit.ODR_C);
8685d22bbfSMahesh Rajashekhara }
8711604612SMahesh Rajashekhara
8811604612SMahesh Rajashekhara if (dev->sync_fib) {
8911604612SMahesh Rajashekhara if (dev->sync_fib->callback)
9011604612SMahesh Rajashekhara dev->sync_fib->callback(dev->sync_fib->callback_data,
9111604612SMahesh Rajashekhara dev->sync_fib);
9211604612SMahesh Rajashekhara spin_lock_irqsave(&dev->sync_fib->event_lock, sflags);
9311604612SMahesh Rajashekhara if (dev->sync_fib->flags & FIB_CONTEXT_FLAG_WAIT) {
9411604612SMahesh Rajashekhara dev->management_fib_count--;
95bc127d93SArnd Bergmann complete(&dev->sync_fib->event_wait);
9611604612SMahesh Rajashekhara }
97495c0217SMahesh Rajashekhara spin_unlock_irqrestore(&dev->sync_fib->event_lock,
98495c0217SMahesh Rajashekhara sflags);
9911604612SMahesh Rajashekhara spin_lock_irqsave(&dev->sync_lock, sflags);
10011604612SMahesh Rajashekhara if (!list_empty(&dev->sync_fib_list)) {
10111604612SMahesh Rajashekhara entry = dev->sync_fib_list.next;
102495c0217SMahesh Rajashekhara dev->sync_fib = list_entry(entry,
103495c0217SMahesh Rajashekhara struct fib,
104495c0217SMahesh Rajashekhara fiblink);
10511604612SMahesh Rajashekhara list_del(entry);
10611604612SMahesh Rajashekhara send_it = 1;
10711604612SMahesh Rajashekhara } else {
10811604612SMahesh Rajashekhara dev->sync_fib = NULL;
10911604612SMahesh Rajashekhara }
11011604612SMahesh Rajashekhara spin_unlock_irqrestore(&dev->sync_lock, sflags);
11111604612SMahesh Rajashekhara if (send_it) {
11211604612SMahesh Rajashekhara aac_adapter_sync_cmd(dev, SEND_SYNCHRONOUS_FIB,
113495c0217SMahesh Rajashekhara (u32)dev->sync_fib->hw_fib_pa,
114495c0217SMahesh Rajashekhara 0, 0, 0, 0, 0,
11511604612SMahesh Rajashekhara NULL, NULL, NULL, NULL, NULL);
11611604612SMahesh Rajashekhara }
11711604612SMahesh Rajashekhara }
118495c0217SMahesh Rajashekhara if (!dev->msi_enabled)
119495c0217SMahesh Rajashekhara mode = 0;
120495c0217SMahesh Rajashekhara
121e8b12f0fSMahesh Rajashekhara }
122e8b12f0fSMahesh Rajashekhara
123495c0217SMahesh Rajashekhara if (mode & AAC_INT_MODE_AIF) {
124495c0217SMahesh Rajashekhara /* handle AIF */
1253ffd6c5aSRaghava Aditya Renukunta if (dev->sa_firmware) {
1263ffd6c5aSRaghava Aditya Renukunta u32 events = src_readl(dev, MUnit.SCR0);
1273ffd6c5aSRaghava Aditya Renukunta
1283ffd6c5aSRaghava Aditya Renukunta aac_intr_normal(dev, events, 1, 0, NULL);
1293ffd6c5aSRaghava Aditya Renukunta writel(events, &dev->IndexRegs->Mailbox[0]);
1303ffd6c5aSRaghava Aditya Renukunta src_writel(dev, MUnit.IDR, 1 << 23);
1313ffd6c5aSRaghava Aditya Renukunta } else {
1329cb62fa2SRaghava Aditya Renukunta if (dev->aif_thread && dev->fsa_dev)
133495c0217SMahesh Rajashekhara aac_intr_normal(dev, 0, 2, 0, NULL);
1343ffd6c5aSRaghava Aditya Renukunta }
135495c0217SMahesh Rajashekhara if (dev->msi_enabled)
136495c0217SMahesh Rajashekhara aac_src_access_devreg(dev, AAC_CLEAR_AIF_BIT);
137495c0217SMahesh Rajashekhara mode = 0;
138e8b12f0fSMahesh Rajashekhara }
139495c0217SMahesh Rajashekhara
140495c0217SMahesh Rajashekhara if (mode) {
141495c0217SMahesh Rajashekhara index = dev->host_rrq_idx[vector_no];
142495c0217SMahesh Rajashekhara
143495c0217SMahesh Rajashekhara for (;;) {
144495c0217SMahesh Rajashekhara isFastResponse = 0;
145495c0217SMahesh Rajashekhara /* remove toggle bit (31) */
1463ffd6c5aSRaghava Aditya Renukunta handle = le32_to_cpu((dev->host_rrq[index])
1473ffd6c5aSRaghava Aditya Renukunta & 0x7fffffff);
1483ffd6c5aSRaghava Aditya Renukunta /* check fast response bits (30, 1) */
149495c0217SMahesh Rajashekhara if (handle & 0x40000000)
150495c0217SMahesh Rajashekhara isFastResponse = 1;
151495c0217SMahesh Rajashekhara handle &= 0x0000ffff;
152495c0217SMahesh Rajashekhara if (handle == 0)
153495c0217SMahesh Rajashekhara break;
1543ffd6c5aSRaghava Aditya Renukunta handle >>= 2;
155495c0217SMahesh Rajashekhara if (dev->msi_enabled && dev->max_msix > 1)
156495c0217SMahesh Rajashekhara atomic_dec(&dev->rrq_outstanding[vector_no]);
1573ffd6c5aSRaghava Aditya Renukunta aac_intr_normal(dev, handle, 0, isFastResponse, NULL);
158495c0217SMahesh Rajashekhara dev->host_rrq[index++] = 0;
159495c0217SMahesh Rajashekhara if (index == (vector_no + 1) * dev->vector_cap)
160495c0217SMahesh Rajashekhara index = vector_no * dev->vector_cap;
161495c0217SMahesh Rajashekhara dev->host_rrq_idx[vector_no] = index;
162495c0217SMahesh Rajashekhara }
163495c0217SMahesh Rajashekhara mode = 0;
164495c0217SMahesh Rajashekhara }
165495c0217SMahesh Rajashekhara
166495c0217SMahesh Rajashekhara return IRQ_HANDLED;
167e8b12f0fSMahesh Rajashekhara }
168e8b12f0fSMahesh Rajashekhara
169e8b12f0fSMahesh Rajashekhara /**
170e8b12f0fSMahesh Rajashekhara * aac_src_disable_interrupt - Disable interrupts
171e8b12f0fSMahesh Rajashekhara * @dev: Adapter
172e8b12f0fSMahesh Rajashekhara */
173e8b12f0fSMahesh Rajashekhara
aac_src_disable_interrupt(struct aac_dev * dev)174e8b12f0fSMahesh Rajashekhara static void aac_src_disable_interrupt(struct aac_dev *dev)
175e8b12f0fSMahesh Rajashekhara {
176e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.OIMR, dev->OIMR = 0xffffffff);
177e8b12f0fSMahesh Rajashekhara }
178e8b12f0fSMahesh Rajashekhara
179e8b12f0fSMahesh Rajashekhara /**
180e8b12f0fSMahesh Rajashekhara * aac_src_enable_interrupt_message - Enable interrupts
181e8b12f0fSMahesh Rajashekhara * @dev: Adapter
182e8b12f0fSMahesh Rajashekhara */
183e8b12f0fSMahesh Rajashekhara
aac_src_enable_interrupt_message(struct aac_dev * dev)184e8b12f0fSMahesh Rajashekhara static void aac_src_enable_interrupt_message(struct aac_dev *dev)
185e8b12f0fSMahesh Rajashekhara {
186495c0217SMahesh Rajashekhara aac_src_access_devreg(dev, AAC_ENABLE_INTERRUPT);
187e8b12f0fSMahesh Rajashekhara }
188e8b12f0fSMahesh Rajashekhara
189e8b12f0fSMahesh Rajashekhara /**
190e8b12f0fSMahesh Rajashekhara * src_sync_cmd - send a command and wait
191e8b12f0fSMahesh Rajashekhara * @dev: Adapter
192e8b12f0fSMahesh Rajashekhara * @command: Command to execute
193e8b12f0fSMahesh Rajashekhara * @p1: first parameter
194a1368911SLee Jones * @p2: second parameter
195a1368911SLee Jones * @p3: third parameter
196a1368911SLee Jones * @p4: forth parameter
197a1368911SLee Jones * @p5: fifth parameter
198a1368911SLee Jones * @p6: sixth parameter
199a1368911SLee Jones * @status: adapter status
200a1368911SLee Jones * @r1: first return value
201a1368911SLee Jones * @r2: second return valu
202a1368911SLee Jones * @r3: third return value
203a1368911SLee Jones * @r4: forth return value
204e8b12f0fSMahesh Rajashekhara *
205e8b12f0fSMahesh Rajashekhara * This routine will send a synchronous command to the adapter and wait
206e8b12f0fSMahesh Rajashekhara * for its completion.
207e8b12f0fSMahesh Rajashekhara */
208e8b12f0fSMahesh Rajashekhara
src_sync_cmd(struct aac_dev * dev,u32 command,u32 p1,u32 p2,u32 p3,u32 p4,u32 p5,u32 p6,u32 * status,u32 * r1,u32 * r2,u32 * r3,u32 * r4)209e8b12f0fSMahesh Rajashekhara static int src_sync_cmd(struct aac_dev *dev, u32 command,
210e8b12f0fSMahesh Rajashekhara u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
211e8b12f0fSMahesh Rajashekhara u32 *status, u32 * r1, u32 * r2, u32 * r3, u32 * r4)
212e8b12f0fSMahesh Rajashekhara {
213e8b12f0fSMahesh Rajashekhara unsigned long start;
214dafde947SMahesh Rajashekhara unsigned long delay;
215e8b12f0fSMahesh Rajashekhara int ok;
216e8b12f0fSMahesh Rajashekhara
217e8b12f0fSMahesh Rajashekhara /*
218e8b12f0fSMahesh Rajashekhara * Write the command into Mailbox 0
219e8b12f0fSMahesh Rajashekhara */
220e8b12f0fSMahesh Rajashekhara writel(command, &dev->IndexRegs->Mailbox[0]);
221e8b12f0fSMahesh Rajashekhara /*
222e8b12f0fSMahesh Rajashekhara * Write the parameters into Mailboxes 1 - 6
223e8b12f0fSMahesh Rajashekhara */
224e8b12f0fSMahesh Rajashekhara writel(p1, &dev->IndexRegs->Mailbox[1]);
225e8b12f0fSMahesh Rajashekhara writel(p2, &dev->IndexRegs->Mailbox[2]);
226e8b12f0fSMahesh Rajashekhara writel(p3, &dev->IndexRegs->Mailbox[3]);
227e8b12f0fSMahesh Rajashekhara writel(p4, &dev->IndexRegs->Mailbox[4]);
228e8b12f0fSMahesh Rajashekhara
229e8b12f0fSMahesh Rajashekhara /*
230e8b12f0fSMahesh Rajashekhara * Clear the synch command doorbell to start on a clean slate.
231e8b12f0fSMahesh Rajashekhara */
232495c0217SMahesh Rajashekhara if (!dev->msi_enabled)
233495c0217SMahesh Rajashekhara src_writel(dev,
234495c0217SMahesh Rajashekhara MUnit.ODR_C,
235495c0217SMahesh Rajashekhara OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
236e8b12f0fSMahesh Rajashekhara
237e8b12f0fSMahesh Rajashekhara /*
238e8b12f0fSMahesh Rajashekhara * Disable doorbell interrupts
239e8b12f0fSMahesh Rajashekhara */
240e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.OIMR, dev->OIMR = 0xffffffff);
241e8b12f0fSMahesh Rajashekhara
242e8b12f0fSMahesh Rajashekhara /*
243e8b12f0fSMahesh Rajashekhara * Force the completion of the mask register write before issuing
244e8b12f0fSMahesh Rajashekhara * the interrupt.
245e8b12f0fSMahesh Rajashekhara */
246e8b12f0fSMahesh Rajashekhara src_readl(dev, MUnit.OIMR);
247e8b12f0fSMahesh Rajashekhara
248e8b12f0fSMahesh Rajashekhara /*
249e8b12f0fSMahesh Rajashekhara * Signal that there is a new synch command
250e8b12f0fSMahesh Rajashekhara */
251e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.IDR, INBOUNDDOORBELL_0 << SRC_IDR_SHIFT);
252e8b12f0fSMahesh Rajashekhara
25344f1ce7dSRaghava Aditya Renukunta if ((!dev->sync_mode || command != SEND_SYNCHRONOUS_FIB) &&
25444f1ce7dSRaghava Aditya Renukunta !dev->in_soft_reset) {
255e8b12f0fSMahesh Rajashekhara ok = 0;
256e8b12f0fSMahesh Rajashekhara start = jiffies;
257e8b12f0fSMahesh Rajashekhara
258dafde947SMahesh Rajashekhara if (command == IOP_RESET_ALWAYS) {
259dafde947SMahesh Rajashekhara /* Wait up to 10 sec */
260dafde947SMahesh Rajashekhara delay = 10*HZ;
261dafde947SMahesh Rajashekhara } else {
262dafde947SMahesh Rajashekhara /* Wait up to 5 minutes */
263dafde947SMahesh Rajashekhara delay = 300*HZ;
264dafde947SMahesh Rajashekhara }
265dafde947SMahesh Rajashekhara while (time_before(jiffies, start+delay)) {
26611604612SMahesh Rajashekhara udelay(5); /* Delay 5 microseconds to let Mon960 get info. */
26711604612SMahesh Rajashekhara /*
26811604612SMahesh Rajashekhara * Mon960 will set doorbell0 bit when it has completed the command.
269e8b12f0fSMahesh Rajashekhara */
270495c0217SMahesh Rajashekhara if (aac_src_get_sync_status(dev) & OUTBOUNDDOORBELL_0) {
27111604612SMahesh Rajashekhara /*
27211604612SMahesh Rajashekhara * Clear the doorbell.
27311604612SMahesh Rajashekhara */
274495c0217SMahesh Rajashekhara if (dev->msi_enabled)
275495c0217SMahesh Rajashekhara aac_src_access_devreg(dev,
276495c0217SMahesh Rajashekhara AAC_CLEAR_SYNC_BIT);
277495c0217SMahesh Rajashekhara else
278495c0217SMahesh Rajashekhara src_writel(dev,
279495c0217SMahesh Rajashekhara MUnit.ODR_C,
280495c0217SMahesh Rajashekhara OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
281e8b12f0fSMahesh Rajashekhara ok = 1;
282e8b12f0fSMahesh Rajashekhara break;
283e8b12f0fSMahesh Rajashekhara }
28411604612SMahesh Rajashekhara /*
28511604612SMahesh Rajashekhara * Yield the processor in case we are slow
28611604612SMahesh Rajashekhara */
287e8b12f0fSMahesh Rajashekhara msleep(1);
288e8b12f0fSMahesh Rajashekhara }
289e8b12f0fSMahesh Rajashekhara if (unlikely(ok != 1)) {
29011604612SMahesh Rajashekhara /*
29111604612SMahesh Rajashekhara * Restore interrupt mask even though we timed out
29211604612SMahesh Rajashekhara */
293e8b12f0fSMahesh Rajashekhara aac_adapter_enable_int(dev);
294e8b12f0fSMahesh Rajashekhara return -ETIMEDOUT;
295e8b12f0fSMahesh Rajashekhara }
29611604612SMahesh Rajashekhara /*
29711604612SMahesh Rajashekhara * Pull the synch status from Mailbox 0.
29811604612SMahesh Rajashekhara */
299e8b12f0fSMahesh Rajashekhara if (status)
300e8b12f0fSMahesh Rajashekhara *status = readl(&dev->IndexRegs->Mailbox[0]);
301e8b12f0fSMahesh Rajashekhara if (r1)
302e8b12f0fSMahesh Rajashekhara *r1 = readl(&dev->IndexRegs->Mailbox[1]);
303e8b12f0fSMahesh Rajashekhara if (r2)
304e8b12f0fSMahesh Rajashekhara *r2 = readl(&dev->IndexRegs->Mailbox[2]);
305e8b12f0fSMahesh Rajashekhara if (r3)
306e8b12f0fSMahesh Rajashekhara *r3 = readl(&dev->IndexRegs->Mailbox[3]);
307e8b12f0fSMahesh Rajashekhara if (r4)
308e8b12f0fSMahesh Rajashekhara *r4 = readl(&dev->IndexRegs->Mailbox[4]);
309495c0217SMahesh Rajashekhara if (command == GET_COMM_PREFERRED_SETTINGS)
310495c0217SMahesh Rajashekhara dev->max_msix =
311495c0217SMahesh Rajashekhara readl(&dev->IndexRegs->Mailbox[5]) & 0xFFFF;
31211604612SMahesh Rajashekhara /*
31311604612SMahesh Rajashekhara * Clear the synch command doorbell.
31411604612SMahesh Rajashekhara */
315495c0217SMahesh Rajashekhara if (!dev->msi_enabled)
316495c0217SMahesh Rajashekhara src_writel(dev,
317495c0217SMahesh Rajashekhara MUnit.ODR_C,
318495c0217SMahesh Rajashekhara OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
31911604612SMahesh Rajashekhara }
320e8b12f0fSMahesh Rajashekhara
32111604612SMahesh Rajashekhara /*
32211604612SMahesh Rajashekhara * Restore interrupt mask
32311604612SMahesh Rajashekhara */
324e8b12f0fSMahesh Rajashekhara aac_adapter_enable_int(dev);
325e8b12f0fSMahesh Rajashekhara return 0;
326e8b12f0fSMahesh Rajashekhara }
327e8b12f0fSMahesh Rajashekhara
328e8b12f0fSMahesh Rajashekhara /**
329e8b12f0fSMahesh Rajashekhara * aac_src_interrupt_adapter - interrupt adapter
330e8b12f0fSMahesh Rajashekhara * @dev: Adapter
331e8b12f0fSMahesh Rajashekhara *
332e8b12f0fSMahesh Rajashekhara * Send an interrupt to the i960 and breakpoint it.
333e8b12f0fSMahesh Rajashekhara */
334e8b12f0fSMahesh Rajashekhara
aac_src_interrupt_adapter(struct aac_dev * dev)335e8b12f0fSMahesh Rajashekhara static void aac_src_interrupt_adapter(struct aac_dev *dev)
336e8b12f0fSMahesh Rajashekhara {
337e8b12f0fSMahesh Rajashekhara src_sync_cmd(dev, BREAKPOINT_REQUEST,
338e8b12f0fSMahesh Rajashekhara 0, 0, 0, 0, 0, 0,
339e8b12f0fSMahesh Rajashekhara NULL, NULL, NULL, NULL, NULL);
340e8b12f0fSMahesh Rajashekhara }
341e8b12f0fSMahesh Rajashekhara
342e8b12f0fSMahesh Rajashekhara /**
343e8b12f0fSMahesh Rajashekhara * aac_src_notify_adapter - send an event to the adapter
344e8b12f0fSMahesh Rajashekhara * @dev: Adapter
345e8b12f0fSMahesh Rajashekhara * @event: Event to send
346e8b12f0fSMahesh Rajashekhara *
347e8b12f0fSMahesh Rajashekhara * Notify the i960 that something it probably cares about has
348e8b12f0fSMahesh Rajashekhara * happened.
349e8b12f0fSMahesh Rajashekhara */
350e8b12f0fSMahesh Rajashekhara
aac_src_notify_adapter(struct aac_dev * dev,u32 event)351e8b12f0fSMahesh Rajashekhara static void aac_src_notify_adapter(struct aac_dev *dev, u32 event)
352e8b12f0fSMahesh Rajashekhara {
353e8b12f0fSMahesh Rajashekhara switch (event) {
354e8b12f0fSMahesh Rajashekhara
355e8b12f0fSMahesh Rajashekhara case AdapNormCmdQue:
356e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C,
357e8b12f0fSMahesh Rajashekhara INBOUNDDOORBELL_1 << SRC_ODR_SHIFT);
358e8b12f0fSMahesh Rajashekhara break;
359e8b12f0fSMahesh Rajashekhara case HostNormRespNotFull:
360e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C,
361e8b12f0fSMahesh Rajashekhara INBOUNDDOORBELL_4 << SRC_ODR_SHIFT);
362e8b12f0fSMahesh Rajashekhara break;
363e8b12f0fSMahesh Rajashekhara case AdapNormRespQue:
364e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C,
365e8b12f0fSMahesh Rajashekhara INBOUNDDOORBELL_2 << SRC_ODR_SHIFT);
366e8b12f0fSMahesh Rajashekhara break;
367e8b12f0fSMahesh Rajashekhara case HostNormCmdNotFull:
368e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C,
369e8b12f0fSMahesh Rajashekhara INBOUNDDOORBELL_3 << SRC_ODR_SHIFT);
370e8b12f0fSMahesh Rajashekhara break;
371e8b12f0fSMahesh Rajashekhara case FastIo:
372e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C,
373e8b12f0fSMahesh Rajashekhara INBOUNDDOORBELL_6 << SRC_ODR_SHIFT);
374e8b12f0fSMahesh Rajashekhara break;
375e8b12f0fSMahesh Rajashekhara case AdapPrintfDone:
376e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C,
377e8b12f0fSMahesh Rajashekhara INBOUNDDOORBELL_5 << SRC_ODR_SHIFT);
378e8b12f0fSMahesh Rajashekhara break;
379e8b12f0fSMahesh Rajashekhara default:
380e8b12f0fSMahesh Rajashekhara BUG();
381e8b12f0fSMahesh Rajashekhara break;
382e8b12f0fSMahesh Rajashekhara }
383e8b12f0fSMahesh Rajashekhara }
384e8b12f0fSMahesh Rajashekhara
385e8b12f0fSMahesh Rajashekhara /**
386e8b12f0fSMahesh Rajashekhara * aac_src_start_adapter - activate adapter
387e8b12f0fSMahesh Rajashekhara * @dev: Adapter
388e8b12f0fSMahesh Rajashekhara *
389e8b12f0fSMahesh Rajashekhara * Start up processing on an i960 based AAC adapter
390e8b12f0fSMahesh Rajashekhara */
391e8b12f0fSMahesh Rajashekhara
aac_src_start_adapter(struct aac_dev * dev)392e8b12f0fSMahesh Rajashekhara static void aac_src_start_adapter(struct aac_dev *dev)
393e8b12f0fSMahesh Rajashekhara {
394d1ef4da8SRaghava Aditya Renukunta union aac_init *init;
395495c0217SMahesh Rajashekhara int i;
396e8b12f0fSMahesh Rajashekhara
39785d22bbfSMahesh Rajashekhara /* reset host_rrq_idx first */
398495c0217SMahesh Rajashekhara for (i = 0; i < dev->max_msix; i++) {
399495c0217SMahesh Rajashekhara dev->host_rrq_idx[i] = i * dev->vector_cap;
400495c0217SMahesh Rajashekhara atomic_set(&dev->rrq_outstanding[i], 0);
401495c0217SMahesh Rajashekhara }
4023ffd6c5aSRaghava Aditya Renukunta atomic_set(&dev->msix_counter, 0);
403495c0217SMahesh Rajashekhara dev->fibs_pushed_no = 0;
40485d22bbfSMahesh Rajashekhara
405e8b12f0fSMahesh Rajashekhara init = dev->init;
406d1ef4da8SRaghava Aditya Renukunta if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE3) {
40738150f7aSArnd Bergmann init->r8.host_elapsed_seconds =
40838150f7aSArnd Bergmann cpu_to_le32(ktime_get_real_seconds());
409d1ef4da8SRaghava Aditya Renukunta src_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS,
41080a94bb3SArnd Bergmann lower_32_bits(dev->init_pa),
41180a94bb3SArnd Bergmann upper_32_bits(dev->init_pa),
412d1ef4da8SRaghava Aditya Renukunta sizeof(struct _r8) +
413d1ef4da8SRaghava Aditya Renukunta (AAC_MAX_HRRQ - 1) * sizeof(struct _rrq),
414d1ef4da8SRaghava Aditya Renukunta 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
415d1ef4da8SRaghava Aditya Renukunta } else {
41638150f7aSArnd Bergmann init->r7.host_elapsed_seconds =
41738150f7aSArnd Bergmann cpu_to_le32(ktime_get_real_seconds());
418d1ef4da8SRaghava Aditya Renukunta // We can only use a 32 bit address here
419d1ef4da8SRaghava Aditya Renukunta src_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS,
420d1ef4da8SRaghava Aditya Renukunta (u32)(ulong)dev->init_pa, 0, 0, 0, 0, 0,
421d1ef4da8SRaghava Aditya Renukunta NULL, NULL, NULL, NULL, NULL);
422d1ef4da8SRaghava Aditya Renukunta }
423e8b12f0fSMahesh Rajashekhara
424e8b12f0fSMahesh Rajashekhara }
425e8b12f0fSMahesh Rajashekhara
426e8b12f0fSMahesh Rajashekhara /**
427e8b12f0fSMahesh Rajashekhara * aac_src_check_health
428e8b12f0fSMahesh Rajashekhara * @dev: device to check if healthy
429e8b12f0fSMahesh Rajashekhara *
430e8b12f0fSMahesh Rajashekhara * Will attempt to determine if the specified adapter is alive and
431e8b12f0fSMahesh Rajashekhara * capable of handling requests, returning 0 if alive.
432e8b12f0fSMahesh Rajashekhara */
aac_src_check_health(struct aac_dev * dev)433e8b12f0fSMahesh Rajashekhara static int aac_src_check_health(struct aac_dev *dev)
434e8b12f0fSMahesh Rajashekhara {
435e8b12f0fSMahesh Rajashekhara u32 status = src_readl(dev, MUnit.OMR);
436e8b12f0fSMahesh Rajashekhara
437e8b12f0fSMahesh Rajashekhara /*
438e8b12f0fSMahesh Rajashekhara * Check to see if the board panic'd.
439e8b12f0fSMahesh Rajashekhara */
440e8b12f0fSMahesh Rajashekhara if (unlikely(status & KERNEL_PANIC))
441c421530bSRaghava Aditya Renukunta goto err_blink;
442c421530bSRaghava Aditya Renukunta
443c421530bSRaghava Aditya Renukunta /*
444c421530bSRaghava Aditya Renukunta * Check to see if the board failed any self tests.
445c421530bSRaghava Aditya Renukunta */
446c421530bSRaghava Aditya Renukunta if (unlikely(status & SELF_TEST_FAILED))
447c421530bSRaghava Aditya Renukunta goto err_out;
448c421530bSRaghava Aditya Renukunta
449c421530bSRaghava Aditya Renukunta /*
450c421530bSRaghava Aditya Renukunta * Check to see if the board failed any self tests.
451c421530bSRaghava Aditya Renukunta */
452c421530bSRaghava Aditya Renukunta if (unlikely(status & MONITOR_PANIC))
453c421530bSRaghava Aditya Renukunta goto err_out;
454c421530bSRaghava Aditya Renukunta
455e8b12f0fSMahesh Rajashekhara /*
456e8b12f0fSMahesh Rajashekhara * Wait for the adapter to be up and running.
457e8b12f0fSMahesh Rajashekhara */
458e8b12f0fSMahesh Rajashekhara if (unlikely(!(status & KERNEL_UP_AND_RUNNING)))
459e8b12f0fSMahesh Rajashekhara return -3;
460e8b12f0fSMahesh Rajashekhara /*
461e8b12f0fSMahesh Rajashekhara * Everything is OK
462e8b12f0fSMahesh Rajashekhara */
463e8b12f0fSMahesh Rajashekhara return 0;
464c421530bSRaghava Aditya Renukunta
465c421530bSRaghava Aditya Renukunta err_out:
466c421530bSRaghava Aditya Renukunta return -1;
467c421530bSRaghava Aditya Renukunta
468c421530bSRaghava Aditya Renukunta err_blink:
469934767c5SRaghava Aditya Renukunta return (status >> 16) & 0xFF;
470e8b12f0fSMahesh Rajashekhara }
471e8b12f0fSMahesh Rajashekhara
aac_get_vector(struct aac_dev * dev)472423400e6SRaghava Aditya Renukunta static inline u32 aac_get_vector(struct aac_dev *dev)
473423400e6SRaghava Aditya Renukunta {
474423400e6SRaghava Aditya Renukunta return atomic_inc_return(&dev->msix_counter)%dev->max_msix;
475423400e6SRaghava Aditya Renukunta }
476423400e6SRaghava Aditya Renukunta
477e8b12f0fSMahesh Rajashekhara /**
478e8b12f0fSMahesh Rajashekhara * aac_src_deliver_message
479e8b12f0fSMahesh Rajashekhara * @fib: fib to issue
480e8b12f0fSMahesh Rajashekhara *
481e8b12f0fSMahesh Rajashekhara * Will send a fib, returning 0 if successful.
482e8b12f0fSMahesh Rajashekhara */
aac_src_deliver_message(struct fib * fib)483e8b12f0fSMahesh Rajashekhara static int aac_src_deliver_message(struct fib *fib)
484e8b12f0fSMahesh Rajashekhara {
485e8b12f0fSMahesh Rajashekhara struct aac_dev *dev = fib->dev;
486e8b12f0fSMahesh Rajashekhara struct aac_queue *q = &dev->queues->queue[AdapNormCmdQueue];
487e8b12f0fSMahesh Rajashekhara u32 fibsize;
488b5f1758fSBen Collins dma_addr_t address;
489e8b12f0fSMahesh Rajashekhara struct aac_fib_xporthdr *pFibX;
490423400e6SRaghava Aditya Renukunta int native_hba;
491c6992781SMahesh Rajashekhara #if !defined(writeq)
492c6992781SMahesh Rajashekhara unsigned long flags;
493c6992781SMahesh Rajashekhara #endif
494c6992781SMahesh Rajashekhara
4953f4ce057SRaghava Aditya Renukunta u16 vector_no;
496e8b12f0fSMahesh Rajashekhara
497ef616233SMahesh Rajashekhara atomic_inc(&q->numpending);
498e8b12f0fSMahesh Rajashekhara
499423400e6SRaghava Aditya Renukunta native_hba = (fib->flags & FIB_CONTEXT_FLAG_NATIVE_HBA) ? 1 : 0;
500423400e6SRaghava Aditya Renukunta
501423400e6SRaghava Aditya Renukunta
502423400e6SRaghava Aditya Renukunta if (dev->msi_enabled && dev->max_msix > 1 &&
503423400e6SRaghava Aditya Renukunta (native_hba || fib->hw_fib_va->header.Command != AifRequest)) {
504423400e6SRaghava Aditya Renukunta
505423400e6SRaghava Aditya Renukunta if ((dev->comm_interface == AAC_COMM_MESSAGE_TYPE3)
506423400e6SRaghava Aditya Renukunta && dev->sa_firmware)
507423400e6SRaghava Aditya Renukunta vector_no = aac_get_vector(dev);
508423400e6SRaghava Aditya Renukunta else
509*71758d4dSMartin K. Petersen vector_no = fib->vector_no;
510423400e6SRaghava Aditya Renukunta
511423400e6SRaghava Aditya Renukunta if (native_hba) {
512954b2b5aSRaghava Aditya Renukunta if (fib->flags & FIB_CONTEXT_FLAG_NATIVE_HBA_TMF) {
513954b2b5aSRaghava Aditya Renukunta struct aac_hba_tm_req *tm_req;
514954b2b5aSRaghava Aditya Renukunta
515954b2b5aSRaghava Aditya Renukunta tm_req = (struct aac_hba_tm_req *)
516954b2b5aSRaghava Aditya Renukunta fib->hw_fib_va;
517954b2b5aSRaghava Aditya Renukunta if (tm_req->iu_type ==
518954b2b5aSRaghava Aditya Renukunta HBA_IU_TYPE_SCSI_TM_REQ) {
519954b2b5aSRaghava Aditya Renukunta ((struct aac_hba_tm_req *)
520954b2b5aSRaghava Aditya Renukunta fib->hw_fib_va)->reply_qid
521423400e6SRaghava Aditya Renukunta = vector_no;
522954b2b5aSRaghava Aditya Renukunta ((struct aac_hba_tm_req *)
523954b2b5aSRaghava Aditya Renukunta fib->hw_fib_va)->request_id
524423400e6SRaghava Aditya Renukunta += (vector_no << 16);
525423400e6SRaghava Aditya Renukunta } else {
526954b2b5aSRaghava Aditya Renukunta ((struct aac_hba_reset_req *)
527954b2b5aSRaghava Aditya Renukunta fib->hw_fib_va)->reply_qid
528954b2b5aSRaghava Aditya Renukunta = vector_no;
529954b2b5aSRaghava Aditya Renukunta ((struct aac_hba_reset_req *)
530954b2b5aSRaghava Aditya Renukunta fib->hw_fib_va)->request_id
531954b2b5aSRaghava Aditya Renukunta += (vector_no << 16);
532954b2b5aSRaghava Aditya Renukunta }
533954b2b5aSRaghava Aditya Renukunta } else {
534954b2b5aSRaghava Aditya Renukunta ((struct aac_hba_cmd_req *)
535954b2b5aSRaghava Aditya Renukunta fib->hw_fib_va)->reply_qid
536954b2b5aSRaghava Aditya Renukunta = vector_no;
537954b2b5aSRaghava Aditya Renukunta ((struct aac_hba_cmd_req *)
538954b2b5aSRaghava Aditya Renukunta fib->hw_fib_va)->request_id
539954b2b5aSRaghava Aditya Renukunta += (vector_no << 16);
540954b2b5aSRaghava Aditya Renukunta }
541954b2b5aSRaghava Aditya Renukunta } else {
542495c0217SMahesh Rajashekhara fib->hw_fib_va->header.Handle += (vector_no << 16);
543423400e6SRaghava Aditya Renukunta }
5443f4ce057SRaghava Aditya Renukunta } else {
5453f4ce057SRaghava Aditya Renukunta vector_no = 0;
546495c0217SMahesh Rajashekhara }
547495c0217SMahesh Rajashekhara
5483f4ce057SRaghava Aditya Renukunta atomic_inc(&dev->rrq_outstanding[vector_no]);
5493f4ce057SRaghava Aditya Renukunta
550423400e6SRaghava Aditya Renukunta if (native_hba) {
551423400e6SRaghava Aditya Renukunta address = fib->hw_fib_pa;
552423400e6SRaghava Aditya Renukunta fibsize = (fib->hbacmd_size + 127) / 128 - 1;
553423400e6SRaghava Aditya Renukunta if (fibsize > 31)
554423400e6SRaghava Aditya Renukunta fibsize = 31;
555423400e6SRaghava Aditya Renukunta address |= fibsize;
556423400e6SRaghava Aditya Renukunta #if defined(writeq)
557423400e6SRaghava Aditya Renukunta src_writeq(dev, MUnit.IQN_L, (u64)address);
558423400e6SRaghava Aditya Renukunta #else
559423400e6SRaghava Aditya Renukunta spin_lock_irqsave(&fib->dev->iq_lock, flags);
560423400e6SRaghava Aditya Renukunta src_writel(dev, MUnit.IQN_H,
561423400e6SRaghava Aditya Renukunta upper_32_bits(address) & 0xffffffff);
562423400e6SRaghava Aditya Renukunta src_writel(dev, MUnit.IQN_L, address & 0xffffffff);
563423400e6SRaghava Aditya Renukunta spin_unlock_irqrestore(&fib->dev->iq_lock, flags);
564423400e6SRaghava Aditya Renukunta #endif
565423400e6SRaghava Aditya Renukunta } else {
566423400e6SRaghava Aditya Renukunta if (dev->comm_interface == AAC_COMM_MESSAGE_TYPE2 ||
567423400e6SRaghava Aditya Renukunta dev->comm_interface == AAC_COMM_MESSAGE_TYPE3) {
56885d22bbfSMahesh Rajashekhara /* Calculate the amount to the fibsize bits */
569423400e6SRaghava Aditya Renukunta fibsize = (le16_to_cpu(fib->hw_fib_va->header.Size)
570423400e6SRaghava Aditya Renukunta + 127) / 128 - 1;
57185d22bbfSMahesh Rajashekhara /* New FIB header, 32-bit */
57285d22bbfSMahesh Rajashekhara address = fib->hw_fib_pa;
57385d22bbfSMahesh Rajashekhara fib->hw_fib_va->header.StructType = FIB_MAGIC2;
574423400e6SRaghava Aditya Renukunta fib->hw_fib_va->header.SenderFibAddress =
575423400e6SRaghava Aditya Renukunta cpu_to_le32((u32)address);
57685d22bbfSMahesh Rajashekhara fib->hw_fib_va->header.u.TimeStamp = 0;
57780a94bb3SArnd Bergmann WARN_ON(upper_32_bits(address) != 0L);
57885d22bbfSMahesh Rajashekhara } else {
579e8b12f0fSMahesh Rajashekhara /* Calculate the amount to the fibsize bits */
580423400e6SRaghava Aditya Renukunta fibsize = (sizeof(struct aac_fib_xporthdr) +
581423400e6SRaghava Aditya Renukunta le16_to_cpu(fib->hw_fib_va->header.Size)
582423400e6SRaghava Aditya Renukunta + 127) / 128 - 1;
583e8b12f0fSMahesh Rajashekhara /* Fill XPORT header */
584423400e6SRaghava Aditya Renukunta pFibX = (struct aac_fib_xporthdr *)
585423400e6SRaghava Aditya Renukunta ((unsigned char *)fib->hw_fib_va -
586423400e6SRaghava Aditya Renukunta sizeof(struct aac_fib_xporthdr));
587423400e6SRaghava Aditya Renukunta pFibX->Handle = fib->hw_fib_va->header.Handle;
588423400e6SRaghava Aditya Renukunta pFibX->HostAddress =
589423400e6SRaghava Aditya Renukunta cpu_to_le64((u64)fib->hw_fib_pa);
590423400e6SRaghava Aditya Renukunta pFibX->Size = cpu_to_le32(
591423400e6SRaghava Aditya Renukunta le16_to_cpu(fib->hw_fib_va->header.Size));
592423400e6SRaghava Aditya Renukunta address = fib->hw_fib_pa -
593423400e6SRaghava Aditya Renukunta (u64)sizeof(struct aac_fib_xporthdr);
59485d22bbfSMahesh Rajashekhara }
595423400e6SRaghava Aditya Renukunta if (fibsize > 31)
596423400e6SRaghava Aditya Renukunta fibsize = 31;
597423400e6SRaghava Aditya Renukunta address |= fibsize;
598423400e6SRaghava Aditya Renukunta
599c6992781SMahesh Rajashekhara #if defined(writeq)
600c6992781SMahesh Rajashekhara src_writeq(dev, MUnit.IQ_L, (u64)address);
601c6992781SMahesh Rajashekhara #else
602c6992781SMahesh Rajashekhara spin_lock_irqsave(&fib->dev->iq_lock, flags);
603423400e6SRaghava Aditya Renukunta src_writel(dev, MUnit.IQ_H,
604423400e6SRaghava Aditya Renukunta upper_32_bits(address) & 0xffffffff);
605b5f1758fSBen Collins src_writel(dev, MUnit.IQ_L, address & 0xffffffff);
606c6992781SMahesh Rajashekhara spin_unlock_irqrestore(&fib->dev->iq_lock, flags);
607c6992781SMahesh Rajashekhara #endif
608423400e6SRaghava Aditya Renukunta }
609e8b12f0fSMahesh Rajashekhara return 0;
610e8b12f0fSMahesh Rajashekhara }
611e8b12f0fSMahesh Rajashekhara
612e8b12f0fSMahesh Rajashekhara /**
613e8b12f0fSMahesh Rajashekhara * aac_src_ioremap
614a1368911SLee Jones * @dev: device ioremap
615e8b12f0fSMahesh Rajashekhara * @size: mapping resize request
616e8b12f0fSMahesh Rajashekhara *
617e8b12f0fSMahesh Rajashekhara */
aac_src_ioremap(struct aac_dev * dev,u32 size)618e8b12f0fSMahesh Rajashekhara static int aac_src_ioremap(struct aac_dev *dev, u32 size)
619e8b12f0fSMahesh Rajashekhara {
620e8b12f0fSMahesh Rajashekhara if (!size) {
62171552505STomas Henzl iounmap(dev->regs.src.bar1);
62271552505STomas Henzl dev->regs.src.bar1 = NULL;
623e8b12f0fSMahesh Rajashekhara iounmap(dev->regs.src.bar0);
62411604612SMahesh Rajashekhara dev->base = dev->regs.src.bar0 = NULL;
625e8b12f0fSMahesh Rajashekhara return 0;
626e8b12f0fSMahesh Rajashekhara }
627e8b12f0fSMahesh Rajashekhara dev->regs.src.bar1 = ioremap(pci_resource_start(dev->pdev, 2),
628e8b12f0fSMahesh Rajashekhara AAC_MIN_SRC_BAR1_SIZE);
629e8b12f0fSMahesh Rajashekhara dev->base = NULL;
630e8b12f0fSMahesh Rajashekhara if (dev->regs.src.bar1 == NULL)
631e8b12f0fSMahesh Rajashekhara return -1;
632ff08784bSBen Collins dev->base = dev->regs.src.bar0 = ioremap(dev->base_start, size);
633e8b12f0fSMahesh Rajashekhara if (dev->base == NULL) {
634e8b12f0fSMahesh Rajashekhara iounmap(dev->regs.src.bar1);
635e8b12f0fSMahesh Rajashekhara dev->regs.src.bar1 = NULL;
636e8b12f0fSMahesh Rajashekhara return -1;
637e8b12f0fSMahesh Rajashekhara }
638e8b12f0fSMahesh Rajashekhara dev->IndexRegs = &((struct src_registers __iomem *)
63911604612SMahesh Rajashekhara dev->base)->u.tupelo.IndexRegs;
64011604612SMahesh Rajashekhara return 0;
64111604612SMahesh Rajashekhara }
64211604612SMahesh Rajashekhara
64311604612SMahesh Rajashekhara /**
64411604612SMahesh Rajashekhara * aac_srcv_ioremap
645a1368911SLee Jones * @dev: device ioremap
64611604612SMahesh Rajashekhara * @size: mapping resize request
64711604612SMahesh Rajashekhara *
64811604612SMahesh Rajashekhara */
aac_srcv_ioremap(struct aac_dev * dev,u32 size)64911604612SMahesh Rajashekhara static int aac_srcv_ioremap(struct aac_dev *dev, u32 size)
65011604612SMahesh Rajashekhara {
65111604612SMahesh Rajashekhara if (!size) {
65211604612SMahesh Rajashekhara iounmap(dev->regs.src.bar0);
65311604612SMahesh Rajashekhara dev->base = dev->regs.src.bar0 = NULL;
65411604612SMahesh Rajashekhara return 0;
65511604612SMahesh Rajashekhara }
6563ffd6c5aSRaghava Aditya Renukunta
6573ffd6c5aSRaghava Aditya Renukunta dev->regs.src.bar1 =
6583ffd6c5aSRaghava Aditya Renukunta ioremap(pci_resource_start(dev->pdev, 2), AAC_MIN_SRCV_BAR1_SIZE);
6593ffd6c5aSRaghava Aditya Renukunta dev->base = NULL;
6603ffd6c5aSRaghava Aditya Renukunta if (dev->regs.src.bar1 == NULL)
66111604612SMahesh Rajashekhara return -1;
6623ffd6c5aSRaghava Aditya Renukunta dev->base = dev->regs.src.bar0 = ioremap(dev->base_start, size);
6633ffd6c5aSRaghava Aditya Renukunta if (dev->base == NULL) {
6643ffd6c5aSRaghava Aditya Renukunta iounmap(dev->regs.src.bar1);
6653ffd6c5aSRaghava Aditya Renukunta dev->regs.src.bar1 = NULL;
6663ffd6c5aSRaghava Aditya Renukunta return -1;
6673ffd6c5aSRaghava Aditya Renukunta }
66811604612SMahesh Rajashekhara dev->IndexRegs = &((struct src_registers __iomem *)
66911604612SMahesh Rajashekhara dev->base)->u.denali.IndexRegs;
670e8b12f0fSMahesh Rajashekhara return 0;
671e8b12f0fSMahesh Rajashekhara }
672e8b12f0fSMahesh Rajashekhara
aac_set_intx_mode(struct aac_dev * dev)673a7e2c642SRaghava Aditya Renukunta void aac_set_intx_mode(struct aac_dev *dev)
67431364329SRaghava Aditya Renukunta {
67531364329SRaghava Aditya Renukunta if (dev->msi_enabled) {
67631364329SRaghava Aditya Renukunta aac_src_access_devreg(dev, AAC_ENABLE_INTX);
67731364329SRaghava Aditya Renukunta dev->msi_enabled = 0;
67831364329SRaghava Aditya Renukunta msleep(5000); /* Delay 5 seconds */
67931364329SRaghava Aditya Renukunta }
68031364329SRaghava Aditya Renukunta }
68131364329SRaghava Aditya Renukunta
aac_clear_omr(struct aac_dev * dev)682a5799d74SRaghava Aditya Renukunta static void aac_clear_omr(struct aac_dev *dev)
683a5799d74SRaghava Aditya Renukunta {
684a5799d74SRaghava Aditya Renukunta u32 omr_value = 0;
685a5799d74SRaghava Aditya Renukunta
686a5799d74SRaghava Aditya Renukunta omr_value = src_readl(dev, MUnit.OMR);
687a5799d74SRaghava Aditya Renukunta
688a5799d74SRaghava Aditya Renukunta /*
689a5799d74SRaghava Aditya Renukunta * Check for PCI Errors or Kernel Panic
690a5799d74SRaghava Aditya Renukunta */
691a5799d74SRaghava Aditya Renukunta if ((omr_value == INVALID_OMR) || (omr_value & KERNEL_PANIC))
692a5799d74SRaghava Aditya Renukunta omr_value = 0;
693a5799d74SRaghava Aditya Renukunta
694a5799d74SRaghava Aditya Renukunta /*
695a5799d74SRaghava Aditya Renukunta * Preserve MSIX Value if any
696a5799d74SRaghava Aditya Renukunta */
697a5799d74SRaghava Aditya Renukunta src_writel(dev, MUnit.OMR, omr_value & AAC_INT_MODE_MSIX);
698a5799d74SRaghava Aditya Renukunta src_readl(dev, MUnit.OMR);
699a5799d74SRaghava Aditya Renukunta }
700a5799d74SRaghava Aditya Renukunta
aac_dump_fw_fib_iop_reset(struct aac_dev * dev)70109624645SRaghava Aditya Renukunta static void aac_dump_fw_fib_iop_reset(struct aac_dev *dev)
70209624645SRaghava Aditya Renukunta {
70309624645SRaghava Aditya Renukunta __le32 supported_options3;
70409624645SRaghava Aditya Renukunta
70509624645SRaghava Aditya Renukunta if (!aac_fib_dump)
70609624645SRaghava Aditya Renukunta return;
70709624645SRaghava Aditya Renukunta
70809624645SRaghava Aditya Renukunta supported_options3 = dev->supplement_adapter_info.supported_options3;
70909624645SRaghava Aditya Renukunta if (!(supported_options3 & AAC_OPTION_SUPPORTED3_IOP_RESET_FIB_DUMP))
71009624645SRaghava Aditya Renukunta return;
71109624645SRaghava Aditya Renukunta
71209624645SRaghava Aditya Renukunta aac_adapter_sync_cmd(dev, IOP_RESET_FW_FIB_DUMP,
71309624645SRaghava Aditya Renukunta 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
71409624645SRaghava Aditya Renukunta }
71509624645SRaghava Aditya Renukunta
aac_is_ctrl_up_and_running(struct aac_dev * dev)7160e9973edSRaghava Aditya Renukunta static bool aac_is_ctrl_up_and_running(struct aac_dev *dev)
7170e9973edSRaghava Aditya Renukunta {
7180e9973edSRaghava Aditya Renukunta bool ctrl_up = true;
7190e9973edSRaghava Aditya Renukunta unsigned long status, start;
7200e9973edSRaghava Aditya Renukunta bool is_up = false;
7210e9973edSRaghava Aditya Renukunta
7220e9973edSRaghava Aditya Renukunta start = jiffies;
7230e9973edSRaghava Aditya Renukunta do {
7240e9973edSRaghava Aditya Renukunta schedule();
7250e9973edSRaghava Aditya Renukunta status = src_readl(dev, MUnit.OMR);
7260e9973edSRaghava Aditya Renukunta
7270e9973edSRaghava Aditya Renukunta if (status == 0xffffffff)
7280e9973edSRaghava Aditya Renukunta status = 0;
7290e9973edSRaghava Aditya Renukunta
7300e9973edSRaghava Aditya Renukunta if (status & KERNEL_BOOTING) {
7310e9973edSRaghava Aditya Renukunta start = jiffies;
7320e9973edSRaghava Aditya Renukunta continue;
7330e9973edSRaghava Aditya Renukunta }
7340e9973edSRaghava Aditya Renukunta
7350e9973edSRaghava Aditya Renukunta if (time_after(jiffies, start+HZ*SOFT_RESET_TIME)) {
7360e9973edSRaghava Aditya Renukunta ctrl_up = false;
7370e9973edSRaghava Aditya Renukunta break;
7380e9973edSRaghava Aditya Renukunta }
7390e9973edSRaghava Aditya Renukunta
7400e9973edSRaghava Aditya Renukunta is_up = status & KERNEL_UP_AND_RUNNING;
7410e9973edSRaghava Aditya Renukunta
7420e9973edSRaghava Aditya Renukunta } while (!is_up);
7430e9973edSRaghava Aditya Renukunta
7440e9973edSRaghava Aditya Renukunta return ctrl_up;
7450e9973edSRaghava Aditya Renukunta }
7460e9973edSRaghava Aditya Renukunta
aac_src_drop_io(struct aac_dev * dev)747c02a3342SBalsundar P static void aac_src_drop_io(struct aac_dev *dev)
748c02a3342SBalsundar P {
749c02a3342SBalsundar P if (!dev->soft_reset_support)
750c02a3342SBalsundar P return;
751c02a3342SBalsundar P
752c02a3342SBalsundar P aac_adapter_sync_cmd(dev, DROP_IO,
753c02a3342SBalsundar P 0, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL);
754c02a3342SBalsundar P }
755c02a3342SBalsundar P
aac_notify_fw_of_iop_reset(struct aac_dev * dev)75680c7d8a5SRaghava Aditya Renukunta static void aac_notify_fw_of_iop_reset(struct aac_dev *dev)
757e8b12f0fSMahesh Rajashekhara {
75880c7d8a5SRaghava Aditya Renukunta aac_adapter_sync_cmd(dev, IOP_RESET_ALWAYS, 0, 0, 0, 0, 0, 0, NULL,
75980c7d8a5SRaghava Aditya Renukunta NULL, NULL, NULL, NULL);
760c02a3342SBalsundar P aac_src_drop_io(dev);
76180c7d8a5SRaghava Aditya Renukunta }
762e8b12f0fSMahesh Rajashekhara
aac_send_iop_reset(struct aac_dev * dev)76380c7d8a5SRaghava Aditya Renukunta static void aac_send_iop_reset(struct aac_dev *dev)
76480c7d8a5SRaghava Aditya Renukunta {
76509624645SRaghava Aditya Renukunta aac_dump_fw_fib_iop_reset(dev);
76609624645SRaghava Aditya Renukunta
76780c7d8a5SRaghava Aditya Renukunta aac_notify_fw_of_iop_reset(dev);
76831364329SRaghava Aditya Renukunta
76931364329SRaghava Aditya Renukunta aac_set_intx_mode(dev);
770495c0217SMahesh Rajashekhara
771a5799d74SRaghava Aditya Renukunta aac_clear_omr(dev);
772a5799d74SRaghava Aditya Renukunta
7736b24d425SRaghava Aditya Renukunta src_writel(dev, MUnit.IDR, IOP_SRC_RESET_MASK);
774d1b49093SGuilherme G. Piccoli
775d1b49093SGuilherme G. Piccoli msleep(5000);
776e8b12f0fSMahesh Rajashekhara }
777e8b12f0fSMahesh Rajashekhara
aac_send_hardware_soft_reset(struct aac_dev * dev)77831364329SRaghava Aditya Renukunta static void aac_send_hardware_soft_reset(struct aac_dev *dev)
77931364329SRaghava Aditya Renukunta {
78031364329SRaghava Aditya Renukunta u_int32_t val;
78131364329SRaghava Aditya Renukunta
782a5799d74SRaghava Aditya Renukunta aac_clear_omr(dev);
78331364329SRaghava Aditya Renukunta val = readl(((char *)(dev->base) + IBW_SWR_OFFSET));
78431364329SRaghava Aditya Renukunta val |= 0x01;
78531364329SRaghava Aditya Renukunta writel(val, ((char *)(dev->base) + IBW_SWR_OFFSET));
78631364329SRaghava Aditya Renukunta msleep_interruptible(20000);
78731364329SRaghava Aditya Renukunta }
78831364329SRaghava Aditya Renukunta
aac_src_restart_adapter(struct aac_dev * dev,int bled,u8 reset_type)78931364329SRaghava Aditya Renukunta static int aac_src_restart_adapter(struct aac_dev *dev, int bled, u8 reset_type)
79031364329SRaghava Aditya Renukunta {
7910e9973edSRaghava Aditya Renukunta bool is_ctrl_up;
79277cb6d5eSRaghava Aditya Renukunta int ret = 0;
79331364329SRaghava Aditya Renukunta
79431364329SRaghava Aditya Renukunta if (bled < 0)
79531364329SRaghava Aditya Renukunta goto invalid_out;
79631364329SRaghava Aditya Renukunta
79731364329SRaghava Aditya Renukunta if (bled)
7984a76be0dSRaghava Aditya Renukunta dev_err(&dev->pdev->dev, "adapter kernel panic'd %x.\n", bled);
79931364329SRaghava Aditya Renukunta
800146aa178SRaghava Aditya Renukunta /*
801146aa178SRaghava Aditya Renukunta * When there is a BlinkLED, IOP_RESET has not effect
802146aa178SRaghava Aditya Renukunta */
803146aa178SRaghava Aditya Renukunta if (bled >= 2 && dev->sa_firmware && reset_type & HW_IOP_RESET)
804146aa178SRaghava Aditya Renukunta reset_type &= ~HW_IOP_RESET;
805146aa178SRaghava Aditya Renukunta
80631364329SRaghava Aditya Renukunta dev->a_ops.adapter_enable_int = aac_src_disable_interrupt;
80731364329SRaghava Aditya Renukunta
8084a76be0dSRaghava Aditya Renukunta dev_err(&dev->pdev->dev, "Controller reset type is %d\n", reset_type);
8094a76be0dSRaghava Aditya Renukunta
8105aa60732SRaghava Aditya Renukunta if (reset_type & HW_IOP_RESET) {
8114a76be0dSRaghava Aditya Renukunta dev_info(&dev->pdev->dev, "Issuing IOP reset\n");
81280c7d8a5SRaghava Aditya Renukunta aac_send_iop_reset(dev);
8130e9973edSRaghava Aditya Renukunta
8140e9973edSRaghava Aditya Renukunta /*
8150e9973edSRaghava Aditya Renukunta * Creates a delay or wait till up and running comes thru
8160e9973edSRaghava Aditya Renukunta */
8170e9973edSRaghava Aditya Renukunta is_ctrl_up = aac_is_ctrl_up_and_running(dev);
8180e9973edSRaghava Aditya Renukunta if (!is_ctrl_up)
8190e9973edSRaghava Aditya Renukunta dev_err(&dev->pdev->dev, "IOP reset failed\n");
8204a76be0dSRaghava Aditya Renukunta else {
821bc8282a7SMasanari Iida dev_info(&dev->pdev->dev, "IOP reset succeeded\n");
8220e9973edSRaghava Aditya Renukunta goto set_startup;
8235aa60732SRaghava Aditya Renukunta }
8244a76be0dSRaghava Aditya Renukunta }
8250e9973edSRaghava Aditya Renukunta
82677cb6d5eSRaghava Aditya Renukunta if (!dev->sa_firmware) {
8274a76be0dSRaghava Aditya Renukunta dev_err(&dev->pdev->dev, "ARC Reset attempt failed\n");
82877cb6d5eSRaghava Aditya Renukunta ret = -ENODEV;
82977cb6d5eSRaghava Aditya Renukunta goto out;
83077cb6d5eSRaghava Aditya Renukunta }
83177cb6d5eSRaghava Aditya Renukunta
8325aa60732SRaghava Aditya Renukunta if (reset_type & HW_SOFT_RESET) {
8334a76be0dSRaghava Aditya Renukunta dev_info(&dev->pdev->dev, "Issuing SOFT reset\n");
83431364329SRaghava Aditya Renukunta aac_send_hardware_soft_reset(dev);
83577cb6d5eSRaghava Aditya Renukunta dev->msi_enabled = 0;
83677cb6d5eSRaghava Aditya Renukunta
83777cb6d5eSRaghava Aditya Renukunta is_ctrl_up = aac_is_ctrl_up_and_running(dev);
83877cb6d5eSRaghava Aditya Renukunta if (!is_ctrl_up) {
83977cb6d5eSRaghava Aditya Renukunta dev_err(&dev->pdev->dev, "SOFT reset failed\n");
84077cb6d5eSRaghava Aditya Renukunta ret = -ENODEV;
84177cb6d5eSRaghava Aditya Renukunta goto out;
8424a76be0dSRaghava Aditya Renukunta } else
843bc8282a7SMasanari Iida dev_info(&dev->pdev->dev, "SOFT reset succeeded\n");
84431364329SRaghava Aditya Renukunta }
845e8b12f0fSMahesh Rajashekhara
8460e9973edSRaghava Aditya Renukunta set_startup:
847e8b12f0fSMahesh Rajashekhara if (startup_timeout < 300)
848e8b12f0fSMahesh Rajashekhara startup_timeout = 300;
849e8b12f0fSMahesh Rajashekhara
85077cb6d5eSRaghava Aditya Renukunta out:
85177cb6d5eSRaghava Aditya Renukunta return ret;
8525aa60732SRaghava Aditya Renukunta
8535aa60732SRaghava Aditya Renukunta invalid_out:
8545aa60732SRaghava Aditya Renukunta if (src_readl(dev, MUnit.OMR) & KERNEL_PANIC)
8555aa60732SRaghava Aditya Renukunta ret = -ENODEV;
8565aa60732SRaghava Aditya Renukunta goto out;
857e8b12f0fSMahesh Rajashekhara }
858e8b12f0fSMahesh Rajashekhara
859e8b12f0fSMahesh Rajashekhara /**
860e8b12f0fSMahesh Rajashekhara * aac_src_select_comm - Select communications method
861e8b12f0fSMahesh Rajashekhara * @dev: Adapter
862e8b12f0fSMahesh Rajashekhara * @comm: communications method
863e8b12f0fSMahesh Rajashekhara */
aac_src_select_comm(struct aac_dev * dev,int comm)864a44199eeSBaoyou Xie static int aac_src_select_comm(struct aac_dev *dev, int comm)
865e8b12f0fSMahesh Rajashekhara {
866e8b12f0fSMahesh Rajashekhara switch (comm) {
867e8b12f0fSMahesh Rajashekhara case AAC_COMM_MESSAGE:
868e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_intr = aac_src_intr_message;
869e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_deliver = aac_src_deliver_message;
870e8b12f0fSMahesh Rajashekhara break;
871e8b12f0fSMahesh Rajashekhara default:
872e8b12f0fSMahesh Rajashekhara return 1;
873e8b12f0fSMahesh Rajashekhara }
874e8b12f0fSMahesh Rajashekhara return 0;
875e8b12f0fSMahesh Rajashekhara }
876e8b12f0fSMahesh Rajashekhara
877e8b12f0fSMahesh Rajashekhara /**
878e8b12f0fSMahesh Rajashekhara * aac_src_init - initialize an Cardinal Frey Bar card
879e8b12f0fSMahesh Rajashekhara * @dev: device to configure
880e8b12f0fSMahesh Rajashekhara *
881e8b12f0fSMahesh Rajashekhara */
882e8b12f0fSMahesh Rajashekhara
aac_src_init(struct aac_dev * dev)883e8b12f0fSMahesh Rajashekhara int aac_src_init(struct aac_dev *dev)
884e8b12f0fSMahesh Rajashekhara {
885e8b12f0fSMahesh Rajashekhara unsigned long start;
886e8b12f0fSMahesh Rajashekhara unsigned long status;
887e8b12f0fSMahesh Rajashekhara int restart = 0;
888e8b12f0fSMahesh Rajashekhara int instance = dev->id;
889e8b12f0fSMahesh Rajashekhara const char *name = dev->name;
890e8b12f0fSMahesh Rajashekhara
891e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_ioremap = aac_src_ioremap;
892e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_comm = aac_src_select_comm;
893e8b12f0fSMahesh Rajashekhara
894e8b12f0fSMahesh Rajashekhara dev->base_size = AAC_MIN_SRC_BAR0_SIZE;
895e8b12f0fSMahesh Rajashekhara if (aac_adapter_ioremap(dev, dev->base_size)) {
896e8b12f0fSMahesh Rajashekhara printk(KERN_WARNING "%s: unable to map adapter.\n", name);
897e8b12f0fSMahesh Rajashekhara goto error_iounmap;
898e8b12f0fSMahesh Rajashekhara }
899e8b12f0fSMahesh Rajashekhara
900e8b12f0fSMahesh Rajashekhara /* Failure to reset here is an option ... */
901e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_sync_cmd = src_sync_cmd;
902e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_enable_int = aac_src_disable_interrupt;
903d9b6d85aSGuilherme G. Piccoli
904d9b6d85aSGuilherme G. Piccoli if (dev->init_reset) {
905d9b6d85aSGuilherme G. Piccoli dev->init_reset = false;
906d9b6d85aSGuilherme G. Piccoli if (!aac_src_restart_adapter(dev, 0, IOP_HWSOFT_RESET))
907e8b12f0fSMahesh Rajashekhara ++restart;
908d9b6d85aSGuilherme G. Piccoli }
909d9b6d85aSGuilherme G. Piccoli
910e8b12f0fSMahesh Rajashekhara /*
911e8b12f0fSMahesh Rajashekhara * Check to see if the board panic'd while booting.
912e8b12f0fSMahesh Rajashekhara */
913e8b12f0fSMahesh Rajashekhara status = src_readl(dev, MUnit.OMR);
914e8b12f0fSMahesh Rajashekhara if (status & KERNEL_PANIC) {
91531364329SRaghava Aditya Renukunta if (aac_src_restart_adapter(dev,
91631364329SRaghava Aditya Renukunta aac_src_check_health(dev), IOP_HWSOFT_RESET))
917e8b12f0fSMahesh Rajashekhara goto error_iounmap;
918e8b12f0fSMahesh Rajashekhara ++restart;
919e8b12f0fSMahesh Rajashekhara }
920e8b12f0fSMahesh Rajashekhara /*
921e8b12f0fSMahesh Rajashekhara * Check to see if the board failed any self tests.
922e8b12f0fSMahesh Rajashekhara */
923e8b12f0fSMahesh Rajashekhara status = src_readl(dev, MUnit.OMR);
924e8b12f0fSMahesh Rajashekhara if (status & SELF_TEST_FAILED) {
925e8b12f0fSMahesh Rajashekhara printk(KERN_ERR "%s%d: adapter self-test failed.\n",
926e8b12f0fSMahesh Rajashekhara dev->name, instance);
927e8b12f0fSMahesh Rajashekhara goto error_iounmap;
928e8b12f0fSMahesh Rajashekhara }
929e8b12f0fSMahesh Rajashekhara /*
930e8b12f0fSMahesh Rajashekhara * Check to see if the monitor panic'd while booting.
931e8b12f0fSMahesh Rajashekhara */
932e8b12f0fSMahesh Rajashekhara if (status & MONITOR_PANIC) {
933e8b12f0fSMahesh Rajashekhara printk(KERN_ERR "%s%d: adapter monitor panic.\n",
934e8b12f0fSMahesh Rajashekhara dev->name, instance);
935e8b12f0fSMahesh Rajashekhara goto error_iounmap;
936e8b12f0fSMahesh Rajashekhara }
937e8b12f0fSMahesh Rajashekhara start = jiffies;
938e8b12f0fSMahesh Rajashekhara /*
939e8b12f0fSMahesh Rajashekhara * Wait for the adapter to be up and running. Wait up to 3 minutes
940e8b12f0fSMahesh Rajashekhara */
941e8b12f0fSMahesh Rajashekhara while (!((status = src_readl(dev, MUnit.OMR)) &
942e8b12f0fSMahesh Rajashekhara KERNEL_UP_AND_RUNNING)) {
943e8b12f0fSMahesh Rajashekhara if ((restart &&
944e8b12f0fSMahesh Rajashekhara (status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC))) ||
945e8b12f0fSMahesh Rajashekhara time_after(jiffies, start+HZ*startup_timeout)) {
946e8b12f0fSMahesh Rajashekhara printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n",
947e8b12f0fSMahesh Rajashekhara dev->name, instance, status);
948e8b12f0fSMahesh Rajashekhara goto error_iounmap;
949e8b12f0fSMahesh Rajashekhara }
950e8b12f0fSMahesh Rajashekhara if (!restart &&
951e8b12f0fSMahesh Rajashekhara ((status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC)) ||
952e8b12f0fSMahesh Rajashekhara time_after(jiffies, start + HZ *
953e8b12f0fSMahesh Rajashekhara ((startup_timeout > 60)
954e8b12f0fSMahesh Rajashekhara ? (startup_timeout - 60)
955e8b12f0fSMahesh Rajashekhara : (startup_timeout / 2))))) {
956e8b12f0fSMahesh Rajashekhara if (likely(!aac_src_restart_adapter(dev,
95731364329SRaghava Aditya Renukunta aac_src_check_health(dev), IOP_HWSOFT_RESET)))
958e8b12f0fSMahesh Rajashekhara start = jiffies;
959e8b12f0fSMahesh Rajashekhara ++restart;
960e8b12f0fSMahesh Rajashekhara }
961e8b12f0fSMahesh Rajashekhara msleep(1);
962e8b12f0fSMahesh Rajashekhara }
963e8b12f0fSMahesh Rajashekhara if (restart && aac_commit)
964e8b12f0fSMahesh Rajashekhara aac_commit = 1;
965e8b12f0fSMahesh Rajashekhara /*
966e8b12f0fSMahesh Rajashekhara * Fill in the common function dispatch table.
967e8b12f0fSMahesh Rajashekhara */
968e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_interrupt = aac_src_interrupt_adapter;
969e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_disable_int = aac_src_disable_interrupt;
970dafde947SMahesh Rajashekhara dev->a_ops.adapter_enable_int = aac_src_disable_interrupt;
971e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_notify = aac_src_notify_adapter;
972e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_sync_cmd = src_sync_cmd;
973e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_check_health = aac_src_check_health;
974e8b12f0fSMahesh Rajashekhara dev->a_ops.adapter_restart = aac_src_restart_adapter;
975de665f28SMahesh Rajashekhara dev->a_ops.adapter_start = aac_src_start_adapter;
976e8b12f0fSMahesh Rajashekhara
977e8b12f0fSMahesh Rajashekhara /*
978e8b12f0fSMahesh Rajashekhara * First clear out all interrupts. Then enable the one's that we
979e8b12f0fSMahesh Rajashekhara * can handle.
980e8b12f0fSMahesh Rajashekhara */
981e8b12f0fSMahesh Rajashekhara aac_adapter_comm(dev, AAC_COMM_MESSAGE);
982e8b12f0fSMahesh Rajashekhara aac_adapter_disable_int(dev);
983e8b12f0fSMahesh Rajashekhara src_writel(dev, MUnit.ODR_C, 0xffffffff);
984e8b12f0fSMahesh Rajashekhara aac_adapter_enable_int(dev);
985e8b12f0fSMahesh Rajashekhara
986e8b12f0fSMahesh Rajashekhara if (aac_init_adapter(dev) == NULL)
987e8b12f0fSMahesh Rajashekhara goto error_iounmap;
988e8b12f0fSMahesh Rajashekhara if (dev->comm_interface != AAC_COMM_MESSAGE_TYPE1)
989e8b12f0fSMahesh Rajashekhara goto error_iounmap;
990e8b12f0fSMahesh Rajashekhara
9919022d375SMahesh Rajashekhara dev->msi = !pci_enable_msi(dev->pdev);
992e8b12f0fSMahesh Rajashekhara
993495c0217SMahesh Rajashekhara dev->aac_msix[0].vector_no = 0;
994495c0217SMahesh Rajashekhara dev->aac_msix[0].dev = dev;
995495c0217SMahesh Rajashekhara
996e8b12f0fSMahesh Rajashekhara if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
997495c0217SMahesh Rajashekhara IRQF_SHARED, "aacraid", &(dev->aac_msix[0])) < 0) {
998e8b12f0fSMahesh Rajashekhara
999e8b12f0fSMahesh Rajashekhara if (dev->msi)
1000e8b12f0fSMahesh Rajashekhara pci_disable_msi(dev->pdev);
1001e8b12f0fSMahesh Rajashekhara
1002e8b12f0fSMahesh Rajashekhara printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
1003e8b12f0fSMahesh Rajashekhara name, instance);
1004e8b12f0fSMahesh Rajashekhara goto error_iounmap;
1005e8b12f0fSMahesh Rajashekhara }
1006e8b12f0fSMahesh Rajashekhara dev->dbg_base = pci_resource_start(dev->pdev, 2);
1007e8b12f0fSMahesh Rajashekhara dev->dbg_base_mapped = dev->regs.src.bar1;
1008e8b12f0fSMahesh Rajashekhara dev->dbg_size = AAC_MIN_SRC_BAR1_SIZE;
1009dafde947SMahesh Rajashekhara dev->a_ops.adapter_enable_int = aac_src_enable_interrupt_message;
1010e8b12f0fSMahesh Rajashekhara
1011e8b12f0fSMahesh Rajashekhara aac_adapter_enable_int(dev);
101211604612SMahesh Rajashekhara
101311604612SMahesh Rajashekhara if (!dev->sync_mode) {
1014e8b12f0fSMahesh Rajashekhara /*
1015e8b12f0fSMahesh Rajashekhara * Tell the adapter that all is configured, and it can
1016e8b12f0fSMahesh Rajashekhara * start accepting requests
1017e8b12f0fSMahesh Rajashekhara */
1018e8b12f0fSMahesh Rajashekhara aac_src_start_adapter(dev);
101911604612SMahesh Rajashekhara }
1020e8b12f0fSMahesh Rajashekhara return 0;
1021e8b12f0fSMahesh Rajashekhara
1022e8b12f0fSMahesh Rajashekhara error_iounmap:
1023e8b12f0fSMahesh Rajashekhara
1024e8b12f0fSMahesh Rajashekhara return -1;
1025e8b12f0fSMahesh Rajashekhara }
102611604612SMahesh Rajashekhara
aac_src_wait_sync(struct aac_dev * dev,int * status)102744f1ce7dSRaghava Aditya Renukunta static int aac_src_wait_sync(struct aac_dev *dev, int *status)
102844f1ce7dSRaghava Aditya Renukunta {
102944f1ce7dSRaghava Aditya Renukunta unsigned long start = jiffies;
103044f1ce7dSRaghava Aditya Renukunta unsigned long usecs = 0;
103144f1ce7dSRaghava Aditya Renukunta int delay = 5 * HZ;
103244f1ce7dSRaghava Aditya Renukunta int rc = 1;
103344f1ce7dSRaghava Aditya Renukunta
103444f1ce7dSRaghava Aditya Renukunta while (time_before(jiffies, start+delay)) {
103544f1ce7dSRaghava Aditya Renukunta /*
103644f1ce7dSRaghava Aditya Renukunta * Delay 5 microseconds to let Mon960 get info.
103744f1ce7dSRaghava Aditya Renukunta */
103844f1ce7dSRaghava Aditya Renukunta udelay(5);
103944f1ce7dSRaghava Aditya Renukunta
104044f1ce7dSRaghava Aditya Renukunta /*
104144f1ce7dSRaghava Aditya Renukunta * Mon960 will set doorbell0 bit when it has completed the
104244f1ce7dSRaghava Aditya Renukunta * command.
104344f1ce7dSRaghava Aditya Renukunta */
104444f1ce7dSRaghava Aditya Renukunta if (aac_src_get_sync_status(dev) & OUTBOUNDDOORBELL_0) {
104544f1ce7dSRaghava Aditya Renukunta /*
104644f1ce7dSRaghava Aditya Renukunta * Clear: the doorbell.
104744f1ce7dSRaghava Aditya Renukunta */
104844f1ce7dSRaghava Aditya Renukunta if (dev->msi_enabled)
104944f1ce7dSRaghava Aditya Renukunta aac_src_access_devreg(dev, AAC_CLEAR_SYNC_BIT);
105044f1ce7dSRaghava Aditya Renukunta else
105144f1ce7dSRaghava Aditya Renukunta src_writel(dev, MUnit.ODR_C,
105244f1ce7dSRaghava Aditya Renukunta OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
105344f1ce7dSRaghava Aditya Renukunta rc = 0;
105444f1ce7dSRaghava Aditya Renukunta
105544f1ce7dSRaghava Aditya Renukunta break;
105644f1ce7dSRaghava Aditya Renukunta }
105744f1ce7dSRaghava Aditya Renukunta
105844f1ce7dSRaghava Aditya Renukunta /*
105944f1ce7dSRaghava Aditya Renukunta * Yield the processor in case we are slow
106044f1ce7dSRaghava Aditya Renukunta */
106144f1ce7dSRaghava Aditya Renukunta usecs = 1 * USEC_PER_MSEC;
106244f1ce7dSRaghava Aditya Renukunta usleep_range(usecs, usecs + 50);
106344f1ce7dSRaghava Aditya Renukunta }
106444f1ce7dSRaghava Aditya Renukunta /*
106544f1ce7dSRaghava Aditya Renukunta * Pull the synch status from Mailbox 0.
106644f1ce7dSRaghava Aditya Renukunta */
106744f1ce7dSRaghava Aditya Renukunta if (status && !rc) {
106844f1ce7dSRaghava Aditya Renukunta status[0] = readl(&dev->IndexRegs->Mailbox[0]);
106944f1ce7dSRaghava Aditya Renukunta status[1] = readl(&dev->IndexRegs->Mailbox[1]);
107044f1ce7dSRaghava Aditya Renukunta status[2] = readl(&dev->IndexRegs->Mailbox[2]);
107144f1ce7dSRaghava Aditya Renukunta status[3] = readl(&dev->IndexRegs->Mailbox[3]);
107244f1ce7dSRaghava Aditya Renukunta status[4] = readl(&dev->IndexRegs->Mailbox[4]);
107344f1ce7dSRaghava Aditya Renukunta }
107444f1ce7dSRaghava Aditya Renukunta
107544f1ce7dSRaghava Aditya Renukunta return rc;
107644f1ce7dSRaghava Aditya Renukunta }
107744f1ce7dSRaghava Aditya Renukunta
107844f1ce7dSRaghava Aditya Renukunta /**
107944f1ce7dSRaghava Aditya Renukunta * aac_src_soft_reset - perform soft reset to speed up
108044f1ce7dSRaghava Aditya Renukunta * access
108144f1ce7dSRaghava Aditya Renukunta *
108244f1ce7dSRaghava Aditya Renukunta * Assumptions: That the controller is in a state where we can
108344f1ce7dSRaghava Aditya Renukunta * bring it back to life with an init struct. We can only use
108444f1ce7dSRaghava Aditya Renukunta * fast sync commands, as the timeout is 5 seconds.
108544f1ce7dSRaghava Aditya Renukunta *
108644f1ce7dSRaghava Aditya Renukunta * @dev: device to configure
108744f1ce7dSRaghava Aditya Renukunta *
108844f1ce7dSRaghava Aditya Renukunta */
108944f1ce7dSRaghava Aditya Renukunta
aac_src_soft_reset(struct aac_dev * dev)109044f1ce7dSRaghava Aditya Renukunta static int aac_src_soft_reset(struct aac_dev *dev)
109144f1ce7dSRaghava Aditya Renukunta {
109244f1ce7dSRaghava Aditya Renukunta u32 status_omr = src_readl(dev, MUnit.OMR);
109344f1ce7dSRaghava Aditya Renukunta u32 status[5];
109444f1ce7dSRaghava Aditya Renukunta int rc = 1;
109544f1ce7dSRaghava Aditya Renukunta int state = 0;
109644f1ce7dSRaghava Aditya Renukunta char *state_str[7] = {
109744f1ce7dSRaghava Aditya Renukunta "GET_ADAPTER_PROPERTIES Failed",
109844f1ce7dSRaghava Aditya Renukunta "GET_ADAPTER_PROPERTIES timeout",
109944f1ce7dSRaghava Aditya Renukunta "SOFT_RESET not supported",
110044f1ce7dSRaghava Aditya Renukunta "DROP_IO Failed",
110144f1ce7dSRaghava Aditya Renukunta "DROP_IO timeout",
110244f1ce7dSRaghava Aditya Renukunta "Check Health failed"
110344f1ce7dSRaghava Aditya Renukunta };
110444f1ce7dSRaghava Aditya Renukunta
110544f1ce7dSRaghava Aditya Renukunta if (status_omr == INVALID_OMR)
110644f1ce7dSRaghava Aditya Renukunta return 1; // pcie hosed
110744f1ce7dSRaghava Aditya Renukunta
110844f1ce7dSRaghava Aditya Renukunta if (!(status_omr & KERNEL_UP_AND_RUNNING))
110944f1ce7dSRaghava Aditya Renukunta return 1; // not up and running
111044f1ce7dSRaghava Aditya Renukunta
111144f1ce7dSRaghava Aditya Renukunta /*
111244f1ce7dSRaghava Aditya Renukunta * We go into soft reset mode to allow us to handle response
111344f1ce7dSRaghava Aditya Renukunta */
111444f1ce7dSRaghava Aditya Renukunta dev->in_soft_reset = 1;
111544f1ce7dSRaghava Aditya Renukunta dev->msi_enabled = status_omr & AAC_INT_MODE_MSIX;
111644f1ce7dSRaghava Aditya Renukunta
111744f1ce7dSRaghava Aditya Renukunta /* Get adapter properties */
111844f1ce7dSRaghava Aditya Renukunta rc = aac_adapter_sync_cmd(dev, GET_ADAPTER_PROPERTIES, 0, 0, 0,
111944f1ce7dSRaghava Aditya Renukunta 0, 0, 0, status+0, status+1, status+2, status+3, status+4);
112044f1ce7dSRaghava Aditya Renukunta if (rc)
112144f1ce7dSRaghava Aditya Renukunta goto out;
112244f1ce7dSRaghava Aditya Renukunta
112344f1ce7dSRaghava Aditya Renukunta state++;
112444f1ce7dSRaghava Aditya Renukunta if (aac_src_wait_sync(dev, status)) {
112544f1ce7dSRaghava Aditya Renukunta rc = 1;
112644f1ce7dSRaghava Aditya Renukunta goto out;
112744f1ce7dSRaghava Aditya Renukunta }
112844f1ce7dSRaghava Aditya Renukunta
112944f1ce7dSRaghava Aditya Renukunta state++;
113044f1ce7dSRaghava Aditya Renukunta if (!(status[1] & le32_to_cpu(AAC_OPT_EXTENDED) &&
113144f1ce7dSRaghava Aditya Renukunta (status[4] & le32_to_cpu(AAC_EXTOPT_SOFT_RESET)))) {
113244f1ce7dSRaghava Aditya Renukunta rc = 2;
113344f1ce7dSRaghava Aditya Renukunta goto out;
113444f1ce7dSRaghava Aditya Renukunta }
113544f1ce7dSRaghava Aditya Renukunta
113644f1ce7dSRaghava Aditya Renukunta if ((status[1] & le32_to_cpu(AAC_OPT_EXTENDED)) &&
113744f1ce7dSRaghava Aditya Renukunta (status[4] & le32_to_cpu(AAC_EXTOPT_SA_FIRMWARE)))
113844f1ce7dSRaghava Aditya Renukunta dev->sa_firmware = 1;
113944f1ce7dSRaghava Aditya Renukunta
114044f1ce7dSRaghava Aditya Renukunta state++;
114144f1ce7dSRaghava Aditya Renukunta rc = aac_adapter_sync_cmd(dev, DROP_IO, 0, 0, 0, 0, 0, 0,
114244f1ce7dSRaghava Aditya Renukunta status+0, status+1, status+2, status+3, status+4);
114344f1ce7dSRaghava Aditya Renukunta
114444f1ce7dSRaghava Aditya Renukunta if (rc)
114544f1ce7dSRaghava Aditya Renukunta goto out;
114644f1ce7dSRaghava Aditya Renukunta
114744f1ce7dSRaghava Aditya Renukunta state++;
114844f1ce7dSRaghava Aditya Renukunta if (aac_src_wait_sync(dev, status)) {
114944f1ce7dSRaghava Aditya Renukunta rc = 3;
115044f1ce7dSRaghava Aditya Renukunta goto out;
115144f1ce7dSRaghava Aditya Renukunta }
115244f1ce7dSRaghava Aditya Renukunta
115344f1ce7dSRaghava Aditya Renukunta if (status[1])
115444f1ce7dSRaghava Aditya Renukunta dev_err(&dev->pdev->dev, "%s: %d outstanding I/O pending\n",
115544f1ce7dSRaghava Aditya Renukunta __func__, status[1]);
115644f1ce7dSRaghava Aditya Renukunta
115744f1ce7dSRaghava Aditya Renukunta state++;
115844f1ce7dSRaghava Aditya Renukunta rc = aac_src_check_health(dev);
115944f1ce7dSRaghava Aditya Renukunta
116044f1ce7dSRaghava Aditya Renukunta out:
116144f1ce7dSRaghava Aditya Renukunta dev->in_soft_reset = 0;
116244f1ce7dSRaghava Aditya Renukunta dev->msi_enabled = 0;
116344f1ce7dSRaghava Aditya Renukunta if (rc)
116444f1ce7dSRaghava Aditya Renukunta dev_err(&dev->pdev->dev, "%s: %s status = %d", __func__,
116544f1ce7dSRaghava Aditya Renukunta state_str[state], rc);
116644f1ce7dSRaghava Aditya Renukunta
116744f1ce7dSRaghava Aditya Renukunta return rc;
116844f1ce7dSRaghava Aditya Renukunta }
116911604612SMahesh Rajashekhara /**
117011604612SMahesh Rajashekhara * aac_srcv_init - initialize an SRCv card
117111604612SMahesh Rajashekhara * @dev: device to configure
117211604612SMahesh Rajashekhara *
117311604612SMahesh Rajashekhara */
117411604612SMahesh Rajashekhara
aac_srcv_init(struct aac_dev * dev)117511604612SMahesh Rajashekhara int aac_srcv_init(struct aac_dev *dev)
117611604612SMahesh Rajashekhara {
117711604612SMahesh Rajashekhara unsigned long start;
117811604612SMahesh Rajashekhara unsigned long status;
117911604612SMahesh Rajashekhara int restart = 0;
118011604612SMahesh Rajashekhara int instance = dev->id;
118111604612SMahesh Rajashekhara const char *name = dev->name;
118211604612SMahesh Rajashekhara
118311604612SMahesh Rajashekhara dev->a_ops.adapter_ioremap = aac_srcv_ioremap;
118411604612SMahesh Rajashekhara dev->a_ops.adapter_comm = aac_src_select_comm;
118511604612SMahesh Rajashekhara
118611604612SMahesh Rajashekhara dev->base_size = AAC_MIN_SRCV_BAR0_SIZE;
118711604612SMahesh Rajashekhara if (aac_adapter_ioremap(dev, dev->base_size)) {
118811604612SMahesh Rajashekhara printk(KERN_WARNING "%s: unable to map adapter.\n", name);
118911604612SMahesh Rajashekhara goto error_iounmap;
119011604612SMahesh Rajashekhara }
119111604612SMahesh Rajashekhara
119211604612SMahesh Rajashekhara /* Failure to reset here is an option ... */
119311604612SMahesh Rajashekhara dev->a_ops.adapter_sync_cmd = src_sync_cmd;
119411604612SMahesh Rajashekhara dev->a_ops.adapter_enable_int = aac_src_disable_interrupt;
1195d9b6d85aSGuilherme G. Piccoli
1196d9b6d85aSGuilherme G. Piccoli if (dev->init_reset) {
1197d9b6d85aSGuilherme G. Piccoli dev->init_reset = false;
119844f1ce7dSRaghava Aditya Renukunta if (aac_src_soft_reset(dev)) {
119944f1ce7dSRaghava Aditya Renukunta aac_src_restart_adapter(dev, 0, IOP_HWSOFT_RESET);
120011604612SMahesh Rajashekhara ++restart;
1201d9b6d85aSGuilherme G. Piccoli }
120244f1ce7dSRaghava Aditya Renukunta }
1203d9b6d85aSGuilherme G. Piccoli
120411604612SMahesh Rajashekhara /*
12052c10cd43SMahesh Rajashekhara * Check to see if flash update is running.
12062c10cd43SMahesh Rajashekhara * Wait for the adapter to be up and running. Wait up to 5 minutes
12072c10cd43SMahesh Rajashekhara */
12082c10cd43SMahesh Rajashekhara status = src_readl(dev, MUnit.OMR);
12092c10cd43SMahesh Rajashekhara if (status & FLASH_UPD_PENDING) {
12102c10cd43SMahesh Rajashekhara start = jiffies;
12112c10cd43SMahesh Rajashekhara do {
12122c10cd43SMahesh Rajashekhara status = src_readl(dev, MUnit.OMR);
12132c10cd43SMahesh Rajashekhara if (time_after(jiffies, start+HZ*FWUPD_TIMEOUT)) {
12142c10cd43SMahesh Rajashekhara printk(KERN_ERR "%s%d: adapter flash update failed.\n",
12152c10cd43SMahesh Rajashekhara dev->name, instance);
12162c10cd43SMahesh Rajashekhara goto error_iounmap;
12172c10cd43SMahesh Rajashekhara }
12182c10cd43SMahesh Rajashekhara } while (!(status & FLASH_UPD_SUCCESS) &&
12192c10cd43SMahesh Rajashekhara !(status & FLASH_UPD_FAILED));
12202c10cd43SMahesh Rajashekhara /* Delay 10 seconds.
12212c10cd43SMahesh Rajashekhara * Because right now FW is doing a soft reset,
12222c10cd43SMahesh Rajashekhara * do not read scratch pad register at this time
12232c10cd43SMahesh Rajashekhara */
12242c10cd43SMahesh Rajashekhara ssleep(10);
12252c10cd43SMahesh Rajashekhara }
12262c10cd43SMahesh Rajashekhara /*
122711604612SMahesh Rajashekhara * Check to see if the board panic'd while booting.
122811604612SMahesh Rajashekhara */
122911604612SMahesh Rajashekhara status = src_readl(dev, MUnit.OMR);
123011604612SMahesh Rajashekhara if (status & KERNEL_PANIC) {
123131364329SRaghava Aditya Renukunta if (aac_src_restart_adapter(dev,
123231364329SRaghava Aditya Renukunta aac_src_check_health(dev), IOP_HWSOFT_RESET))
123311604612SMahesh Rajashekhara goto error_iounmap;
123411604612SMahesh Rajashekhara ++restart;
123511604612SMahesh Rajashekhara }
123611604612SMahesh Rajashekhara /*
123711604612SMahesh Rajashekhara * Check to see if the board failed any self tests.
123811604612SMahesh Rajashekhara */
123911604612SMahesh Rajashekhara status = src_readl(dev, MUnit.OMR);
124011604612SMahesh Rajashekhara if (status & SELF_TEST_FAILED) {
124111604612SMahesh Rajashekhara printk(KERN_ERR "%s%d: adapter self-test failed.\n", dev->name, instance);
124211604612SMahesh Rajashekhara goto error_iounmap;
124311604612SMahesh Rajashekhara }
124411604612SMahesh Rajashekhara /*
124511604612SMahesh Rajashekhara * Check to see if the monitor panic'd while booting.
124611604612SMahesh Rajashekhara */
124711604612SMahesh Rajashekhara if (status & MONITOR_PANIC) {
124811604612SMahesh Rajashekhara printk(KERN_ERR "%s%d: adapter monitor panic.\n", dev->name, instance);
124911604612SMahesh Rajashekhara goto error_iounmap;
125011604612SMahesh Rajashekhara }
125144f1ce7dSRaghava Aditya Renukunta
125211604612SMahesh Rajashekhara start = jiffies;
125311604612SMahesh Rajashekhara /*
125411604612SMahesh Rajashekhara * Wait for the adapter to be up and running. Wait up to 3 minutes
125511604612SMahesh Rajashekhara */
125644f1ce7dSRaghava Aditya Renukunta do {
125744f1ce7dSRaghava Aditya Renukunta status = src_readl(dev, MUnit.OMR);
125844f1ce7dSRaghava Aditya Renukunta if (status == INVALID_OMR)
125944f1ce7dSRaghava Aditya Renukunta status = 0;
126044f1ce7dSRaghava Aditya Renukunta
126111604612SMahesh Rajashekhara if ((restart &&
126211604612SMahesh Rajashekhara (status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC))) ||
126311604612SMahesh Rajashekhara time_after(jiffies, start+HZ*startup_timeout)) {
126411604612SMahesh Rajashekhara printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n",
126511604612SMahesh Rajashekhara dev->name, instance, status);
126611604612SMahesh Rajashekhara goto error_iounmap;
126711604612SMahesh Rajashekhara }
126811604612SMahesh Rajashekhara if (!restart &&
126911604612SMahesh Rajashekhara ((status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC)) ||
127011604612SMahesh Rajashekhara time_after(jiffies, start + HZ *
127111604612SMahesh Rajashekhara ((startup_timeout > 60)
127211604612SMahesh Rajashekhara ? (startup_timeout - 60)
127311604612SMahesh Rajashekhara : (startup_timeout / 2))))) {
127431364329SRaghava Aditya Renukunta if (likely(!aac_src_restart_adapter(dev,
127531364329SRaghava Aditya Renukunta aac_src_check_health(dev), IOP_HWSOFT_RESET)))
127611604612SMahesh Rajashekhara start = jiffies;
127711604612SMahesh Rajashekhara ++restart;
127811604612SMahesh Rajashekhara }
127911604612SMahesh Rajashekhara msleep(1);
128044f1ce7dSRaghava Aditya Renukunta } while (!(status & KERNEL_UP_AND_RUNNING));
128144f1ce7dSRaghava Aditya Renukunta
128211604612SMahesh Rajashekhara if (restart && aac_commit)
128311604612SMahesh Rajashekhara aac_commit = 1;
128411604612SMahesh Rajashekhara /*
128511604612SMahesh Rajashekhara * Fill in the common function dispatch table.
128611604612SMahesh Rajashekhara */
128711604612SMahesh Rajashekhara dev->a_ops.adapter_interrupt = aac_src_interrupt_adapter;
128811604612SMahesh Rajashekhara dev->a_ops.adapter_disable_int = aac_src_disable_interrupt;
1289dafde947SMahesh Rajashekhara dev->a_ops.adapter_enable_int = aac_src_disable_interrupt;
129011604612SMahesh Rajashekhara dev->a_ops.adapter_notify = aac_src_notify_adapter;
129111604612SMahesh Rajashekhara dev->a_ops.adapter_sync_cmd = src_sync_cmd;
129211604612SMahesh Rajashekhara dev->a_ops.adapter_check_health = aac_src_check_health;
129311604612SMahesh Rajashekhara dev->a_ops.adapter_restart = aac_src_restart_adapter;
1294de665f28SMahesh Rajashekhara dev->a_ops.adapter_start = aac_src_start_adapter;
129511604612SMahesh Rajashekhara
129611604612SMahesh Rajashekhara /*
129711604612SMahesh Rajashekhara * First clear out all interrupts. Then enable the one's that we
129811604612SMahesh Rajashekhara * can handle.
129911604612SMahesh Rajashekhara */
130011604612SMahesh Rajashekhara aac_adapter_comm(dev, AAC_COMM_MESSAGE);
130111604612SMahesh Rajashekhara aac_adapter_disable_int(dev);
130211604612SMahesh Rajashekhara src_writel(dev, MUnit.ODR_C, 0xffffffff);
130311604612SMahesh Rajashekhara aac_adapter_enable_int(dev);
130411604612SMahesh Rajashekhara
130511604612SMahesh Rajashekhara if (aac_init_adapter(dev) == NULL)
130611604612SMahesh Rajashekhara goto error_iounmap;
1307d1ef4da8SRaghava Aditya Renukunta if ((dev->comm_interface != AAC_COMM_MESSAGE_TYPE2) &&
1308d1ef4da8SRaghava Aditya Renukunta (dev->comm_interface != AAC_COMM_MESSAGE_TYPE3))
130911604612SMahesh Rajashekhara goto error_iounmap;
1310495c0217SMahesh Rajashekhara if (dev->msi_enabled)
1311495c0217SMahesh Rajashekhara aac_src_access_devreg(dev, AAC_ENABLE_MSIX);
1312495c0217SMahesh Rajashekhara
13138b1462e0SMahesh Rajashekhara if (aac_acquire_irq(dev))
1314495c0217SMahesh Rajashekhara goto error_iounmap;
1315495c0217SMahesh Rajashekhara
13163ffd6c5aSRaghava Aditya Renukunta dev->dbg_base = pci_resource_start(dev->pdev, 2);
13173ffd6c5aSRaghava Aditya Renukunta dev->dbg_base_mapped = dev->regs.src.bar1;
13183ffd6c5aSRaghava Aditya Renukunta dev->dbg_size = AAC_MIN_SRCV_BAR1_SIZE;
1319dafde947SMahesh Rajashekhara dev->a_ops.adapter_enable_int = aac_src_enable_interrupt_message;
132011604612SMahesh Rajashekhara
132111604612SMahesh Rajashekhara aac_adapter_enable_int(dev);
132211604612SMahesh Rajashekhara
132311604612SMahesh Rajashekhara if (!dev->sync_mode) {
132411604612SMahesh Rajashekhara /*
132511604612SMahesh Rajashekhara * Tell the adapter that all is configured, and it can
132611604612SMahesh Rajashekhara * start accepting requests
132711604612SMahesh Rajashekhara */
132811604612SMahesh Rajashekhara aac_src_start_adapter(dev);
132911604612SMahesh Rajashekhara }
133011604612SMahesh Rajashekhara return 0;
133111604612SMahesh Rajashekhara
133211604612SMahesh Rajashekhara error_iounmap:
133311604612SMahesh Rajashekhara
133411604612SMahesh Rajashekhara return -1;
133511604612SMahesh Rajashekhara }
133611604612SMahesh Rajashekhara
aac_src_access_devreg(struct aac_dev * dev,int mode)1337495c0217SMahesh Rajashekhara void aac_src_access_devreg(struct aac_dev *dev, int mode)
1338495c0217SMahesh Rajashekhara {
1339495c0217SMahesh Rajashekhara u_int32_t val;
1340495c0217SMahesh Rajashekhara
1341495c0217SMahesh Rajashekhara switch (mode) {
1342495c0217SMahesh Rajashekhara case AAC_ENABLE_INTERRUPT:
1343495c0217SMahesh Rajashekhara src_writel(dev,
1344495c0217SMahesh Rajashekhara MUnit.OIMR,
1345495c0217SMahesh Rajashekhara dev->OIMR = (dev->msi_enabled ?
1346495c0217SMahesh Rajashekhara AAC_INT_ENABLE_TYPE1_MSIX :
1347495c0217SMahesh Rajashekhara AAC_INT_ENABLE_TYPE1_INTX));
1348495c0217SMahesh Rajashekhara break;
1349495c0217SMahesh Rajashekhara
1350495c0217SMahesh Rajashekhara case AAC_DISABLE_INTERRUPT:
1351495c0217SMahesh Rajashekhara src_writel(dev,
1352495c0217SMahesh Rajashekhara MUnit.OIMR,
1353495c0217SMahesh Rajashekhara dev->OIMR = AAC_INT_DISABLE_ALL);
1354495c0217SMahesh Rajashekhara break;
1355495c0217SMahesh Rajashekhara
1356495c0217SMahesh Rajashekhara case AAC_ENABLE_MSIX:
1357495c0217SMahesh Rajashekhara /* set bit 6 */
1358495c0217SMahesh Rajashekhara val = src_readl(dev, MUnit.IDR);
1359495c0217SMahesh Rajashekhara val |= 0x40;
1360495c0217SMahesh Rajashekhara src_writel(dev, MUnit.IDR, val);
1361495c0217SMahesh Rajashekhara src_readl(dev, MUnit.IDR);
1362495c0217SMahesh Rajashekhara /* unmask int. */
1363495c0217SMahesh Rajashekhara val = PMC_ALL_INTERRUPT_BITS;
1364495c0217SMahesh Rajashekhara src_writel(dev, MUnit.IOAR, val);
1365495c0217SMahesh Rajashekhara val = src_readl(dev, MUnit.OIMR);
1366495c0217SMahesh Rajashekhara src_writel(dev,
1367495c0217SMahesh Rajashekhara MUnit.OIMR,
1368495c0217SMahesh Rajashekhara val & (~(PMC_GLOBAL_INT_BIT2 | PMC_GLOBAL_INT_BIT0)));
1369495c0217SMahesh Rajashekhara break;
1370495c0217SMahesh Rajashekhara
1371495c0217SMahesh Rajashekhara case AAC_DISABLE_MSIX:
1372495c0217SMahesh Rajashekhara /* reset bit 6 */
1373495c0217SMahesh Rajashekhara val = src_readl(dev, MUnit.IDR);
1374495c0217SMahesh Rajashekhara val &= ~0x40;
1375495c0217SMahesh Rajashekhara src_writel(dev, MUnit.IDR, val);
1376495c0217SMahesh Rajashekhara src_readl(dev, MUnit.IDR);
1377495c0217SMahesh Rajashekhara break;
1378495c0217SMahesh Rajashekhara
1379495c0217SMahesh Rajashekhara case AAC_CLEAR_AIF_BIT:
1380495c0217SMahesh Rajashekhara /* set bit 5 */
1381495c0217SMahesh Rajashekhara val = src_readl(dev, MUnit.IDR);
1382495c0217SMahesh Rajashekhara val |= 0x20;
1383495c0217SMahesh Rajashekhara src_writel(dev, MUnit.IDR, val);
1384495c0217SMahesh Rajashekhara src_readl(dev, MUnit.IDR);
1385495c0217SMahesh Rajashekhara break;
1386495c0217SMahesh Rajashekhara
1387495c0217SMahesh Rajashekhara case AAC_CLEAR_SYNC_BIT:
1388495c0217SMahesh Rajashekhara /* set bit 4 */
1389495c0217SMahesh Rajashekhara val = src_readl(dev, MUnit.IDR);
1390495c0217SMahesh Rajashekhara val |= 0x10;
1391495c0217SMahesh Rajashekhara src_writel(dev, MUnit.IDR, val);
1392495c0217SMahesh Rajashekhara src_readl(dev, MUnit.IDR);
1393495c0217SMahesh Rajashekhara break;
1394495c0217SMahesh Rajashekhara
1395495c0217SMahesh Rajashekhara case AAC_ENABLE_INTX:
1396495c0217SMahesh Rajashekhara /* set bit 7 */
1397495c0217SMahesh Rajashekhara val = src_readl(dev, MUnit.IDR);
1398495c0217SMahesh Rajashekhara val |= 0x80;
1399495c0217SMahesh Rajashekhara src_writel(dev, MUnit.IDR, val);
1400495c0217SMahesh Rajashekhara src_readl(dev, MUnit.IDR);
1401495c0217SMahesh Rajashekhara /* unmask int. */
1402495c0217SMahesh Rajashekhara val = PMC_ALL_INTERRUPT_BITS;
1403495c0217SMahesh Rajashekhara src_writel(dev, MUnit.IOAR, val);
1404495c0217SMahesh Rajashekhara src_readl(dev, MUnit.IOAR);
1405495c0217SMahesh Rajashekhara val = src_readl(dev, MUnit.OIMR);
1406495c0217SMahesh Rajashekhara src_writel(dev, MUnit.OIMR,
1407495c0217SMahesh Rajashekhara val & (~(PMC_GLOBAL_INT_BIT2)));
1408495c0217SMahesh Rajashekhara break;
1409495c0217SMahesh Rajashekhara
1410495c0217SMahesh Rajashekhara default:
1411495c0217SMahesh Rajashekhara break;
1412495c0217SMahesh Rajashekhara }
1413495c0217SMahesh Rajashekhara }
1414495c0217SMahesh Rajashekhara
aac_src_get_sync_status(struct aac_dev * dev)1415495c0217SMahesh Rajashekhara static int aac_src_get_sync_status(struct aac_dev *dev)
1416495c0217SMahesh Rajashekhara {
1417eee549e1SRaghava Aditya Renukunta int msix_val = 0;
1418eee549e1SRaghava Aditya Renukunta int legacy_val = 0;
1419495c0217SMahesh Rajashekhara
1420eee549e1SRaghava Aditya Renukunta msix_val = src_readl(dev, MUnit.ODR_MSI) & SRC_MSI_READ_MASK ? 1 : 0;
1421495c0217SMahesh Rajashekhara
1422eee549e1SRaghava Aditya Renukunta if (!dev->msi_enabled) {
1423eee549e1SRaghava Aditya Renukunta /*
1424eee549e1SRaghava Aditya Renukunta * if Legacy int status indicates cmd is not complete
1425eee549e1SRaghava Aditya Renukunta * sample MSIx register to see if it indiactes cmd complete,
1426eee549e1SRaghava Aditya Renukunta * if yes set the controller in MSIx mode and consider cmd
1427eee549e1SRaghava Aditya Renukunta * completed
1428eee549e1SRaghava Aditya Renukunta */
1429eee549e1SRaghava Aditya Renukunta legacy_val = src_readl(dev, MUnit.ODR_R) >> SRC_ODR_SHIFT;
1430eee549e1SRaghava Aditya Renukunta if (!(legacy_val & 1) && msix_val)
1431eee549e1SRaghava Aditya Renukunta dev->msi_enabled = 1;
1432eee549e1SRaghava Aditya Renukunta return legacy_val;
1433eee549e1SRaghava Aditya Renukunta }
1434495c0217SMahesh Rajashekhara
1435eee549e1SRaghava Aditya Renukunta return msix_val;
1436495c0217SMahesh Rajashekhara }
1437