2 * Disk Array driver for Compaq SMART2 Controllers
3 * Copyright 1998 Compaq Computer Corporation
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.
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.
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.
19 * Questions/Comments/Bugfixes to iss_storagedev@hp.com
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>
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/smp_lock.h>
39 #include <linux/spinlock.h>
40 #include <linux/blkdev.h>
41 #include <linux/genhd.h>
42 #include <linux/scatterlist.h>
43 #include <asm/uaccess.h>
47 #define SMART2_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
49 #define DRIVER_NAME "Compaq SMART2 Driver (v 2.6.0)"
50 #define DRIVER_VERSION SMART2_DRIVER_VERSION(2,6,0)
52 /* Embedded module documentation macros - see modules.h */
53 /* Original author Chris Frantz - Compaq Computer Corporation */
54 MODULE_AUTHOR("Compaq Computer Corporation");
55 MODULE_DESCRIPTION("Driver for Compaq Smart2 Array Controllers version 2.6.0");
56 MODULE_LICENSE("GPL");
61 #include "ida_ioctl.h"
63 #define READ_AHEAD 128
64 #define NR_CMDS 128 /* This could probably go as high as ~400 */
69 #define CPQARRAY_DMA_MASK 0xFFFFFFFF /* 32 bit DMA */
72 static ctlr_info_t *hba[MAX_CTLR];
76 #define NR_PRODUCTS ARRAY_SIZE(products)
78 /* board_id = Subsystem Device ID & Vendor ID
79 * product = Marketing Name for the board
80 * access = Address of the struct of function pointers
82 static struct board_type products[] = {
83 { 0x0040110E, "IDA", &smart1_access },
84 { 0x0140110E, "IDA-2", &smart1_access },
85 { 0x1040110E, "IAES", &smart1_access },
86 { 0x2040110E, "SMART", &smart1_access },
87 { 0x3040110E, "SMART-2/E", &smart2e_access },
88 { 0x40300E11, "SMART-2/P", &smart2_access },
89 { 0x40310E11, "SMART-2SL", &smart2_access },
90 { 0x40320E11, "Smart Array 3200", &smart2_access },
91 { 0x40330E11, "Smart Array 3100ES", &smart2_access },
92 { 0x40340E11, "Smart Array 221", &smart2_access },
93 { 0x40400E11, "Integrated Array", &smart4_access },
94 { 0x40480E11, "Compaq Raid LC2", &smart4_access },
95 { 0x40500E11, "Smart Array 4200", &smart4_access },
96 { 0x40510E11, "Smart Array 4250ES", &smart4_access },
97 { 0x40580E11, "Smart Array 431", &smart4_access },
100 /* define the PCI info for the PCI cards this driver can control */
101 static const struct pci_device_id cpqarray_pci_device_id[] =
103 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_COMPAQ_42XX,
104 0x0E11, 0x4058, 0, 0, 0}, /* SA431 */
105 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_COMPAQ_42XX,
106 0x0E11, 0x4051, 0, 0, 0}, /* SA4250ES */
107 { PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_COMPAQ_42XX,
108 0x0E11, 0x4050, 0, 0, 0}, /* SA4200 */
109 { PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C1510,
110 0x0E11, 0x4048, 0, 0, 0}, /* LC2 */
111 { PCI_VENDOR_ID_NCR, PCI_DEVICE_ID_NCR_53C1510,
112 0x0E11, 0x4040, 0, 0, 0}, /* Integrated Array */
113 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
114 0x0E11, 0x4034, 0, 0, 0}, /* SA 221 */
115 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
116 0x0E11, 0x4033, 0, 0, 0}, /* SA 3100ES*/
117 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
118 0x0E11, 0x4032, 0, 0, 0}, /* SA 3200*/
119 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
120 0x0E11, 0x4031, 0, 0, 0}, /* SA 2SL*/
121 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_SMART2P,
122 0x0E11, 0x4030, 0, 0, 0}, /* SA 2P */
126 MODULE_DEVICE_TABLE(pci, cpqarray_pci_device_id);
128 static struct gendisk *ida_gendisk[MAX_CTLR][NWD];
131 #define DBG(s) do { s } while(0)
132 /* Debug (general info)... */
133 #define DBGINFO(s) do { } while(0)
134 /* Debug Paranoid... */
135 #define DBGP(s) do { } while(0)
136 /* Debug Extra Paranoid... */
137 #define DBGPX(s) do { } while(0)
139 static int cpqarray_pci_init(ctlr_info_t *c, struct pci_dev *pdev);
140 static void __iomem *remap_pci_mem(ulong base, ulong size);
141 static int cpqarray_eisa_detect(void);
142 static int pollcomplete(int ctlr);
143 static void getgeometry(int ctlr);
144 static void start_fwbk(int ctlr);
146 static cmdlist_t * cmd_alloc(ctlr_info_t *h, int get_from_pool);
147 static void cmd_free(ctlr_info_t *h, cmdlist_t *c, int got_from_pool);
149 static void free_hba(int i);
150 static int alloc_cpqarray_hba(void);
159 unsigned int log_unit );
161 static int ida_unlocked_open(struct block_device *bdev, fmode_t mode);
162 static int ida_release(struct gendisk *disk, fmode_t mode);
163 static int ida_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg);
164 static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo);
165 static int ida_ctlr_ioctl(ctlr_info_t *h, int dsk, ida_ioctl_t *io);
167 static void do_ida_request(struct request_queue *q);
168 static void start_io(ctlr_info_t *h);
170 static inline void addQ(cmdlist_t **Qptr, cmdlist_t *c);
171 static inline cmdlist_t *removeQ(cmdlist_t **Qptr, cmdlist_t *c);
172 static inline void complete_command(cmdlist_t *cmd, int timeout);
174 static irqreturn_t do_ida_intr(int irq, void *dev_id);
175 static void ida_timer(unsigned long tdata);
176 static int ida_revalidate(struct gendisk *disk);
177 static int revalidate_allvol(ctlr_info_t *host);
178 static int cpqarray_register_ctlr(int ctlr, struct pci_dev *pdev);
180 #ifdef CONFIG_PROC_FS
181 static void ida_procinit(int i);
183 static void ida_procinit(int i) {}
186 static inline drv_info_t *get_drv(struct gendisk *disk)
188 return disk->private_data;
191 static inline ctlr_info_t *get_host(struct gendisk *disk)
193 return disk->queue->queuedata;
197 static const struct block_device_operations ida_fops = {
198 .owner = THIS_MODULE,
199 .open = ida_unlocked_open,
200 .release = ida_release,
202 .getgeo = ida_getgeo,
203 .revalidate_disk= ida_revalidate,
207 #ifdef CONFIG_PROC_FS
209 static struct proc_dir_entry *proc_array;
210 static const struct file_operations ida_proc_fops;
213 * Get us a file in /proc/array that says something about each controller.
214 * Create /proc/array if it doesn't exist yet.
216 static void __init ida_procinit(int i)
218 if (proc_array == NULL) {
219 proc_array = proc_mkdir("driver/cpqarray", NULL);
220 if (!proc_array) return;
223 proc_create_data(hba[i]->devname, 0, proc_array, &ida_proc_fops, hba[i]);
227 * Report information about this controller.
229 static int ida_proc_show(struct seq_file *m, void *v)
232 ctlr_info_t *h = (ctlr_info_t*)m->private;
234 #ifdef CPQ_PROC_PRINT_QUEUES
240 seq_printf(m, "%s: Compaq %s Controller\n"
241 " Board ID: 0x%08lx\n"
242 " Firmware Revision: %c%c%c%c\n"
243 " Controller Sig: 0x%08lx\n"
244 " Memory Address: 0x%08lx\n"
245 " I/O Port: 0x%04x\n"
247 " Logical drives: %d\n"
248 " Physical drives: %d\n\n"
249 " Current Q depth: %d\n"
250 " Max Q depth since init: %d\n\n",
253 (unsigned long)h->board_id,
254 h->firm_rev[0], h->firm_rev[1], h->firm_rev[2], h->firm_rev[3],
255 (unsigned long)h->ctlr_sig, (unsigned long)h->vaddr,
256 (unsigned int) h->io_mem_addr, (unsigned int)h->intr,
257 h->log_drives, h->phys_drives,
258 h->Qdepth, h->maxQsinceinit);
260 seq_puts(m, "Logical Drive Info:\n");
262 for(i=0; i<h->log_drives; i++) {
264 seq_printf(m, "ida/c%dd%d: blksz=%d nr_blks=%d\n",
265 ctlr, i, drv->blk_size, drv->nr_blks);
268 #ifdef CPQ_PROC_PRINT_QUEUES
269 spin_lock_irqsave(IDA_LOCK(h->ctlr), flags);
270 seq_puts(m, "\nCurrent Queues:\n");
273 seq_printf(m, "reqQ = %p", c);
275 while(c && c != h->reqQ) {
276 seq_printf(m, "->%p", c);
281 seq_printf(m, "\ncmpQ = %p", c);
283 while(c && c != h->cmpQ) {
284 seq_printf(m, "->%p", c);
289 spin_unlock_irqrestore(IDA_LOCK(h->ctlr), flags);
291 seq_printf(m, "nr_allocs = %d\nnr_frees = %d\n",
292 h->nr_allocs, h->nr_frees);
296 static int ida_proc_open(struct inode *inode, struct file *file)
298 return single_open(file, ida_proc_show, PDE(inode)->data);
301 static const struct file_operations ida_proc_fops = {
302 .owner = THIS_MODULE,
303 .open = ida_proc_open,
306 .release = single_release,
308 #endif /* CONFIG_PROC_FS */
310 module_param_array(eisa, int, NULL, 0);
312 static void release_io_mem(ctlr_info_t *c)
314 /* if IO mem was not protected do nothing */
315 if( c->io_mem_addr == 0)
317 release_region(c->io_mem_addr, c->io_mem_length);
319 c->io_mem_length = 0;
322 static void __devexit cpqarray_remove_one(int i)
327 /* sendcmd will turn off interrupt, and send the flush...
328 * To write all data in the battery backed cache to disks
329 * no data returned, but don't want to send NULL to sendcmd */
330 if( sendcmd(FLUSH_CACHE, i, buff, 4, 0, 0, 0))
332 printk(KERN_WARNING "Unable to flush cache on controller %d\n",
335 free_irq(hba[i]->intr, hba[i]);
336 iounmap(hba[i]->vaddr);
337 unregister_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname);
338 del_timer(&hba[i]->timer);
339 remove_proc_entry(hba[i]->devname, proc_array);
340 pci_free_consistent(hba[i]->pci_dev,
341 NR_CMDS * sizeof(cmdlist_t), (hba[i]->cmd_pool),
342 hba[i]->cmd_pool_dhandle);
343 kfree(hba[i]->cmd_pool_bits);
344 for(j = 0; j < NWD; j++) {
345 if (ida_gendisk[i][j]->flags & GENHD_FL_UP)
346 del_gendisk(ida_gendisk[i][j]);
347 put_disk(ida_gendisk[i][j]);
349 blk_cleanup_queue(hba[i]->queue);
350 release_io_mem(hba[i]);
354 static void __devexit cpqarray_remove_one_pci (struct pci_dev *pdev)
357 ctlr_info_t *tmp_ptr;
359 if (pci_get_drvdata(pdev) == NULL) {
360 printk( KERN_ERR "cpqarray: Unable to remove device \n");
364 tmp_ptr = pci_get_drvdata(pdev);
366 if (hba[i] == NULL) {
367 printk(KERN_ERR "cpqarray: controller %d appears to have"
368 "already been removed \n", i);
371 pci_set_drvdata(pdev, NULL);
373 cpqarray_remove_one(i);
376 /* removing an instance that was not removed automatically..
377 * must be an eisa card.
379 static void __devexit cpqarray_remove_one_eisa (int i)
381 if (hba[i] == NULL) {
382 printk(KERN_ERR "cpqarray: controller %d appears to have"
383 "already been removed \n", i);
386 cpqarray_remove_one(i);
389 /* pdev is NULL for eisa */
390 static int __devinit cpqarray_register_ctlr( int i, struct pci_dev *pdev)
392 struct request_queue *q;
396 * register block devices
397 * Find disks and fill in structs
398 * Get an interrupt, set the Q depth and get into /proc
401 /* If this successful it should insure that we are the only */
402 /* instance of the driver */
403 if (register_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname)) {
406 hba[i]->access.set_intr_mask(hba[i], 0);
407 if (request_irq(hba[i]->intr, do_ida_intr,
408 IRQF_DISABLED|IRQF_SHARED, hba[i]->devname, hba[i]))
410 printk(KERN_ERR "cpqarray: Unable to get irq %d for %s\n",
411 hba[i]->intr, hba[i]->devname);
415 for (j=0; j<NWD; j++) {
416 ida_gendisk[i][j] = alloc_disk(1 << NWD_SHIFT);
417 if (!ida_gendisk[i][j])
421 hba[i]->cmd_pool = pci_alloc_consistent(
422 hba[i]->pci_dev, NR_CMDS * sizeof(cmdlist_t),
423 &(hba[i]->cmd_pool_dhandle));
424 hba[i]->cmd_pool_bits = kcalloc(
425 DIV_ROUND_UP(NR_CMDS, BITS_PER_LONG), sizeof(unsigned long),
428 if (!hba[i]->cmd_pool_bits || !hba[i]->cmd_pool)
431 memset(hba[i]->cmd_pool, 0, NR_CMDS * sizeof(cmdlist_t));
432 printk(KERN_INFO "cpqarray: Finding drives on %s",
435 spin_lock_init(&hba[i]->lock);
436 q = blk_init_queue(do_ida_request, &hba[i]->lock);
441 q->queuedata = hba[i];
449 blk_queue_bounce_limit(q, hba[i]->pci_dev->dma_mask);
451 /* This is a hardware imposed limit. */
452 blk_queue_max_segments(q, SG_MAX);
454 init_timer(&hba[i]->timer);
455 hba[i]->timer.expires = jiffies + IDA_TIMER;
456 hba[i]->timer.data = (unsigned long)hba[i];
457 hba[i]->timer.function = ida_timer;
458 add_timer(&hba[i]->timer);
460 /* Enable IRQ now that spinlock and rate limit timer are set up */
461 hba[i]->access.set_intr_mask(hba[i], FIFO_NOT_EMPTY);
463 for(j=0; j<NWD; j++) {
464 struct gendisk *disk = ida_gendisk[i][j];
465 drv_info_t *drv = &hba[i]->drv[j];
466 sprintf(disk->disk_name, "ida/c%dd%d", i, j);
467 disk->major = COMPAQ_SMART2_MAJOR + i;
468 disk->first_minor = j<<NWD_SHIFT;
469 disk->fops = &ida_fops;
470 if (j && !drv->nr_blks)
472 blk_queue_logical_block_size(hba[i]->queue, drv->blk_size);
473 set_capacity(disk, drv->nr_blks);
474 disk->queue = hba[i]->queue;
475 disk->private_data = drv;
484 kfree(hba[i]->cmd_pool_bits);
485 if (hba[i]->cmd_pool)
486 pci_free_consistent(hba[i]->pci_dev, NR_CMDS*sizeof(cmdlist_t),
487 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
490 put_disk(ida_gendisk[i][j]);
491 ida_gendisk[i][j] = NULL;
493 free_irq(hba[i]->intr, hba[i]);
495 unregister_blkdev(COMPAQ_SMART2_MAJOR+i, hba[i]->devname);
498 pci_set_drvdata(pdev, NULL);
499 release_io_mem(hba[i]);
502 printk( KERN_ERR "cpqarray: out of memory");
507 static int __devinit cpqarray_init_one( struct pci_dev *pdev,
508 const struct pci_device_id *ent)
512 printk(KERN_DEBUG "cpqarray: Device 0x%x has been found at"
513 " bus %d dev %d func %d\n",
514 pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
515 PCI_FUNC(pdev->devfn));
516 i = alloc_cpqarray_hba();
519 memset(hba[i], 0, sizeof(ctlr_info_t));
520 sprintf(hba[i]->devname, "ida%d", i);
522 /* Initialize the pdev driver private data */
523 pci_set_drvdata(pdev, hba[i]);
525 if (cpqarray_pci_init(hba[i], pdev) != 0) {
526 pci_set_drvdata(pdev, NULL);
527 release_io_mem(hba[i]);
532 return (cpqarray_register_ctlr(i, pdev));
535 static struct pci_driver cpqarray_pci_driver = {
537 .probe = cpqarray_init_one,
538 .remove = __devexit_p(cpqarray_remove_one_pci),
539 .id_table = cpqarray_pci_device_id,
543 * This is it. Find all the controllers and register them.
544 * returns the number of block devices registered.
546 static int __init cpqarray_init(void)
548 int num_cntlrs_reg = 0;
552 /* detect controllers */
553 printk(DRIVER_NAME "\n");
555 rc = pci_register_driver(&cpqarray_pci_driver);
558 cpqarray_eisa_detect();
560 for (i=0; i < MAX_CTLR; i++) {
568 pci_unregister_driver(&cpqarray_pci_driver);
573 /* Function to find the first free pointer into our hba[] array */
574 /* Returns -1 if no free entries are left. */
575 static int alloc_cpqarray_hba(void)
579 for(i=0; i< MAX_CTLR; i++) {
580 if (hba[i] == NULL) {
581 hba[i] = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
583 printk(KERN_ERR "cpqarray: out of memory.\n");
589 printk(KERN_WARNING "cpqarray: This driver supports a maximum"
590 " of 8 controllers.\n");
594 static void free_hba(int i)
601 * Find the IO address of the controller, its IRQ and so forth. Fill
602 * in some basic stuff into the ctlr_info_t structure.
604 static int cpqarray_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
606 ushort vendor_id, device_id, command;
607 unchar cache_line_size, latency_timer;
608 unchar irq, revision;
609 unsigned long addr[6];
615 pci_set_master(pdev);
616 if (pci_enable_device(pdev)) {
617 printk(KERN_ERR "cpqarray: Unable to Enable PCI device\n");
620 vendor_id = pdev->vendor;
621 device_id = pdev->device;
625 addr[i] = pci_resource_start(pdev, i);
627 if (pci_set_dma_mask(pdev, CPQARRAY_DMA_MASK) != 0)
629 printk(KERN_ERR "cpqarray: Unable to set DMA mask\n");
633 pci_read_config_word(pdev, PCI_COMMAND, &command);
634 pci_read_config_byte(pdev, PCI_CLASS_REVISION, &revision);
635 pci_read_config_byte(pdev, PCI_CACHE_LINE_SIZE, &cache_line_size);
636 pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &latency_timer);
638 pci_read_config_dword(pdev, 0x2c, &board_id);
640 /* check to see if controller has been disabled */
641 if(!(command & 0x02)) {
643 "cpqarray: controller appears to be disabled\n");
648 printk("vendor_id = %x\n", vendor_id);
649 printk("device_id = %x\n", device_id);
650 printk("command = %x\n", command);
652 printk("addr[%d] = %lx\n", i, addr[i]);
653 printk("revision = %x\n", revision);
654 printk("irq = %x\n", irq);
655 printk("cache_line_size = %x\n", cache_line_size);
656 printk("latency_timer = %x\n", latency_timer);
657 printk("board_id = %x\n", board_id);
663 if (pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE_IO)
665 c->io_mem_addr = addr[i];
666 c->io_mem_length = pci_resource_end(pdev, i)
667 - pci_resource_start(pdev, i) + 1;
668 if(!request_region( c->io_mem_addr, c->io_mem_length,
671 printk( KERN_WARNING "cpqarray I/O memory range already in use addr %lx length = %ld\n", c->io_mem_addr, c->io_mem_length);
673 c->io_mem_length = 0;
681 if (!(pci_resource_flags(pdev, i) &
682 PCI_BASE_ADDRESS_SPACE_IO)) {
683 c->paddr = pci_resource_start (pdev, i);
688 c->vaddr = remap_pci_mem(c->paddr, 128);
691 c->board_id = board_id;
693 for(i=0; i<NR_PRODUCTS; i++) {
694 if (board_id == products[i].board_id) {
695 c->product_name = products[i].product_name;
696 c->access = *(products[i].access);
700 if (i == NR_PRODUCTS) {
701 printk(KERN_WARNING "cpqarray: Sorry, I don't know how"
702 " to access the SMART Array controller %08lx\n",
703 (unsigned long)board_id);
711 * Map (physical) PCI mem into (virtual) kernel space
713 static void __iomem *remap_pci_mem(ulong base, ulong size)
715 ulong page_base = ((ulong) base) & PAGE_MASK;
716 ulong page_offs = ((ulong) base) - page_base;
717 void __iomem *page_remapped = ioremap(page_base, page_offs+size);
719 return (page_remapped ? (page_remapped + page_offs) : NULL);
724 * Config string is a comma separated set of i/o addresses of EISA cards.
726 static int cpqarray_setup(char *str)
730 (void)get_options(str, ARRAY_SIZE(ints), ints);
732 for(i=0; i<ints[0] && i<8; i++)
737 __setup("smart2=", cpqarray_setup);
742 * Find an EISA controller's signature. Set up an hba if we find it.
744 static int __devinit cpqarray_eisa_detect(void)
752 while(i<8 && eisa[i]) {
753 ctlr = alloc_cpqarray_hba();
756 board_id = inl(eisa[i]+0xC80);
757 for(j=0; j < NR_PRODUCTS; j++)
758 if (board_id == products[j].board_id)
761 if (j == NR_PRODUCTS) {
762 printk(KERN_WARNING "cpqarray: Sorry, I don't know how"
763 " to access the SMART Array controller %08lx\n", (unsigned long)board_id);
767 memset(hba[ctlr], 0, sizeof(ctlr_info_t));
768 hba[ctlr]->io_mem_addr = eisa[i];
769 hba[ctlr]->io_mem_length = 0x7FF;
770 if(!request_region(hba[ctlr]->io_mem_addr,
771 hba[ctlr]->io_mem_length,
774 printk(KERN_WARNING "cpqarray: I/O range already in "
775 "use addr = %lx length = %ld\n",
776 hba[ctlr]->io_mem_addr,
777 hba[ctlr]->io_mem_length);
783 * Read the config register to find our interrupt
785 intr = inb(eisa[i]+0xCC0) >> 4;
786 if (intr & 1) intr = 11;
787 else if (intr & 2) intr = 10;
788 else if (intr & 4) intr = 14;
789 else if (intr & 8) intr = 15;
791 hba[ctlr]->intr = intr;
792 sprintf(hba[ctlr]->devname, "ida%d", nr_ctlr);
793 hba[ctlr]->product_name = products[j].product_name;
794 hba[ctlr]->access = *(products[j].access);
795 hba[ctlr]->ctlr = ctlr;
796 hba[ctlr]->board_id = board_id;
797 hba[ctlr]->pci_dev = NULL; /* not PCI */
800 printk("i = %d, j = %d\n", i, j);
801 printk("irq = %x\n", intr);
802 printk("product name = %s\n", products[j].product_name);
803 printk("board_id = %x\n", board_id);
809 if (cpqarray_register_ctlr(ctlr, NULL) == -1)
811 "cpqarray: Can't register EISA controller %d\n",
820 * Open. Make sure the device is really there.
822 static int ida_open(struct block_device *bdev, fmode_t mode)
824 drv_info_t *drv = get_drv(bdev->bd_disk);
825 ctlr_info_t *host = get_host(bdev->bd_disk);
827 DBGINFO(printk("ida_open %s\n", bdev->bd_disk->disk_name));
829 * Root is allowed to open raw volume zero even if it's not configured
830 * so array config can still work. I don't think I really like this,
831 * but I'm already using way to many device nodes to claim another one
832 * for "raw controller".
835 if (!capable(CAP_SYS_RAWIO))
837 if (!capable(CAP_SYS_ADMIN) && drv != host->drv)
844 static int ida_unlocked_open(struct block_device *bdev, fmode_t mode)
849 ret = ida_open(bdev, mode);
858 static int ida_release(struct gendisk *disk, fmode_t mode)
863 host = get_host(disk);
871 * Enqueuing and dequeuing functions for cmdlists.
873 static inline void addQ(cmdlist_t **Qptr, cmdlist_t *c)
877 c->next = c->prev = c;
879 c->prev = (*Qptr)->prev;
881 (*Qptr)->prev->next = c;
886 static inline cmdlist_t *removeQ(cmdlist_t **Qptr, cmdlist_t *c)
888 if (c && c->next != c) {
889 if (*Qptr == c) *Qptr = c->next;
890 c->prev->next = c->next;
891 c->next->prev = c->prev;
899 * Get a request and submit it to the controller.
900 * This routine needs to grab all the requests it possibly can from the
901 * req Q and submit them. Interrupts are off (and need to be off) when you
902 * are in here (either via the dummy do_ida_request functions or by being
903 * called from the interrupt handler
905 static void do_ida_request(struct request_queue *q)
907 ctlr_info_t *h = q->queuedata;
909 struct request *creq;
910 struct scatterlist tmp_sg[SG_MAX];
913 if (blk_queue_plugged(q))
917 creq = blk_peek_request(q);
921 BUG_ON(creq->nr_phys_segments > SG_MAX);
923 if ((c = cmd_alloc(h,1)) == NULL)
926 blk_start_request(creq);
929 c->hdr.unit = (drv_info_t *)(creq->rq_disk->private_data) - h->drv;
930 c->hdr.size = sizeof(rblk_t) >> 2;
931 c->size += sizeof(rblk_t);
933 c->req.hdr.blk = blk_rq_pos(creq);
936 printk("sector=%d, nr_sectors=%u\n",
937 blk_rq_pos(creq), blk_rq_sectors(creq));
939 sg_init_table(tmp_sg, SG_MAX);
940 seg = blk_rq_map_sg(q, creq, tmp_sg);
942 /* Now do all the DMA Mappings */
943 if (rq_data_dir(creq) == READ)
944 dir = PCI_DMA_FROMDEVICE;
946 dir = PCI_DMA_TODEVICE;
947 for( i=0; i < seg; i++)
949 c->req.sg[i].size = tmp_sg[i].length;
950 c->req.sg[i].addr = (__u32) pci_map_page(h->pci_dev,
953 tmp_sg[i].length, dir);
955 DBGPX( printk("Submitting %u sectors in %d segments\n", blk_rq_sectors(creq), seg); );
956 c->req.hdr.sg_cnt = seg;
957 c->req.hdr.blk_cnt = blk_rq_sectors(creq);
958 c->req.hdr.cmd = (rq_data_dir(creq) == READ) ? IDA_READ : IDA_WRITE;
961 /* Put the request on the tail of the request queue */
964 if (h->Qdepth > h->maxQsinceinit)
965 h->maxQsinceinit = h->Qdepth;
974 * start_io submits everything on a controller's request queue
975 * and moves it to the completion queue.
977 * Interrupts had better be off if you're in here
979 static void start_io(ctlr_info_t *h)
983 while((c = h->reqQ) != NULL) {
984 /* Can't do anything if we're busy */
985 if (h->access.fifo_full(h) == 0)
988 /* Get the first entry from the request Q */
989 removeQ(&h->reqQ, c);
992 /* Tell the controller to do our bidding */
993 h->access.submit_command(h, c);
995 /* Get onto the completion Q */
1001 * Mark all buffers that cmd was responsible for
1003 static inline void complete_command(cmdlist_t *cmd, int timeout)
1005 struct request *rq = cmd->rq;
1009 if (cmd->req.hdr.rcode & RCODE_NONFATAL &&
1010 (hba[cmd->ctlr]->misc_tflags & MISC_NONFATAL_WARN) == 0) {
1011 printk(KERN_NOTICE "Non Fatal error on ida/c%dd%d\n",
1012 cmd->ctlr, cmd->hdr.unit);
1013 hba[cmd->ctlr]->misc_tflags |= MISC_NONFATAL_WARN;
1015 if (cmd->req.hdr.rcode & RCODE_FATAL) {
1016 printk(KERN_WARNING "Fatal error on ida/c%dd%d\n",
1017 cmd->ctlr, cmd->hdr.unit);
1020 if (cmd->req.hdr.rcode & RCODE_INVREQ) {
1021 printk(KERN_WARNING "Invalid request on ida/c%dd%d = (cmd=%x sect=%d cnt=%d sg=%d ret=%x)\n",
1022 cmd->ctlr, cmd->hdr.unit, cmd->req.hdr.cmd,
1023 cmd->req.hdr.blk, cmd->req.hdr.blk_cnt,
1024 cmd->req.hdr.sg_cnt, cmd->req.hdr.rcode);
1029 /* unmap the DMA mapping for all the scatter gather elements */
1030 if (cmd->req.hdr.cmd == IDA_READ)
1031 ddir = PCI_DMA_FROMDEVICE;
1033 ddir = PCI_DMA_TODEVICE;
1034 for(i=0; i<cmd->req.hdr.sg_cnt; i++)
1035 pci_unmap_page(hba[cmd->ctlr]->pci_dev, cmd->req.sg[i].addr,
1036 cmd->req.sg[i].size, ddir);
1038 DBGPX(printk("Done with %p\n", rq););
1039 __blk_end_request_all(rq, error);
1043 * The controller will interrupt us upon completion of commands.
1044 * Find the command on the completion queue, remove it, tell the OS and
1045 * try to queue up more IO
1047 static irqreturn_t do_ida_intr(int irq, void *dev_id)
1049 ctlr_info_t *h = dev_id;
1051 unsigned long istat;
1052 unsigned long flags;
1055 istat = h->access.intr_pending(h);
1056 /* Is this interrupt for us? */
1061 * If there are completed commands in the completion queue,
1062 * we had better do something about it.
1064 spin_lock_irqsave(IDA_LOCK(h->ctlr), flags);
1065 if (istat & FIFO_NOT_EMPTY) {
1066 while((a = h->access.command_completed(h))) {
1068 if ((c = h->cmpQ) == NULL)
1070 printk(KERN_WARNING "cpqarray: Completion of %08lx ignored\n", (unsigned long)a1);
1073 while(c->busaddr != a) {
1079 * If we've found the command, take it off the
1080 * completion Q and free it
1082 if (c->busaddr == a) {
1083 removeQ(&h->cmpQ, c);
1084 /* Check for invalid command.
1085 * Controller returns command error,
1089 if((a1 & 0x03) && (c->req.hdr.rcode == 0))
1091 c->req.hdr.rcode = RCODE_INVREQ;
1093 if (c->type == CMD_RWREQ) {
1094 complete_command(c, 0);
1096 } else if (c->type == CMD_IOCTL_PEND) {
1097 c->type = CMD_IOCTL_DONE;
1105 * See if we can queue up some more IO
1107 do_ida_request(h->queue);
1108 spin_unlock_irqrestore(IDA_LOCK(h->ctlr), flags);
1113 * This timer was for timing out requests that haven't happened after
1114 * IDA_TIMEOUT. That wasn't such a good idea. This timer is used to
1115 * reset a flags structure so we don't flood the user with
1116 * "Non-Fatal error" messages.
1118 static void ida_timer(unsigned long tdata)
1120 ctlr_info_t *h = (ctlr_info_t*)tdata;
1122 h->timer.expires = jiffies + IDA_TIMER;
1123 add_timer(&h->timer);
1127 static int ida_getgeo(struct block_device *bdev, struct hd_geometry *geo)
1129 drv_info_t *drv = get_drv(bdev->bd_disk);
1131 if (drv->cylinders) {
1132 geo->heads = drv->heads;
1133 geo->sectors = drv->sectors;
1134 geo->cylinders = drv->cylinders;
1137 geo->sectors = 0x3f;
1138 geo->cylinders = drv->nr_blks / (0xff*0x3f);
1145 * ida_ioctl does some miscellaneous stuff like reporting drive geometry,
1146 * setting readahead and submitting commands from userspace to the controller.
1148 static int ida_locked_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd, unsigned long arg)
1150 drv_info_t *drv = get_drv(bdev->bd_disk);
1151 ctlr_info_t *host = get_host(bdev->bd_disk);
1153 ida_ioctl_t __user *io = (ida_ioctl_t __user *)arg;
1158 if (copy_to_user(&io->c.drv, drv, sizeof(drv_info_t)))
1162 if (!capable(CAP_SYS_RAWIO))
1164 my_io = kmalloc(sizeof(ida_ioctl_t), GFP_KERNEL);
1168 if (copy_from_user(my_io, io, sizeof(*my_io)))
1170 error = ida_ctlr_ioctl(host, drv - host->drv, my_io);
1174 if (copy_to_user(io, my_io, sizeof(*my_io)))
1181 if (!arg) return -EINVAL;
1182 if (put_user(host->ctlr_sig, (int __user *)arg))
1185 case IDAREVALIDATEVOLS:
1186 if (MINOR(bdev->bd_dev) != 0)
1188 return revalidate_allvol(host);
1189 case IDADRIVERVERSION:
1190 if (!arg) return -EINVAL;
1191 if (put_user(DRIVER_VERSION, (unsigned long __user *)arg))
1197 ida_pci_info_struct pciinfo;
1199 if (!arg) return -EINVAL;
1200 pciinfo.bus = host->pci_dev->bus->number;
1201 pciinfo.dev_fn = host->pci_dev->devfn;
1202 pciinfo.board_id = host->board_id;
1203 if(copy_to_user((void __user *) arg, &pciinfo,
1204 sizeof( ida_pci_info_struct)))
1215 static int ida_ioctl(struct block_device *bdev, fmode_t mode,
1216 unsigned int cmd, unsigned long param)
1221 ret = ida_locked_ioctl(bdev, mode, cmd, param);
1228 * ida_ctlr_ioctl is for passing commands to the controller from userspace.
1229 * The command block (io) has already been copied to kernel space for us,
1230 * however, any elements in the sglist need to be copied to kernel space
1231 * or copied back to userspace.
1233 * Only root may perform a controller passthru command, however I'm not doing
1234 * any serious sanity checking on the arguments. Doing an IDA_WRITE_MEDIA and
1235 * putting a 64M buffer in the sglist is probably a *bad* idea.
1237 static int ida_ctlr_ioctl(ctlr_info_t *h, int dsk, ida_ioctl_t *io)
1242 unsigned long flags;
1245 if ((c = cmd_alloc(h, 0)) == NULL)
1248 c->hdr.unit = (io->unit & UNITVALID) ? (io->unit & ~UNITVALID) : dsk;
1249 c->hdr.size = sizeof(rblk_t) >> 2;
1250 c->size += sizeof(rblk_t);
1252 c->req.hdr.cmd = io->cmd;
1253 c->req.hdr.blk = io->blk;
1254 c->req.hdr.blk_cnt = io->blk_cnt;
1255 c->type = CMD_IOCTL_PEND;
1257 /* Pre submit processing */
1260 p = memdup_user(io->sg[0].addr, io->sg[0].size);
1266 c->req.hdr.blk = pci_map_single(h->pci_dev, &(io->c),
1267 sizeof(ida_ioctl_t),
1268 PCI_DMA_BIDIRECTIONAL);
1269 c->req.sg[0].size = io->sg[0].size;
1270 c->req.sg[0].addr = pci_map_single(h->pci_dev, p,
1271 c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1272 c->req.hdr.sg_cnt = 1;
1275 case READ_FLASH_ROM:
1276 case SENSE_CONTROLLER_PERFORMANCE:
1277 p = kmalloc(io->sg[0].size, GFP_KERNEL);
1285 c->req.sg[0].size = io->sg[0].size;
1286 c->req.sg[0].addr = pci_map_single(h->pci_dev, p,
1287 c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1288 c->req.hdr.sg_cnt = 1;
1291 case IDA_WRITE_MEDIA:
1292 case DIAG_PASS_THRU:
1293 case COLLECT_BUFFER:
1294 case WRITE_FLASH_ROM:
1295 p = memdup_user(io->sg[0].addr, io->sg[0].size);
1301 c->req.sg[0].size = io->sg[0].size;
1302 c->req.sg[0].addr = pci_map_single(h->pci_dev, p,
1303 c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1304 c->req.hdr.sg_cnt = 1;
1307 c->req.sg[0].size = sizeof(io->c);
1308 c->req.sg[0].addr = pci_map_single(h->pci_dev,&io->c,
1309 c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1310 c->req.hdr.sg_cnt = 1;
1313 /* Put the request on the tail of the request queue */
1314 spin_lock_irqsave(IDA_LOCK(ctlr), flags);
1318 spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1320 /* Wait for completion */
1321 while(c->type != CMD_IOCTL_DONE)
1325 pci_unmap_single(h->pci_dev, c->req.sg[0].addr, c->req.sg[0].size,
1326 PCI_DMA_BIDIRECTIONAL);
1327 /* Post submit processing */
1330 pci_unmap_single(h->pci_dev, c->req.hdr.blk,
1331 sizeof(ida_ioctl_t),
1332 PCI_DMA_BIDIRECTIONAL);
1334 case DIAG_PASS_THRU:
1335 case SENSE_CONTROLLER_PERFORMANCE:
1336 case READ_FLASH_ROM:
1337 if (copy_to_user(io->sg[0].addr, p, io->sg[0].size)) {
1341 /* fall through and free p */
1343 case IDA_WRITE_MEDIA:
1344 case COLLECT_BUFFER:
1345 case WRITE_FLASH_ROM:
1352 io->rcode = c->req.hdr.rcode;
1358 * Commands are pre-allocated in a large block. Here we use a simple bitmap
1359 * scheme to suballocte them to the driver. Operations that are not time
1360 * critical (and can wait for kmalloc and possibly sleep) can pass in NULL
1361 * as the first argument to get a new command.
1363 static cmdlist_t * cmd_alloc(ctlr_info_t *h, int get_from_pool)
1367 dma_addr_t cmd_dhandle;
1369 if (!get_from_pool) {
1370 c = (cmdlist_t*)pci_alloc_consistent(h->pci_dev,
1371 sizeof(cmdlist_t), &cmd_dhandle);
1376 i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
1379 } while(test_and_set_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
1380 c = h->cmd_pool + i;
1381 cmd_dhandle = h->cmd_pool_dhandle + i*sizeof(cmdlist_t);
1385 memset(c, 0, sizeof(cmdlist_t));
1386 c->busaddr = cmd_dhandle;
1390 static void cmd_free(ctlr_info_t *h, cmdlist_t *c, int got_from_pool)
1394 if (!got_from_pool) {
1395 pci_free_consistent(h->pci_dev, sizeof(cmdlist_t), c,
1398 i = c - h->cmd_pool;
1399 clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
1404 /***********************************************************************
1406 Send a command to an IDA using the memory mapped FIFO interface
1407 and wait for it to complete.
1408 This routine should only be called at init time.
1409 ***********************************************************************/
1416 unsigned int blkcnt,
1417 unsigned int log_unit )
1423 ctlr_info_t *info_p = hba[ctlr];
1425 c = cmd_alloc(info_p, 1);
1429 c->hdr.unit = log_unit;
1431 c->hdr.size = sizeof(rblk_t) >> 2;
1432 c->size += sizeof(rblk_t);
1434 /* The request information. */
1435 c->req.hdr.next = 0;
1436 c->req.hdr.rcode = 0;
1438 c->req.hdr.sg_cnt = 1;
1439 c->req.hdr.reserved = 0;
1442 c->req.sg[0].size = 512;
1444 c->req.sg[0].size = size;
1446 c->req.hdr.blk = blk;
1447 c->req.hdr.blk_cnt = blkcnt;
1448 c->req.hdr.cmd = (unsigned char) cmd;
1449 c->req.sg[0].addr = (__u32) pci_map_single(info_p->pci_dev,
1450 buff, c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1454 info_p->access.set_intr_mask(info_p, 0);
1455 /* Make sure there is room in the command FIFO */
1456 /* Actually it should be completely empty at this time. */
1457 for (i = 200000; i > 0; i--) {
1458 temp = info_p->access.fifo_full(info_p);
1464 printk(KERN_WARNING "cpqarray ida%d: idaSendPciCmd FIFO full,"
1465 " waiting!\n", ctlr);
1471 info_p->access.submit_command(info_p, c);
1472 complete = pollcomplete(ctlr);
1474 pci_unmap_single(info_p->pci_dev, (dma_addr_t) c->req.sg[0].addr,
1475 c->req.sg[0].size, PCI_DMA_BIDIRECTIONAL);
1476 if (complete != 1) {
1477 if (complete != c->busaddr) {
1478 printk( KERN_WARNING
1479 "cpqarray ida%d: idaSendPciCmd "
1480 "Invalid command list address returned! (%08lx)\n",
1481 ctlr, (unsigned long)complete);
1482 cmd_free(info_p, c, 1);
1486 printk( KERN_WARNING
1487 "cpqarray ida%d: idaSendPciCmd Timeout out, "
1488 "No command list address returned!\n",
1490 cmd_free(info_p, c, 1);
1494 if (c->req.hdr.rcode & 0x00FE) {
1495 if (!(c->req.hdr.rcode & BIG_PROBLEM)) {
1496 printk( KERN_WARNING
1497 "cpqarray ida%d: idaSendPciCmd, error: "
1498 "Controller failed at init time "
1499 "cmd: 0x%x, return code = 0x%x\n",
1500 ctlr, c->req.hdr.cmd, c->req.hdr.rcode);
1502 cmd_free(info_p, c, 1);
1506 cmd_free(info_p, c, 1);
1511 * revalidate_allvol is for online array config utilities. After a
1512 * utility reconfigures the drives in the array, it can use this function
1513 * (through an ioctl) to make the driver zap any previous disk structs for
1514 * that controller and get new ones.
1516 * Right now I'm using the getgeometry() function to do this, but this
1517 * function should probably be finer grained and allow you to revalidate one
1518 * particualar logical volume (instead of all of them on a particular
1521 static int revalidate_allvol(ctlr_info_t *host)
1523 int ctlr = host->ctlr;
1525 unsigned long flags;
1527 spin_lock_irqsave(IDA_LOCK(ctlr), flags);
1528 if (host->usage_count > 1) {
1529 spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1530 printk(KERN_WARNING "cpqarray: Device busy for volume"
1531 " revalidation (usage=%d)\n", host->usage_count);
1534 host->usage_count++;
1535 spin_unlock_irqrestore(IDA_LOCK(ctlr), flags);
1538 * Set the partition and block size structures for all volumes
1539 * on this controller to zero. We will reread all of this data
1541 set_capacity(ida_gendisk[ctlr][0], 0);
1542 for (i = 1; i < NWD; i++) {
1543 struct gendisk *disk = ida_gendisk[ctlr][i];
1544 if (disk->flags & GENHD_FL_UP)
1547 memset(host->drv, 0, sizeof(drv_info_t)*NWD);
1550 * Tell the array controller not to give us any interrupts while
1551 * we check the new geometry. Then turn interrupts back on when
1554 host->access.set_intr_mask(host, 0);
1556 host->access.set_intr_mask(host, FIFO_NOT_EMPTY);
1558 for(i=0; i<NWD; i++) {
1559 struct gendisk *disk = ida_gendisk[ctlr][i];
1560 drv_info_t *drv = &host->drv[i];
1561 if (i && !drv->nr_blks)
1563 blk_queue_logical_block_size(host->queue, drv->blk_size);
1564 set_capacity(disk, drv->nr_blks);
1565 disk->queue = host->queue;
1566 disk->private_data = drv;
1571 host->usage_count--;
1575 static int ida_revalidate(struct gendisk *disk)
1577 drv_info_t *drv = disk->private_data;
1578 set_capacity(disk, drv->nr_blks);
1582 /********************************************************************
1584 Wait polling for a command to complete.
1585 The memory mapped FIFO is polled for the completion.
1586 Used only at init time, interrupts disabled.
1587 ********************************************************************/
1588 static int pollcomplete(int ctlr)
1593 /* Wait (up to 2 seconds) for a command to complete */
1595 for (i = 200000; i > 0; i--) {
1596 done = hba[ctlr]->access.command_completed(hba[ctlr]);
1598 udelay(10); /* a short fixed delay */
1602 /* Invalid address to tell caller we ran out of time */
1605 /*****************************************************************
1607 Starts controller firmwares background processing.
1608 Currently only the Integrated Raid controller needs this done.
1609 If the PCI mem address registers are written to after this,
1610 data corruption may occur
1611 *****************************************************************/
1612 static void start_fwbk(int ctlr)
1614 id_ctlr_t *id_ctlr_buf;
1617 if( (hba[ctlr]->board_id != 0x40400E11)
1618 && (hba[ctlr]->board_id != 0x40480E11) )
1620 /* Not a Integrated Raid, so there is nothing for us to do */
1622 printk(KERN_DEBUG "cpqarray: Starting firmware's background"
1624 /* Command does not return anything, but idasend command needs a
1626 id_ctlr_buf = kmalloc(sizeof(id_ctlr_t), GFP_KERNEL);
1627 if(id_ctlr_buf==NULL)
1629 printk(KERN_WARNING "cpqarray: Out of memory. "
1630 "Unable to start background processing.\n");
1633 ret_code = sendcmd(RESUME_BACKGROUND_ACTIVITY, ctlr,
1634 id_ctlr_buf, 0, 0, 0, 0);
1635 if(ret_code != IO_OK)
1636 printk(KERN_WARNING "cpqarray: Unable to start"
1637 " background processing\n");
1641 /*****************************************************************
1643 Get ida logical volume geometry from the controller
1644 This is a large bit of code which once existed in two flavors,
1645 It is used only at init time.
1646 *****************************************************************/
1647 static void getgeometry(int ctlr)
1649 id_log_drv_t *id_ldrive;
1650 id_ctlr_t *id_ctlr_buf;
1651 sense_log_drv_stat_t *id_lstatus_buf;
1652 config_t *sense_config_buf;
1653 unsigned int log_unit, log_index;
1656 ctlr_info_t *info_p = hba[ctlr];
1659 info_p->log_drv_map = 0;
1661 id_ldrive = kzalloc(sizeof(id_log_drv_t), GFP_KERNEL);
1663 printk( KERN_ERR "cpqarray: out of memory.\n");
1667 id_ctlr_buf = kzalloc(sizeof(id_ctlr_t), GFP_KERNEL);
1669 printk( KERN_ERR "cpqarray: out of memory.\n");
1673 id_lstatus_buf = kzalloc(sizeof(sense_log_drv_stat_t), GFP_KERNEL);
1674 if (!id_lstatus_buf) {
1675 printk( KERN_ERR "cpqarray: out of memory.\n");
1679 sense_config_buf = kzalloc(sizeof(config_t), GFP_KERNEL);
1680 if (!sense_config_buf) {
1681 printk( KERN_ERR "cpqarray: out of memory.\n");
1685 info_p->phys_drives = 0;
1686 info_p->log_drv_map = 0;
1687 info_p->drv_assign_map = 0;
1688 info_p->drv_spare_map = 0;
1689 info_p->mp_failed_drv_map = 0; /* only initialized here */
1690 /* Get controllers info for this logical drive */
1691 ret_code = sendcmd(ID_CTLR, ctlr, id_ctlr_buf, 0, 0, 0, 0);
1692 if (ret_code == IO_ERROR) {
1694 * If can't get controller info, set the logical drive map to 0,
1695 * so the idastubopen will fail on all logical drives
1696 * on the controller.
1698 printk(KERN_ERR "cpqarray: error sending ID controller\n");
1702 info_p->log_drives = id_ctlr_buf->nr_drvs;
1704 info_p->firm_rev[i] = id_ctlr_buf->firm_rev[i];
1705 info_p->ctlr_sig = id_ctlr_buf->cfg_sig;
1707 printk(" (%s)\n", info_p->product_name);
1709 * Initialize logical drive map to zero
1713 * Get drive geometry for all logical drives
1715 if (id_ctlr_buf->nr_drvs > 16)
1716 printk(KERN_WARNING "cpqarray ida%d: This driver supports "
1717 "16 logical drives per controller.\n. "
1718 " Additional drives will not be "
1719 "detected\n", ctlr);
1722 (log_index < id_ctlr_buf->nr_drvs)
1723 && (log_unit < NWD);
1725 size = sizeof(sense_log_drv_stat_t);
1728 Send "Identify logical drive status" cmd
1730 ret_code = sendcmd(SENSE_LOG_DRV_STAT,
1731 ctlr, id_lstatus_buf, size, 0, 0, log_unit);
1732 if (ret_code == IO_ERROR) {
1734 If can't get logical drive status, set
1735 the logical drive map to 0, so the
1736 idastubopen will fail for all logical drives
1739 info_p->log_drv_map = 0;
1740 printk( KERN_WARNING
1741 "cpqarray ida%d: idaGetGeometry - Controller"
1742 " failed to report status of logical drive %d\n"
1743 "Access to this controller has been disabled\n",
1748 Make sure the logical drive is configured
1750 if (id_lstatus_buf->status != LOG_NOT_CONF) {
1751 ret_code = sendcmd(ID_LOG_DRV, ctlr, id_ldrive,
1752 sizeof(id_log_drv_t), 0, 0, log_unit);
1754 If error, the bit for this
1755 logical drive won't be set and
1756 idastubopen will return error.
1758 if (ret_code != IO_ERROR) {
1759 drv = &info_p->drv[log_unit];
1760 drv->blk_size = id_ldrive->blk_size;
1761 drv->nr_blks = id_ldrive->nr_blks;
1762 drv->cylinders = id_ldrive->drv.cyl;
1763 drv->heads = id_ldrive->drv.heads;
1764 drv->sectors = id_ldrive->drv.sect_per_track;
1765 info_p->log_drv_map |= (1 << log_unit);
1767 printk(KERN_INFO "cpqarray ida/c%dd%d: blksz=%d nr_blks=%d\n",
1768 ctlr, log_unit, drv->blk_size, drv->nr_blks);
1769 ret_code = sendcmd(SENSE_CONFIG,
1770 ctlr, sense_config_buf,
1771 sizeof(config_t), 0, 0, log_unit);
1772 if (ret_code == IO_ERROR) {
1773 info_p->log_drv_map = 0;
1774 printk(KERN_ERR "cpqarray: error sending sense config\n");
1778 info_p->phys_drives =
1779 sense_config_buf->ctlr_phys_drv;
1780 info_p->drv_assign_map
1781 |= sense_config_buf->drv_asgn_map;
1782 info_p->drv_assign_map
1783 |= sense_config_buf->spare_asgn_map;
1784 info_p->drv_spare_map
1785 |= sense_config_buf->spare_asgn_map;
1786 } /* end of if no error on id_ldrive */
1787 log_index = log_index + 1;
1788 } /* end of if logical drive configured */
1789 } /* end of for log_unit */
1791 /* Free all the buffers and return */
1793 kfree(sense_config_buf);
1795 kfree(id_lstatus_buf);
1804 static void __exit cpqarray_exit(void)
1808 pci_unregister_driver(&cpqarray_pci_driver);
1810 /* Double check that all controller entries have been removed */
1811 for(i=0; i<MAX_CTLR; i++) {
1812 if (hba[i] != NULL) {
1813 printk(KERN_WARNING "cpqarray: Removing EISA "
1814 "controller %d\n", i);
1815 cpqarray_remove_one_eisa(i);
1819 remove_proc_entry("driver/cpqarray", NULL);
1822 module_init(cpqarray_init)
1823 module_exit(cpqarray_exit)