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