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