2 * Adaptec AAC series RAID controller driver
3 * (c) Copyright 2001 Red Hat Inc. <alan@redhat.com>
5 * based on the old aacraid driver that is..
6 * Adaptec aacraid device driver for Linux.
8 * Copyright (c) 2000 Adaptec, Inc. (aacraid@adaptec.com)
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2, or (at your option)
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; see the file COPYING. If not, write to
22 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
27 * Abstract: Hardware miniport for Drawbridge specific hardware functions.
31 #include <linux/kernel.h>
32 #include <linux/init.h>
33 #include <linux/types.h>
34 #include <linux/sched.h>
35 #include <linux/pci.h>
36 #include <linux/spinlock.h>
37 #include <linux/slab.h>
38 #include <linux/blkdev.h>
39 #include <linux/delay.h>
40 #include <linux/completion.h>
41 #include <linux/time.h>
42 #include <linux/interrupt.h>
43 #include <asm/semaphore.h>
45 #include <scsi/scsi_host.h>
49 static irqreturn_t aac_rkt_intr(int irq, void *dev_id, struct pt_regs *regs)
51 struct aac_dev *dev = dev_id;
52 unsigned long bellbits;
54 intstat = rkt_readb(dev, MUnit.OISR);
56 * Read mask and invert because drawbridge is reversed.
57 * This allows us to only service interrupts that have
61 /* Check to see if this is our interrupt. If it isn't just return */
64 bellbits = rkt_readl(dev, OutboundDoorbellReg);
65 if (bellbits & DoorBellPrintfReady) {
66 aac_printf(dev, le32_to_cpu(rkt_readl (dev, IndexRegs.Mailbox[5])));
67 rkt_writel(dev, MUnit.ODR,DoorBellPrintfReady);
68 rkt_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
70 else if (bellbits & DoorBellAdapterNormCmdReady) {
71 rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
72 aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
74 else if (bellbits & DoorBellAdapterNormRespReady) {
75 aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
76 rkt_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
78 else if (bellbits & DoorBellAdapterNormCmdNotFull) {
79 rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
81 else if (bellbits & DoorBellAdapterNormRespNotFull) {
82 rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
83 rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
91 * aac_rkt_enable_interrupt - Enable event reporting
93 * @event: Event to enable
95 * Enable event reporting from the i960 for a given event.
98 static void aac_rkt_enable_interrupt(struct aac_dev * dev, u32 event)
103 dev->irq_mask &= ~(OUTBOUNDDOORBELL_1);
106 case HostNormRespQue:
107 dev->irq_mask &= ~(OUTBOUNDDOORBELL_2);
110 case AdapNormCmdNotFull:
111 dev->irq_mask &= ~(OUTBOUNDDOORBELL_3);
114 case AdapNormRespNotFull:
115 dev->irq_mask &= ~(OUTBOUNDDOORBELL_4);
121 * aac_rkt_disable_interrupt - Disable event reporting
123 * @event: Event to enable
125 * Disable event reporting from the i960 for a given event.
128 static void aac_rkt_disable_interrupt(struct aac_dev *dev, u32 event)
133 dev->irq_mask |= (OUTBOUNDDOORBELL_1);
136 case HostNormRespQue:
137 dev->irq_mask |= (OUTBOUNDDOORBELL_2);
140 case AdapNormCmdNotFull:
141 dev->irq_mask |= (OUTBOUNDDOORBELL_3);
144 case AdapNormRespNotFull:
145 dev->irq_mask |= (OUTBOUNDDOORBELL_4);
151 * rkt_sync_cmd - send a command and wait
153 * @command: Command to execute
154 * @p1: first parameter
155 * @ret: adapter status
157 * This routine will send a synchronous comamnd to the adapter and wait
158 * for its completion.
161 static int rkt_sync_cmd(struct aac_dev *dev, u32 command, u32 p1, u32 *status)
166 * Write the command into Mailbox 0
168 rkt_writel(dev, InboundMailbox0, cpu_to_le32(command));
170 * Write the parameters into Mailboxes 1 - 4
172 rkt_writel(dev, InboundMailbox1, cpu_to_le32(p1));
173 rkt_writel(dev, InboundMailbox2, 0);
174 rkt_writel(dev, InboundMailbox3, 0);
175 rkt_writel(dev, InboundMailbox4, 0);
177 * Clear the synch command doorbell to start on a clean slate.
179 rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
181 * Disable doorbell interrupts
183 rkt_writeb(dev, MUnit.OIMR, dev->OIMR |= 0x04);
185 * Force the completion of the mask register write before issuing
188 rkt_readb (dev, MUnit.OIMR);
190 * Signal that there is a new synch command
192 rkt_writel(dev, InboundDoorbellReg, INBOUNDDOORBELL_0);
198 * Wait up to 30 seconds
200 while (time_before(jiffies, start+30*HZ))
202 udelay(5); /* Delay 5 microseconds to let Mon960 get info. */
204 * Mon960 will set doorbell0 bit when it has completed the command.
206 if (rkt_readl(dev, OutboundDoorbellReg) & OUTBOUNDDOORBELL_0) {
208 * Clear the doorbell.
210 rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
215 * Yield the processor in case we are slow
217 set_current_state(TASK_UNINTERRUPTIBLE);
222 * Restore interrupt mask even though we timed out
224 rkt_writeb(dev, MUnit.OIMR, dev->OIMR &= 0xfb);
228 * Pull the synch status from Mailbox 0.
230 *status = le32_to_cpu(rkt_readl(dev, IndexRegs.Mailbox[0]));
232 * Clear the synch command doorbell.
234 rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0);
236 * Restore interrupt mask
238 rkt_writeb(dev, MUnit.OIMR, dev->OIMR &= 0xfb);
244 * aac_rkt_interrupt_adapter - interrupt adapter
247 * Send an interrupt to the i960 and breakpoint it.
250 static void aac_rkt_interrupt_adapter(struct aac_dev *dev)
253 rkt_sync_cmd(dev, BREAKPOINT_REQUEST, 0, &ret);
257 * aac_rkt_notify_adapter - send an event to the adapter
259 * @event: Event to send
261 * Notify the i960 that something it probably cares about has
265 static void aac_rkt_notify_adapter(struct aac_dev *dev, u32 event)
270 rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_1);
272 case HostNormRespNotFull:
273 rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_4);
275 case AdapNormRespQue:
276 rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_2);
278 case HostNormCmdNotFull:
279 rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_3);
282 // rkt_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, &ret);
285 rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_6);
288 rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_5);
297 * aac_rkt_start_adapter - activate adapter
300 * Start up processing on an i960 based AAC adapter
303 static void aac_rkt_start_adapter(struct aac_dev *dev)
306 struct aac_init *init;
309 init->HostElapsedSeconds = cpu_to_le32(get_seconds());
311 * Tell the adapter we are back and up and running so it will scan
312 * its command queues and enable our interrupts
314 dev->irq_mask = (DoorBellPrintfReady | OUTBOUNDDOORBELL_1 | OUTBOUNDDOORBELL_2 | OUTBOUNDDOORBELL_3 | OUTBOUNDDOORBELL_4);
316 * First clear out all interrupts. Then enable the one's that we
319 rkt_writeb(dev, MUnit.OIMR, 0xff);
320 rkt_writel(dev, MUnit.ODR, 0xffffffff);
321 // rkt_writeb(dev, MUnit.OIMR, ~(u8)OUTBOUND_DOORBELL_INTERRUPT_MASK);
322 rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
324 // We can only use a 32 bit address here
325 rkt_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa, &status);
329 * aac_rkt_check_health
330 * @dev: device to check if healthy
332 * Will attempt to determine if the specified adapter is alive and
333 * capable of handling requests, returning 0 if alive.
335 static int aac_rkt_check_health(struct aac_dev *dev)
337 long status = rkt_readl(dev, IndexRegs.Mailbox[7]);
340 * Check to see if the board failed any self tests.
342 if (status & SELF_TEST_FAILED)
345 * Check to see if the board panic'd.
347 if (status & KERNEL_PANIC)
349 char * buffer = kmalloc(512, GFP_KERNEL|__GFP_DMA);
353 } * post = kmalloc(sizeof(struct POSTSTATUS), GFP_KERNEL);
354 dma_addr_t paddr = pci_map_single(dev->pdev, post, sizeof(struct POSTSTATUS), 2);
355 dma_addr_t baddr = pci_map_single(dev->pdev, buffer, 512, 1);
359 memset(buffer, 0, 512);
360 post->Post_Command = cpu_to_le32(COMMAND_POST_RESULTS);
361 post->Post_Address = cpu_to_le32(baddr);
362 rkt_writel(dev, MUnit.IMRx[0], cpu_to_le32(paddr));
363 rkt_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, &status);
364 pci_unmap_single(dev->pdev, paddr, sizeof(struct POSTSTATUS),2);
366 if ((buffer[0] == '0') && (buffer[1] == 'x')) {
367 ret = (buffer[2] <= '9') ? (buffer[2] - '0') : (buffer[2] - 'A' + 10);
369 ret += (buffer[3] <= '9') ? (buffer[3] - '0') : (buffer[3] - 'A' + 10);
371 pci_unmap_single(dev->pdev, baddr, 512, 1);
376 * Wait for the adapter to be up and running.
378 if (!(status & KERNEL_UP_AND_RUNNING))
387 * aac_rkt_init - initialize an i960 based AAC card
388 * @dev: device to configure
390 * Allocate and set up resources for the i960 based AAC variants. The
391 * device_interface in the commregion will be allocated and linked
392 * to the comm region.
395 int aac_rkt_init(struct aac_dev *dev)
398 unsigned long status;
406 * Map in the registers from the adapter.
408 if((dev->regs.rkt = (struct rkt_registers *)ioremap((unsigned long)dev->scsi_host_ptr->base, 8192))==NULL)
410 printk(KERN_WARNING "aacraid: unable to map i960.\n" );
414 * Check to see if the board failed any self tests.
416 if (rkt_readl(dev, MUnit.OMRx[0]) & SELF_TEST_FAILED) {
417 printk(KERN_ERR "%s%d: adapter self-test failed.\n", dev->name, instance);
421 * Check to see if the monitor panic'd while booting.
423 if (rkt_readl(dev, MUnit.OMRx[0]) & MONITOR_PANIC) {
424 printk(KERN_ERR "%s%d: adapter monitor panic.\n", dev->name, instance);
428 * Check to see if the board panic'd while booting.
430 if (rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_PANIC) {
431 printk(KERN_ERR "%s%d: adapter kernel panic'd.\n", dev->name, instance);
436 * Wait for the adapter to be up and running. Wait up to 3 minutes
438 while (!(rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_UP_AND_RUNNING))
440 if(time_after(jiffies, start+180*HZ))
442 status = rkt_readl(dev, IndexRegs.Mailbox[7]) >> 16;
443 printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %ld.\n", dev->name, instance, status);
446 set_current_state(TASK_UNINTERRUPTIBLE);
449 if (request_irq(dev->scsi_host_ptr->irq, aac_rkt_intr, SA_SHIRQ|SA_INTERRUPT, "aacraid", (void *)dev)<0)
451 printk(KERN_ERR "%s%d: Interrupt unavailable.\n", name, instance);
455 * Fill in the function dispatch table.
457 dev->a_ops.adapter_interrupt = aac_rkt_interrupt_adapter;
458 dev->a_ops.adapter_enable_int = aac_rkt_enable_interrupt;
459 dev->a_ops.adapter_disable_int = aac_rkt_disable_interrupt;
460 dev->a_ops.adapter_notify = aac_rkt_notify_adapter;
461 dev->a_ops.adapter_sync_cmd = rkt_sync_cmd;
462 dev->a_ops.adapter_check_health = aac_rkt_check_health;
464 if (aac_init_adapter(dev) == NULL)
467 * Start any kernel threads needed
469 dev->thread_pid = kernel_thread((int (*)(void *))aac_command_thread, dev, 0);
470 if(dev->thread_pid < 0)
472 printk(KERN_ERR "aacraid: Unable to create rkt thread.\n");
476 * Tell the adapter that all is configured, and it can start
479 aac_rkt_start_adapter(dev);
486 free_irq(dev->scsi_host_ptr->irq, (void *)dev);
489 iounmap(dev->regs.rkt);