virtio: Add memory statistics reporting to the balloon driver (V4)
[linux-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_hw_segments(q, SG_MAX);
452
453         /* This is a driver limit and could be eliminated. */
454         blk_queue_max_phys_segments(q, SG_MAX);
455         
456         init_timer(&hba[i]->timer);
457         hba[i]->timer.expires = jiffies + IDA_TIMER;
458         hba[i]->timer.data = (unsigned long)hba[i];
459         hba[i]->timer.function = ida_timer;
460         add_timer(&hba[i]->timer);
461
462         /* Enable IRQ now that spinlock and rate limit timer are set up */
463         hba[i]->access.set_intr_mask(hba[i], FIFO_NOT_EMPTY);
464
465         for(j=0; j<NWD; j++) {
466                 struct gendisk *disk = ida_gendisk[i][j];
467                 drv_info_t *drv = &hba[i]->drv[j];
468                 sprintf(disk->disk_name, "ida/c%dd%d", i, j);
469                 disk->major = COMPAQ_SMART2_MAJOR + i;
470                 disk->first_minor = j<<NWD_SHIFT;
471                 disk->fops = &ida_fops;
472                 if (j && !drv->nr_blks)
473                         continue;
474                 blk_queue_logical_block_size(hba[i]->queue, drv->blk_size);
475                 set_capacity(disk, drv->nr_blks);
476                 disk->queue = hba[i]->queue;
477                 disk->private_data = drv;
478                 add_disk(disk);
479         }
480
481         /* done ! */
482         return(i);
483
484 Enomem1:
485         nr_ctlr = i; 
486         kfree(hba[i]->cmd_pool_bits);
487         if (hba[i]->cmd_pool)
488                 pci_free_consistent(hba[i]->pci_dev, NR_CMDS*sizeof(cmdlist_t), 
489                                     hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
490 Enomem2:
491         while (j--) {
492                 put_disk(ida_gendisk[i][j]);
493                 ida_gendisk[i][j] = NULL;
494         }
495         free_irq(hba[i]->intr, hba[i]);
496 Enomem3:
497         unregister_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname);
498 Enomem4:
499         if (pdev)
500                 pci_set_drvdata(pdev, NULL);
501         release_io_mem(hba[i]);
502         free_hba(i);
503
504         printk( KERN_ERR "cpqarray: out of memory");
505
506         return -1;
507 }
508
509 static int __init cpqarray_init_one( struct pci_dev *pdev,
510         const struct pci_device_id *ent)
511 {
512         int i;
513
514         printk(KERN_DEBUG "cpqarray: Device 0x%x has been found at"
515                         " bus %d dev %d func %d\n",
516                         pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
517                         PCI_FUNC(pdev->devfn));
518         i = alloc_cpqarray_hba();
519         if( i < 0 )
520                 return (-1);
521         memset(hba[i], 0, sizeof(ctlr_info_t));
522         sprintf(hba[i]->devname, "ida%d", i);
523         hba[i]->ctlr = i;
524         /* Initialize the pdev driver private data */
525         pci_set_drvdata(pdev, hba[i]);
526
527         if (cpqarray_pci_init(hba[i], pdev) != 0) {
528                 pci_set_drvdata(pdev, NULL);
529                 release_io_mem(hba[i]);
530                 free_hba(i);
531                 return -1;
532         }
533
534         return (cpqarray_register_ctlr(i, pdev));
535 }
536
537 static struct pci_driver cpqarray_pci_driver = {
538         .name = "cpqarray",
539         .probe = cpqarray_init_one,
540         .remove = __devexit_p(cpqarray_remove_one_pci),
541         .id_table = cpqarray_pci_device_id,
542 };
543
544 /*
545  *  This is it.  Find all the controllers and register them.
546  *  returns the number of block devices registered.
547  */
548 static int __init cpqarray_init(void)
549 {
550         int num_cntlrs_reg = 0;
551         int i;
552         int rc = 0;
553
554         /* detect controllers */
555         printk(DRIVER_NAME "\n");
556
557         rc = pci_register_driver(&cpqarray_pci_driver);
558         if (rc)
559                 return rc;
560         cpqarray_eisa_detect();
561         
562         for (i=0; i < MAX_CTLR; i++) {
563                 if (hba[i] != NULL)
564                         num_cntlrs_reg++;
565         }
566
567         if (num_cntlrs_reg)
568                 return 0;
569         else {
570                 pci_unregister_driver(&cpqarray_pci_driver);
571                 return -ENODEV;
572         }
573 }
574
575 /* Function to find the first free pointer into our hba[] array */
576 /* Returns -1 if no free entries are left.  */
577 static int alloc_cpqarray_hba(void)
578 {
579         int i;
580
581         for(i=0; i< MAX_CTLR; i++) {
582                 if (hba[i] == NULL) {
583                         hba[i] = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
584                         if(hba[i]==NULL) {
585                                 printk(KERN_ERR "cpqarray: out of memory.\n");
586                                 return (-1);
587                         }
588                         return (i);
589                 }
590         }
591         printk(KERN_WARNING "cpqarray: This driver supports a maximum"
592                 " of 8 controllers.\n");
593         return(-1);
594 }
595
596 static void free_hba(int i)
597 {
598         kfree(hba[i]);
599         hba[i]=NULL;
600 }
601
602 /*
603  * Find the IO address of the controller, its IRQ and so forth.  Fill
604  * in some basic stuff into the ctlr_info_t structure.
605  */
606 static int cpqarray_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
607 {
608         ushort vendor_id, device_id, command;
609         unchar cache_line_size, latency_timer;
610         unchar irq, revision;
611         unsigned long addr[6];
612         __u32 board_id;
613
614         int i;
615
616         c->pci_dev = pdev;
617         pci_set_master(pdev);
618         if (pci_enable_device(pdev)) {
619                 printk(KERN_ERR "cpqarray: Unable to Enable PCI device\n");
620                 return -1;
621         }
622         vendor_id = pdev->vendor;
623         device_id = pdev->device;
624         irq = pdev->irq;
625
626         for(i=0; i<6; i++)
627                 addr[i] = pci_resource_start(pdev, i);
628
629         if (pci_set_dma_mask(pdev, CPQARRAY_DMA_MASK) != 0)
630         {
631                 printk(KERN_ERR "cpqarray: Unable to set DMA mask\n");
632                 return -1;
633         }
634
635         pci_read_config_word(pdev, PCI_COMMAND, &command);
636         pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
637         pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_line_size);
638         pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency_timer);
639
640         pci_read_config_dword(pdev, 0x2c, &board_id);
641
642         /* check to see if controller has been disabled */
643         if(!(command & 0x02)) {
644                 printk(KERN_WARNING
645                         "cpqarray: controller appears to be disabled\n");
646                 return(-1);
647         }
648
649 DBGINFO(
650         printk("vendor_id = %x\n", vendor_id);
651         printk("device_id = %x\n", device_id);
652         printk("command = %x\n", command);
653         for(i=0; i<6; i++)
654                 printk("addr[%d] = %lx\n", i, addr[i]);
655         printk("revision = %x\n", revision);
656         printk("irq = %x\n", irq);
657         printk("cache_line_size = %x\n", cache_line_size);
658         printk("latency_timer = %x\n", latency_timer);
659         printk("board_id = %x\n", board_id);
660 );
661
662         c->intr = irq;
663
664         for(i=0; i<6; i++) {
665                 if (pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE_IO)
666                 { /* IO space */
667                         c->io_mem_addr = addr[i];
668                         c->io_mem_length = pci_resource_end(pdev, i)
669                                 - pci_resource_start(pdev, i) + 1;
670                         if(!request_region( c->io_mem_addr, c->io_mem_length,
671                                 "cpqarray"))
672                         {
673                                 printk( KERN_WARNING "cpqarray I/O memory range already in use addr %lx length = %ld\n", c->io_mem_addr, c->io_mem_length);
674                                 c->io_mem_addr = 0;
675                                 c->io_mem_length = 0;
676                         }
677                         break;
678                 }
679         }
680
681         c->paddr = 0;
682         for(i=0; i<6; i++)
683                 if (!(pci_resource_flags(pdev, i) &
684                                 PCI_BASE_ADDRESS_SPACE_IO)) {
685                         c->paddr = pci_resource_start (pdev, i);
686                         break;
687                 }
688         if (!c->paddr)
689                 return -1;
690         c->vaddr = remap_pci_mem(c->paddr, 128);
691         if (!c->vaddr)
692                 return -1;
693         c->board_id = board_id;
694
695         for(i=0; i<NR_PRODUCTS; i++) {
696                 if (board_id == products[i].board_id) {
697                         c->product_name = products[i].product_name;
698                         c->access = *(products[i].access);
699                         break;
700                 }
701         }
702         if (i == NR_PRODUCTS) {
703                 printk(KERN_WARNING "cpqarray: Sorry, I don't know how"
704                         " to access the SMART Array controller %08lx\n", 
705                                 (unsigned long)board_id);
706                 return -1;
707         }
708
709         return 0;
710 }
711
712 /*
713  * Map (physical) PCI mem into (virtual) kernel space
714  */
715 static void __iomem *remap_pci_mem(ulong base, ulong size)
716 {
717         ulong page_base        = ((ulong) base) & PAGE_MASK;
718         ulong page_offs        = ((ulong) base) - page_base;
719         void __iomem *page_remapped    = ioremap(page_base, page_offs+size);
720
721         return (page_remapped ? (page_remapped + page_offs) : NULL);
722 }
723
724 #ifndef MODULE
725 /*
726  * Config string is a comma separated set of i/o addresses of EISA cards.
727  */
728 static int cpqarray_setup(char *str)
729 {
730         int i, ints[9];
731
732         (void)get_options(str, ARRAY_SIZE(ints), ints);
733
734         for(i=0; i<ints[0] && i<8; i++)
735                 eisa[i] = ints[i+1];
736         return 1;
737 }
738
739 __setup("smart2=", cpqarray_setup);
740
741 #endif
742
743 /*
744  * Find an EISA controller's signature.  Set up an hba if we find it.
745  */
746 static int __init cpqarray_eisa_detect(void)
747 {
748         int i=0, j;
749         __u32 board_id;
750         int intr;
751         int ctlr;
752         int num_ctlr = 0;
753
754         while(i<8 && eisa[i]) {
755                 ctlr = alloc_cpqarray_hba();
756                 if(ctlr == -1)
757                         break;
758                 board_id = inl(eisa[i]+0xC80);
759                 for(j=0; j < NR_PRODUCTS; j++)
760                         if (board_id == products[j].board_id) 
761                                 break;
762
763                 if (j == NR_PRODUCTS) {
764                         printk(KERN_WARNING "cpqarray: Sorry, I don't know how"
765                                 " to access the SMART Array controller %08lx\n",                                 (unsigned long)board_id);
766                         continue;
767                 }
768
769                 memset(hba[ctlr], 0, sizeof(ctlr_info_t));
770                 hba[ctlr]->io_mem_addr = eisa[i];
771                 hba[ctlr]->io_mem_length = 0x7FF;
772                 if(!request_region(hba[ctlr]->io_mem_addr,
773                                 hba[ctlr]->io_mem_length,
774                                 "cpqarray"))
775                 {
776                         printk(KERN_WARNING "cpqarray: I/O range already in "
777                                         "use addr = %lx length = %ld\n",
778                                         hba[ctlr]->io_mem_addr,
779                                         hba[ctlr]->io_mem_length);
780                         free_hba(ctlr);
781                         continue;
782                 }
783
784                 /*
785                  * Read the config register to find our interrupt
786                  */
787                 intr = inb(eisa[i]+0xCC0) >> 4;
788                 if (intr & 1) intr = 11;
789                 else if (intr & 2) intr = 10;
790                 else if (intr & 4) intr = 14;
791                 else if (intr & 8) intr = 15;
792                 
793                 hba[ctlr]->intr = intr;
794                 sprintf(hba[ctlr]->devname, "ida%d", nr_ctlr);
795                 hba[ctlr]->product_name = products[j].product_name;
796                 hba[ctlr]->access = *(products[j].access);
797                 hba[ctlr]->ctlr = ctlr;
798                 hba[ctlr]->board_id = board_id;
799                 hba[ctlr]->pci_dev = NULL; /* not PCI */
800
801 DBGINFO(
802         printk("i = %d, j = %d\n", i, j);
803         printk("irq = %x\n", intr);
804         printk("product name = %s\n", products[j].product_name);
805         printk("board_id = %x\n", board_id);
806 );
807
808                 num_ctlr++;
809                 i++;
810
811                 if (cpqarray_register_ctlr(ctlr, NULL) == -1)
812                         printk(KERN_WARNING
813                                 "cpqarray: Can't register EISA controller %d\n",
814                                 ctlr);
815
816         }
817
818         return num_ctlr;
819 }
820
821 /*
822  * Open.  Make sure the device is really there.
823  */
824 static int ida_open(struct block_device *bdev, fmode_t mode)
825 {
826         drv_info_t *drv = get_drv(bdev->bd_disk);
827         ctlr_info_t *host = get_host(bdev->bd_disk);
828
829         DBGINFO(printk("ida_open %s\n", bdev->bd_disk->disk_name));
830         /*
831          * Root is allowed to open raw volume zero even if it's not configured
832          * so array config can still work.  I don't think I really like this,
833          * but I'm already using way to many device nodes to claim another one
834          * for "raw controller".
835          */
836         if (!drv->nr_blks) {
837                 if (!capable(CAP_SYS_RAWIO))
838                         return -ENXIO;
839                 if (!capable(CAP_SYS_ADMIN) && drv != host->drv)
840                         return -ENXIO;
841         }
842         host->usage_count++;
843         return 0;
844 }
845
846 /*
847  * Close.  Sync first.
848  */
849 static int ida_release(struct gendisk *disk, fmode_t mode)
850 {
851         ctlr_info_t *host = get_host(disk);
852         host->usage_count--;
853         return 0;
854 }
855
856 /*
857  * Enqueuing and dequeuing functions for cmdlists.
858  */
859 static inline void addQ(cmdlist_t **Qptr, cmdlist_t *c)
860 {
861         if (*Qptr == NULL) {
862                 *Qptr = c;
863                 c->next = c->prev = c;
864         } else {
865                 c->prev = (*Qptr)->prev;
866                 c->next = (*Qptr);
867                 (*Qptr)->prev->next = c;
868                 (*Qptr)->prev = c;
869         }
870 }
871
872 static inline cmdlist_t *removeQ(cmdlist_t **Qptr, cmdlist_t *c)
873 {
874         if (c && c->next != c) {
875                 if (*Qptr == c) *Qptr = c->next;
876                 c->prev->next = c->next;
877                 c->next->prev = c->prev;
878         } else {
879                 *Qptr = NULL;
880         }
881         return c;
882 }
883
884 /*
885  * Get a request and submit it to the controller.
886  * This routine needs to grab all the requests it possibly can from the
887  * req Q and submit them.  Interrupts are off (and need to be off) when you
888  * are in here (either via the dummy do_ida_request functions or by being
889  * called from the interrupt handler
890  */
891 static void do_ida_request(struct request_queue *q)
892 {
893         ctlr_info_t *h = q->queuedata;
894         cmdlist_t *c;
895         struct request *creq;
896         struct scatterlist tmp_sg[SG_MAX];
897         int i, dir, seg;
898
899         if (blk_queue_plugged(q))
900                 goto startio;
901
902 queue_next:
903         creq = blk_peek_request(q);
904         if (!creq)
905                 goto startio;
906
907         BUG_ON(creq->nr_phys_segments > SG_MAX);
908
909         if ((c = cmd_alloc(h,1)) == NULL)
910                 goto startio;
911
912         blk_start_request(creq);
913
914         c->ctlr = h->ctlr;
915         c->hdr.unit = (drv_info_t *)(creq->rq_disk->private_data) - h->drv;
916         c->hdr.size = sizeof(rblk_t) >> 2;
917         c->size += sizeof(rblk_t);
918
919         c->req.hdr.blk = blk_rq_pos(creq);
920         c->rq = creq;
921 DBGPX(
922         printk("sector=%d, nr_sectors=%u\n",
923                blk_rq_pos(creq), blk_rq_sectors(creq));
924 );
925         sg_init_table(tmp_sg, SG_MAX);
926         seg = blk_rq_map_sg(q, creq, tmp_sg);
927
928         /* Now do all the DMA Mappings */
929         if (rq_data_dir(creq) == READ)
930                 dir = PCI_DMA_FROMDEVICE;
931         else
932                 dir = PCI_DMA_TODEVICE;
933         for( i=0; i < seg; i++)
934         {
935                 c->req.sg[i].size = tmp_sg[i].length;
936                 c->req.sg[i].addr = (__u32) pci_map_page(h->pci_dev,
937                                                  sg_page(&tmp_sg[i]),
938                                                  tmp_sg[i].offset,
939                                                  tmp_sg[i].length, dir);
940         }
941 DBGPX(  printk("Submitting %u sectors in %d segments\n", blk_rq_sectors(creq), seg); );
942         c->req.hdr.sg_cnt = seg;
943         c->req.hdr.blk_cnt = blk_rq_sectors(creq);
944         c->req.hdr.cmd = (rq_data_dir(creq) == READ) ? IDA_READ : IDA_WRITE;
945         c->type = CMD_RWREQ;
946
947         /* Put the request on the tail of the request queue */
948         addQ(&h->reqQ, c);
949         h->Qdepth++;
950         if (h->Qdepth > h->maxQsinceinit) 
951                 h->maxQsinceinit = h->Qdepth;
952
953         goto queue_next;
954
955 startio:
956         start_io(h);
957 }
958
959 /* 
960  * start_io submits everything on a controller's request queue
961  * and moves it to the completion queue.
962  *
963  * Interrupts had better be off if you're in here
964  */
965 static void start_io(ctlr_info_t *h)
966 {
967         cmdlist_t *c;
968
969         while((c = h->reqQ) != NULL) {
970                 /* Can't do anything if we're busy */
971                 if (h->access.fifo_full(h) == 0)
972                         return;
973
974                 /* Get the first entry from the request Q */
975                 removeQ(&h->reqQ, c);
976                 h->Qdepth--;
977         
978                 /* Tell the controller to do our bidding */
979                 h->access.submit_command(h, c);
980
981                 /* Get onto the completion Q */
982                 addQ(&h->cmpQ, c);
983         }
984 }
985
986 /*
987  * Mark all buffers that cmd was responsible for
988  */
989 static inline void complete_command(cmdlist_t *cmd, int timeout)
990 {
991         struct request *rq = cmd->rq;
992         int error = 0;
993         int i, ddir;
994
995         if (cmd->req.hdr.rcode & RCODE_NONFATAL &&
996            (hba[cmd->ctlr]->misc_tflags & MISC_NONFATAL_WARN) == 0) {
997                 printk(KERN_NOTICE "Non Fatal error on ida/c%dd%d\n",
998                                 cmd->ctlr, cmd->hdr.unit);
999                 hba[cmd->ctlr]->misc_tflags |= MISC_NONFATAL_WARN;
1000         }
1001         if (cmd->req.hdr.rcode & RCODE_FATAL) {
1002                 printk(KERN_WARNING "Fatal error on ida/c%dd%d\n",
1003                                 cmd->ctlr, cmd->hdr.unit);
1004                 error = -EIO;
1005         }
1006         if (cmd->req.hdr.rcode & RCODE_INVREQ) {
1007                                 printk(KERN_WARNING "Invalid request on ida/c%dd%d = (cmd=%x sect=%d cnt=%d sg=%d ret=%x)\n",
1008                                 cmd->ctlr, cmd->hdr.unit, cmd->req.hdr.cmd,
1009                                 cmd->req.hdr.blk, cmd->req.hdr.blk_cnt,
1010                                 cmd->req.hdr.sg_cnt, cmd->req.hdr.rcode);
1011                 error = -EIO;
1012         }
1013         if (timeout)
1014                 error = -EIO;
1015         /* unmap the DMA mapping for all the scatter gather elements */
1016         if (cmd->req.hdr.cmd == IDA_READ)
1017                 ddir = PCI_DMA_FROMDEVICE;
1018         else
1019                 ddir = PCI_DMA_TODEVICE;
1020         for(i=0; i<cmd->req.hdr.sg_cnt; i++)
1021                 pci_unmap_page(hba[cmd->ctlr]->pci_dev, cmd->req.sg[i].addr,
1022                                 cmd->req.sg[i].size, ddir);
1023
1024         DBGPX(printk("Done with %p\n", rq););
1025         __blk_end_request_all(rq, error);
1026 }
1027
1028 /*
1029  *  The controller will interrupt us upon completion of commands.
1030  *  Find the command on the completion queue, remove it, tell the OS and
1031  *  try to queue up more IO
1032  */
1033 static irqreturn_t do_ida_intr(int irq, void *dev_id)
1034 {
1035         ctlr_info_t *h = dev_id;
1036         cmdlist_t *c;
1037         unsigned long istat;
1038         unsigned long flags;
1039         __u32 a,a1;
1040
1041         istat = h->access.intr_pending(h);
1042         /* Is this interrupt for us? */
1043         if (istat == 0)
1044                 return IRQ_NONE;
1045
1046         /*
1047          * If there are completed commands in the completion queue,
1048          * we had better do something about it.
1049          */
1050         spin_lock_irqsave(IDA_LOCK(h->ctlr), flags);
1051         if (istat & FIFO_NOT_EMPTY) {
1052                 while((a = h->access.command_completed(h))) {
1053                         a1 = a; a &= ~3;
1054                         if ((c = h->cmpQ) == NULL)
1055                         {  
1056                                 printk(KERN_WARNING "cpqarray: Completion of %08lx ignored\n", (unsigned long)a1);
1057                                 continue;       
1058                         } 
1059                         while(c->busaddr != a) {
1060                                 c = c->next;
1061                                 if (c == h->cmpQ) 
1062                                         break;
1063                         }
1064                         /*
1065                          * If we've found the command, take it off the
1066                          * completion Q and free it
1067                          */
1068                         if (c->busaddr == a) {
1069                                 removeQ(&h->cmpQ, c);
1070                                 /*  Check for invalid command.
1071                                  *  Controller returns command error,
1072                                  *  But rcode = 0.
1073                                  */
1074
1075                                 if((a1 & 0x03) && (c->req.hdr.rcode == 0))
1076                                 {
1077                                         c->req.hdr.rcode = RCODE_INVREQ;
1078                                 }
1079                                 if (c->type == CMD_RWREQ) {
1080                                         complete_command(c, 0);
1081                                         cmd_free(h, c, 1);
1082                                 } else if (c->type == CMD_IOCTL_PEND) {
1083                                         c->type = CMD_IOCTL_DONE;
1084                                 }
1085                                 continue;
1086                         }
1087                 }
1088         }
1089
1090         /*
1091          * See if we can queue up some more IO
1092          */
1093         do_ida_request(h->queue);
1094         spin_unlock_irqrestore(IDA_LOCK(h->ctlr), flags); 
1095         return IRQ_HANDLED;
1096 }
1097
1098 /*
1099  * This timer was for timing out requests that haven't happened after
1100  * IDA_TIMEOUT.  That wasn't such a good idea.  This timer is used to
1101  * reset a flags structure so we don't flood the user with
1102  * "Non-Fatal error" messages.
1103  */
1104 static void ida_timer(unsigned long tdata)
1105 {
1106         ctlr_info_t *h = (ctlr_info_t*)tdata;
1107
1108         h->timer.expires = jiffies + IDA_TIMER;
1109         add_timer(&h->timer);
1110         h->misc_tflags = 0;
1111 }
1112
1113 static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1114 {
1115         drv_info_t *drv = get_drv(bdev->bd_disk);
1116
1117         if (drv->cylinders) {
1118                 geo->heads = drv->heads;
1119                 geo->sectors = drv->sectors;
1120                 geo->cylinders = drv->cylinders;
1121         } else {
1122                 geo->heads = 0xff;
1123                 geo->sectors = 0x3f;
1124                 geo->cylinders = drv->nr_blks / (0xff*0x3f);
1125         }
1126
1127         return 0;
1128 }
1129
1130 /*
1131  *  ida_ioctl does some miscellaneous stuff like reporting drive geometry,
1132  *  setting readahead and submitting commands from userspace to the controller.
1133  */
1134 static int ida_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
1135 {
1136         drv_info_t *drv = get_drv(bdev->bd_disk);
1137         ctlr_info_t *host = get_host(bdev->bd_disk);
1138         int error;
1139         ida_ioctl_t __user *io = (ida_ioctl_t __user *)arg;
1140         ida_ioctl_t *my_io;
1141
1142         switch(cmd) {
1143         case IDAGETDRVINFO:
1144                 if (copy_to_user(&io->c.drv, drv, sizeof(drv_info_t)))
1145                         return -EFAULT;
1146                 return 0;
1147         case IDAPASSTHRU:
1148                 if (!capable(CAP_SYS_RAWIO))
1149                         return -EPERM;
1150                 my_io = kmalloc(sizeof(ida_ioctl_t), GFP_KERNEL);
1151                 if (!my_io)
1152                         return -ENOMEM;
1153                 error = -EFAULT;
1154                 if (copy_from_user(my_io, io, sizeof(*my_io)))
1155                         goto out_passthru;
1156                 error = ida_ctlr_ioctl(host, drv - host->drv, my_io);
1157                 if (error)
1158                         goto out_passthru;
1159                 error = -EFAULT;
1160                 if (copy_to_user(io, my_io, sizeof(*my_io)))
1161                         goto out_passthru;
1162                 error = 0;
1163 out_passthru:
1164                 kfree(my_io);
1165                 return error;
1166         case IDAGETCTLRSIG:
1167                 if (!arg) return -EINVAL;
1168                 put_user(host->ctlr_sig, (int __user *)arg);
1169                 return 0;
1170         case IDAREVALIDATEVOLS:
1171                 if (MINOR(bdev->bd_dev) != 0)
1172                         return -ENXIO;
1173                 return revalidate_allvol(host);
1174         case IDADRIVERVERSION:
1175                 if (!arg) return -EINVAL;
1176                 put_user(DRIVER_VERSION, (unsigned long __user *)arg);
1177                 return 0;
1178         case IDAGETPCIINFO:
1179         {
1180                 
1181                 ida_pci_info_struct pciinfo;
1182
1183                 if (!arg) return -EINVAL;
1184                 pciinfo.bus = host->pci_dev->bus->number;
1185                 pciinfo.dev_fn = host->pci_dev->devfn;
1186                 pciinfo.board_id = host->board_id;
1187                 if(copy_to_user((void __user *) arg, &pciinfo,  
1188                         sizeof( ida_pci_info_struct)))
1189                                 return -EFAULT;
1190                 return(0);
1191         }       
1192
1193         default:
1194                 return -EINVAL;
1195         }
1196                 
1197 }
1198 /*
1199  * ida_ctlr_ioctl is for passing commands to the controller from userspace.
1200  * The command block (io) has already been copied to kernel space for us,
1201  * however, any elements in the sglist need to be copied to kernel space
1202  * or copied back to userspace.
1203  *
1204  * Only root may perform a controller passthru command, however I'm not doing
1205  * any serious sanity checking on the arguments.  Doing an IDA_WRITE_MEDIA and
1206  * putting a 64M buffer in the sglist is probably a *bad* idea.
1207  */
1208 static int ida_ctlr_ioctl(ctlr_info_t *h, int dsk, ida_ioctl_t *io)
1209 {
1210         int ctlr = h->ctlr;
1211         cmdlist_t *c;
1212         void *p = NULL;
1213         unsigned long flags;
1214         int error;
1215
1216         if ((c = cmd_alloc(h, 0)) == NULL)
1217                 return -ENOMEM;
1218         c->ctlr = ctlr;
1219         c->hdr.unit = (io->unit & UNITVALID) ? (io->unit & ~UNITVALID) : dsk;
1220         c->hdr.size = sizeof(rblk_t) >> 2;
1221         c->size += sizeof(rblk_t);
1222
1223         c->req.hdr.cmd = io->cmd;
1224         c->req.hdr.blk = io->blk;
1225         c->req.hdr.blk_cnt = io->blk_cnt;
1226         c->type = CMD_IOCTL_PEND;
1227
1228         /* Pre submit processing */
1229         switch(io->cmd) {
1230         case PASSTHRU_A:
1231                 p = kmalloc(io->sg[0].size, GFP_KERNEL);
1232                 if (!p) 
1233                 { 
1234                         error = -ENOMEM; 
1235                         cmd_free(h, c, 0); 
1236                         return(error);
1237                 }
1238                 if (copy_from_user(p, io->sg[0].addr, io->sg[0].size)) {
1239                         kfree(p);
1240                         cmd_free(h, c, 0); 
1241                         return -EFAULT;
1242                 }
1243                 c->req.hdr.blk = pci_map_single(h->pci_dev, &(io->c), 
1244                                 sizeof(ida_ioctl_t), 
1245                                 PCI_DMA_BIDIRECTIONAL);
1246                 c->req.sg[0].size = io->sg[0].size;
1247                 c->req.sg[0].addr = pci_map_single(h->pci_dev, p, 
1248                         c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1249                 c->req.hdr.sg_cnt = 1;
1250                 break;
1251         case IDA_READ:
1252         case READ_FLASH_ROM:
1253         case SENSE_CONTROLLER_PERFORMANCE:
1254                 p = kmalloc(io->sg[0].size, GFP_KERNEL);
1255                 if (!p) 
1256                 { 
1257                         error = -ENOMEM; 
1258                         cmd_free(h, c, 0);
1259                         return(error);
1260                 }
1261
1262                 c->req.sg[0].size = io->sg[0].size;
1263                 c->req.sg[0].addr = pci_map_single(h->pci_dev, p, 
1264                         c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL); 
1265                 c->req.hdr.sg_cnt = 1;
1266                 break;
1267         case IDA_WRITE:
1268         case IDA_WRITE_MEDIA:
1269         case DIAG_PASS_THRU:
1270         case COLLECT_BUFFER:
1271         case WRITE_FLASH_ROM:
1272                 p = kmalloc(io->sg[0].size, GFP_KERNEL);
1273                 if (!p) 
1274                 { 
1275                         error = -ENOMEM; 
1276                         cmd_free(h, c, 0);
1277                         return(error);
1278                 }
1279                 if (copy_from_user(p, io->sg[0].addr, io->sg[0].size)) {
1280                         kfree(p);
1281                         cmd_free(h, c, 0);
1282                         return -EFAULT;
1283                 }
1284                 c->req.sg[0].size = io->sg[0].size;
1285                 c->req.sg[0].addr = pci_map_single(h->pci_dev, p, 
1286                         c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL); 
1287                 c->req.hdr.sg_cnt = 1;
1288                 break;
1289         default:
1290                 c->req.sg[0].size = sizeof(io->c);
1291                 c->req.sg[0].addr = pci_map_single(h->pci_dev,&io->c, 
1292                         c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1293                 c->req.hdr.sg_cnt = 1;
1294         }
1295         
1296         /* Put the request on the tail of the request queue */
1297         spin_lock_irqsave(IDA_LOCK(ctlr), flags);
1298         addQ(&h->reqQ, c);
1299         h->Qdepth++;
1300         start_io(h);
1301         spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1302
1303         /* Wait for completion */
1304         while(c->type != CMD_IOCTL_DONE)
1305                 schedule();
1306
1307         /* Unmap the DMA  */
1308         pci_unmap_single(h->pci_dev, c->req.sg[0].addr, c->req.sg[0].size, 
1309                 PCI_DMA_BIDIRECTIONAL);
1310         /* Post submit processing */
1311         switch(io->cmd) {
1312         case PASSTHRU_A:
1313                 pci_unmap_single(h->pci_dev, c->req.hdr.blk,
1314                                 sizeof(ida_ioctl_t),
1315                                 PCI_DMA_BIDIRECTIONAL);
1316         case IDA_READ:
1317         case DIAG_PASS_THRU:
1318         case SENSE_CONTROLLER_PERFORMANCE:
1319         case READ_FLASH_ROM:
1320                 if (copy_to_user(io->sg[0].addr, p, io->sg[0].size)) {
1321                         kfree(p);
1322                         return -EFAULT;
1323                 }
1324                 /* fall through and free p */
1325         case IDA_WRITE:
1326         case IDA_WRITE_MEDIA:
1327         case COLLECT_BUFFER:
1328         case WRITE_FLASH_ROM:
1329                 kfree(p);
1330                 break;
1331         default:;
1332                 /* Nothing to do */
1333         }
1334
1335         io->rcode = c->req.hdr.rcode;
1336         cmd_free(h, c, 0);
1337         return(0);
1338 }
1339
1340 /*
1341  * Commands are pre-allocated in a large block.  Here we use a simple bitmap
1342  * scheme to suballocte them to the driver.  Operations that are not time
1343  * critical (and can wait for kmalloc and possibly sleep) can pass in NULL
1344  * as the first argument to get a new command.
1345  */
1346 static cmdlist_t * cmd_alloc(ctlr_info_t *h, int get_from_pool)
1347 {
1348         cmdlist_t * c;
1349         int i;
1350         dma_addr_t cmd_dhandle;
1351
1352         if (!get_from_pool) {
1353                 c = (cmdlist_t*)pci_alloc_consistent(h->pci_dev, 
1354                         sizeof(cmdlist_t), &cmd_dhandle);
1355                 if(c==NULL)
1356                         return NULL;
1357         } else {
1358                 do {
1359                         i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
1360                         if (i == NR_CMDS)
1361                                 return NULL;
1362                 } while(test_and_set_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
1363                 c = h->cmd_pool + i;
1364                 cmd_dhandle = h->cmd_pool_dhandle + i*sizeof(cmdlist_t);
1365                 h->nr_allocs++;
1366         }
1367
1368         memset(c, 0, sizeof(cmdlist_t));
1369         c->busaddr = cmd_dhandle; 
1370         return c;
1371 }
1372
1373 static void cmd_free(ctlr_info_t *h, cmdlist_t *c, int got_from_pool)
1374 {
1375         int i;
1376
1377         if (!got_from_pool) {
1378                 pci_free_consistent(h->pci_dev, sizeof(cmdlist_t), c,
1379                         c->busaddr);
1380         } else {
1381                 i = c - h->cmd_pool;
1382                 clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
1383                 h->nr_frees++;
1384         }
1385 }
1386
1387 /***********************************************************************
1388     name:        sendcmd
1389     Send a command to an IDA using the memory mapped FIFO interface
1390     and wait for it to complete.  
1391     This routine should only be called at init time.
1392 ***********************************************************************/
1393 static int sendcmd(
1394         __u8    cmd,
1395         int     ctlr,
1396         void    *buff,
1397         size_t  size,
1398         unsigned int blk,
1399         unsigned int blkcnt,
1400         unsigned int log_unit )
1401 {
1402         cmdlist_t *c;
1403         int complete;
1404         unsigned long temp;
1405         unsigned long i;
1406         ctlr_info_t *info_p = hba[ctlr];
1407
1408         c = cmd_alloc(info_p, 1);
1409         if(!c)
1410                 return IO_ERROR;
1411         c->ctlr = ctlr;
1412         c->hdr.unit = log_unit;
1413         c->hdr.prio = 0;
1414         c->hdr.size = sizeof(rblk_t) >> 2;
1415         c->size += sizeof(rblk_t);
1416
1417         /* The request information. */
1418         c->req.hdr.next = 0;
1419         c->req.hdr.rcode = 0;
1420         c->req.bp = 0;
1421         c->req.hdr.sg_cnt = 1;
1422         c->req.hdr.reserved = 0;
1423         
1424         if (size == 0)
1425                 c->req.sg[0].size = 512;
1426         else
1427                 c->req.sg[0].size = size;
1428
1429         c->req.hdr.blk = blk;
1430         c->req.hdr.blk_cnt = blkcnt;
1431         c->req.hdr.cmd = (unsigned char) cmd;
1432         c->req.sg[0].addr = (__u32) pci_map_single(info_p->pci_dev, 
1433                 buff, c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1434         /*
1435          * Disable interrupt
1436          */
1437         info_p->access.set_intr_mask(info_p, 0);
1438         /* Make sure there is room in the command FIFO */
1439         /* Actually it should be completely empty at this time. */
1440         for (i = 200000; i > 0; i--) {
1441                 temp = info_p->access.fifo_full(info_p);
1442                 if (temp != 0) {
1443                         break;
1444                 }
1445                 udelay(10);
1446 DBG(
1447                 printk(KERN_WARNING "cpqarray ida%d: idaSendPciCmd FIFO full,"
1448                         " waiting!\n", ctlr);
1449 );
1450         } 
1451         /*
1452          * Send the cmd
1453          */
1454         info_p->access.submit_command(info_p, c);
1455         complete = pollcomplete(ctlr);
1456         
1457         pci_unmap_single(info_p->pci_dev, (dma_addr_t) c->req.sg[0].addr, 
1458                 c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1459         if (complete != 1) {
1460                 if (complete != c->busaddr) {
1461                         printk( KERN_WARNING
1462                         "cpqarray ida%d: idaSendPciCmd "
1463                       "Invalid command list address returned! (%08lx)\n",
1464                                 ctlr, (unsigned long)complete);
1465                         cmd_free(info_p, c, 1);
1466                         return (IO_ERROR);
1467                 }
1468         } else {
1469                 printk( KERN_WARNING
1470                         "cpqarray ida%d: idaSendPciCmd Timeout out, "
1471                         "No command list address returned!\n",
1472                         ctlr);
1473                 cmd_free(info_p, c, 1);
1474                 return (IO_ERROR);
1475         }
1476
1477         if (c->req.hdr.rcode & 0x00FE) {
1478                 if (!(c->req.hdr.rcode & BIG_PROBLEM)) {
1479                         printk( KERN_WARNING
1480                         "cpqarray ida%d: idaSendPciCmd, error: "
1481                                 "Controller failed at init time "
1482                                 "cmd: 0x%x, return code = 0x%x\n",
1483                                 ctlr, c->req.hdr.cmd, c->req.hdr.rcode);
1484
1485                         cmd_free(info_p, c, 1);
1486                         return (IO_ERROR);
1487                 }
1488         }
1489         cmd_free(info_p, c, 1);
1490         return (IO_OK);
1491 }
1492
1493 /*
1494  * revalidate_allvol is for online array config utilities.  After a
1495  * utility reconfigures the drives in the array, it can use this function
1496  * (through an ioctl) to make the driver zap any previous disk structs for
1497  * that controller and get new ones.
1498  *
1499  * Right now I'm using the getgeometry() function to do this, but this
1500  * function should probably be finer grained and allow you to revalidate one
1501  * particualar logical volume (instead of all of them on a particular
1502  * controller).
1503  */
1504 static int revalidate_allvol(ctlr_info_t *host)
1505 {
1506         int ctlr = host->ctlr;
1507         int i;
1508         unsigned long flags;
1509
1510         spin_lock_irqsave(IDA_LOCK(ctlr), flags);
1511         if (host->usage_count > 1) {
1512                 spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1513                 printk(KERN_WARNING "cpqarray: Device busy for volume"
1514                         " revalidation (usage=%d)\n", host->usage_count);
1515                 return -EBUSY;
1516         }
1517         host->usage_count++;
1518         spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1519
1520         /*
1521          * Set the partition and block size structures for all volumes
1522          * on this controller to zero.  We will reread all of this data
1523          */
1524         set_capacity(ida_gendisk[ctlr][0], 0);
1525         for (i = 1; i < NWD; i++) {
1526                 struct gendisk *disk = ida_gendisk[ctlr][i];
1527                 if (disk->flags & GENHD_FL_UP)
1528                         del_gendisk(disk);
1529         }
1530         memset(host->drv, 0, sizeof(drv_info_t)*NWD);
1531
1532         /*
1533          * Tell the array controller not to give us any interrupts while
1534          * we check the new geometry.  Then turn interrupts back on when
1535          * we're done.
1536          */
1537         host->access.set_intr_mask(host, 0);
1538         getgeometry(ctlr);
1539         host->access.set_intr_mask(host, FIFO_NOT_EMPTY);
1540
1541         for(i=0; i<NWD; i++) {
1542                 struct gendisk *disk = ida_gendisk[ctlr][i];
1543                 drv_info_t *drv = &host->drv[i];
1544                 if (i && !drv->nr_blks)
1545                         continue;
1546                 blk_queue_logical_block_size(host->queue, drv->blk_size);
1547                 set_capacity(disk, drv->nr_blks);
1548                 disk->queue = host->queue;
1549                 disk->private_data = drv;
1550                 if (i)
1551                         add_disk(disk);
1552         }
1553
1554         host->usage_count--;
1555         return 0;
1556 }
1557
1558 static int ida_revalidate(struct gendisk *disk)
1559 {
1560         drv_info_t *drv = disk->private_data;
1561         set_capacity(disk, drv->nr_blks);
1562         return 0;
1563 }
1564
1565 /********************************************************************
1566     name: pollcomplete
1567     Wait polling for a command to complete.
1568     The memory mapped FIFO is polled for the completion.
1569     Used only at init time, interrupts disabled.
1570  ********************************************************************/
1571 static int pollcomplete(int ctlr)
1572 {
1573         int done;
1574         int i;
1575
1576         /* Wait (up to 2 seconds) for a command to complete */
1577
1578         for (i = 200000; i > 0; i--) {
1579                 done = hba[ctlr]->access.command_completed(hba[ctlr]);
1580                 if (done == 0) {
1581                         udelay(10);     /* a short fixed delay */
1582                 } else
1583                         return (done);
1584         }
1585         /* Invalid address to tell caller we ran out of time */
1586         return 1;
1587 }
1588 /*****************************************************************
1589     start_fwbk
1590     Starts controller firmwares background processing. 
1591     Currently only the Integrated Raid controller needs this done.
1592     If the PCI mem address registers are written to after this, 
1593          data corruption may occur
1594 *****************************************************************/
1595 static void start_fwbk(int ctlr)
1596 {
1597                 id_ctlr_t *id_ctlr_buf; 
1598         int ret_code;
1599
1600         if(     (hba[ctlr]->board_id != 0x40400E11)
1601                 && (hba[ctlr]->board_id != 0x40480E11) )
1602
1603         /* Not a Integrated Raid, so there is nothing for us to do */
1604                 return;
1605         printk(KERN_DEBUG "cpqarray: Starting firmware's background"
1606                 " processing\n");
1607         /* Command does not return anything, but idasend command needs a 
1608                 buffer */
1609         id_ctlr_buf = kmalloc(sizeof(id_ctlr_t), GFP_KERNEL);
1610         if(id_ctlr_buf==NULL)
1611         {
1612                 printk(KERN_WARNING "cpqarray: Out of memory. "
1613                         "Unable to start background processing.\n");
1614                 return;
1615         }               
1616         ret_code = sendcmd(RESUME_BACKGROUND_ACTIVITY, ctlr, 
1617                 id_ctlr_buf, 0, 0, 0, 0);
1618         if(ret_code != IO_OK)
1619                 printk(KERN_WARNING "cpqarray: Unable to start"
1620                         " background processing\n");
1621
1622         kfree(id_ctlr_buf);
1623 }
1624 /*****************************************************************
1625     getgeometry
1626     Get ida logical volume geometry from the controller 
1627     This is a large bit of code which once existed in two flavors,
1628     It is used only at init time.
1629 *****************************************************************/
1630 static void getgeometry(int ctlr)
1631 {                               
1632         id_log_drv_t *id_ldrive;
1633         id_ctlr_t *id_ctlr_buf;
1634         sense_log_drv_stat_t *id_lstatus_buf;
1635         config_t *sense_config_buf;
1636         unsigned int log_unit, log_index;
1637         int ret_code, size;
1638         drv_info_t *drv;
1639         ctlr_info_t *info_p = hba[ctlr];
1640         int i;
1641
1642         info_p->log_drv_map = 0;        
1643         
1644         id_ldrive = kzalloc(sizeof(id_log_drv_t), GFP_KERNEL);
1645         if (!id_ldrive) {
1646                 printk( KERN_ERR "cpqarray:  out of memory.\n");
1647                 goto err_0;
1648         }
1649
1650         id_ctlr_buf = kzalloc(sizeof(id_ctlr_t), GFP_KERNEL);
1651         if (!id_ctlr_buf) {
1652                 printk( KERN_ERR "cpqarray:  out of memory.\n");
1653                 goto err_1;
1654         }
1655
1656         id_lstatus_buf = kzalloc(sizeof(sense_log_drv_stat_t), GFP_KERNEL);
1657         if (!id_lstatus_buf) {
1658                 printk( KERN_ERR "cpqarray:  out of memory.\n");
1659                 goto err_2;
1660         }
1661
1662         sense_config_buf = kzalloc(sizeof(config_t), GFP_KERNEL);
1663         if (!sense_config_buf) {
1664                 printk( KERN_ERR "cpqarray:  out of memory.\n");
1665                 goto err_3;
1666         }
1667
1668         info_p->phys_drives = 0;
1669         info_p->log_drv_map = 0;
1670         info_p->drv_assign_map = 0;
1671         info_p->drv_spare_map = 0;
1672         info_p->mp_failed_drv_map = 0;  /* only initialized here */
1673         /* Get controllers info for this logical drive */
1674         ret_code = sendcmd(ID_CTLR, ctlr, id_ctlr_buf, 0, 0, 0, 0);
1675         if (ret_code == IO_ERROR) {
1676                 /*
1677                  * If can't get controller info, set the logical drive map to 0,
1678                  * so the idastubopen will fail on all logical drives
1679                  * on the controller.
1680                  */
1681                 printk(KERN_ERR "cpqarray: error sending ID controller\n");
1682                 goto err_4;
1683         }
1684
1685         info_p->log_drives = id_ctlr_buf->nr_drvs;
1686         for(i=0;i<4;i++)
1687                 info_p->firm_rev[i] = id_ctlr_buf->firm_rev[i];
1688         info_p->ctlr_sig = id_ctlr_buf->cfg_sig;
1689
1690         printk(" (%s)\n", info_p->product_name);
1691         /*
1692          * Initialize logical drive map to zero
1693          */
1694         log_index = 0;
1695         /*
1696          * Get drive geometry for all logical drives
1697          */
1698         if (id_ctlr_buf->nr_drvs > 16)
1699                 printk(KERN_WARNING "cpqarray ida%d:  This driver supports "
1700                         "16 logical drives per controller.\n.  "
1701                         " Additional drives will not be "
1702                         "detected\n", ctlr);
1703
1704         for (log_unit = 0;
1705              (log_index < id_ctlr_buf->nr_drvs)
1706              && (log_unit < NWD);
1707              log_unit++) {
1708                 size = sizeof(sense_log_drv_stat_t);
1709
1710                 /*
1711                    Send "Identify logical drive status" cmd
1712                  */
1713                 ret_code = sendcmd(SENSE_LOG_DRV_STAT,
1714                              ctlr, id_lstatus_buf, size, 0, 0, log_unit);
1715                 if (ret_code == IO_ERROR) {
1716                         /*
1717                            If can't get logical drive status, set
1718                            the logical drive map to 0, so the
1719                            idastubopen will fail for all logical drives
1720                            on the controller. 
1721                          */
1722                         info_p->log_drv_map = 0;        
1723                         printk( KERN_WARNING
1724                              "cpqarray ida%d: idaGetGeometry - Controller"
1725                                 " failed to report status of logical drive %d\n"
1726                          "Access to this controller has been disabled\n",
1727                                 ctlr, log_unit);
1728                         goto err_4;
1729                 }
1730                 /*
1731                    Make sure the logical drive is configured
1732                  */
1733                 if (id_lstatus_buf->status != LOG_NOT_CONF) {
1734                         ret_code = sendcmd(ID_LOG_DRV, ctlr, id_ldrive,
1735                                sizeof(id_log_drv_t), 0, 0, log_unit);
1736                         /*
1737                            If error, the bit for this
1738                            logical drive won't be set and
1739                            idastubopen will return error. 
1740                          */
1741                         if (ret_code != IO_ERROR) {
1742                                 drv = &info_p->drv[log_unit];
1743                                 drv->blk_size = id_ldrive->blk_size;
1744                                 drv->nr_blks = id_ldrive->nr_blks;
1745                                 drv->cylinders = id_ldrive->drv.cyl;
1746                                 drv->heads = id_ldrive->drv.heads;
1747                                 drv->sectors = id_ldrive->drv.sect_per_track;
1748                                 info_p->log_drv_map |=  (1 << log_unit);
1749
1750         printk(KERN_INFO "cpqarray ida/c%dd%d: blksz=%d nr_blks=%d\n",
1751                 ctlr, log_unit, drv->blk_size, drv->nr_blks);
1752                                 ret_code = sendcmd(SENSE_CONFIG,
1753                                                   ctlr, sense_config_buf,
1754                                  sizeof(config_t), 0, 0, log_unit);
1755                                 if (ret_code == IO_ERROR) {
1756                                         info_p->log_drv_map = 0;
1757                                         printk(KERN_ERR "cpqarray: error sending sense config\n");
1758                                         goto err_4;
1759                                 }
1760
1761                                 info_p->phys_drives =
1762                                     sense_config_buf->ctlr_phys_drv;
1763                                 info_p->drv_assign_map
1764                                     |= sense_config_buf->drv_asgn_map;
1765                                 info_p->drv_assign_map
1766                                     |= sense_config_buf->spare_asgn_map;
1767                                 info_p->drv_spare_map
1768                                     |= sense_config_buf->spare_asgn_map;
1769                         }       /* end of if no error on id_ldrive */
1770                         log_index = log_index + 1;
1771                 }               /* end of if logical drive configured */
1772         }                       /* end of for log_unit */
1773
1774         /* Free all the buffers and return */
1775 err_4:
1776         kfree(sense_config_buf);
1777 err_3:
1778         kfree(id_lstatus_buf);
1779 err_2:
1780         kfree(id_ctlr_buf);
1781 err_1:
1782         kfree(id_ldrive);
1783 err_0:
1784         return;
1785 }
1786
1787 static void __exit cpqarray_exit(void)
1788 {
1789         int i;
1790
1791         pci_unregister_driver(&cpqarray_pci_driver);
1792
1793         /* Double check that all controller entries have been removed */
1794         for(i=0; i<MAX_CTLR; i++) {
1795                 if (hba[i] != NULL) {
1796                         printk(KERN_WARNING "cpqarray: Removing EISA "
1797                                         "controller %d\n", i);
1798                         cpqarray_remove_one_eisa(i);
1799                 }
1800         }
1801
1802         remove_proc_entry("driver/cpqarray", NULL);
1803 }
1804
1805 module_init(cpqarray_init)
1806 module_exit(cpqarray_exit)