1/* 2 * Adaptec AAC series RAID controller driver 3 * (c) Copyright 2001 Red Hat Inc. 4 * 5 * based on the old aacraid driver that is.. 6 * Adaptec aacraid device driver for Linux. 7 * 8 * Copyright (c) 2000-2007 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 * dpcsup.c 26 * 27 * Abstract: All DPC processing routines for the cyclone board occur here. 28 * 29 * 30 */ 31 32#include <linux/kernel.h> 33#include <linux/init.h> 34#include <linux/types.h> 35#include <linux/spinlock.h> 36#include <linux/slab.h> 37#include <linux/completion.h> 38#include <linux/blkdev.h> 39#include <linux/semaphore.h> 40 41#include "aacraid.h" 42 43/** 44 * aac_response_normal - Handle command replies 45 * @q: Queue to read from 46 * 47 * This DPC routine will be run when the adapter interrupts us to let us 48 * know there is a response on our normal priority queue. We will pull off 49 * all QE there are and wake up all the waiters before exiting. We will 50 * take a spinlock out on the queue before operating on it. 51 */ 52 53unsigned int aac_response_normal(struct aac_queue * q) 54{ 55 struct aac_dev * dev = q->dev; 56 struct aac_entry *entry; 57 struct hw_fib * hwfib; 58 struct fib * fib; 59 int consumed = 0; 60 unsigned long flags, mflags; 61 62 spin_lock_irqsave(q->lock, flags); 63 /* 64 * Keep pulling response QEs off the response queue and waking 65 * up the waiters until there are no more QEs. We then return 66 * back to the system. If no response was requesed we just 67 * deallocate the Fib here and continue. 68 */ 69 while(aac_consumer_get(dev, q, &entry)) 70 { 71 int fast; 72 u32 index = le32_to_cpu(entry->addr); 73 fast = index & 0x01; 74 fib = &dev->fibs[index >> 2]; 75 hwfib = fib->hw_fib_va; 76 77 aac_consumer_free(dev, q, HostNormRespQueue); 78 /* 79 * Remove this fib from the Outstanding I/O queue. 80 * But only if it has not already been timed out. 81 * 82 * If the fib has been timed out already, then just 83 * continue. The caller has already been notified that 84 * the fib timed out. 85 */ 86 dev->queues->queue[AdapNormCmdQueue].numpending--; 87 88 if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) { 89 spin_unlock_irqrestore(q->lock, flags); 90 aac_fib_complete(fib); 91 aac_fib_free(fib); 92 spin_lock_irqsave(q->lock, flags); 93 continue; 94 } 95 spin_unlock_irqrestore(q->lock, flags); 96 97 if (fast) { 98 /* 99 * Doctor the fib 100 */ 101 *(__le32 *)hwfib->data = cpu_to_le32(ST_OK); 102 hwfib->header.XferState |= cpu_to_le32(AdapterProcessed); 103 } 104 105 FIB_COUNTER_INCREMENT(aac_config.FibRecved); 106 107 if (hwfib->header.Command == cpu_to_le16(NuFileSystem)) 108 { 109 __le32 *pstatus = (__le32 *)hwfib->data; 110 if (*pstatus & cpu_to_le32(0xffff0000)) 111 *pstatus = cpu_to_le32(ST_OK); 112 } 113 if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected | Async)) 114 { 115 if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected)) 116 FIB_COUNTER_INCREMENT(aac_config.NoResponseRecved); 117 else 118 FIB_COUNTER_INCREMENT(aac_config.AsyncRecved); 119 /* 120 * NOTE: we cannot touch the fib after this 121 * call, because it may have been deallocated. 122 */ 123 fib->flags = 0; 124 fib->callback(fib->callback_data, fib); 125 } else { 126 unsigned long flagv; 127 spin_lock_irqsave(&fib->event_lock, flagv); 128 if (!fib->done) { 129 fib->done = 1; 130 up(&fib->event_wait); 131 } 132 spin_unlock_irqrestore(&fib->event_lock, flagv); 133 134 spin_lock_irqsave(&dev->manage_lock, mflags); 135 dev->management_fib_count--; 136 spin_unlock_irqrestore(&dev->manage_lock, mflags); 137 138 FIB_COUNTER_INCREMENT(aac_config.NormalRecved); 139 if (fib->done == 2) { 140 spin_lock_irqsave(&fib->event_lock, flagv); 141 fib->done = 0; 142 spin_unlock_irqrestore(&fib->event_lock, flagv); 143 aac_fib_complete(fib); 144 aac_fib_free(fib); 145 } 146 } 147 consumed++; 148 spin_lock_irqsave(q->lock, flags); 149 } 150 151 if (consumed > aac_config.peak_fibs) 152 aac_config.peak_fibs = consumed; 153 if (consumed == 0) 154 aac_config.zero_fibs++; 155 156 spin_unlock_irqrestore(q->lock, flags); 157 return 0; 158} 159 160 161/** 162 * aac_command_normal - handle commands 163 * @q: queue to process 164 * 165 * This DPC routine will be queued when the adapter interrupts us to 166 * let us know there is a command on our normal priority queue. We will 167 * pull off all QE there are and wake up all the waiters before exiting. 168 * We will take a spinlock out on the queue before operating on it. 169 */ 170 171unsigned int aac_command_normal(struct aac_queue *q) 172{ 173 struct aac_dev * dev = q->dev; 174 struct aac_entry *entry; 175 unsigned long flags; 176 177 spin_lock_irqsave(q->lock, flags); 178 179 /* 180 * Keep pulling response QEs off the response queue and waking 181 * up the waiters until there are no more QEs. We then return 182 * back to the system. 183 */ 184 while(aac_consumer_get(dev, q, &entry)) 185 { 186 struct fib fibctx; 187 struct hw_fib * hw_fib; 188 u32 index; 189 struct fib *fib = &fibctx; 190 191 index = le32_to_cpu(entry->addr) / sizeof(struct hw_fib); 192 hw_fib = &dev->aif_base_va[index]; 193 194 /* 195 * Allocate a FIB at all costs. For non queued stuff 196 * we can just use the stack so we are happy. We need 197 * a fib object in order to manage the linked lists 198 */ 199 if (dev->aif_thread) 200 if((fib = kmalloc(sizeof(struct fib), GFP_ATOMIC)) == NULL) 201 fib = &fibctx; 202 203 memset(fib, 0, sizeof(struct fib)); 204 INIT_LIST_HEAD(&fib->fiblink); 205 fib->type = FSAFS_NTC_FIB_CONTEXT; 206 fib->size = sizeof(struct fib); 207 fib->hw_fib_va = hw_fib; 208 fib->data = hw_fib->data; 209 fib->dev = dev; 210 211 212 if (dev->aif_thread && fib != &fibctx) { 213 list_add_tail(&fib->fiblink, &q->cmdq); 214 aac_consumer_free(dev, q, HostNormCmdQueue); 215 wake_up_interruptible(&q->cmdready); 216 } else { 217 aac_consumer_free(dev, q, HostNormCmdQueue); 218 spin_unlock_irqrestore(q->lock, flags); 219 /* 220 * Set the status of this FIB 221 */ 222 *(__le32 *)hw_fib->data = cpu_to_le32(ST_OK); 223 aac_fib_adapter_complete(fib, sizeof(u32)); 224 spin_lock_irqsave(q->lock, flags); 225 } 226 } 227 spin_unlock_irqrestore(q->lock, flags); 228 return 0; 229} 230 231 232/** 233 * aac_intr_normal - Handle command replies 234 * @dev: Device 235 * @index: completion reference 236 * 237 * This DPC routine will be run when the adapter interrupts us to let us 238 * know there is a response on our normal priority queue. We will pull off 239 * all QE there are and wake up all the waiters before exiting. 240 */ 241 242unsigned int aac_intr_normal(struct aac_dev * dev, u32 index) 243{ 244 unsigned long mflags; 245 dprintk((KERN_INFO "aac_intr_normal(%p,%x)\n", dev, index)); 246 if ((index & 0x00000002L)) { 247 struct hw_fib * hw_fib; 248 struct fib * fib; 249 struct aac_queue *q = &dev->queues->queue[HostNormCmdQueue]; 250 unsigned long flags; 251 252 if (index == 0xFFFFFFFEL) /* Special Case */ 253 return 0; /* Do nothing */ 254 /* 255 * Allocate a FIB. For non queued stuff we can just use 256 * the stack so we are happy. We need a fib object in order to 257 * manage the linked lists. 258 */ 259 if ((!dev->aif_thread) 260 || (!(fib = kzalloc(sizeof(struct fib),GFP_ATOMIC)))) 261 return 1; 262 if (!(hw_fib = kzalloc(sizeof(struct hw_fib),GFP_ATOMIC))) { 263 kfree (fib); 264 return 1; 265 } 266 memcpy(hw_fib, (struct hw_fib *)(((uintptr_t)(dev->regs.sa)) + 267 (index & ~0x00000002L)), sizeof(struct hw_fib)); 268 INIT_LIST_HEAD(&fib->fiblink); 269 fib->type = FSAFS_NTC_FIB_CONTEXT; 270 fib->size = sizeof(struct fib); 271 fib->hw_fib_va = hw_fib; 272 fib->data = hw_fib->data; 273 fib->dev = dev; 274 275 spin_lock_irqsave(q->lock, flags); 276 list_add_tail(&fib->fiblink, &q->cmdq); 277 wake_up_interruptible(&q->cmdready); 278 spin_unlock_irqrestore(q->lock, flags); 279 return 1; 280 } else { 281 int fast = index & 0x01; 282 struct fib * fib = &dev->fibs[index >> 2]; 283 struct hw_fib * hwfib = fib->hw_fib_va; 284 285 /* 286 * Remove this fib from the Outstanding I/O queue. 287 * But only if it has not already been timed out. 288 * 289 * If the fib has been timed out already, then just 290 * continue. The caller has already been notified that 291 * the fib timed out. 292 */ 293 dev->queues->queue[AdapNormCmdQueue].numpending--; 294 295 if (unlikely(fib->flags & FIB_CONTEXT_FLAG_TIMED_OUT)) { 296 aac_fib_complete(fib); 297 aac_fib_free(fib); 298 return 0; 299 } 300 301 if (fast) { 302 /* 303 * Doctor the fib 304 */ 305 *(__le32 *)hwfib->data = cpu_to_le32(ST_OK); 306 hwfib->header.XferState |= cpu_to_le32(AdapterProcessed); 307 } 308 309 FIB_COUNTER_INCREMENT(aac_config.FibRecved); 310 311 if (hwfib->header.Command == cpu_to_le16(NuFileSystem)) 312 { 313 __le32 *pstatus = (__le32 *)hwfib->data; 314 if (*pstatus & cpu_to_le32(0xffff0000)) 315 *pstatus = cpu_to_le32(ST_OK); 316 } 317 if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected | Async)) 318 { 319 if (hwfib->header.XferState & cpu_to_le32(NoResponseExpected)) 320 FIB_COUNTER_INCREMENT(aac_config.NoResponseRecved); 321 else 322 FIB_COUNTER_INCREMENT(aac_config.AsyncRecved); 323 /* 324 * NOTE: we cannot touch the fib after this 325 * call, because it may have been deallocated. 326 */ 327 fib->flags = 0; 328 fib->callback(fib->callback_data, fib); 329 } else { 330 unsigned long flagv; 331 dprintk((KERN_INFO "event_wait up\n")); 332 spin_lock_irqsave(&fib->event_lock, flagv); 333 if (!fib->done) { 334 fib->done = 1; 335 up(&fib->event_wait); 336 } 337 spin_unlock_irqrestore(&fib->event_lock, flagv); 338 339 spin_lock_irqsave(&dev->manage_lock, mflags); 340 dev->management_fib_count--; 341 spin_unlock_irqrestore(&dev->manage_lock, mflags); 342 343 FIB_COUNTER_INCREMENT(aac_config.NormalRecved); 344 if (fib->done == 2) { 345 spin_lock_irqsave(&fib->event_lock, flagv); 346 fib->done = 0; 347 spin_unlock_irqrestore(&fib->event_lock, flagv); 348 aac_fib_complete(fib); 349 aac_fib_free(fib); 350 } 351 352 } 353 return 0; 354 } 355} 356