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