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_disable_interrupt - disable interrupt 86 * @dev: Which adapter to enable. 87 */ 88 89 static void aac_sa_disable_interrupt (struct aac_dev *dev) 90 { 91 sa_writew(dev, SaDbCSR.PRISETIRQMASK, 0xffff); 92 } 93 94 /** 95 * aac_sa_notify_adapter - handle adapter notification 96 * @dev: Adapter that notification is for 97 * @event: Event to notidy 98 * 99 * Notify the adapter of an event 100 */ 101 102 static void aac_sa_notify_adapter(struct aac_dev *dev, u32 event) 103 { 104 switch (event) { 105 106 case AdapNormCmdQue: 107 sa_writew(dev, DoorbellReg_s,DOORBELL_1); 108 break; 109 case HostNormRespNotFull: 110 sa_writew(dev, DoorbellReg_s,DOORBELL_4); 111 break; 112 case AdapNormRespQue: 113 sa_writew(dev, DoorbellReg_s,DOORBELL_2); 114 break; 115 case HostNormCmdNotFull: 116 sa_writew(dev, DoorbellReg_s,DOORBELL_3); 117 break; 118 case HostShutdown: 119 /* 120 sa_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, 0, 0, 121 NULL, NULL, NULL, NULL, NULL); 122 */ 123 break; 124 case FastIo: 125 sa_writew(dev, DoorbellReg_s,DOORBELL_6); 126 break; 127 case AdapPrintfDone: 128 sa_writew(dev, DoorbellReg_s,DOORBELL_5); 129 break; 130 default: 131 BUG(); 132 break; 133 } 134 } 135 136 137 /** 138 * sa_sync_cmd - send a command and wait 139 * @dev: Adapter 140 * @command: Command to execute 141 * @p1: first parameter 142 * @ret: adapter status 143 * 144 * This routine will send a synchronous command to the adapter and wait 145 * for its completion. 146 */ 147 148 static int sa_sync_cmd(struct aac_dev *dev, u32 command, 149 u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6, 150 u32 *ret, u32 *r1, u32 *r2, u32 *r3, u32 *r4) 151 { 152 unsigned long start; 153 int ok; 154 /* 155 * Write the Command into Mailbox 0 156 */ 157 sa_writel(dev, Mailbox0, command); 158 /* 159 * Write the parameters into Mailboxes 1 - 4 160 */ 161 sa_writel(dev, Mailbox1, p1); 162 sa_writel(dev, Mailbox2, p2); 163 sa_writel(dev, Mailbox3, p3); 164 sa_writel(dev, Mailbox4, p4); 165 166 /* 167 * Clear the synch command doorbell to start on a clean slate. 168 */ 169 sa_writew(dev, DoorbellClrReg_p, DOORBELL_0); 170 /* 171 * Signal that there is a new synch command 172 */ 173 sa_writew(dev, DoorbellReg_s, DOORBELL_0); 174 175 ok = 0; 176 start = jiffies; 177 178 while(time_before(jiffies, start+30*HZ)) 179 { 180 /* 181 * Delay 5uS so that the monitor gets access 182 */ 183 udelay(5); 184 /* 185 * Mon110 will set doorbell0 bit when it has 186 * completed the command. 187 */ 188 if(sa_readw(dev, DoorbellReg_p) & DOORBELL_0) { 189 ok = 1; 190 break; 191 } 192 set_current_state(TASK_UNINTERRUPTIBLE); 193 schedule_timeout(1); 194 } 195 196 if (ok != 1) 197 return -ETIMEDOUT; 198 /* 199 * Clear the synch command doorbell. 200 */ 201 sa_writew(dev, DoorbellClrReg_p, DOORBELL_0); 202 /* 203 * Pull the synch status from Mailbox 0. 204 */ 205 if (ret) 206 *ret = sa_readl(dev, Mailbox0); 207 if (r1) 208 *r1 = sa_readl(dev, Mailbox1); 209 if (r2) 210 *r2 = sa_readl(dev, Mailbox2); 211 if (r3) 212 *r3 = sa_readl(dev, Mailbox3); 213 if (r4) 214 *r4 = sa_readl(dev, Mailbox4); 215 return 0; 216 } 217 218 /** 219 * aac_sa_interrupt_adapter - interrupt an adapter 220 * @dev: Which adapter to enable. 221 * 222 * Breakpoint an adapter. 223 */ 224 225 static void aac_sa_interrupt_adapter (struct aac_dev *dev) 226 { 227 sa_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0, 228 NULL, NULL, NULL, NULL, NULL); 229 } 230 231 /** 232 * aac_sa_start_adapter - activate adapter 233 * @dev: Adapter 234 * 235 * Start up processing on an ARM based AAC adapter 236 */ 237 238 static void aac_sa_start_adapter(struct aac_dev *dev) 239 { 240 u32 ret; 241 struct aac_init *init; 242 /* 243 * Fill in the remaining pieces of the init. 244 */ 245 init = dev->init; 246 init->HostElapsedSeconds = cpu_to_le32(get_seconds()); 247 248 /* 249 * Tell the adapter we are back and up and running so it will scan its command 250 * queues and enable our interrupts 251 */ 252 dev->irq_mask = (PrintfReady | DOORBELL_1 | DOORBELL_2 | DOORBELL_3 | DOORBELL_4); 253 /* 254 * First clear out all interrupts. Then enable the one's that 255 * we can handle. 256 */ 257 sa_writew(dev, SaDbCSR.PRISETIRQMASK, 0xffff); 258 sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, (PrintfReady | DOORBELL_1 | DOORBELL_2 | DOORBELL_3 | DOORBELL_4)); 259 /* We can only use a 32 bit address here */ 260 sa_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, 261 (u32)(ulong)dev->init_pa, 0, 0, 0, 0, 0, 262 &ret, NULL, NULL, NULL, NULL); 263 } 264 265 /** 266 * aac_sa_check_health 267 * @dev: device to check if healthy 268 * 269 * Will attempt to determine if the specified adapter is alive and 270 * capable of handling requests, returning 0 if alive. 271 */ 272 static int aac_sa_check_health(struct aac_dev *dev) 273 { 274 long status = sa_readl(dev, Mailbox7); 275 276 /* 277 * Check to see if the board failed any self tests. 278 */ 279 if (status & SELF_TEST_FAILED) 280 return -1; 281 /* 282 * Check to see if the board panic'd while booting. 283 */ 284 if (status & KERNEL_PANIC) 285 return -2; 286 /* 287 * Wait for the adapter to be up and running. Wait up to 3 minutes 288 */ 289 if (!(status & KERNEL_UP_AND_RUNNING)) 290 return -3; 291 /* 292 * Everything is OK 293 */ 294 return 0; 295 } 296 297 /** 298 * aac_sa_init - initialize an ARM based AAC card 299 * @dev: device to configure 300 * 301 * Allocate and set up resources for the ARM based AAC variants. The 302 * device_interface in the commregion will be allocated and linked 303 * to the comm region. 304 */ 305 306 int aac_sa_init(struct aac_dev *dev) 307 { 308 unsigned long start; 309 unsigned long status; 310 int instance; 311 const char *name; 312 313 instance = dev->id; 314 name = dev->name; 315 316 /* 317 * Map in the registers from the adapter. 318 */ 319 320 if((dev->regs.sa = ioremap((unsigned long)dev->scsi_host_ptr->base, 8192))==NULL) 321 { 322 printk(KERN_WARNING "aacraid: unable to map ARM.\n" ); 323 goto error_iounmap; 324 } 325 /* 326 * Check to see if the board failed any self tests. 327 */ 328 if (sa_readl(dev, Mailbox7) & SELF_TEST_FAILED) { 329 printk(KERN_WARNING "%s%d: adapter self-test failed.\n", name, instance); 330 goto error_iounmap; 331 } 332 /* 333 * Check to see if the board panic'd while booting. 334 */ 335 if (sa_readl(dev, Mailbox7) & KERNEL_PANIC) { 336 printk(KERN_WARNING "%s%d: adapter kernel panic'd.\n", name, instance); 337 goto error_iounmap; 338 } 339 start = jiffies; 340 /* 341 * Wait for the adapter to be up and running. Wait up to 3 minutes. 342 */ 343 while (!(sa_readl(dev, Mailbox7) & KERNEL_UP_AND_RUNNING)) { 344 if (time_after(jiffies, start+180*HZ)) { 345 status = sa_readl(dev, Mailbox7); 346 printk(KERN_WARNING "%s%d: adapter kernel failed to start, init status = %lx.\n", 347 name, instance, status); 348 goto error_iounmap; 349 } 350 set_current_state(TASK_UNINTERRUPTIBLE); 351 schedule_timeout(1); 352 } 353 354 if (request_irq(dev->scsi_host_ptr->irq, aac_sa_intr, SA_SHIRQ|SA_INTERRUPT, "aacraid", (void *)dev ) < 0) { 355 printk(KERN_WARNING "%s%d: Interrupt unavailable.\n", name, instance); 356 goto error_iounmap; 357 } 358 359 /* 360 * Fill in the function dispatch table. 361 */ 362 363 dev->a_ops.adapter_interrupt = aac_sa_interrupt_adapter; 364 dev->a_ops.adapter_disable_int = aac_sa_disable_interrupt; 365 dev->a_ops.adapter_notify = aac_sa_notify_adapter; 366 dev->a_ops.adapter_sync_cmd = sa_sync_cmd; 367 dev->a_ops.adapter_check_health = aac_sa_check_health; 368 369 /* 370 * First clear out all interrupts. Then enable the one's that 371 * we can handle. 372 */ 373 sa_writew(dev, SaDbCSR.PRISETIRQMASK, 0xffff); 374 sa_writew(dev, SaDbCSR.PRICLEARIRQMASK, (PrintfReady | DOORBELL_1 | 375 DOORBELL_2 | DOORBELL_3 | DOORBELL_4)); 376 377 if(aac_init_adapter(dev) == NULL) 378 goto error_irq; 379 380 /* 381 * Start any kernel threads needed 382 */ 383 dev->thread_pid = kernel_thread((int (*)(void *))aac_command_thread, dev, 0); 384 if (dev->thread_pid < 0) { 385 printk(KERN_ERR "aacraid: Unable to create command thread.\n"); 386 goto error_kfree; 387 } 388 389 /* 390 * Tell the adapter that all is configure, and it can start 391 * accepting requests 392 */ 393 aac_sa_start_adapter(dev); 394 return 0; 395 396 397 error_kfree: 398 kfree(dev->queues); 399 400 error_irq: 401 sa_writew(dev, SaDbCSR.PRISETIRQMASK, 0xffff); 402 free_irq(dev->scsi_host_ptr->irq, (void *)dev); 403 404 error_iounmap: 405 iounmap(dev->regs.sa); 406 407 return -1; 408 } 409 410