fs: fix superblock iteration race
[sfrench/cifs-2.6.git] / drivers / block / cpqarray.c
1 /*
2  *    Disk Array driver for Compaq SMART2 Controllers
3  *    Copyright 1998 Compaq Computer Corporation
4  *
5  *    This program is free software; you can redistribute it and/or modify
6  *    it under the terms of the GNU General Public License as published by
7  *    the Free Software Foundation; either version 2 of the License, or
8  *    (at your option) any later version.
9  *
10  *    This program is distributed in the hope that it will be useful,
11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
13  *    NON INFRINGEMENT.  See the GNU General Public License for more details.
14  *
15  *    You should have received a copy of the GNU General Public License
16  *    along with this program; if not, write to the Free Software
17  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  *    Questions/Comments/Bugfixes to iss_storagedev@hp.com
20  *
21  */
22 #include <linux/module.h>
23 #include <linux/types.h>
24 #include <linux/pci.h>
25 #include <linux/bio.h>
26 #include <linux/interrupt.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/delay.h>
30 #include <linux/major.h>
31 #include <linux/fs.h>
32 #include <linux/blkpg.h>
33 #include <linux/timer.h>
34 #include <linux/proc_fs.h>
35 #include <linux/seq_file.h>
36 #include <linux/init.h>
37 #include <linux/hdreg.h>
38 #include <linux/spinlock.h>
39 #include <linux/blkdev.h>
40 #include <linux/genhd.h>
41 #include <linux/scatterlist.h>
42 #include <asm/uaccess.h>
43 #include <asm/io.h>
44
45
46 #define SMART2_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
47
48 #define DRIVER_NAME "Compaq SMART2 Driver (v 2.6.0)"
49 #define DRIVER_VERSION SMART2_DRIVER_VERSION(2,6,0)
50
51 /* Embedded module documentation macros - see modules.h */
52 /* Original author Chris Frantz - Compaq Computer Corporation */
53 MODULE_AUTHOR("Compaq Computer Corporation");
54 MODULE_DESCRIPTION("Driver for Compaq Smart2 Array Controllers version 2.6.0");
55 MODULE_LICENSE("GPL");
56
57 #include "cpqarray.h"
58 #include "ida_cmd.h"
59 #include "smart1,2.h"
60 #include "ida_ioctl.h"
61
62 #define READ_AHEAD      128
63 #define NR_CMDS         128 /* This could probably go as high as ~400 */
64
65 #define MAX_CTLR        8
66 #define CTLR_SHIFT      8
67
68 #define CPQARRAY_DMA_MASK       0xFFFFFFFF      /* 32 bit DMA */
69
70 static int nr_ctlr;
71 static ctlr_info_t *hba[MAX_CTLR];
72
73 static int eisa[8];
74
75 #define NR_PRODUCTS ARRAY_SIZE(products)
76
77 /*  board_id = Subsystem Device ID & Vendor ID
78  *  product = Marketing Name for the board
79  *  access = Address of the struct of function pointers
80  */
81 static struct board_type products[] = {
82         { 0x0040110E, "IDA",                    &smart1_access },
83         { 0x0140110E, "IDA-2",                  &smart1_access },
84         { 0x1040110E, "IAES",                   &smart1_access },
85         { 0x2040110E, "SMART",                  &smart1_access },
86         { 0x3040110E, "SMART-2/E",              &smart2e_access },
87         { 0x40300E11, "SMART-2/P",              &smart2_access },
88         { 0x40310E11, "SMART-2SL",              &smart2_access },
89         { 0x40320E11, "Smart Array 3200",       &smart2_access },
90         { 0x40330E11, "Smart Array 3100ES",     &smart2_access },
91         { 0x40340E11, "Smart Array 221",        &smart2_access },
92         { 0x40400E11, "Integrated Array",       &smart4_access },
93         { 0x40480E11, "Compaq Raid LC2",        &smart4_access },
94         { 0x40500E11, "Smart Array 4200",       &smart4_access },
95         { 0x40510E11, "Smart Array 4250ES",     &smart4_access },
96         { 0x40580E11, "Smart Array 431",        &smart4_access },
97 };
98
99 /* define the PCI info for the PCI cards this driver can control */
100 static const struct pci_device_id cpqarray_pci_device_id[] =
101 {
102         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_COMPAQ_42XX,
103                 0x0E11, 0x4058, 0, 0, 0},       /* SA431 */
104         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_COMPAQ_42XX,
105                 0x0E11, 0x4051, 0, 0, 0},      /* SA4250ES */
106         { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_COMPAQ_42XX,
107                 0x0E11, 0x4050, 0, 0, 0},      /* SA4200 */
108         { PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C1510,
109                 0x0E11, 0x4048, 0, 0, 0},       /* LC2 */
110         { PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C1510,
111                 0x0E11, 0x4040, 0, 0, 0},      /* Integrated Array */
112         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
113                 0x0E11, 0x4034, 0, 0, 0},       /* SA 221 */
114         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
115                 0x0E11, 0x4033, 0, 0, 0},       /* SA 3100ES*/
116         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
117                 0x0E11, 0x4032, 0, 0, 0},       /* SA 3200*/
118         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
119                 0x0E11, 0x4031, 0, 0, 0},       /* SA 2SL*/
120         { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
121                 0x0E11, 0x4030, 0, 0, 0},       /* SA 2P */
122         { 0 }
123 };
124
125 MODULE_DEVICE_TABLE(pci, cpqarray_pci_device_id);
126
127 static struct gendisk *ida_gendisk[MAX_CTLR][NWD];
128
129 /* Debug... */
130 #define DBG(s)  do { s } while(0)
131 /* Debug (general info)... */
132 #define DBGINFO(s) do { } while(0)
133 /* Debug Paranoid... */
134 #define DBGP(s)  do { } while(0)
135 /* Debug Extra Paranoid... */
136 #define DBGPX(s) do { } while(0)
137
138 static int cpqarray_pci_init(ctlr_info_t *c, struct pci_dev *pdev);
139 static void __iomem *remap_pci_mem(ulong base, ulong size);
140 static int cpqarray_eisa_detect(void);
141 static int pollcomplete(int ctlr);
142 static void getgeometry(int ctlr);
143 static void start_fwbk(int ctlr);
144
145 static cmdlist_t * cmd_alloc(ctlr_info_t *h, int get_from_pool);
146 static void cmd_free(ctlr_info_t *h, cmdlist_t *c, int got_from_pool);
147
148 static void free_hba(int i);
149 static int alloc_cpqarray_hba(void);
150
151 static int sendcmd(
152         __u8    cmd,
153         int     ctlr,
154         void    *buff,
155         size_t  size,
156         unsigned int blk,
157         unsigned int blkcnt,
158         unsigned int log_unit );
159
160 static int ida_open(struct block_device *bdev, fmode_t mode);
161 static int ida_release(struct gendisk *disk, fmode_t mode);
162 static int ida_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg);
163 static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo);
164 static int ida_ctlr_ioctl(ctlr_info_t *h, int dsk, ida_ioctl_t *io);
165
166 static void do_ida_request(struct request_queue *q);
167 static void start_io(ctlr_info_t *h);
168
169 static inline void addQ(cmdlist_t **Qptr, cmdlist_t *c);
170 static inline cmdlist_t *removeQ(cmdlist_t **Qptr, cmdlist_t *c);
171 static inline void complete_command(cmdlist_t *cmd, int timeout);
172
173 static irqreturn_t do_ida_intr(int irq, void *dev_id);
174 static void ida_timer(unsigned long tdata);
175 static int ida_revalidate(struct gendisk *disk);
176 static int revalidate_allvol(ctlr_info_t *host);
177 static int cpqarray_register_ctlr(int ctlr, struct pci_dev *pdev);
178
179 #ifdef CONFIG_PROC_FS
180 static void ida_procinit(int i);
181 #else
182 static void ida_procinit(int i) {}
183 #endif
184
185 static inline drv_info_t *get_drv(struct gendisk *disk)
186 {
187         return disk->private_data;
188 }
189
190 static inline ctlr_info_t *get_host(struct gendisk *disk)
191 {
192         return disk->queue->queuedata;
193 }
194
195
196 static const struct block_device_operations ida_fops  = {
197         .owner          = THIS_MODULE,
198         .open           = ida_open,
199         .release        = ida_release,
200         .locked_ioctl   = ida_ioctl,
201         .getgeo         = ida_getgeo,
202         .revalidate_disk= ida_revalidate,
203 };
204
205
206 #ifdef CONFIG_PROC_FS
207
208 static struct proc_dir_entry *proc_array;
209 static const struct file_operations ida_proc_fops;
210
211 /*
212  * Get us a file in /proc/array that says something about each controller.
213  * Create /proc/array if it doesn't exist yet.
214  */
215 static void __init ida_procinit(int i)
216 {
217         if (proc_array == NULL) {
218                 proc_array = proc_mkdir("driver/cpqarray", NULL);
219                 if (!proc_array) return;
220         }
221
222         proc_create_data(hba[i]->devname, 0, proc_array, &ida_proc_fops, hba[i]);
223 }
224
225 /*
226  * Report information about this controller.
227  */
228 static int ida_proc_show(struct seq_file *m, void *v)
229 {
230         int i, ctlr;
231         ctlr_info_t *h = (ctlr_info_t*)m->private;
232         drv_info_t *drv;
233 #ifdef CPQ_PROC_PRINT_QUEUES
234         cmdlist_t *c;
235         unsigned long flags;
236 #endif
237
238         ctlr = h->ctlr;
239         seq_printf(m, "%s:  Compaq %s Controller\n"
240                 "       Board ID: 0x%08lx\n"
241                 "       Firmware Revision: %c%c%c%c\n"
242                 "       Controller Sig: 0x%08lx\n"
243                 "       Memory Address: 0x%08lx\n"
244                 "       I/O Port: 0x%04x\n"
245                 "       IRQ: %d\n"
246                 "       Logical drives: %d\n"
247                 "       Physical drives: %d\n\n"
248                 "       Current Q depth: %d\n"
249                 "       Max Q depth since init: %d\n\n",
250                 h->devname, 
251                 h->product_name,
252                 (unsigned long)h->board_id,
253                 h->firm_rev[0], h->firm_rev[1], h->firm_rev[2], h->firm_rev[3],
254                 (unsigned long)h->ctlr_sig, (unsigned long)h->vaddr,
255                 (unsigned int) h->io_mem_addr, (unsigned int)h->intr,
256                 h->log_drives, h->phys_drives,
257                 h->Qdepth, h->maxQsinceinit);
258
259         seq_puts(m, "Logical Drive Info:\n");
260
261         for(i=0; i<h->log_drives; i++) {
262                 drv = &h->drv[i];
263                 seq_printf(m, "ida/c%dd%d: blksz=%d nr_blks=%d\n",
264                                 ctlr, i, drv->blk_size, drv->nr_blks);
265         }
266
267 #ifdef CPQ_PROC_PRINT_QUEUES
268         spin_lock_irqsave(IDA_LOCK(h->ctlr), flags); 
269         seq_puts(m, "\nCurrent Queues:\n");
270
271         c = h->reqQ;
272         seq_printf(m, "reqQ = %p", c);
273         if (c) c=c->next;
274         while(c && c != h->reqQ) {
275                 seq_printf(m, "->%p", c);
276                 c=c->next;
277         }
278
279         c = h->cmpQ;
280         seq_printf(m, "\ncmpQ = %p", c);
281         if (c) c=c->next;
282         while(c && c != h->cmpQ) {
283                 seq_printf(m, "->%p", c);
284                 c=c->next;
285         }
286
287         seq_putc(m, '\n');
288         spin_unlock_irqrestore(IDA_LOCK(h->ctlr), flags); 
289 #endif
290         seq_printf(m, "nr_allocs = %d\nnr_frees = %d\n",
291                         h->nr_allocs, h->nr_frees);
292         return 0;
293 }
294
295 static int ida_proc_open(struct inode *inode, struct file *file)
296 {
297         return single_open(file, ida_proc_show, PDE(inode)->data);
298 }
299
300 static const struct file_operations ida_proc_fops = {
301         .owner          = THIS_MODULE,
302         .open           = ida_proc_open,
303         .read           = seq_read,
304         .llseek         = seq_lseek,
305         .release        = single_release,
306 };
307 #endif /* CONFIG_PROC_FS */
308
309 module_param_array(eisa, int, NULL, 0);
310
311 static void release_io_mem(ctlr_info_t *c)
312 {
313         /* if IO mem was not protected do nothing */
314         if( c->io_mem_addr == 0)
315                 return;
316         release_region(c->io_mem_addr, c->io_mem_length);
317         c->io_mem_addr = 0;
318         c->io_mem_length = 0;
319 }
320
321 static void __devexit cpqarray_remove_one(int i)
322 {
323         int j;
324         char buff[4];
325
326         /* sendcmd will turn off interrupt, and send the flush...
327          * To write all data in the battery backed cache to disks
328          * no data returned, but don't want to send NULL to sendcmd */
329         if( sendcmd(FLUSH_CACHE, i, buff, 4, 0, 0, 0))
330         {
331                 printk(KERN_WARNING "Unable to flush cache on controller %d\n",
332                                 i);
333         }
334         free_irq(hba[i]->intr, hba[i]);
335         iounmap(hba[i]->vaddr);
336         unregister_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname);
337         del_timer(&hba[i]->timer);
338         remove_proc_entry(hba[i]->devname, proc_array);
339         pci_free_consistent(hba[i]->pci_dev,
340                         NR_CMDS * sizeof(cmdlist_t), (hba[i]->cmd_pool),
341                         hba[i]->cmd_pool_dhandle);
342         kfree(hba[i]->cmd_pool_bits);
343         for(j = 0; j < NWD; j++) {
344                 if (ida_gendisk[i][j]->flags & GENHD_FL_UP)
345                         del_gendisk(ida_gendisk[i][j]);
346                 put_disk(ida_gendisk[i][j]);
347         }
348         blk_cleanup_queue(hba[i]->queue);
349         release_io_mem(hba[i]);
350         free_hba(i);
351 }
352
353 static void __devexit cpqarray_remove_one_pci (struct pci_dev *pdev)
354 {
355         int i;
356         ctlr_info_t *tmp_ptr;
357
358         if (pci_get_drvdata(pdev) == NULL) {
359                 printk( KERN_ERR "cpqarray: Unable to remove device \n");
360                 return;
361         }
362
363         tmp_ptr = pci_get_drvdata(pdev);
364         i = tmp_ptr->ctlr;
365         if (hba[i] == NULL) {
366                 printk(KERN_ERR "cpqarray: controller %d appears to have"
367                         "already been removed \n", i);
368                 return;
369         }
370         pci_set_drvdata(pdev, NULL);
371
372         cpqarray_remove_one(i);
373 }
374
375 /* removing an instance that was not removed automatically..
376  * must be an eisa card.
377  */
378 static void __devexit cpqarray_remove_one_eisa (int i)
379 {
380         if (hba[i] == NULL) {
381                 printk(KERN_ERR "cpqarray: controller %d appears to have"
382                         "already been removed \n", i);
383                 return;
384         }
385         cpqarray_remove_one(i);
386 }
387
388 /* pdev is NULL for eisa */
389 static int __init cpqarray_register_ctlr( int i, struct pci_dev *pdev)
390 {
391         struct request_queue *q;
392         int j;
393
394         /* 
395          * register block devices
396          * Find disks and fill in structs
397          * Get an interrupt, set the Q depth and get into /proc
398          */
399
400         /* If this successful it should insure that we are the only */
401         /* instance of the driver */
402         if (register_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname)) {
403                 goto Enomem4;
404         }
405         hba[i]->access.set_intr_mask(hba[i], 0);
406         if (request_irq(hba[i]->intr, do_ida_intr,
407                 IRQF_DISABLED|IRQF_SHARED, hba[i]->devname, hba[i]))
408         {
409                 printk(KERN_ERR "cpqarray: Unable to get irq %d for %s\n",
410                                 hba[i]->intr, hba[i]->devname);
411                 goto Enomem3;
412         }
413                 
414         for (j=0; j<NWD; j++) {
415                 ida_gendisk[i][j] = alloc_disk(1 << NWD_SHIFT);
416                 if (!ida_gendisk[i][j])
417                         goto Enomem2;
418         }
419
420         hba[i]->cmd_pool = pci_alloc_consistent(
421                 hba[i]->pci_dev, NR_CMDS * sizeof(cmdlist_t),
422                 &(hba[i]->cmd_pool_dhandle));
423         hba[i]->cmd_pool_bits = kcalloc(
424                 DIV_ROUND_UP(NR_CMDS, BITS_PER_LONG), sizeof(unsigned long),
425                 GFP_KERNEL);
426
427         if (!hba[i]->cmd_pool_bits || !hba[i]->cmd_pool)
428                         goto Enomem1;
429
430         memset(hba[i]->cmd_pool, 0, NR_CMDS * sizeof(cmdlist_t));
431         printk(KERN_INFO "cpqarray: Finding drives on %s",
432                 hba[i]->devname);
433
434         spin_lock_init(&hba[i]->lock);
435         q = blk_init_queue(do_ida_request, &hba[i]->lock);
436         if (!q)
437                 goto Enomem1;
438
439         hba[i]->queue = q;
440         q->queuedata = hba[i];
441
442         getgeometry(i);
443         start_fwbk(i);
444
445         ida_procinit(i);
446
447         if (pdev)
448                 blk_queue_bounce_limit(q, hba[i]->pci_dev->dma_mask);
449
450         /* This is a hardware imposed limit. */
451         blk_queue_max_segments(q, SG_MAX);
452
453         init_timer(&hba[i]->timer);
454         hba[i]->timer.expires = jiffies + IDA_TIMER;
455         hba[i]->timer.data = (unsigned long)hba[i];
456         hba[i]->timer.function = ida_timer;
457         add_timer(&hba[i]->timer);
458
459         /* Enable IRQ now that spinlock and rate limit timer are set up */
460         hba[i]->access.set_intr_mask(hba[i], FIFO_NOT_EMPTY);
461
462         for(j=0; j<NWD; j++) {
463                 struct gendisk *disk = ida_gendisk[i][j];
464                 drv_info_t *drv = &hba[i]->drv[j];
465                 sprintf(disk->disk_name, "ida/c%dd%d", i, j);
466                 disk->major = COMPAQ_SMART2_MAJOR + i;
467                 disk->first_minor = j<<NWD_SHIFT;
468                 disk->fops = &ida_fops;
469                 if (j && !drv->nr_blks)
470                         continue;
471                 blk_queue_logical_block_size(hba[i]->queue, drv->blk_size);
472                 set_capacity(disk, drv->nr_blks);
473                 disk->queue = hba[i]->queue;
474                 disk->private_data = drv;
475                 add_disk(disk);
476         }
477
478         /* done ! */
479         return(i);
480
481 Enomem1:
482         nr_ctlr = i; 
483         kfree(hba[i]->cmd_pool_bits);
484         if (hba[i]->cmd_pool)
485                 pci_free_consistent(hba[i]->pci_dev, NR_CMDS*sizeof(cmdlist_t), 
486                                     hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
487 Enomem2:
488         while (j--) {
489                 put_disk(ida_gendisk[i][j]);
490                 ida_gendisk[i][j] = NULL;
491         }
492         free_irq(hba[i]->intr, hba[i]);
493 Enomem3:
494         unregister_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname);
495 Enomem4:
496         if (pdev)
497                 pci_set_drvdata(pdev, NULL);
498         release_io_mem(hba[i]);
499         free_hba(i);
500
501         printk( KERN_ERR "cpqarray: out of memory");
502
503         return -1;
504 }
505
506 static int __init cpqarray_init_one( struct pci_dev *pdev,
507         const struct pci_device_id *ent)
508 {
509         int i;
510
511         printk(KERN_DEBUG "cpqarray: Device 0x%x has been found at"
512                         " bus %d dev %d func %d\n",
513                         pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
514                         PCI_FUNC(pdev->devfn));
515         i = alloc_cpqarray_hba();
516         if( i < 0 )
517                 return (-1);
518         memset(hba[i], 0, sizeof(ctlr_info_t));
519         sprintf(hba[i]->devname, "ida%d", i);
520         hba[i]->ctlr = i;
521         /* Initialize the pdev driver private data */
522         pci_set_drvdata(pdev, hba[i]);
523
524         if (cpqarray_pci_init(hba[i], pdev) != 0) {
525                 pci_set_drvdata(pdev, NULL);
526                 release_io_mem(hba[i]);
527                 free_hba(i);
528                 return -1;
529         }
530
531         return (cpqarray_register_ctlr(i, pdev));
532 }
533
534 static struct pci_driver cpqarray_pci_driver = {
535         .name = "cpqarray",
536         .probe = cpqarray_init_one,
537         .remove = __devexit_p(cpqarray_remove_one_pci),
538         .id_table = cpqarray_pci_device_id,
539 };
540
541 /*
542  *  This is it.  Find all the controllers and register them.
543  *  returns the number of block devices registered.
544  */
545 static int __init cpqarray_init(void)
546 {
547         int num_cntlrs_reg = 0;
548         int i;
549         int rc = 0;
550
551         /* detect controllers */
552         printk(DRIVER_NAME "\n");
553
554         rc = pci_register_driver(&cpqarray_pci_driver);
555         if (rc)
556                 return rc;
557         cpqarray_eisa_detect();
558         
559         for (i=0; i < MAX_CTLR; i++) {
560                 if (hba[i] != NULL)
561                         num_cntlrs_reg++;
562         }
563
564         if (num_cntlrs_reg)
565                 return 0;
566         else {
567                 pci_unregister_driver(&cpqarray_pci_driver);
568                 return -ENODEV;
569         }
570 }
571
572 /* Function to find the first free pointer into our hba[] array */
573 /* Returns -1 if no free entries are left.  */
574 static int alloc_cpqarray_hba(void)
575 {
576         int i;
577
578         for(i=0; i< MAX_CTLR; i++) {
579                 if (hba[i] == NULL) {
580                         hba[i] = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
581                         if(hba[i]==NULL) {
582                                 printk(KERN_ERR "cpqarray: out of memory.\n");
583                                 return (-1);
584                         }
585                         return (i);
586                 }
587         }
588         printk(KERN_WARNING "cpqarray: This driver supports a maximum"
589                 " of 8 controllers.\n");
590         return(-1);
591 }
592
593 static void free_hba(int i)
594 {
595         kfree(hba[i]);
596         hba[i]=NULL;
597 }
598
599 /*
600  * Find the IO address of the controller, its IRQ and so forth.  Fill
601  * in some basic stuff into the ctlr_info_t structure.
602  */
603 static int cpqarray_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
604 {
605         ushort vendor_id, device_id, command;
606         unchar cache_line_size, latency_timer;
607         unchar irq, revision;
608         unsigned long addr[6];
609         __u32 board_id;
610
611         int i;
612
613         c->pci_dev = pdev;
614         pci_set_master(pdev);
615         if (pci_enable_device(pdev)) {
616                 printk(KERN_ERR "cpqarray: Unable to Enable PCI device\n");
617                 return -1;
618         }
619         vendor_id = pdev->vendor;
620         device_id = pdev->device;
621         irq = pdev->irq;
622
623         for(i=0; i<6; i++)
624                 addr[i] = pci_resource_start(pdev, i);
625
626         if (pci_set_dma_mask(pdev, CPQARRAY_DMA_MASK) != 0)
627         {
628                 printk(KERN_ERR "cpqarray: Unable to set DMA mask\n");
629                 return -1;
630         }
631
632         pci_read_config_word(pdev, PCI_COMMAND, &command);
633         pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
634         pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_line_size);
635         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency_timer);
636
637         pci_read_config_dword(pdev, 0x2c, &board_id);
638
639         /* check to see if controller has been disabled */
640         if(!(command & 0x02)) {
641                 printk(KERN_WARNING
642                         "cpqarray: controller appears to be disabled\n");
643                 return(-1);
644         }
645
646 DBGINFO(
647         printk("vendor_id = %x\n", vendor_id);
648         printk("device_id = %x\n", device_id);
649         printk("command = %x\n", command);
650         for(i=0; i<6; i++)
651                 printk("addr[%d] = %lx\n", i, addr[i]);
652         printk("revision = %x\n", revision);
653         printk("irq = %x\n", irq);
654         printk("cache_line_size = %x\n", cache_line_size);
655         printk("latency_timer = %x\n", latency_timer);
656         printk("board_id = %x\n", board_id);
657 );
658
659         c->intr = irq;
660
661         for(i=0; i<6; i++) {
662                 if (pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE_IO)
663                 { /* IO space */
664                         c->io_mem_addr = addr[i];
665                         c->io_mem_length = pci_resource_end(pdev, i)
666                                 - pci_resource_start(pdev, i) + 1;
667                         if(!request_region( c->io_mem_addr, c->io_mem_length,
668                                 "cpqarray"))
669                         {
670                                 printk( KERN_WARNING "cpqarray I/O memory range already in use addr %lx length = %ld\n", c->io_mem_addr, c->io_mem_length);
671                                 c->io_mem_addr = 0;
672                                 c->io_mem_length = 0;
673                         }
674                         break;
675                 }
676         }
677
678         c->paddr = 0;
679         for(i=0; i<6; i++)
680                 if (!(pci_resource_flags(pdev, i) &
681                                 PCI_BASE_ADDRESS_SPACE_IO)) {
682                         c->paddr = pci_resource_start (pdev, i);
683                         break;
684                 }
685         if (!c->paddr)
686                 return -1;
687         c->vaddr = remap_pci_mem(c->paddr, 128);
688         if (!c->vaddr)
689                 return -1;
690         c->board_id = board_id;
691
692         for(i=0; i<NR_PRODUCTS; i++) {
693                 if (board_id == products[i].board_id) {
694                         c->product_name = products[i].product_name;
695                         c->access = *(products[i].access);
696                         break;
697                 }
698         }
699         if (i == NR_PRODUCTS) {
700                 printk(KERN_WARNING "cpqarray: Sorry, I don't know how"
701                         " to access the SMART Array controller %08lx\n", 
702                                 (unsigned long)board_id);
703                 return -1;
704         }
705
706         return 0;
707 }
708
709 /*
710  * Map (physical) PCI mem into (virtual) kernel space
711  */
712 static void __iomem *remap_pci_mem(ulong base, ulong size)
713 {
714         ulong page_base        = ((ulong) base) & PAGE_MASK;
715         ulong page_offs        = ((ulong) base) - page_base;
716         void __iomem *page_remapped    = ioremap(page_base, page_offs+size);
717
718         return (page_remapped ? (page_remapped + page_offs) : NULL);
719 }
720
721 #ifndef MODULE
722 /*
723  * Config string is a comma separated set of i/o addresses of EISA cards.
724  */
725 static int cpqarray_setup(char *str)
726 {
727         int i, ints[9];
728
729         (void)get_options(str, ARRAY_SIZE(ints), ints);
730
731         for(i=0; i<ints[0] && i<8; i++)
732                 eisa[i] = ints[i+1];
733         return 1;
734 }
735
736 __setup("smart2=", cpqarray_setup);
737
738 #endif
739
740 /*
741  * Find an EISA controller's signature.  Set up an hba if we find it.
742  */
743 static int __init cpqarray_eisa_detect(void)
744 {
745         int i=0, j;
746         __u32 board_id;
747         int intr;
748         int ctlr;
749         int num_ctlr = 0;
750
751         while(i<8 && eisa[i]) {
752                 ctlr = alloc_cpqarray_hba();
753                 if(ctlr == -1)
754                         break;
755                 board_id = inl(eisa[i]+0xC80);
756                 for(j=0; j < NR_PRODUCTS; j++)
757                         if (board_id == products[j].board_id) 
758                                 break;
759
760                 if (j == NR_PRODUCTS) {
761                         printk(KERN_WARNING "cpqarray: Sorry, I don't know how"
762                                 " to access the SMART Array controller %08lx\n",                                 (unsigned long)board_id);
763                         continue;
764                 }
765
766                 memset(hba[ctlr], 0, sizeof(ctlr_info_t));
767                 hba[ctlr]->io_mem_addr = eisa[i];
768                 hba[ctlr]->io_mem_length = 0x7FF;
769                 if(!request_region(hba[ctlr]->io_mem_addr,
770                                 hba[ctlr]->io_mem_length,
771                                 "cpqarray"))
772                 {
773                         printk(KERN_WARNING "cpqarray: I/O range already in "
774                                         "use addr = %lx length = %ld\n",
775                                         hba[ctlr]->io_mem_addr,
776                                         hba[ctlr]->io_mem_length);
777                         free_hba(ctlr);
778                         continue;
779                 }
780
781                 /*
782                  * Read the config register to find our interrupt
783                  */
784                 intr = inb(eisa[i]+0xCC0) >> 4;
785                 if (intr & 1) intr = 11;
786                 else if (intr & 2) intr = 10;
787                 else if (intr & 4) intr = 14;
788                 else if (intr & 8) intr = 15;
789                 
790                 hba[ctlr]->intr = intr;
791                 sprintf(hba[ctlr]->devname, "ida%d", nr_ctlr);
792                 hba[ctlr]->product_name = products[j].product_name;
793                 hba[ctlr]->access = *(products[j].access);
794                 hba[ctlr]->ctlr = ctlr;
795                 hba[ctlr]->board_id = board_id;
796                 hba[ctlr]->pci_dev = NULL; /* not PCI */
797
798 DBGINFO(
799         printk("i = %d, j = %d\n", i, j);
800         printk("irq = %x\n", intr);
801         printk("product name = %s\n", products[j].product_name);
802         printk("board_id = %x\n", board_id);
803 );
804
805                 num_ctlr++;
806                 i++;
807
808                 if (cpqarray_register_ctlr(ctlr, NULL) == -1)
809                         printk(KERN_WARNING
810                                 "cpqarray: Can't register EISA controller %d\n",
811                                 ctlr);
812
813         }
814
815         return num_ctlr;
816 }
817
818 /*
819  * Open.  Make sure the device is really there.
820  */
821 static int ida_open(struct block_device *bdev, fmode_t mode)
822 {
823         drv_info_t *drv = get_drv(bdev->bd_disk);
824         ctlr_info_t *host = get_host(bdev->bd_disk);
825
826         DBGINFO(printk("ida_open %s\n", bdev->bd_disk->disk_name));
827         /*
828          * Root is allowed to open raw volume zero even if it's not configured
829          * so array config can still work.  I don't think I really like this,
830          * but I'm already using way to many device nodes to claim another one
831          * for "raw controller".
832          */
833         if (!drv->nr_blks) {
834                 if (!capable(CAP_SYS_RAWIO))
835                         return -ENXIO;
836                 if (!capable(CAP_SYS_ADMIN) && drv != host->drv)
837                         return -ENXIO;
838         }
839         host->usage_count++;
840         return 0;
841 }
842
843 /*
844  * Close.  Sync first.
845  */
846 static int ida_release(struct gendisk *disk, fmode_t mode)
847 {
848         ctlr_info_t *host = get_host(disk);
849         host->usage_count--;
850         return 0;
851 }
852
853 /*
854  * Enqueuing and dequeuing functions for cmdlists.
855  */
856 static inline void addQ(cmdlist_t **Qptr, cmdlist_t *c)
857 {
858         if (*Qptr == NULL) {
859                 *Qptr = c;
860                 c->next = c->prev = c;
861         } else {
862                 c->prev = (*Qptr)->prev;
863                 c->next = (*Qptr);
864                 (*Qptr)->prev->next = c;
865                 (*Qptr)->prev = c;
866         }
867 }
868
869 static inline cmdlist_t *removeQ(cmdlist_t **Qptr, cmdlist_t *c)
870 {
871         if (c && c->next != c) {
872                 if (*Qptr == c) *Qptr = c->next;
873                 c->prev->next = c->next;
874                 c->next->prev = c->prev;
875         } else {
876                 *Qptr = NULL;
877         }
878         return c;
879 }
880
881 /*
882  * Get a request and submit it to the controller.
883  * This routine needs to grab all the requests it possibly can from the
884  * req Q and submit them.  Interrupts are off (and need to be off) when you
885  * are in here (either via the dummy do_ida_request functions or by being
886  * called from the interrupt handler
887  */
888 static void do_ida_request(struct request_queue *q)
889 {
890         ctlr_info_t *h = q->queuedata;
891         cmdlist_t *c;
892         struct request *creq;
893         struct scatterlist tmp_sg[SG_MAX];
894         int i, dir, seg;
895
896         if (blk_queue_plugged(q))
897                 goto startio;
898
899 queue_next:
900         creq = blk_peek_request(q);
901         if (!creq)
902                 goto startio;
903
904         BUG_ON(creq->nr_phys_segments > SG_MAX);
905
906         if ((c = cmd_alloc(h,1)) == NULL)
907                 goto startio;
908
909         blk_start_request(creq);
910
911         c->ctlr = h->ctlr;
912         c->hdr.unit = (drv_info_t *)(creq->rq_disk->private_data) - h->drv;
913         c->hdr.size = sizeof(rblk_t) >> 2;
914         c->size += sizeof(rblk_t);
915
916         c->req.hdr.blk = blk_rq_pos(creq);
917         c->rq = creq;
918 DBGPX(
919         printk("sector=%d, nr_sectors=%u\n",
920                blk_rq_pos(creq), blk_rq_sectors(creq));
921 );
922         sg_init_table(tmp_sg, SG_MAX);
923         seg = blk_rq_map_sg(q, creq, tmp_sg);
924
925         /* Now do all the DMA Mappings */
926         if (rq_data_dir(creq) == READ)
927                 dir = PCI_DMA_FROMDEVICE;
928         else
929                 dir = PCI_DMA_TODEVICE;
930         for( i=0; i < seg; i++)
931         {
932                 c->req.sg[i].size = tmp_sg[i].length;
933                 c->req.sg[i].addr = (__u32) pci_map_page(h->pci_dev,
934                                                  sg_page(&tmp_sg[i]),
935                                                  tmp_sg[i].offset,
936                                                  tmp_sg[i].length, dir);
937         }
938 DBGPX(  printk("Submitting %u sectors in %d segments\n", blk_rq_sectors(creq), seg); );
939         c->req.hdr.sg_cnt = seg;
940         c->req.hdr.blk_cnt = blk_rq_sectors(creq);
941         c->req.hdr.cmd = (rq_data_dir(creq) == READ) ? IDA_READ : IDA_WRITE;
942         c->type = CMD_RWREQ;
943
944         /* Put the request on the tail of the request queue */
945         addQ(&h->reqQ, c);
946         h->Qdepth++;
947         if (h->Qdepth > h->maxQsinceinit) 
948                 h->maxQsinceinit = h->Qdepth;
949
950         goto queue_next;
951
952 startio:
953         start_io(h);
954 }
955
956 /* 
957  * start_io submits everything on a controller's request queue
958  * and moves it to the completion queue.
959  *
960  * Interrupts had better be off if you're in here
961  */
962 static void start_io(ctlr_info_t *h)
963 {
964         cmdlist_t *c;
965
966         while((c = h->reqQ) != NULL) {
967                 /* Can't do anything if we're busy */
968                 if (h->access.fifo_full(h) == 0)
969                         return;
970
971                 /* Get the first entry from the request Q */
972                 removeQ(&h->reqQ, c);
973                 h->Qdepth--;
974         
975                 /* Tell the controller to do our bidding */
976                 h->access.submit_command(h, c);
977
978                 /* Get onto the completion Q */
979                 addQ(&h->cmpQ, c);
980         }
981 }
982
983 /*
984  * Mark all buffers that cmd was responsible for
985  */
986 static inline void complete_command(cmdlist_t *cmd, int timeout)
987 {
988         struct request *rq = cmd->rq;
989         int error = 0;
990         int i, ddir;
991
992         if (cmd->req.hdr.rcode & RCODE_NONFATAL &&
993            (hba[cmd->ctlr]->misc_tflags & MISC_NONFATAL_WARN) == 0) {
994                 printk(KERN_NOTICE "Non Fatal error on ida/c%dd%d\n",
995                                 cmd->ctlr, cmd->hdr.unit);
996                 hba[cmd->ctlr]->misc_tflags |= MISC_NONFATAL_WARN;
997         }
998         if (cmd->req.hdr.rcode & RCODE_FATAL) {
999                 printk(KERN_WARNING "Fatal error on ida/c%dd%d\n",
1000                                 cmd->ctlr, cmd->hdr.unit);
1001                 error = -EIO;
1002         }
1003         if (cmd->req.hdr.rcode & RCODE_INVREQ) {
1004                                 printk(KERN_WARNING "Invalid request on ida/c%dd%d = (cmd=%x sect=%d cnt=%d sg=%d ret=%x)\n",
1005                                 cmd->ctlr, cmd->hdr.unit, cmd->req.hdr.cmd,
1006                                 cmd->req.hdr.blk, cmd->req.hdr.blk_cnt,
1007                                 cmd->req.hdr.sg_cnt, cmd->req.hdr.rcode);
1008                 error = -EIO;
1009         }
1010         if (timeout)
1011                 error = -EIO;
1012         /* unmap the DMA mapping for all the scatter gather elements */
1013         if (cmd->req.hdr.cmd == IDA_READ)
1014                 ddir = PCI_DMA_FROMDEVICE;
1015         else
1016                 ddir = PCI_DMA_TODEVICE;
1017         for(i=0; i<cmd->req.hdr.sg_cnt; i++)
1018                 pci_unmap_page(hba[cmd->ctlr]->pci_dev, cmd->req.sg[i].addr,
1019                                 cmd->req.sg[i].size, ddir);
1020
1021         DBGPX(printk("Done with %p\n", rq););
1022         __blk_end_request_all(rq, error);
1023 }
1024
1025 /*
1026  *  The controller will interrupt us upon completion of commands.
1027  *  Find the command on the completion queue, remove it, tell the OS and
1028  *  try to queue up more IO
1029  */
1030 static irqreturn_t do_ida_intr(int irq, void *dev_id)
1031 {
1032         ctlr_info_t *h = dev_id;
1033         cmdlist_t *c;
1034         unsigned long istat;
1035         unsigned long flags;
1036         __u32 a,a1;
1037
1038         istat = h->access.intr_pending(h);
1039         /* Is this interrupt for us? */
1040         if (istat == 0)
1041                 return IRQ_NONE;
1042
1043         /*
1044          * If there are completed commands in the completion queue,
1045          * we had better do something about it.
1046          */
1047         spin_lock_irqsave(IDA_LOCK(h->ctlr), flags);
1048         if (istat & FIFO_NOT_EMPTY) {
1049                 while((a = h->access.command_completed(h))) {
1050                         a1 = a; a &= ~3;
1051                         if ((c = h->cmpQ) == NULL)
1052                         {  
1053                                 printk(KERN_WARNING "cpqarray: Completion of %08lx ignored\n", (unsigned long)a1);
1054                                 continue;       
1055                         } 
1056                         while(c->busaddr != a) {
1057                                 c = c->next;
1058                                 if (c == h->cmpQ) 
1059                                         break;
1060                         }
1061                         /*
1062                          * If we've found the command, take it off the
1063                          * completion Q and free it
1064                          */
1065                         if (c->busaddr == a) {
1066                                 removeQ(&h->cmpQ, c);
1067                                 /*  Check for invalid command.
1068                                  *  Controller returns command error,
1069                                  *  But rcode = 0.
1070                                  */
1071
1072                                 if((a1 & 0x03) && (c->req.hdr.rcode == 0))
1073                                 {
1074                                         c->req.hdr.rcode = RCODE_INVREQ;
1075                                 }
1076                                 if (c->type == CMD_RWREQ) {
1077                                         complete_command(c, 0);
1078                                         cmd_free(h, c, 1);
1079                                 } else if (c->type == CMD_IOCTL_PEND) {
1080                                         c->type = CMD_IOCTL_DONE;
1081                                 }
1082                                 continue;
1083                         }
1084                 }
1085         }
1086
1087         /*
1088          * See if we can queue up some more IO
1089          */
1090         do_ida_request(h->queue);
1091         spin_unlock_irqrestore(IDA_LOCK(h->ctlr), flags); 
1092         return IRQ_HANDLED;
1093 }
1094
1095 /*
1096  * This timer was for timing out requests that haven't happened after
1097  * IDA_TIMEOUT.  That wasn't such a good idea.  This timer is used to
1098  * reset a flags structure so we don't flood the user with
1099  * "Non-Fatal error" messages.
1100  */
1101 static void ida_timer(unsigned long tdata)
1102 {
1103         ctlr_info_t *h = (ctlr_info_t*)tdata;
1104
1105         h->timer.expires = jiffies + IDA_TIMER;
1106         add_timer(&h->timer);
1107         h->misc_tflags = 0;
1108 }
1109
1110 static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1111 {
1112         drv_info_t *drv = get_drv(bdev->bd_disk);
1113
1114         if (drv->cylinders) {
1115                 geo->heads = drv->heads;
1116                 geo->sectors = drv->sectors;
1117                 geo->cylinders = drv->cylinders;
1118         } else {
1119                 geo->heads = 0xff;
1120                 geo->sectors = 0x3f;
1121                 geo->cylinders = drv->nr_blks / (0xff*0x3f);
1122         }
1123
1124         return 0;
1125 }
1126
1127 /*
1128  *  ida_ioctl does some miscellaneous stuff like reporting drive geometry,
1129  *  setting readahead and submitting commands from userspace to the controller.
1130  */
1131 static int ida_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
1132 {
1133         drv_info_t *drv = get_drv(bdev->bd_disk);
1134         ctlr_info_t *host = get_host(bdev->bd_disk);
1135         int error;
1136         ida_ioctl_t __user *io = (ida_ioctl_t __user *)arg;
1137         ida_ioctl_t *my_io;
1138
1139         switch(cmd) {
1140         case IDAGETDRVINFO:
1141                 if (copy_to_user(&io->c.drv, drv, sizeof(drv_info_t)))
1142                         return -EFAULT;
1143                 return 0;
1144         case IDAPASSTHRU:
1145                 if (!capable(CAP_SYS_RAWIO))
1146                         return -EPERM;
1147                 my_io = kmalloc(sizeof(ida_ioctl_t), GFP_KERNEL);
1148                 if (!my_io)
1149                         return -ENOMEM;
1150                 error = -EFAULT;
1151                 if (copy_from_user(my_io, io, sizeof(*my_io)))
1152                         goto out_passthru;
1153                 error = ida_ctlr_ioctl(host, drv - host->drv, my_io);
1154                 if (error)
1155                         goto out_passthru;
1156                 error = -EFAULT;
1157                 if (copy_to_user(io, my_io, sizeof(*my_io)))
1158                         goto out_passthru;
1159                 error = 0;
1160 out_passthru:
1161                 kfree(my_io);
1162                 return error;
1163         case IDAGETCTLRSIG:
1164                 if (!arg) return -EINVAL;
1165                 put_user(host->ctlr_sig, (int __user *)arg);
1166                 return 0;
1167         case IDAREVALIDATEVOLS:
1168                 if (MINOR(bdev->bd_dev) != 0)
1169                         return -ENXIO;
1170                 return revalidate_allvol(host);
1171         case IDADRIVERVERSION:
1172                 if (!arg) return -EINVAL;
1173                 put_user(DRIVER_VERSION, (unsigned long __user *)arg);
1174                 return 0;
1175         case IDAGETPCIINFO:
1176         {
1177                 
1178                 ida_pci_info_struct pciinfo;
1179
1180                 if (!arg) return -EINVAL;
1181                 pciinfo.bus = host->pci_dev->bus->number;
1182                 pciinfo.dev_fn = host->pci_dev->devfn;
1183                 pciinfo.board_id = host->board_id;
1184                 if(copy_to_user((void __user *) arg, &pciinfo,  
1185                         sizeof( ida_pci_info_struct)))
1186                                 return -EFAULT;
1187                 return(0);
1188         }       
1189
1190         default:
1191                 return -EINVAL;
1192         }
1193                 
1194 }
1195 /*
1196  * ida_ctlr_ioctl is for passing commands to the controller from userspace.
1197  * The command block (io) has already been copied to kernel space for us,
1198  * however, any elements in the sglist need to be copied to kernel space
1199  * or copied back to userspace.
1200  *
1201  * Only root may perform a controller passthru command, however I'm not doing
1202  * any serious sanity checking on the arguments.  Doing an IDA_WRITE_MEDIA and
1203  * putting a 64M buffer in the sglist is probably a *bad* idea.
1204  */
1205 static int ida_ctlr_ioctl(ctlr_info_t *h, int dsk, ida_ioctl_t *io)
1206 {
1207         int ctlr = h->ctlr;
1208         cmdlist_t *c;
1209         void *p = NULL;
1210         unsigned long flags;
1211         int error;
1212
1213         if ((c = cmd_alloc(h, 0)) == NULL)
1214                 return -ENOMEM;
1215         c->ctlr = ctlr;
1216         c->hdr.unit = (io->unit & UNITVALID) ? (io->unit & ~UNITVALID) : dsk;
1217         c->hdr.size = sizeof(rblk_t) >> 2;
1218         c->size += sizeof(rblk_t);
1219
1220         c->req.hdr.cmd = io->cmd;
1221         c->req.hdr.blk = io->blk;
1222         c->req.hdr.blk_cnt = io->blk_cnt;
1223         c->type = CMD_IOCTL_PEND;
1224
1225         /* Pre submit processing */
1226         switch(io->cmd) {
1227         case PASSTHRU_A:
1228                 p = kmalloc(io->sg[0].size, GFP_KERNEL);
1229                 if (!p) 
1230                 { 
1231                         error = -ENOMEM; 
1232                         cmd_free(h, c, 0); 
1233                         return(error);
1234                 }
1235                 if (copy_from_user(p, io->sg[0].addr, io->sg[0].size)) {
1236                         kfree(p);
1237                         cmd_free(h, c, 0); 
1238                         return -EFAULT;
1239                 }
1240                 c->req.hdr.blk = pci_map_single(h->pci_dev, &(io->c), 
1241                                 sizeof(ida_ioctl_t), 
1242                                 PCI_DMA_BIDIRECTIONAL);
1243                 c->req.sg[0].size = io->sg[0].size;
1244                 c->req.sg[0].addr = pci_map_single(h->pci_dev, p, 
1245                         c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1246                 c->req.hdr.sg_cnt = 1;
1247                 break;
1248         case IDA_READ:
1249         case READ_FLASH_ROM:
1250         case SENSE_CONTROLLER_PERFORMANCE:
1251                 p = kmalloc(io->sg[0].size, GFP_KERNEL);
1252                 if (!p) 
1253                 { 
1254                         error = -ENOMEM; 
1255                         cmd_free(h, c, 0);
1256                         return(error);
1257                 }
1258
1259                 c->req.sg[0].size = io->sg[0].size;
1260                 c->req.sg[0].addr = pci_map_single(h->pci_dev, p, 
1261                         c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL); 
1262                 c->req.hdr.sg_cnt = 1;
1263                 break;
1264         case IDA_WRITE:
1265         case IDA_WRITE_MEDIA:
1266         case DIAG_PASS_THRU:
1267         case COLLECT_BUFFER:
1268         case WRITE_FLASH_ROM:
1269                 p = kmalloc(io->sg[0].size, GFP_KERNEL);
1270                 if (!p) 
1271                 { 
1272                         error = -ENOMEM; 
1273                         cmd_free(h, c, 0);
1274                         return(error);
1275                 }
1276                 if (copy_from_user(p, io->sg[0].addr, io->sg[0].size)) {
1277                         kfree(p);
1278                         cmd_free(h, c, 0);
1279                         return -EFAULT;
1280                 }
1281                 c->req.sg[0].size = io->sg[0].size;
1282                 c->req.sg[0].addr = pci_map_single(h->pci_dev, p, 
1283                         c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL); 
1284                 c->req.hdr.sg_cnt = 1;
1285                 break;
1286         default:
1287                 c->req.sg[0].size = sizeof(io->c);
1288                 c->req.sg[0].addr = pci_map_single(h->pci_dev,&io->c, 
1289                         c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1290                 c->req.hdr.sg_cnt = 1;
1291         }
1292         
1293         /* Put the request on the tail of the request queue */
1294         spin_lock_irqsave(IDA_LOCK(ctlr), flags);
1295         addQ(&h->reqQ, c);
1296         h->Qdepth++;
1297         start_io(h);
1298         spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1299
1300         /* Wait for completion */
1301         while(c->type != CMD_IOCTL_DONE)
1302                 schedule();
1303
1304         /* Unmap the DMA  */
1305         pci_unmap_single(h->pci_dev, c->req.sg[0].addr, c->req.sg[0].size, 
1306                 PCI_DMA_BIDIRECTIONAL);
1307         /* Post submit processing */
1308         switch(io->cmd) {
1309         case PASSTHRU_A:
1310                 pci_unmap_single(h->pci_dev, c->req.hdr.blk,
1311                                 sizeof(ida_ioctl_t),
1312                                 PCI_DMA_BIDIRECTIONAL);
1313         case IDA_READ:
1314         case DIAG_PASS_THRU:
1315         case SENSE_CONTROLLER_PERFORMANCE:
1316         case READ_FLASH_ROM:
1317                 if (copy_to_user(io->sg[0].addr, p, io->sg[0].size)) {
1318                         kfree(p);
1319                         return -EFAULT;
1320                 }
1321                 /* fall through and free p */
1322         case IDA_WRITE:
1323         case IDA_WRITE_MEDIA:
1324         case COLLECT_BUFFER:
1325         case WRITE_FLASH_ROM:
1326                 kfree(p);
1327                 break;
1328         default:;
1329                 /* Nothing to do */
1330         }
1331
1332         io->rcode = c->req.hdr.rcode;
1333         cmd_free(h, c, 0);
1334         return(0);
1335 }
1336
1337 /*
1338  * Commands are pre-allocated in a large block.  Here we use a simple bitmap
1339  * scheme to suballocte them to the driver.  Operations that are not time
1340  * critical (and can wait for kmalloc and possibly sleep) can pass in NULL
1341  * as the first argument to get a new command.
1342  */
1343 static cmdlist_t * cmd_alloc(ctlr_info_t *h, int get_from_pool)
1344 {
1345         cmdlist_t * c;
1346         int i;
1347         dma_addr_t cmd_dhandle;
1348
1349         if (!get_from_pool) {
1350                 c = (cmdlist_t*)pci_alloc_consistent(h->pci_dev, 
1351                         sizeof(cmdlist_t), &cmd_dhandle);
1352                 if(c==NULL)
1353                         return NULL;
1354         } else {
1355                 do {
1356                         i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
1357                         if (i == NR_CMDS)
1358                                 return NULL;
1359                 } while(test_and_set_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
1360                 c = h->cmd_pool + i;
1361                 cmd_dhandle = h->cmd_pool_dhandle + i*sizeof(cmdlist_t);
1362                 h->nr_allocs++;
1363         }
1364
1365         memset(c, 0, sizeof(cmdlist_t));
1366         c->busaddr = cmd_dhandle; 
1367         return c;
1368 }
1369
1370 static void cmd_free(ctlr_info_t *h, cmdlist_t *c, int got_from_pool)
1371 {
1372         int i;
1373
1374         if (!got_from_pool) {
1375                 pci_free_consistent(h->pci_dev, sizeof(cmdlist_t), c,
1376                         c->busaddr);
1377         } else {
1378                 i = c - h->cmd_pool;
1379                 clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
1380                 h->nr_frees++;
1381         }
1382 }
1383
1384 /***********************************************************************
1385     name:        sendcmd
1386     Send a command to an IDA using the memory mapped FIFO interface
1387     and wait for it to complete.  
1388     This routine should only be called at init time.
1389 ***********************************************************************/
1390 static int sendcmd(
1391         __u8    cmd,
1392         int     ctlr,
1393         void    *buff,
1394         size_t  size,
1395         unsigned int blk,
1396         unsigned int blkcnt,
1397         unsigned int log_unit )
1398 {
1399         cmdlist_t *c;
1400         int complete;
1401         unsigned long temp;
1402         unsigned long i;
1403         ctlr_info_t *info_p = hba[ctlr];
1404
1405         c = cmd_alloc(info_p, 1);
1406         if(!c)
1407                 return IO_ERROR;
1408         c->ctlr = ctlr;
1409         c->hdr.unit = log_unit;
1410         c->hdr.prio = 0;
1411         c->hdr.size = sizeof(rblk_t) >> 2;
1412         c->size += sizeof(rblk_t);
1413
1414         /* The request information. */
1415         c->req.hdr.next = 0;
1416         c->req.hdr.rcode = 0;
1417         c->req.bp = 0;
1418         c->req.hdr.sg_cnt = 1;
1419         c->req.hdr.reserved = 0;
1420         
1421         if (size == 0)
1422                 c->req.sg[0].size = 512;
1423         else
1424                 c->req.sg[0].size = size;
1425
1426         c->req.hdr.blk = blk;
1427         c->req.hdr.blk_cnt = blkcnt;
1428         c->req.hdr.cmd = (unsigned char) cmd;
1429         c->req.sg[0].addr = (__u32) pci_map_single(info_p->pci_dev, 
1430                 buff, c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1431         /*
1432          * Disable interrupt
1433          */
1434         info_p->access.set_intr_mask(info_p, 0);
1435         /* Make sure there is room in the command FIFO */
1436         /* Actually it should be completely empty at this time. */
1437         for (i = 200000; i > 0; i--) {
1438                 temp = info_p->access.fifo_full(info_p);
1439                 if (temp != 0) {
1440                         break;
1441                 }
1442                 udelay(10);
1443 DBG(
1444                 printk(KERN_WARNING "cpqarray ida%d: idaSendPciCmd FIFO full,"
1445                         " waiting!\n", ctlr);
1446 );
1447         } 
1448         /*
1449          * Send the cmd
1450          */
1451         info_p->access.submit_command(info_p, c);
1452         complete = pollcomplete(ctlr);
1453         
1454         pci_unmap_single(info_p->pci_dev, (dma_addr_t) c->req.sg[0].addr, 
1455                 c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1456         if (complete != 1) {
1457                 if (complete != c->busaddr) {
1458                         printk( KERN_WARNING
1459                         "cpqarray ida%d: idaSendPciCmd "
1460                       "Invalid command list address returned! (%08lx)\n",
1461                                 ctlr, (unsigned long)complete);
1462                         cmd_free(info_p, c, 1);
1463                         return (IO_ERROR);
1464                 }
1465         } else {
1466                 printk( KERN_WARNING
1467                         "cpqarray ida%d: idaSendPciCmd Timeout out, "
1468                         "No command list address returned!\n",
1469                         ctlr);
1470                 cmd_free(info_p, c, 1);
1471                 return (IO_ERROR);
1472         }
1473
1474         if (c->req.hdr.rcode & 0x00FE) {
1475                 if (!(c->req.hdr.rcode & BIG_PROBLEM)) {
1476                         printk( KERN_WARNING
1477                         "cpqarray ida%d: idaSendPciCmd, error: "
1478                                 "Controller failed at init time "
1479                                 "cmd: 0x%x, return code = 0x%x\n",
1480                                 ctlr, c->req.hdr.cmd, c->req.hdr.rcode);
1481
1482                         cmd_free(info_p, c, 1);
1483                         return (IO_ERROR);
1484                 }
1485         }
1486         cmd_free(info_p, c, 1);
1487         return (IO_OK);
1488 }
1489
1490 /*
1491  * revalidate_allvol is for online array config utilities.  After a
1492  * utility reconfigures the drives in the array, it can use this function
1493  * (through an ioctl) to make the driver zap any previous disk structs for
1494  * that controller and get new ones.
1495  *
1496  * Right now I'm using the getgeometry() function to do this, but this
1497  * function should probably be finer grained and allow you to revalidate one
1498  * particualar logical volume (instead of all of them on a particular
1499  * controller).
1500  */
1501 static int revalidate_allvol(ctlr_info_t *host)
1502 {
1503         int ctlr = host->ctlr;
1504         int i;
1505         unsigned long flags;
1506
1507         spin_lock_irqsave(IDA_LOCK(ctlr), flags);
1508         if (host->usage_count > 1) {
1509                 spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1510                 printk(KERN_WARNING "cpqarray: Device busy for volume"
1511                         " revalidation (usage=%d)\n", host->usage_count);
1512                 return -EBUSY;
1513         }
1514         host->usage_count++;
1515         spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1516
1517         /*
1518          * Set the partition and block size structures for all volumes
1519          * on this controller to zero.  We will reread all of this data
1520          */
1521         set_capacity(ida_gendisk[ctlr][0], 0);
1522         for (i = 1; i < NWD; i++) {
1523                 struct gendisk *disk = ida_gendisk[ctlr][i];
1524                 if (disk->flags & GENHD_FL_UP)
1525                         del_gendisk(disk);
1526         }
1527         memset(host->drv, 0, sizeof(drv_info_t)*NWD);
1528
1529         /*
1530          * Tell the array controller not to give us any interrupts while
1531          * we check the new geometry.  Then turn interrupts back on when
1532          * we're done.
1533          */
1534         host->access.set_intr_mask(host, 0);
1535         getgeometry(ctlr);
1536         host->access.set_intr_mask(host, FIFO_NOT_EMPTY);
1537
1538         for(i=0; i<NWD; i++) {
1539                 struct gendisk *disk = ida_gendisk[ctlr][i];
1540                 drv_info_t *drv = &host->drv[i];
1541                 if (i && !drv->nr_blks)
1542                         continue;
1543                 blk_queue_logical_block_size(host->queue, drv->blk_size);
1544                 set_capacity(disk, drv->nr_blks);
1545                 disk->queue = host->queue;
1546                 disk->private_data = drv;
1547                 if (i)
1548                         add_disk(disk);
1549         }
1550
1551         host->usage_count--;
1552         return 0;
1553 }
1554
1555 static int ida_revalidate(struct gendisk *disk)
1556 {
1557         drv_info_t *drv = disk->private_data;
1558         set_capacity(disk, drv->nr_blks);
1559         return 0;
1560 }
1561
1562 /********************************************************************
1563     name: pollcomplete
1564     Wait polling for a command to complete.
1565     The memory mapped FIFO is polled for the completion.
1566     Used only at init time, interrupts disabled.
1567  ********************************************************************/
1568 static int pollcomplete(int ctlr)
1569 {
1570         int done;
1571         int i;
1572
1573         /* Wait (up to 2 seconds) for a command to complete */
1574
1575         for (i = 200000; i > 0; i--) {
1576                 done = hba[ctlr]->access.command_completed(hba[ctlr]);
1577                 if (done == 0) {
1578                         udelay(10);     /* a short fixed delay */
1579                 } else
1580                         return (done);
1581         }
1582         /* Invalid address to tell caller we ran out of time */
1583         return 1;
1584 }
1585 /*****************************************************************
1586     start_fwbk
1587     Starts controller firmwares background processing. 
1588     Currently only the Integrated Raid controller needs this done.
1589     If the PCI mem address registers are written to after this, 
1590          data corruption may occur
1591 *****************************************************************/
1592 static void start_fwbk(int ctlr)
1593 {
1594                 id_ctlr_t *id_ctlr_buf; 
1595         int ret_code;
1596
1597         if(     (hba[ctlr]->board_id != 0x40400E11)
1598                 && (hba[ctlr]->board_id != 0x40480E11) )
1599
1600         /* Not a Integrated Raid, so there is nothing for us to do */
1601                 return;
1602         printk(KERN_DEBUG "cpqarray: Starting firmware's background"
1603                 " processing\n");
1604         /* Command does not return anything, but idasend command needs a 
1605                 buffer */
1606         id_ctlr_buf = kmalloc(sizeof(id_ctlr_t), GFP_KERNEL);
1607         if(id_ctlr_buf==NULL)
1608         {
1609                 printk(KERN_WARNING "cpqarray: Out of memory. "
1610                         "Unable to start background processing.\n");
1611                 return;
1612         }               
1613         ret_code = sendcmd(RESUME_BACKGROUND_ACTIVITY, ctlr, 
1614                 id_ctlr_buf, 0, 0, 0, 0);
1615         if(ret_code != IO_OK)
1616                 printk(KERN_WARNING "cpqarray: Unable to start"
1617                         " background processing\n");
1618
1619         kfree(id_ctlr_buf);
1620 }
1621 /*****************************************************************
1622     getgeometry
1623     Get ida logical volume geometry from the controller 
1624     This is a large bit of code which once existed in two flavors,
1625     It is used only at init time.
1626 *****************************************************************/
1627 static void getgeometry(int ctlr)
1628 {                               
1629         id_log_drv_t *id_ldrive;
1630         id_ctlr_t *id_ctlr_buf;
1631         sense_log_drv_stat_t *id_lstatus_buf;
1632         config_t *sense_config_buf;
1633         unsigned int log_unit, log_index;
1634         int ret_code, size;
1635         drv_info_t *drv;
1636         ctlr_info_t *info_p = hba[ctlr];
1637         int i;
1638
1639         info_p->log_drv_map = 0;        
1640         
1641         id_ldrive = kzalloc(sizeof(id_log_drv_t), GFP_KERNEL);
1642         if (!id_ldrive) {
1643                 printk( KERN_ERR "cpqarray:  out of memory.\n");
1644                 goto err_0;
1645         }
1646
1647         id_ctlr_buf = kzalloc(sizeof(id_ctlr_t), GFP_KERNEL);
1648         if (!id_ctlr_buf) {
1649                 printk( KERN_ERR "cpqarray:  out of memory.\n");
1650                 goto err_1;
1651         }
1652
1653         id_lstatus_buf = kzalloc(sizeof(sense_log_drv_stat_t), GFP_KERNEL);
1654         if (!id_lstatus_buf) {
1655                 printk( KERN_ERR "cpqarray:  out of memory.\n");
1656                 goto err_2;
1657         }
1658
1659         sense_config_buf = kzalloc(sizeof(config_t), GFP_KERNEL);
1660         if (!sense_config_buf) {
1661                 printk( KERN_ERR "cpqarray:  out of memory.\n");
1662                 goto err_3;
1663         }
1664
1665         info_p->phys_drives = 0;
1666         info_p->log_drv_map = 0;
1667         info_p->drv_assign_map = 0;
1668         info_p->drv_spare_map = 0;
1669         info_p->mp_failed_drv_map = 0;  /* only initialized here */
1670         /* Get controllers info for this logical drive */
1671         ret_code = sendcmd(ID_CTLR, ctlr, id_ctlr_buf, 0, 0, 0, 0);
1672         if (ret_code == IO_ERROR) {
1673                 /*
1674                  * If can't get controller info, set the logical drive map to 0,
1675                  * so the idastubopen will fail on all logical drives
1676                  * on the controller.
1677                  */
1678                 printk(KERN_ERR "cpqarray: error sending ID controller\n");
1679                 goto err_4;
1680         }
1681
1682         info_p->log_drives = id_ctlr_buf->nr_drvs;
1683         for(i=0;i<4;i++)
1684                 info_p->firm_rev[i] = id_ctlr_buf->firm_rev[i];
1685         info_p->ctlr_sig = id_ctlr_buf->cfg_sig;
1686
1687         printk(" (%s)\n", info_p->product_name);
1688         /*
1689          * Initialize logical drive map to zero
1690          */
1691         log_index = 0;
1692         /*
1693          * Get drive geometry for all logical drives
1694          */
1695         if (id_ctlr_buf->nr_drvs > 16)
1696                 printk(KERN_WARNING "cpqarray ida%d:  This driver supports "
1697                         "16 logical drives per controller.\n.  "
1698                         " Additional drives will not be "
1699                         "detected\n", ctlr);
1700
1701         for (log_unit = 0;
1702              (log_index < id_ctlr_buf->nr_drvs)
1703              && (log_unit < NWD);
1704              log_unit++) {
1705                 size = sizeof(sense_log_drv_stat_t);
1706
1707                 /*
1708                    Send "Identify logical drive status" cmd
1709                  */
1710                 ret_code = sendcmd(SENSE_LOG_DRV_STAT,
1711                              ctlr, id_lstatus_buf, size, 0, 0, log_unit);
1712                 if (ret_code == IO_ERROR) {
1713                         /*
1714                            If can't get logical drive status, set
1715                            the logical drive map to 0, so the
1716                            idastubopen will fail for all logical drives
1717                            on the controller. 
1718                          */
1719                         info_p->log_drv_map = 0;        
1720                         printk( KERN_WARNING
1721                              "cpqarray ida%d: idaGetGeometry - Controller"
1722                                 " failed to report status of logical drive %d\n"
1723                          "Access to this controller has been disabled\n",
1724                                 ctlr, log_unit);
1725                         goto err_4;
1726                 }
1727                 /*
1728                    Make sure the logical drive is configured
1729                  */
1730                 if (id_lstatus_buf->status != LOG_NOT_CONF) {
1731                         ret_code = sendcmd(ID_LOG_DRV, ctlr, id_ldrive,
1732                                sizeof(id_log_drv_t), 0, 0, log_unit);
1733                         /*
1734                            If error, the bit for this
1735                            logical drive won't be set and
1736                            idastubopen will return error. 
1737                          */
1738                         if (ret_code != IO_ERROR) {
1739                                 drv = &info_p->drv[log_unit];
1740                                 drv->blk_size = id_ldrive->blk_size;
1741                                 drv->nr_blks = id_ldrive->nr_blks;
1742                                 drv->cylinders = id_ldrive->drv.cyl;
1743                                 drv->heads = id_ldrive->drv.heads;
1744                                 drv->sectors = id_ldrive->drv.sect_per_track;
1745                                 info_p->log_drv_map |=  (1 << log_unit);
1746
1747         printk(KERN_INFO "cpqarray ida/c%dd%d: blksz=%d nr_blks=%d\n",
1748                 ctlr, log_unit, drv->blk_size, drv->nr_blks);
1749                                 ret_code = sendcmd(SENSE_CONFIG,
1750                                                   ctlr, sense_config_buf,
1751                                  sizeof(config_t), 0, 0, log_unit);
1752                                 if (ret_code == IO_ERROR) {
1753                                         info_p->log_drv_map = 0;
1754                                         printk(KERN_ERR "cpqarray: error sending sense config\n");
1755                                         goto err_4;
1756                                 }
1757
1758                                 info_p->phys_drives =
1759                                     sense_config_buf->ctlr_phys_drv;
1760                                 info_p->drv_assign_map
1761                                     |= sense_config_buf->drv_asgn_map;
1762                                 info_p->drv_assign_map
1763                                     |= sense_config_buf->spare_asgn_map;
1764                                 info_p->drv_spare_map
1765                                     |= sense_config_buf->spare_asgn_map;
1766                         }       /* end of if no error on id_ldrive */
1767                         log_index = log_index + 1;
1768                 }               /* end of if logical drive configured */
1769         }                       /* end of for log_unit */
1770
1771         /* Free all the buffers and return */
1772 err_4:
1773         kfree(sense_config_buf);
1774 err_3:
1775         kfree(id_lstatus_buf);
1776 err_2:
1777         kfree(id_ctlr_buf);
1778 err_1:
1779         kfree(id_ldrive);
1780 err_0:
1781         return;
1782 }
1783
1784 static void __exit cpqarray_exit(void)
1785 {
1786         int i;
1787
1788         pci_unregister_driver(&cpqarray_pci_driver);
1789
1790         /* Double check that all controller entries have been removed */
1791         for(i=0; i<MAX_CTLR; i++) {
1792                 if (hba[i] != NULL) {
1793                         printk(KERN_WARNING "cpqarray: Removing EISA "
1794                                         "controller %d\n", i);
1795                         cpqarray_remove_one_eisa(i);
1796                 }
1797         }
1798
1799         remove_proc_entry("driver/cpqarray", NULL);
1800 }
1801
1802 module_init(cpqarray_init)
1803 module_exit(cpqarray_exit)