diff options
Diffstat (limited to 'drivers/scsi/aacraid/rkt.c')
-rw-r--r-- | drivers/scsi/aacraid/rkt.c | 446 |
1 files changed, 17 insertions, 429 deletions
diff --git a/drivers/scsi/aacraid/rkt.c b/drivers/scsi/aacraid/rkt.c index 458ea897fd72..643f23b5ded8 100644 --- a/drivers/scsi/aacraid/rkt.c +++ b/drivers/scsi/aacraid/rkt.c | |||
@@ -28,370 +28,27 @@ | |||
28 | * | 28 | * |
29 | */ | 29 | */ |
30 | 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> | 31 | #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 | 32 | ||
45 | #include <scsi/scsi_host.h> | 33 | #include <scsi/scsi_host.h> |
46 | 34 | ||
47 | #include "aacraid.h" | 35 | #include "aacraid.h" |
48 | 36 | ||
49 | static irqreturn_t aac_rkt_intr(int irq, void *dev_id, struct pt_regs *regs) | ||
50 | { | ||
51 | struct aac_dev *dev = dev_id; | ||
52 | |||
53 | if (dev->new_comm_interface) { | ||
54 | u32 Index = rkt_readl(dev, MUnit.OutboundQueue); | ||
55 | if (Index == 0xFFFFFFFFL) | ||
56 | Index = rkt_readl(dev, MUnit.OutboundQueue); | ||
57 | if (Index != 0xFFFFFFFFL) { | ||
58 | do { | ||
59 | if (aac_intr_normal(dev, Index)) { | ||
60 | rkt_writel(dev, MUnit.OutboundQueue, Index); | ||
61 | rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespReady); | ||
62 | } | ||
63 | Index = rkt_readl(dev, MUnit.OutboundQueue); | ||
64 | } while (Index != 0xFFFFFFFFL); | ||
65 | return IRQ_HANDLED; | ||
66 | } | ||
67 | } else { | ||
68 | unsigned long bellbits; | ||
69 | u8 intstat; | ||
70 | intstat = rkt_readb(dev, MUnit.OISR); | ||
71 | /* | ||
72 | * Read mask and invert because drawbridge is reversed. | ||
73 | * This allows us to only service interrupts that have | ||
74 | * been enabled. | ||
75 | * Check to see if this is our interrupt. If it isn't just return | ||
76 | */ | ||
77 | if (intstat & ~(dev->OIMR)) | ||
78 | { | ||
79 | bellbits = rkt_readl(dev, OutboundDoorbellReg); | ||
80 | if (bellbits & DoorBellPrintfReady) { | ||
81 | aac_printf(dev, rkt_readl (dev, IndexRegs.Mailbox[5])); | ||
82 | rkt_writel(dev, MUnit.ODR,DoorBellPrintfReady); | ||
83 | rkt_writel(dev, InboundDoorbellReg,DoorBellPrintfDone); | ||
84 | } | ||
85 | else if (bellbits & DoorBellAdapterNormCmdReady) { | ||
86 | rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady); | ||
87 | aac_command_normal(&dev->queues->queue[HostNormCmdQueue]); | ||
88 | // rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady); | ||
89 | } | ||
90 | else if (bellbits & DoorBellAdapterNormRespReady) { | ||
91 | rkt_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady); | ||
92 | aac_response_normal(&dev->queues->queue[HostNormRespQueue]); | ||
93 | } | ||
94 | else if (bellbits & DoorBellAdapterNormCmdNotFull) { | ||
95 | rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull); | ||
96 | } | ||
97 | else if (bellbits & DoorBellAdapterNormRespNotFull) { | ||
98 | rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull); | ||
99 | rkt_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull); | ||
100 | } | ||
101 | return IRQ_HANDLED; | ||
102 | } | ||
103 | } | ||
104 | return IRQ_NONE; | ||
105 | } | ||
106 | |||
107 | /** | ||
108 | * aac_rkt_disable_interrupt - Disable interrupts | ||
109 | * @dev: Adapter | ||
110 | */ | ||
111 | |||
112 | static void aac_rkt_disable_interrupt(struct aac_dev *dev) | ||
113 | { | ||
114 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff); | ||
115 | } | ||
116 | |||
117 | /** | 37 | /** |
118 | * rkt_sync_cmd - send a command and wait | 38 | * aac_rkt_ioremap |
119 | * @dev: Adapter | 39 | * @size: mapping resize request |
120 | * @command: Command to execute | ||
121 | * @p1: first parameter | ||
122 | * @ret: adapter status | ||
123 | * | 40 | * |
124 | * This routine will send a synchronous command to the adapter and wait | ||
125 | * for its completion. | ||
126 | */ | 41 | */ |
127 | 42 | static int aac_rkt_ioremap(struct aac_dev * dev, u32 size) | |
128 | static int rkt_sync_cmd(struct aac_dev *dev, u32 command, | ||
129 | u32 p1, u32 p2, u32 p3, u32 p4, u32 p5, u32 p6, | ||
130 | u32 *status, u32 *r1, u32 *r2, u32 *r3, u32 *r4) | ||
131 | { | 43 | { |
132 | unsigned long start; | 44 | if (!size) { |
133 | int ok; | 45 | iounmap(dev->regs.rkt); |
134 | /* | 46 | return 0; |
135 | * Write the command into Mailbox 0 | ||
136 | */ | ||
137 | rkt_writel(dev, InboundMailbox0, command); | ||
138 | /* | ||
139 | * Write the parameters into Mailboxes 1 - 6 | ||
140 | */ | ||
141 | rkt_writel(dev, InboundMailbox1, p1); | ||
142 | rkt_writel(dev, InboundMailbox2, p2); | ||
143 | rkt_writel(dev, InboundMailbox3, p3); | ||
144 | rkt_writel(dev, InboundMailbox4, p4); | ||
145 | /* | ||
146 | * Clear the synch command doorbell to start on a clean slate. | ||
147 | */ | ||
148 | rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0); | ||
149 | /* | ||
150 | * Disable doorbell interrupts | ||
151 | */ | ||
152 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff); | ||
153 | /* | ||
154 | * Force the completion of the mask register write before issuing | ||
155 | * the interrupt. | ||
156 | */ | ||
157 | rkt_readb (dev, MUnit.OIMR); | ||
158 | /* | ||
159 | * Signal that there is a new synch command | ||
160 | */ | ||
161 | rkt_writel(dev, InboundDoorbellReg, INBOUNDDOORBELL_0); | ||
162 | |||
163 | ok = 0; | ||
164 | start = jiffies; | ||
165 | |||
166 | /* | ||
167 | * Wait up to 30 seconds | ||
168 | */ | ||
169 | while (time_before(jiffies, start+30*HZ)) | ||
170 | { | ||
171 | udelay(5); /* Delay 5 microseconds to let Mon960 get info. */ | ||
172 | /* | ||
173 | * Mon960 will set doorbell0 bit when it has completed the command. | ||
174 | */ | ||
175 | if (rkt_readl(dev, OutboundDoorbellReg) & OUTBOUNDDOORBELL_0) { | ||
176 | /* | ||
177 | * Clear the doorbell. | ||
178 | */ | ||
179 | rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0); | ||
180 | ok = 1; | ||
181 | break; | ||
182 | } | ||
183 | /* | ||
184 | * Yield the processor in case we are slow | ||
185 | */ | ||
186 | msleep(1); | ||
187 | } | 47 | } |
188 | if (ok != 1) { | 48 | dev->base = dev->regs.rkt = ioremap(dev->scsi_host_ptr->base, size); |
189 | /* | 49 | if (dev->base == NULL) |
190 | * Restore interrupt mask even though we timed out | ||
191 | */ | ||
192 | if (dev->new_comm_interface) | ||
193 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7); | ||
194 | else | ||
195 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb); | ||
196 | return -ETIMEDOUT; | ||
197 | } | ||
198 | /* | ||
199 | * Pull the synch status from Mailbox 0. | ||
200 | */ | ||
201 | if (status) | ||
202 | *status = rkt_readl(dev, IndexRegs.Mailbox[0]); | ||
203 | if (r1) | ||
204 | *r1 = rkt_readl(dev, IndexRegs.Mailbox[1]); | ||
205 | if (r2) | ||
206 | *r2 = rkt_readl(dev, IndexRegs.Mailbox[2]); | ||
207 | if (r3) | ||
208 | *r3 = rkt_readl(dev, IndexRegs.Mailbox[3]); | ||
209 | if (r4) | ||
210 | *r4 = rkt_readl(dev, IndexRegs.Mailbox[4]); | ||
211 | /* | ||
212 | * Clear the synch command doorbell. | ||
213 | */ | ||
214 | rkt_writel(dev, OutboundDoorbellReg, OUTBOUNDDOORBELL_0); | ||
215 | /* | ||
216 | * Restore interrupt mask | ||
217 | */ | ||
218 | if (dev->new_comm_interface) | ||
219 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7); | ||
220 | else | ||
221 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb); | ||
222 | return 0; | ||
223 | |||
224 | } | ||
225 | |||
226 | /** | ||
227 | * aac_rkt_interrupt_adapter - interrupt adapter | ||
228 | * @dev: Adapter | ||
229 | * | ||
230 | * Send an interrupt to the i960 and breakpoint it. | ||
231 | */ | ||
232 | |||
233 | static void aac_rkt_interrupt_adapter(struct aac_dev *dev) | ||
234 | { | ||
235 | rkt_sync_cmd(dev, BREAKPOINT_REQUEST, 0, 0, 0, 0, 0, 0, | ||
236 | NULL, NULL, NULL, NULL, NULL); | ||
237 | } | ||
238 | |||
239 | /** | ||
240 | * aac_rkt_notify_adapter - send an event to the adapter | ||
241 | * @dev: Adapter | ||
242 | * @event: Event to send | ||
243 | * | ||
244 | * Notify the i960 that something it probably cares about has | ||
245 | * happened. | ||
246 | */ | ||
247 | |||
248 | static void aac_rkt_notify_adapter(struct aac_dev *dev, u32 event) | ||
249 | { | ||
250 | switch (event) { | ||
251 | |||
252 | case AdapNormCmdQue: | ||
253 | rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_1); | ||
254 | break; | ||
255 | case HostNormRespNotFull: | ||
256 | rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_4); | ||
257 | break; | ||
258 | case AdapNormRespQue: | ||
259 | rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_2); | ||
260 | break; | ||
261 | case HostNormCmdNotFull: | ||
262 | rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_3); | ||
263 | break; | ||
264 | case HostShutdown: | ||
265 | // rkt_sync_cmd(dev, HOST_CRASHING, 0, 0, 0, 0, 0, 0, | ||
266 | // NULL, NULL, NULL, NULL, NULL); | ||
267 | break; | ||
268 | case FastIo: | ||
269 | rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_6); | ||
270 | break; | ||
271 | case AdapPrintfDone: | ||
272 | rkt_writel(dev, MUnit.IDR,INBOUNDDOORBELL_5); | ||
273 | break; | ||
274 | default: | ||
275 | BUG(); | ||
276 | break; | ||
277 | } | ||
278 | } | ||
279 | |||
280 | /** | ||
281 | * aac_rkt_start_adapter - activate adapter | ||
282 | * @dev: Adapter | ||
283 | * | ||
284 | * Start up processing on an i960 based AAC adapter | ||
285 | */ | ||
286 | |||
287 | static void aac_rkt_start_adapter(struct aac_dev *dev) | ||
288 | { | ||
289 | struct aac_init *init; | ||
290 | |||
291 | init = dev->init; | ||
292 | init->HostElapsedSeconds = cpu_to_le32(get_seconds()); | ||
293 | // We can only use a 32 bit address here | ||
294 | rkt_sync_cmd(dev, INIT_STRUCT_BASE_ADDRESS, (u32)(ulong)dev->init_pa, | ||
295 | 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL); | ||
296 | } | ||
297 | |||
298 | /** | ||
299 | * aac_rkt_check_health | ||
300 | * @dev: device to check if healthy | ||
301 | * | ||
302 | * Will attempt to determine if the specified adapter is alive and | ||
303 | * capable of handling requests, returning 0 if alive. | ||
304 | */ | ||
305 | static int aac_rkt_check_health(struct aac_dev *dev) | ||
306 | { | ||
307 | u32 status = rkt_readl(dev, MUnit.OMRx[0]); | ||
308 | |||
309 | /* | ||
310 | * Check to see if the board failed any self tests. | ||
311 | */ | ||
312 | if (status & SELF_TEST_FAILED) | ||
313 | return -1; | 50 | return -1; |
314 | /* | 51 | dev->IndexRegs = &dev->regs.rkt->IndexRegs; |
315 | * Check to see if the board panic'd. | ||
316 | */ | ||
317 | if (status & KERNEL_PANIC) { | ||
318 | char * buffer; | ||
319 | struct POSTSTATUS { | ||
320 | __le32 Post_Command; | ||
321 | __le32 Post_Address; | ||
322 | } * post; | ||
323 | dma_addr_t paddr, baddr; | ||
324 | int ret; | ||
325 | |||
326 | if ((status & 0xFF000000L) == 0xBC000000L) | ||
327 | return (status >> 16) & 0xFF; | ||
328 | buffer = pci_alloc_consistent(dev->pdev, 512, &baddr); | ||
329 | ret = -2; | ||
330 | if (buffer == NULL) | ||
331 | return ret; | ||
332 | post = pci_alloc_consistent(dev->pdev, | ||
333 | sizeof(struct POSTSTATUS), &paddr); | ||
334 | if (post == NULL) { | ||
335 | pci_free_consistent(dev->pdev, 512, buffer, baddr); | ||
336 | return ret; | ||
337 | } | ||
338 | memset(buffer, 0, 512); | ||
339 | post->Post_Command = cpu_to_le32(COMMAND_POST_RESULTS); | ||
340 | post->Post_Address = cpu_to_le32(baddr); | ||
341 | rkt_writel(dev, MUnit.IMRx[0], paddr); | ||
342 | rkt_sync_cmd(dev, COMMAND_POST_RESULTS, baddr, 0, 0, 0, 0, 0, | ||
343 | NULL, NULL, NULL, NULL, NULL); | ||
344 | pci_free_consistent(dev->pdev, sizeof(struct POSTSTATUS), | ||
345 | post, paddr); | ||
346 | if ((buffer[0] == '0') && ((buffer[1] == 'x') || (buffer[1] == 'X'))) { | ||
347 | ret = (buffer[2] <= '9') ? (buffer[2] - '0') : (buffer[2] - 'A' + 10); | ||
348 | ret <<= 4; | ||
349 | ret += (buffer[3] <= '9') ? (buffer[3] - '0') : (buffer[3] - 'A' + 10); | ||
350 | } | ||
351 | pci_free_consistent(dev->pdev, 512, buffer, baddr); | ||
352 | return ret; | ||
353 | } | ||
354 | /* | ||
355 | * Wait for the adapter to be up and running. | ||
356 | */ | ||
357 | if (!(status & KERNEL_UP_AND_RUNNING)) | ||
358 | return -3; | ||
359 | /* | ||
360 | * Everything is OK | ||
361 | */ | ||
362 | return 0; | ||
363 | } | ||
364 | |||
365 | /** | ||
366 | * aac_rkt_send | ||
367 | * @fib: fib to issue | ||
368 | * | ||
369 | * Will send a fib, returning 0 if successful. | ||
370 | */ | ||
371 | static int aac_rkt_send(struct fib * fib) | ||
372 | { | ||
373 | u64 addr = fib->hw_fib_pa; | ||
374 | struct aac_dev *dev = fib->dev; | ||
375 | volatile void __iomem *device = dev->regs.rkt; | ||
376 | u32 Index; | ||
377 | |||
378 | dprintk((KERN_DEBUG "%p->aac_rkt_send(%p->%llx)\n", dev, fib, addr)); | ||
379 | Index = rkt_readl(dev, MUnit.InboundQueue); | ||
380 | if (Index == 0xFFFFFFFFL) | ||
381 | Index = rkt_readl(dev, MUnit.InboundQueue); | ||
382 | dprintk((KERN_DEBUG "Index = 0x%x\n", Index)); | ||
383 | if (Index == 0xFFFFFFFFL) | ||
384 | return Index; | ||
385 | device += Index; | ||
386 | dprintk((KERN_DEBUG "entry = %x %x %u\n", (u32)(addr & 0xffffffff), | ||
387 | (u32)(addr >> 32), (u32)le16_to_cpu(fib->hw_fib->header.Size))); | ||
388 | writel((u32)(addr & 0xffffffff), device); | ||
389 | device += sizeof(u32); | ||
390 | writel((u32)(addr >> 32), device); | ||
391 | device += sizeof(u32); | ||
392 | writel(le16_to_cpu(fib->hw_fib->header.Size), device); | ||
393 | rkt_writel(dev, MUnit.InboundQueue, Index); | ||
394 | dprintk((KERN_DEBUG "aac_rkt_send - return 0\n")); | ||
395 | return 0; | 52 | return 0; |
396 | } | 53 | } |
397 | 54 | ||
@@ -406,78 +63,18 @@ static int aac_rkt_send(struct fib * fib) | |||
406 | 63 | ||
407 | int aac_rkt_init(struct aac_dev *dev) | 64 | int aac_rkt_init(struct aac_dev *dev) |
408 | { | 65 | { |
409 | unsigned long start; | 66 | int retval; |
410 | unsigned long status; | 67 | extern int _aac_rx_init(struct aac_dev *dev); |
411 | int instance; | 68 | extern void aac_rx_start_adapter(struct aac_dev *dev); |
412 | const char * name; | ||
413 | |||
414 | instance = dev->id; | ||
415 | name = dev->name; | ||
416 | 69 | ||
417 | /* | 70 | /* |
418 | * Check to see if the board panic'd while booting. | ||
419 | */ | ||
420 | /* | ||
421 | * Check to see if the board failed any self tests. | ||
422 | */ | ||
423 | if (rkt_readl(dev, MUnit.OMRx[0]) & SELF_TEST_FAILED) { | ||
424 | printk(KERN_ERR "%s%d: adapter self-test failed.\n", dev->name, instance); | ||
425 | goto error_iounmap; | ||
426 | } | ||
427 | /* | ||
428 | * Check to see if the monitor panic'd while booting. | ||
429 | */ | ||
430 | if (rkt_readl(dev, MUnit.OMRx[0]) & MONITOR_PANIC) { | ||
431 | printk(KERN_ERR "%s%d: adapter monitor panic.\n", dev->name, instance); | ||
432 | goto error_iounmap; | ||
433 | } | ||
434 | /* | ||
435 | * Check to see if the board panic'd while booting. | ||
436 | */ | ||
437 | if (rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_PANIC) { | ||
438 | printk(KERN_ERR "%s%d: adapter kernel panic'd.\n", dev->name, instance); | ||
439 | goto error_iounmap; | ||
440 | } | ||
441 | start = jiffies; | ||
442 | /* | ||
443 | * Wait for the adapter to be up and running. Wait up to 3 minutes | ||
444 | */ | ||
445 | while (!(rkt_readl(dev, MUnit.OMRx[0]) & KERNEL_UP_AND_RUNNING)) | ||
446 | { | ||
447 | if(time_after(jiffies, start+startup_timeout*HZ)) | ||
448 | { | ||
449 | status = rkt_readl(dev, MUnit.OMRx[0]); | ||
450 | printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n", | ||
451 | dev->name, instance, status); | ||
452 | goto error_iounmap; | ||
453 | } | ||
454 | msleep(1); | ||
455 | } | ||
456 | if (request_irq(dev->scsi_host_ptr->irq, aac_rkt_intr, IRQF_SHARED|IRQF_DISABLED, "aacraid", (void *)dev)<0) | ||
457 | { | ||
458 | printk(KERN_ERR "%s%d: Interrupt unavailable.\n", name, instance); | ||
459 | goto error_iounmap; | ||
460 | } | ||
461 | /* | ||
462 | * Fill in the function dispatch table. | 71 | * Fill in the function dispatch table. |
463 | */ | 72 | */ |
464 | dev->a_ops.adapter_interrupt = aac_rkt_interrupt_adapter; | 73 | dev->a_ops.adapter_ioremap = aac_rkt_ioremap; |
465 | dev->a_ops.adapter_disable_int = aac_rkt_disable_interrupt; | ||
466 | dev->a_ops.adapter_notify = aac_rkt_notify_adapter; | ||
467 | dev->a_ops.adapter_sync_cmd = rkt_sync_cmd; | ||
468 | dev->a_ops.adapter_check_health = aac_rkt_check_health; | ||
469 | dev->a_ops.adapter_send = aac_rkt_send; | ||
470 | |||
471 | /* | ||
472 | * First clear out all interrupts. Then enable the one's that we | ||
473 | * can handle. | ||
474 | */ | ||
475 | rkt_writeb(dev, MUnit.OIMR, 0xff); | ||
476 | rkt_writel(dev, MUnit.ODR, 0xffffffff); | ||
477 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb); | ||
478 | 74 | ||
479 | if (aac_init_adapter(dev) == NULL) | 75 | retval = _aac_rx_init(dev); |
480 | goto error_irq; | 76 | if (retval) |
77 | return retval; | ||
481 | if (dev->new_comm_interface) { | 78 | if (dev->new_comm_interface) { |
482 | /* | 79 | /* |
483 | * FIB Setup has already been done, but we can minimize the | 80 | * FIB Setup has already been done, but we can minimize the |
@@ -494,20 +91,11 @@ int aac_rkt_init(struct aac_dev *dev) | |||
494 | dev->init->MaxIoCommands = cpu_to_le32(246); | 91 | dev->init->MaxIoCommands = cpu_to_le32(246); |
495 | dev->scsi_host_ptr->can_queue = 246 - AAC_NUM_MGT_FIB; | 92 | dev->scsi_host_ptr->can_queue = 246 - AAC_NUM_MGT_FIB; |
496 | } | 93 | } |
497 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7); | ||
498 | } | 94 | } |
499 | /* | 95 | /* |
500 | * Tell the adapter that all is configured, and it can start | 96 | * Tell the adapter that all is configured, and it can start |
501 | * accepting requests | 97 | * accepting requests |
502 | */ | 98 | */ |
503 | aac_rkt_start_adapter(dev); | 99 | aac_rx_start_adapter(dev); |
504 | return 0; | 100 | return 0; |
505 | |||
506 | error_irq: | ||
507 | rkt_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff); | ||
508 | free_irq(dev->scsi_host_ptr->irq, (void *)dev); | ||
509 | |||
510 | error_iounmap: | ||
511 | |||
512 | return -1; | ||
513 | } | 101 | } |