1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *	Adaptec AAC series RAID controller driver
4  *	(c) Copyright 2001 Red Hat Inc.
5  *
6  * based on the old aacraid driver that is..
7  * Adaptec aacraid device driver for Linux.
8  *
9  * Copyright (c) 2000-2010 Adaptec, Inc.
10  *               2010-2015 PMC-Sierra, Inc. (aacraid@pmc-sierra.com)
11  *		 2016-2017 Microsemi Corp. (aacraid@microsemi.com)
12  *
13  * Module Name:
14  *  sa.c
15  *
16  * Abstract: Drawbridge specific support functions
17  */
18 
19 #include <linux/kernel.h>
20 #include <linux/init.h>
21 #include <linux/types.h>
22 #include <linux/pci.h>
23 #include <linux/spinlock.h>
24 #include <linux/blkdev.h>
25 #include <linux/delay.h>
26 #include <linux/completion.h>
27 #include <linux/time.h>
28 #include <linux/interrupt.h>
29 
30 #include <scsi/scsi_host.h>
31 
32 #include "aacraid.h"
33 
aac_sa_intr(int irq,void * dev_id)34 static irqreturn_t aac_sa_intr(int irq, void *dev_id)
35 {
36 	struct aac_dev *dev = dev_id;
37 	unsigned short intstat, mask;
38 
39 	intstat = sa_readw(dev, DoorbellReg_p);
40 	/*
41 	 *	Read mask and invert because drawbridge is reversed.
42 	 *	This allows us to only service interrupts that have been enabled.
43 	 */
44 	mask = ~(sa_readw(dev, SaDbCSR.PRISETIRQMASK));
45 
46 	/* Check to see if this is our interrupt.  If it isn't just return */
47 
48 	if (intstat & mask) {
49 		if (intstat & PrintfReady) {
50 			aac_printf(dev, sa_readl(dev, Mailbox5));
51 			sa_writew(dev, DoorbellClrReg_p, PrintfReady); /* clear PrintfReady */
52 			sa_writew(dev, DoorbellReg_s, PrintfDone);
53 		} else if (intstat & DOORBELL_1) {	// dev -> Host Normal Command Ready
54 			sa_writew(dev, DoorbellClrReg_p, DOORBELL_1);
55 			aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
56 		} else if (intstat & DOORBELL_2) {	// dev -> Host Normal Response Ready
57 			sa_writew(dev, DoorbellClrReg_p, DOORBELL_2);
58 			aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
59 		} else if (intstat & DOORBELL_3) {	// dev -> Host Normal Command Not Full
60 			sa_writew(dev, DoorbellClrReg_p, DOORBELL_3);
61 		} else if (intstat & DOORBELL_4) {	// dev -> Host Normal Response Not Full
62 			sa_writew(dev, DoorbellClrReg_p, DOORBELL_4);
63 		}
64 		return IRQ_HANDLED;
65 	}
66 	return IRQ_NONE;
67 }
68 
69 /**
70  *	aac_sa_disable_interrupt	-	disable interrupt
71  *	@dev: Which adapter to enable.
72  */
73 
aac_sa_disable_interrupt(struct aac_dev * dev)74 static void aac_sa_disable_interrupt (struct aac_dev *dev)
75 {
76 	sa_writew(dev, SaDbCSR.PRISETIRQMASK, 0xffff);
77 }
78 
79 /**
80  *	aac_sa_enable_interrupt	-	enable interrupt
81  *	@dev: Which adapter to enable.
82  */
83 
aac_sa_enable_interrupt(struct aac_dev * dev)84 static void aac_sa_enable_interrupt (struct aac_dev *dev)
85 {
86 	sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, (PrintfReady | DOORBELL_1 |
87 				DOORBELL_2 | DOORBELL_3 | DOORBELL_4));
88 }
89 
90 /**
91  *	aac_sa_notify_adapter		-	handle adapter notification
92  *	@dev:	Adapter that notification is for
93  *	@event:	Event to notidy
94  *
95  *	Notify the adapter of an event
96  */
97 
aac_sa_notify_adapter(struct aac_dev * dev,u32 event)98 static void aac_sa_notify_adapter(struct aac_dev *dev, u32 event)
99 {
100 	switch (event) {
101 
102 	case AdapNormCmdQue:
103 		sa_writew(dev, DoorbellReg_s,DOORBELL_1);
104 		break;
105 	case HostNormRespNotFull:
106 		sa_writew(dev, DoorbellReg_s,DOORBELL_4);
107 		break;
108 	case AdapNormRespQue:
109 		sa_writew(dev, DoorbellReg_s,DOORBELL_2);
110 		break;
111 	case HostNormCmdNotFull:
112 		sa_writew(dev, DoorbellReg_s,DOORBELL_3);
113 		break;
114 	case HostShutdown:
115 		/*
116 		sa_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, 0, 0,
117 		NULL, NULL, NULL, NULL, NULL);
118 		*/
119 		break;
120 	case FastIo:
121 		sa_writew(dev, DoorbellReg_s,DOORBELL_6);
122 		break;
123 	case AdapPrintfDone:
124 		sa_writew(dev, DoorbellReg_s,DOORBELL_5);
125 		break;
126 	default:
127 		BUG();
128 		break;
129 	}
130 }
131 
132 
133 /**
134  *	sa_sync_cmd	-	send a command and wait
135  *	@dev: Adapter
136  *	@command: Command to execute
137  *	@p1: first parameter
138  *	@p2: second parameter
139  *	@p3: third parameter
140  *	@p4: forth parameter
141  *	@p5: fifth parameter
142  *	@p6: sixth parameter
143  *	@ret: adapter status
144  *	@r1: first return value
145  *	@r2: second return value
146  *	@r3: third return value
147  *	@r4: forth return value
148  *
149  *	This routine will send a synchronous command to the adapter and wait
150  *	for its	completion.
151  */
sa_sync_cmd(struct aac_dev * dev,u32 command,u32 p1,u32 p2,u32 p3,u32 p4,u32 p5,u32 p6,u32 * ret,u32 * r1,u32 * r2,u32 * r3,u32 * r4)152 static int sa_sync_cmd(struct aac_dev *dev, u32 command,
153 		u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6,
154 		u32 *ret, u32 *r1, u32 *r2, u32 *r3, u32 *r4)
155 {
156 	unsigned long start;
157  	int ok;
158 	/*
159 	 *	Write the Command into Mailbox 0
160 	 */
161 	sa_writel(dev, Mailbox0, command);
162 	/*
163 	 *	Write the parameters into Mailboxes 1 - 4
164 	 */
165 	sa_writel(dev, Mailbox1, p1);
166 	sa_writel(dev, Mailbox2, p2);
167 	sa_writel(dev, Mailbox3, p3);
168 	sa_writel(dev, Mailbox4, p4);
169 
170 	/*
171 	 *	Clear the synch command doorbell to start on a clean slate.
172 	 */
173 	sa_writew(dev, DoorbellClrReg_p, DOORBELL_0);
174 	/*
175 	 *	Signal that there is a new synch command
176 	 */
177 	sa_writew(dev, DoorbellReg_s, DOORBELL_0);
178 
179 	ok = 0;
180 	start = jiffies;
181 
182 	while(time_before(jiffies, start+30*HZ))
183 	{
184 		/*
185 		 *	Delay 5uS so that the monitor gets access
186 		 */
187 		udelay(5);
188 		/*
189 		 *	Mon110 will set doorbell0 bit when it has
190 		 *	completed the command.
191 		 */
192 		if(sa_readw(dev, DoorbellReg_p) & DOORBELL_0)  {
193 			ok = 1;
194 			break;
195 		}
196 		msleep(1);
197 	}
198 
199 	if (ok != 1)
200 		return -ETIMEDOUT;
201 	/*
202 	 *	Clear the synch command doorbell.
203 	 */
204 	sa_writew(dev, DoorbellClrReg_p, DOORBELL_0);
205 	/*
206 	 *	Pull the synch status from Mailbox 0.
207 	 */
208 	if (ret)
209 		*ret = sa_readl(dev, Mailbox0);
210 	if (r1)
211 		*r1 = sa_readl(dev, Mailbox1);
212 	if (r2)
213 		*r2 = sa_readl(dev, Mailbox2);
214 	if (r3)
215 		*r3 = sa_readl(dev, Mailbox3);
216 	if (r4)
217 		*r4 = sa_readl(dev, Mailbox4);
218 	return 0;
219 }
220 
221 /**
222  *	aac_sa_interrupt_adapter	-	interrupt an adapter
223  *	@dev: Which adapter to enable.
224  *
225  *	Breakpoint an adapter.
226  */
227 
aac_sa_interrupt_adapter(struct aac_dev * dev)228 static void aac_sa_interrupt_adapter (struct aac_dev *dev)
229 {
230 	sa_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0,
231 			NULL, NULL, NULL, NULL, NULL);
232 }
233 
234 /**
235  *	aac_sa_start_adapter		-	activate adapter
236  *	@dev:	Adapter
237  *
238  *	Start up processing on an ARM based AAC adapter
239  */
240 
aac_sa_start_adapter(struct aac_dev * dev)241 static void aac_sa_start_adapter(struct aac_dev *dev)
242 {
243 	union aac_init *init;
244 	/*
245 	 * Fill in the remaining pieces of the init.
246 	 */
247 	init = dev->init;
248 	init->r7.host_elapsed_seconds = cpu_to_le32(ktime_get_real_seconds());
249 	/* We can only use a 32 bit address here */
250 	sa_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS,
251 			(u32)(ulong)dev->init_pa, 0, 0, 0, 0, 0,
252 			NULL, NULL, NULL, NULL, NULL);
253 }
254 
aac_sa_restart_adapter(struct aac_dev * dev,int bled,u8 reset_type)255 static int aac_sa_restart_adapter(struct aac_dev *dev, int bled, u8 reset_type)
256 {
257 	return -EINVAL;
258 }
259 
260 /**
261  *	aac_sa_check_health
262  *	@dev: device to check if healthy
263  *
264  *	Will attempt to determine if the specified adapter is alive and
265  *	capable of handling requests, returning 0 if alive.
266  */
aac_sa_check_health(struct aac_dev * dev)267 static int aac_sa_check_health(struct aac_dev *dev)
268 {
269 	long status = sa_readl(dev, Mailbox7);
270 
271 	/*
272 	 *	Check to see if the board failed any self tests.
273 	 */
274 	if (status & SELF_TEST_FAILED)
275 		return -1;
276 	/*
277 	 *	Check to see if the board panic'd while booting.
278 	 */
279 	if (status & KERNEL_PANIC)
280 		return -2;
281 	/*
282 	 *	Wait for the adapter to be up and running. Wait up to 3 minutes
283 	 */
284 	if (!(status & KERNEL_UP_AND_RUNNING))
285 		return -3;
286 	/*
287 	 *	Everything is OK
288 	 */
289 	return 0;
290 }
291 
292 /**
293  *	aac_sa_ioremap
294  *	@dev: device to ioremap
295  *	@size: mapping resize request
296  *
297  */
aac_sa_ioremap(struct aac_dev * dev,u32 size)298 static int aac_sa_ioremap(struct aac_dev * dev, u32 size)
299 {
300 	if (!size) {
301 		iounmap(dev->regs.sa);
302 		return 0;
303 	}
304 	dev->base = dev->regs.sa = ioremap(dev->base_start, size);
305 	return (dev->base == NULL) ? -1 : 0;
306 }
307 
308 /**
309  *	aac_sa_init	-	initialize an ARM based AAC card
310  *	@dev: device to configure
311  *
312  *	Allocate and set up resources for the ARM based AAC variants. The
313  *	device_interface in the commregion will be allocated and linked
314  *	to the comm region.
315  */
316 
aac_sa_init(struct aac_dev * dev)317 int aac_sa_init(struct aac_dev *dev)
318 {
319 	unsigned long start;
320 	unsigned long status;
321 	int instance;
322 	const char *name;
323 
324 	instance = dev->id;
325 	name     = dev->name;
326 
327 	/*
328 	 *	Fill in the function dispatch table.
329 	 */
330 
331 	dev->a_ops.adapter_interrupt = aac_sa_interrupt_adapter;
332 	dev->a_ops.adapter_disable_int = aac_sa_disable_interrupt;
333 	dev->a_ops.adapter_enable_int = aac_sa_enable_interrupt;
334 	dev->a_ops.adapter_notify = aac_sa_notify_adapter;
335 	dev->a_ops.adapter_sync_cmd = sa_sync_cmd;
336 	dev->a_ops.adapter_check_health = aac_sa_check_health;
337 	dev->a_ops.adapter_restart = aac_sa_restart_adapter;
338 	dev->a_ops.adapter_start = aac_sa_start_adapter;
339 	dev->a_ops.adapter_intr = aac_sa_intr;
340 	dev->a_ops.adapter_deliver = aac_rx_deliver_producer;
341 	dev->a_ops.adapter_ioremap = aac_sa_ioremap;
342 
343 	if (aac_sa_ioremap(dev, dev->base_size)) {
344 		printk(KERN_WARNING "%s: unable to map adapter.\n", name);
345 		goto error_iounmap;
346 	}
347 
348 	/*
349 	 *	Check to see if the board failed any self tests.
350 	 */
351 	if (sa_readl(dev, Mailbox7) & SELF_TEST_FAILED) {
352 		printk(KERN_WARNING "%s%d: adapter self-test failed.\n", name, instance);
353 		goto error_iounmap;
354 	}
355 	/*
356 	 *	Check to see if the board panic'd while booting.
357 	 */
358 	if (sa_readl(dev, Mailbox7) & KERNEL_PANIC) {
359 		printk(KERN_WARNING "%s%d: adapter kernel panic'd.\n", name, instance);
360 		goto error_iounmap;
361 	}
362 	start = jiffies;
363 	/*
364 	 *	Wait for the adapter to be up and running. Wait up to 3 minutes.
365 	 */
366 	while (!(sa_readl(dev, Mailbox7) & KERNEL_UP_AND_RUNNING)) {
367 		if (time_after(jiffies, start+startup_timeout*HZ)) {
368 			status = sa_readl(dev, Mailbox7);
369 			printk(KERN_WARNING "%s%d: adapter kernel failed to start, init status = %lx.\n",
370 					name, instance, status);
371 			goto error_iounmap;
372 		}
373 		msleep(1);
374 	}
375 
376 	/*
377 	 *	First clear out all interrupts.  Then enable the one's that
378 	 *	we can handle.
379 	 */
380 	aac_adapter_disable_int(dev);
381 	aac_adapter_enable_int(dev);
382 
383 	if(aac_init_adapter(dev) == NULL)
384 		goto error_irq;
385 	dev->sync_mode = 0;	/* sync. mode not supported */
386 	if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
387 			IRQF_SHARED, "aacraid", (void *)dev) < 0) {
388 		printk(KERN_WARNING "%s%d: Interrupt unavailable.\n",
389 			name, instance);
390 		goto error_iounmap;
391 	}
392 	dev->dbg_base = dev->base_start;
393 	dev->dbg_base_mapped = dev->base;
394 	dev->dbg_size = dev->base_size;
395 
396 	aac_adapter_enable_int(dev);
397 
398 	/*
399 	 *	Tell the adapter that all is configure, and it can start
400 	 *	accepting requests
401 	 */
402 	aac_sa_start_adapter(dev);
403 	return 0;
404 
405 error_irq:
406 	aac_sa_disable_interrupt(dev);
407 	free_irq(dev->pdev->irq, (void *)dev);
408 
409 error_iounmap:
410 
411 	return -1;
412 }
413 
414