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