projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / block / cciss.c
1 /*
2 * Disk Array driver for HP SA 5xxx and 6xxx Controllers
3 * Copyright 2000, 2005 Hewlett-Packard Development Company, L.P.
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
23 #include <linux/config.h> /* CONFIG_PROC_FS */
24 #include <linux/module.h>
25 #include <linux/interrupt.h>
26 #include <linux/types.h>
27 #include <linux/pci.h>
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/major.h>
32 #include <linux/fs.h>
33 #include <linux/bio.h>
34 #include <linux/blkpg.h>
35 #include <linux/timer.h>
36 #include <linux/proc_fs.h>
37 #include <linux/init.h>
38 #include <linux/hdreg.h>
39 #include <linux/spinlock.h>
40 #include <linux/compat.h>
41 #include <asm/uaccess.h>
42 #include <asm/io.h>
43
44 #include <linux/dma-mapping.h>
45 #include <linux/blkdev.h>
46 #include <linux/genhd.h>
47 #include <linux/completion.h>
48
49 #define CCISS_DRIVER_VERSION(maj,min,submin) ((maj<<16)|(min<<8)|(submin))
50 #define DRIVER_NAME "HP CISS Driver (v 2.6.8)"
51 #define DRIVER_VERSION CCISS_DRIVER_VERSION(2,6,8)
52
53 /* Embedded module documentation macros - see modules.h */
54 MODULE_AUTHOR("Hewlett-Packard Company");
55 MODULE_DESCRIPTION("Driver for HP Controller SA5xxx SA6xxx version 2.6.8");
56 MODULE_SUPPORTED_DEVICE("HP SA5i SA5i+ SA532 SA5300 SA5312 SA641 SA642 SA6400"
57 " SA6i P600 P800 P400 P400i E200 E200i");
58 MODULE_LICENSE("GPL");
59
60 #include "cciss_cmd.h"
61 #include "cciss.h"
62 #include <linux/cciss_ioctl.h>
63
64 /* define the PCI info for the cards we can control */
65 static const struct pci_device_id cciss_pci_device_id[] = {
66 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISS,
67 0x0E11, 0x4070, 0, 0, 0},
68 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
69 0x0E11, 0x4080, 0, 0, 0},
70 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
71 0x0E11, 0x4082, 0, 0, 0},
72 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSB,
73 0x0E11, 0x4083, 0, 0, 0},
74 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
75 0x0E11, 0x409A, 0, 0, 0},
76 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
77 0x0E11, 0x409B, 0, 0, 0},
78 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
79 0x0E11, 0x409C, 0, 0, 0},
80 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
81 0x0E11, 0x409D, 0, 0, 0},
82 { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_CISSC,
83 0x0E11, 0x4091, 0, 0, 0},
84 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSA,
85 0x103C, 0x3225, 0, 0, 0},
86 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
87 0x103c, 0x3223, 0, 0, 0},
88 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
89 0x103c, 0x3234, 0, 0, 0},
90 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSC,
91 0x103c, 0x3235, 0, 0, 0},
92 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
93 0x103c, 0x3211, 0, 0, 0},
94 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
95 0x103c, 0x3212, 0, 0, 0},
96 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
97 0x103c, 0x3213, 0, 0, 0},
98 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
99 0x103c, 0x3214, 0, 0, 0},
100 { PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_CISSD,
101 0x103c, 0x3215, 0, 0, 0},
102 {0,}
103 };
104 MODULE_DEVICE_TABLE(pci, cciss_pci_device_id);
105
106 #define NR_PRODUCTS (sizeof(products)/sizeof(struct board_type))
107
108 /* board_id = Subsystem Device ID & Vendor ID
109 * product = Marketing Name for the board
110 * access = Address of the struct of function pointers
111 */
112 static struct board_type products[] = {
113 { 0x40700E11, "Smart Array 5300", &SA5_access },
114 { 0x40800E11, "Smart Array 5i", &SA5B_access},
115 { 0x40820E11, "Smart Array 532", &SA5B_access},
116 { 0x40830E11, "Smart Array 5312", &SA5B_access},
117 { 0x409A0E11, "Smart Array 641", &SA5_access},
118 { 0x409B0E11, "Smart Array 642", &SA5_access},
119 { 0x409C0E11, "Smart Array 6400", &SA5_access},
120 { 0x409D0E11, "Smart Array 6400 EM", &SA5_access},
121 { 0x40910E11, "Smart Array 6i", &SA5_access},
122 { 0x3225103C, "Smart Array P600", &SA5_access},
123 { 0x3223103C, "Smart Array P800", &SA5_access},
124 { 0x3234103C, "Smart Array P400", &SA5_access},
125 { 0x3235103C, "Smart Array P400i", &SA5_access},
126 { 0x3211103C, "Smart Array E200i", &SA5_access},
127 { 0x3212103C, "Smart Array E200", &SA5_access},
128 { 0x3213103C, "Smart Array E200i", &SA5_access},
129 { 0x3214103C, "Smart Array E200i", &SA5_access},
130 { 0x3215103C, "Smart Array E200i", &SA5_access},
131 };
132
133 /* How long to wait (in millesconds) for board to go into simple mode */
134 #define MAX_CONFIG_WAIT 30000
135 #define MAX_IOCTL_CONFIG_WAIT 1000
136
137 /*define how many times we will try a command because of bus resets */
138 #define MAX_CMD_RETRIES 3
139
140 #define READ_AHEAD 1024
141 #define NR_CMDS 384 /* #commands that can be outstanding */
142 #define MAX_CTLR 32
143
144 /* Originally cciss driver only supports 8 major numbers */
145 #define MAX_CTLR_ORIG 8
146
147
148 static ctlr_info_t *hba[MAX_CTLR];
149
150 static void do_cciss_request(request_queue_t *q);
151 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs);
152 static int cciss_open(struct inode *inode, struct file *filep);
153 static int cciss_release(struct inode *inode, struct file *filep);
154 static int cciss_ioctl(struct inode *inode, struct file *filep,
155 unsigned int cmd, unsigned long arg);
156
157 static int revalidate_allvol(ctlr_info_t *host);
158 static int cciss_revalidate(struct gendisk *disk);
159 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk);
160 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv, int clear_all);
161
162 static void cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
163 int withirq, unsigned int *total_size, unsigned int *block_size);
164 static void cciss_geometry_inquiry(int ctlr, int logvol,
165 int withirq, unsigned int total_size,
166 unsigned int block_size, InquiryData_struct *inq_buff,
167 drive_info_struct *drv);
168 static void cciss_getgeometry(int cntl_num);
169
170 static void start_io( ctlr_info_t *h);
171 static int sendcmd( __u8 cmd, int ctlr, void *buff, size_t size,
172 unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
173 unsigned char *scsi3addr, int cmd_type);
174 static int sendcmd_withirq(__u8 cmd, int ctlr, void *buff, size_t size,
175 unsigned int use_unit_num, unsigned int log_unit, __u8 page_code,
176 int cmd_type);
177
178 static void fail_all_cmds(unsigned long ctlr);
179
180 #ifdef CONFIG_PROC_FS
181 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
182 int length, int *eof, void *data);
183 static void cciss_procinit(int i);
184 #else
185 static void cciss_procinit(int i) {}
186 #endif /* CONFIG_PROC_FS */
187
188 #ifdef CONFIG_COMPAT
189 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg);
190 #endif
191
192 static struct block_device_operations cciss_fops = {
193 .owner = THIS_MODULE,
194 .open = cciss_open,
195 .release = cciss_release,
196 .ioctl = cciss_ioctl,
197 #ifdef CONFIG_COMPAT
198 .compat_ioctl = cciss_compat_ioctl,
199 #endif
200 .revalidate_disk= cciss_revalidate,
201 };
202
203 /*
204 * Enqueuing and dequeuing functions for cmdlists.
205 */
206 static inline void addQ(CommandList_struct **Qptr, CommandList_struct *c)
207 {
208 if (*Qptr == NULL) {
209 *Qptr = c;
210 c->next = c->prev = c;
211 } else {
212 c->prev = (*Qptr)->prev;
213 c->next = (*Qptr);
214 (*Qptr)->prev->next = c;
215 (*Qptr)->prev = c;
216 }
217 }
218
219 static inline CommandList_struct *removeQ(CommandList_struct **Qptr,
220 CommandList_struct *c)
221 {
222 if (c && c->next != c) {
223 if (*Qptr == c) *Qptr = c->next;
224 c->prev->next = c->next;
225 c->next->prev = c->prev;
226 } else {
227 *Qptr = NULL;
228 }
229 return c;
230 }
231
232 #include "cciss_scsi.c" /* For SCSI tape support */
233
234 #ifdef CONFIG_PROC_FS
235
236 /*
237 * Report information about this controller.
238 */
239 #define ENG_GIG 1000000000
240 #define ENG_GIG_FACTOR (ENG_GIG/512)
241 #define RAID_UNKNOWN 6
242 static const char *raid_label[] = {"0","4","1(1+0)","5","5+1","ADG",
243 "UNKNOWN"};
244
245 static struct proc_dir_entry *proc_cciss;
246
247 static int cciss_proc_get_info(char *buffer, char **start, off_t offset,
248 int length, int *eof, void *data)
249 {
250 off_t pos = 0;
251 off_t len = 0;
252 int size, i, ctlr;
253 ctlr_info_t *h = (ctlr_info_t*)data;
254 drive_info_struct *drv;
255 unsigned long flags;
256 sector_t vol_sz, vol_sz_frac;
257
258 ctlr = h->ctlr;
259
260 /* prevent displaying bogus info during configuration
261 * or deconfiguration of a logical volume
262 */
263 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
264 if (h->busy_configuring) {
265 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
266 return -EBUSY;
267 }
268 h->busy_configuring = 1;
269 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
270
271 size = sprintf(buffer, "%s: HP %s Controller\n"
272 "Board ID: 0x%08lx\n"
273 "Firmware Version: %c%c%c%c\n"
274 "IRQ: %d\n"
275 "Logical drives: %d\n"
276 "Current Q depth: %d\n"
277 "Current # commands on controller: %d\n"
278 "Max Q depth since init: %d\n"
279 "Max # commands on controller since init: %d\n"
280 "Max SG entries since init: %d\n\n",
281 h->devname,
282 h->product_name,
283 (unsigned long)h->board_id,
284 h->firm_ver[0], h->firm_ver[1], h->firm_ver[2], h->firm_ver[3],
285 (unsigned int)h->intr,
286 h->num_luns,
287 h->Qdepth, h->commands_outstanding,
288 h->maxQsinceinit, h->max_outstanding, h->maxSG);
289
290 pos += size; len += size;
291 cciss_proc_tape_report(ctlr, buffer, &pos, &len);
292 for(i=0; i<=h->highest_lun; i++) {
293
294 drv = &h->drv[i];
295 if (drv->heads == 0)
296 continue;
297
298 vol_sz = drv->nr_blocks;
299 vol_sz_frac = sector_div(vol_sz, ENG_GIG_FACTOR);
300 vol_sz_frac *= 100;
301 sector_div(vol_sz_frac, ENG_GIG_FACTOR);
302
303 if (drv->raid_level > 5)
304 drv->raid_level = RAID_UNKNOWN;
305 size = sprintf(buffer+len, "cciss/c%dd%d:"
306 "\t%4u.%02uGB\tRAID %s\n",
307 ctlr, i, (int)vol_sz, (int)vol_sz_frac,
308 raid_label[drv->raid_level]);
309 pos += size; len += size;
310 }
311
312 *eof = 1;
313 *start = buffer+offset;
314 len -= offset;
315 if (len>length)
316 len = length;
317 h->busy_configuring = 0;
318 return len;
319 }
320
321 static int
322 cciss_proc_write(struct file *file, const char __user *buffer,
323 unsigned long count, void *data)
324 {
325 unsigned char cmd[80];
326 int len;
327 #ifdef CONFIG_CISS_SCSI_TAPE
328 ctlr_info_t *h = (ctlr_info_t *) data;
329 int rc;
330 #endif
331
332 if (count > sizeof(cmd)-1) return -EINVAL;
333 if (copy_from_user(cmd, buffer, count)) return -EFAULT;
334 cmd[count] = '\0';
335 len = strlen(cmd); // above 3 lines ensure safety
336 if (len && cmd[len-1] == '\n')
337 cmd[--len] = '\0';
338 # ifdef CONFIG_CISS_SCSI_TAPE
339 if (strcmp("engage scsi", cmd)==0) {
340 rc = cciss_engage_scsi(h->ctlr);
341 if (rc != 0) return -rc;
342 return count;
343 }
344 /* might be nice to have "disengage" too, but it's not
345 safely possible. (only 1 module use count, lock issues.) */
346 # endif
347 return -EINVAL;
348 }
349
350 /*
351 * Get us a file in /proc/cciss that says something about each controller.
352 * Create /proc/cciss if it doesn't exist yet.
353 */
354 static void __devinit cciss_procinit(int i)
355 {
356 struct proc_dir_entry *pde;
357
358 if (proc_cciss == NULL) {
359 proc_cciss = proc_mkdir("cciss", proc_root_driver);
360 if (!proc_cciss)
361 return;
362 }
363
364 pde = create_proc_read_entry(hba[i]->devname,
365 S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH,
366 proc_cciss, cciss_proc_get_info, hba[i]);
367 pde->write_proc = cciss_proc_write;
368 }
369 #endif /* CONFIG_PROC_FS */
370
371 /*
372 * For operations that cannot sleep, a command block is allocated at init,
373 * and managed by cmd_alloc() and cmd_free() using a simple bitmap to track
374 * which ones are free or in use. For operations that can wait for kmalloc
375 * to possible sleep, this routine can be called with get_from_pool set to 0.
376 * cmd_free() MUST be called with a got_from_pool set to 0 if cmd_alloc was.
377 */
378 static CommandList_struct * cmd_alloc(ctlr_info_t *h, int get_from_pool)
379 {
380 CommandList_struct *c;
381 int i;
382 u64bit temp64;
383 dma_addr_t cmd_dma_handle, err_dma_handle;
384
385 if (!get_from_pool)
386 {
387 c = (CommandList_struct *) pci_alloc_consistent(
388 h->pdev, sizeof(CommandList_struct), &cmd_dma_handle);
389 if(c==NULL)
390 return NULL;
391 memset(c, 0, sizeof(CommandList_struct));
392
393 c->cmdindex = -1;
394
395 c->err_info = (ErrorInfo_struct *)pci_alloc_consistent(
396 h->pdev, sizeof(ErrorInfo_struct),
397 &err_dma_handle);
398
399 if (c->err_info == NULL)
400 {
401 pci_free_consistent(h->pdev,
402 sizeof(CommandList_struct), c, cmd_dma_handle);
403 return NULL;
404 }
405 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
406 } else /* get it out of the controllers pool */
407 {
408 do {
409 i = find_first_zero_bit(h->cmd_pool_bits, NR_CMDS);
410 if (i == NR_CMDS)
411 return NULL;
412 } while(test_and_set_bit(i & (BITS_PER_LONG - 1), h->cmd_pool_bits+(i/BITS_PER_LONG)) != 0);
413 #ifdef CCISS_DEBUG
414 printk(KERN_DEBUG "cciss: using command buffer %d\n", i);
415 #endif
416 c = h->cmd_pool + i;
417 memset(c, 0, sizeof(CommandList_struct));
418 cmd_dma_handle = h->cmd_pool_dhandle
419 + i*sizeof(CommandList_struct);
420 c->err_info = h->errinfo_pool + i;
421 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
422 err_dma_handle = h->errinfo_pool_dhandle
423 + i*sizeof(ErrorInfo_struct);
424 h->nr_allocs++;
425
426 c->cmdindex = i;
427 }
428
429 c->busaddr = (__u32) cmd_dma_handle;
430 temp64.val = (__u64) err_dma_handle;
431 c->ErrDesc.Addr.lower = temp64.val32.lower;
432 c->ErrDesc.Addr.upper = temp64.val32.upper;
433 c->ErrDesc.Len = sizeof(ErrorInfo_struct);
434
435 c->ctlr = h->ctlr;
436 return c;
437
438
439 }
440
441 /*
442 * Frees a command block that was previously allocated with cmd_alloc().
443 */
444 static void cmd_free(ctlr_info_t *h, CommandList_struct *c, int got_from_pool)
445 {
446 int i;
447 u64bit temp64;
448
449 if( !got_from_pool)
450 {
451 temp64.val32.lower = c->ErrDesc.Addr.lower;
452 temp64.val32.upper = c->ErrDesc.Addr.upper;
453 pci_free_consistent(h->pdev, sizeof(ErrorInfo_struct),
454 c->err_info, (dma_addr_t) temp64.val);
455 pci_free_consistent(h->pdev, sizeof(CommandList_struct),
456 c, (dma_addr_t) c->busaddr);
457 } else
458 {
459 i = c - h->cmd_pool;
460 clear_bit(i&(BITS_PER_LONG-1), h->cmd_pool_bits+(i/BITS_PER_LONG));
461 h->nr_frees++;
462 }
463 }
464
465 static inline ctlr_info_t *get_host(struct gendisk *disk)
466 {
467 return disk->queue->queuedata;
468 }
469
470 static inline drive_info_struct *get_drv(struct gendisk *disk)
471 {
472 return disk->private_data;
473 }
474
475 /*
476 * Open. Make sure the device is really there.
477 */
478 static int cciss_open(struct inode *inode, struct file *filep)
479 {
480 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
481 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
482
483 #ifdef CCISS_DEBUG
484 printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
485 #endif /* CCISS_DEBUG */
486
487 if (host->busy_initializing || drv->busy_configuring)
488 return -EBUSY;
489 /*
490 * Root is allowed to open raw volume zero even if it's not configured
491 * so array config can still work. Root is also allowed to open any
492 * volume that has a LUN ID, so it can issue IOCTL to reread the
493 * disk information. I don't think I really like this
494 * but I'm already using way to many device nodes to claim another one
495 * for "raw controller".
496 */
497 if (drv->nr_blocks == 0) {
498 if (iminor(inode) != 0) { /* not node 0? */
499 /* if not node 0 make sure it is a partition = 0 */
500 if (iminor(inode) & 0x0f) {
501 return -ENXIO;
502 /* if it is, make sure we have a LUN ID */
503 } else if (drv->LunID == 0) {
504 return -ENXIO;
505 }
506 }
507 if (!capable(CAP_SYS_ADMIN))
508 return -EPERM;
509 }
510 drv->usage_count++;
511 host->usage_count++;
512 return 0;
513 }
514 /*
515 * Close. Sync first.
516 */
517 static int cciss_release(struct inode *inode, struct file *filep)
518 {
519 ctlr_info_t *host = get_host(inode->i_bdev->bd_disk);
520 drive_info_struct *drv = get_drv(inode->i_bdev->bd_disk);
521
522 #ifdef CCISS_DEBUG
523 printk(KERN_DEBUG "cciss_release %s\n", inode->i_bdev->bd_disk->disk_name);
524 #endif /* CCISS_DEBUG */
525
526 drv->usage_count--;
527 host->usage_count--;
528 return 0;
529 }
530
531 #ifdef CONFIG_COMPAT
532
533 static int do_ioctl(struct file *f, unsigned cmd, unsigned long arg)
534 {
535 int ret;
536 lock_kernel();
537 ret = cciss_ioctl(f->f_dentry->d_inode, f, cmd, arg);
538 unlock_kernel();
539 return ret;
540 }
541
542 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg);
543 static int cciss_ioctl32_big_passthru(struct file *f, unsigned cmd, unsigned long arg);
544
545 static long cciss_compat_ioctl(struct file *f, unsigned cmd, unsigned long arg)
546 {
547 switch (cmd) {
548 case CCISS_GETPCIINFO:
549 case CCISS_GETINTINFO:
550 case CCISS_SETINTINFO:
551 case CCISS_GETNODENAME:
552 case CCISS_SETNODENAME:
553 case CCISS_GETHEARTBEAT:
554 case CCISS_GETBUSTYPES:
555 case CCISS_GETFIRMVER:
556 case CCISS_GETDRIVVER:
557 case CCISS_REVALIDVOLS:
558 case CCISS_DEREGDISK:
559 case CCISS_REGNEWDISK:
560 case CCISS_REGNEWD:
561 case CCISS_RESCANDISK:
562 case CCISS_GETLUNINFO:
563 return do_ioctl(f, cmd, arg);
564
565 case CCISS_PASSTHRU32:
566 return cciss_ioctl32_passthru(f, cmd, arg);
567 case CCISS_BIG_PASSTHRU32:
568 return cciss_ioctl32_big_passthru(f, cmd, arg);
569
570 default:
571 return -ENOIOCTLCMD;
572 }
573 }
574
575 static int cciss_ioctl32_passthru(struct file *f, unsigned cmd, unsigned long arg)
576 {
577 IOCTL32_Command_struct __user *arg32 =
578 (IOCTL32_Command_struct __user *) arg;
579 IOCTL_Command_struct arg64;
580 IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
581 int err;
582 u32 cp;
583
584 err = 0;
585 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
586 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
587 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
588 err |= get_user(arg64.buf_size, &arg32->buf_size);
589 err |= get_user(cp, &arg32->buf);
590 arg64.buf = compat_ptr(cp);
591 err |= copy_to_user(p, &arg64, sizeof(arg64));
592
593 if (err)
594 return -EFAULT;
595
596 err = do_ioctl(f, CCISS_PASSTHRU, (unsigned long) p);
597 if (err)
598 return err;
599 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
600 if (err)
601 return -EFAULT;
602 return err;
603 }
604
605 static int cciss_ioctl32_big_passthru(struct file *file, unsigned cmd, unsigned long arg)
606 {
607 BIG_IOCTL32_Command_struct __user *arg32 =
608 (BIG_IOCTL32_Command_struct __user *) arg;
609 BIG_IOCTL_Command_struct arg64;
610 BIG_IOCTL_Command_struct __user *p = compat_alloc_user_space(sizeof(arg64));
611 int err;
612 u32 cp;
613
614 err = 0;
615 err |= copy_from_user(&arg64.LUN_info, &arg32->LUN_info, sizeof(arg64.LUN_info));
616 err |= copy_from_user(&arg64.Request, &arg32->Request, sizeof(arg64.Request));
617 err |= copy_from_user(&arg64.error_info, &arg32->error_info, sizeof(arg64.error_info));
618 err |= get_user(arg64.buf_size, &arg32->buf_size);
619 err |= get_user(arg64.malloc_size, &arg32->malloc_size);
620 err |= get_user(cp, &arg32->buf);
621 arg64.buf = compat_ptr(cp);
622 err |= copy_to_user(p, &arg64, sizeof(arg64));
623
624 if (err)
625 return -EFAULT;
626
627 err = do_ioctl(file, CCISS_BIG_PASSTHRU, (unsigned long) p);
628 if (err)
629 return err;
630 err |= copy_in_user(&arg32->error_info, &p->error_info, sizeof(arg32->error_info));
631 if (err)
632 return -EFAULT;
633 return err;
634 }
635 #endif
636 /*
637 * ioctl
638 */
639 static int cciss_ioctl(struct inode *inode, struct file *filep,
640 unsigned int cmd, unsigned long arg)
641 {
642 struct block_device *bdev = inode->i_bdev;
643 struct gendisk *disk = bdev->bd_disk;
644 ctlr_info_t *host = get_host(disk);
645 drive_info_struct *drv = get_drv(disk);
646 int ctlr = host->ctlr;
647 void __user *argp = (void __user *)arg;
648
649 #ifdef CCISS_DEBUG
650 printk(KERN_DEBUG "cciss_ioctl: Called with cmd=%x %lx\n", cmd, arg);
651 #endif /* CCISS_DEBUG */
652
653 switch(cmd) {
654 case HDIO_GETGEO:
655 {
656 struct hd_geometry driver_geo;
657 if (drv->cylinders) {
658 driver_geo.heads = drv->heads;
659 driver_geo.sectors = drv->sectors;
660 driver_geo.cylinders = drv->cylinders;
661 } else
662 return -ENXIO;
663 driver_geo.start= get_start_sect(inode->i_bdev);
664 if (copy_to_user(argp, &driver_geo, sizeof(struct hd_geometry)))
665 return -EFAULT;
666 return(0);
667 }
668
669 case CCISS_GETPCIINFO:
670 {
671 cciss_pci_info_struct pciinfo;
672
673 if (!arg) return -EINVAL;
674 pciinfo.domain = pci_domain_nr(host->pdev->bus);
675 pciinfo.bus = host->pdev->bus->number;
676 pciinfo.dev_fn = host->pdev->devfn;
677 pciinfo.board_id = host->board_id;
678 if (copy_to_user(argp, &pciinfo, sizeof( cciss_pci_info_struct )))
679 return -EFAULT;
680 return(0);
681 }
682 case CCISS_GETINTINFO:
683 {
684 cciss_coalint_struct intinfo;
685 if (!arg) return -EINVAL;
686 intinfo.delay = readl(&host->cfgtable->HostWrite.CoalIntDelay);
687 intinfo.count = readl(&host->cfgtable->HostWrite.CoalIntCount);
688 if (copy_to_user(argp, &intinfo, sizeof( cciss_coalint_struct )))
689 return -EFAULT;
690 return(0);
691 }
692 case CCISS_SETINTINFO:
693 {
694 cciss_coalint_struct intinfo;
695 unsigned long flags;
696 int i;
697
698 if (!arg) return -EINVAL;
699 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
700 if (copy_from_user(&intinfo, argp, sizeof( cciss_coalint_struct)))
701 return -EFAULT;
702 if ( (intinfo.delay == 0 ) && (intinfo.count == 0))
703
704 {
705 // printk("cciss_ioctl: delay and count cannot be 0\n");
706 return( -EINVAL);
707 }
708 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
709 /* Update the field, and then ring the doorbell */
710 writel( intinfo.delay,
711 &(host->cfgtable->HostWrite.CoalIntDelay));
712 writel( intinfo.count,
713 &(host->cfgtable->HostWrite.CoalIntCount));
714 writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
715
716 for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
717 if (!(readl(host->vaddr + SA5_DOORBELL)
718 & CFGTBL_ChangeReq))
719 break;
720 /* delay and try again */
721 udelay(1000);
722 }
723 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
724 if (i >= MAX_IOCTL_CONFIG_WAIT)
725 return -EAGAIN;
726 return(0);
727 }
728 case CCISS_GETNODENAME:
729 {
730 NodeName_type NodeName;
731 int i;
732
733 if (!arg) return -EINVAL;
734 for(i=0;i<16;i++)
735 NodeName[i] = readb(&host->cfgtable->ServerName[i]);
736 if (copy_to_user(argp, NodeName, sizeof( NodeName_type)))
737 return -EFAULT;
738 return(0);
739 }
740 case CCISS_SETNODENAME:
741 {
742 NodeName_type NodeName;
743 unsigned long flags;
744 int i;
745
746 if (!arg) return -EINVAL;
747 if (!capable(CAP_SYS_ADMIN)) return -EPERM;
748
749 if (copy_from_user(NodeName, argp, sizeof( NodeName_type)))
750 return -EFAULT;
751
752 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
753
754 /* Update the field, and then ring the doorbell */
755 for(i=0;i<16;i++)
756 writeb( NodeName[i], &host->cfgtable->ServerName[i]);
757
758 writel( CFGTBL_ChangeReq, host->vaddr + SA5_DOORBELL);
759
760 for(i=0;i<MAX_IOCTL_CONFIG_WAIT;i++) {
761 if (!(readl(host->vaddr + SA5_DOORBELL)
762 & CFGTBL_ChangeReq))
763 break;
764 /* delay and try again */
765 udelay(1000);
766 }
767 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
768 if (i >= MAX_IOCTL_CONFIG_WAIT)
769 return -EAGAIN;
770 return(0);
771 }
772
773 case CCISS_GETHEARTBEAT:
774 {
775 Heartbeat_type heartbeat;
776
777 if (!arg) return -EINVAL;
778 heartbeat = readl(&host->cfgtable->HeartBeat);
779 if (copy_to_user(argp, &heartbeat, sizeof( Heartbeat_type)))
780 return -EFAULT;
781 return(0);
782 }
783 case CCISS_GETBUSTYPES:
784 {
785 BusTypes_type BusTypes;
786
787 if (!arg) return -EINVAL;
788 BusTypes = readl(&host->cfgtable->BusTypes);
789 if (copy_to_user(argp, &BusTypes, sizeof( BusTypes_type) ))
790 return -EFAULT;
791 return(0);
792 }
793 case CCISS_GETFIRMVER:
794 {
795 FirmwareVer_type firmware;
796
797 if (!arg) return -EINVAL;
798 memcpy(firmware, host->firm_ver, 4);
799
800 if (copy_to_user(argp, firmware, sizeof( FirmwareVer_type)))
801 return -EFAULT;
802 return(0);
803 }
804 case CCISS_GETDRIVVER:
805 {
806 DriverVer_type DriverVer = DRIVER_VERSION;
807
808 if (!arg) return -EINVAL;
809
810 if (copy_to_user(argp, &DriverVer, sizeof( DriverVer_type) ))
811 return -EFAULT;
812 return(0);
813 }
814
815 case CCISS_REVALIDVOLS:
816 if (bdev != bdev->bd_contains || drv != host->drv)
817 return -ENXIO;
818 return revalidate_allvol(host);
819
820 case CCISS_GETLUNINFO: {
821 LogvolInfo_struct luninfo;
822
823 luninfo.LunID = drv->LunID;
824 luninfo.num_opens = drv->usage_count;
825 luninfo.num_parts = 0;
826 if (copy_to_user(argp, &luninfo,
827 sizeof(LogvolInfo_struct)))
828 return -EFAULT;
829 return(0);
830 }
831 case CCISS_DEREGDISK:
832 return rebuild_lun_table(host, disk);
833
834 case CCISS_REGNEWD:
835 return rebuild_lun_table(host, NULL);
836
837 case CCISS_PASSTHRU:
838 {
839 IOCTL_Command_struct iocommand;
840 CommandList_struct *c;
841 char *buff = NULL;
842 u64bit temp64;
843 unsigned long flags;
844 DECLARE_COMPLETION(wait);
845
846 if (!arg) return -EINVAL;
847
848 if (!capable(CAP_SYS_RAWIO)) return -EPERM;
849
850 if (copy_from_user(&iocommand, argp, sizeof( IOCTL_Command_struct) ))
851 return -EFAULT;
852 if((iocommand.buf_size < 1) &&
853 (iocommand.Request.Type.Direction != XFER_NONE))
854 {
855 return -EINVAL;
856 }
857 #if 0 /* 'buf_size' member is 16-bits, and always smaller than kmalloc limit */
858 /* Check kmalloc limits */
859 if(iocommand.buf_size > 128000)
860 return -EINVAL;
861 #endif
862 if(iocommand.buf_size > 0)
863 {
864 buff = kmalloc(iocommand.buf_size, GFP_KERNEL);
865 if( buff == NULL)
866 return -EFAULT;
867 }
868 if (iocommand.Request.Type.Direction == XFER_WRITE)
869 {
870 /* Copy the data into the buffer we created */
871 if (copy_from_user(buff, iocommand.buf, iocommand.buf_size))
872 {
873 kfree(buff);
874 return -EFAULT;
875 }
876 } else {
877 memset(buff, 0, iocommand.buf_size);
878 }
879 if ((c = cmd_alloc(host , 0)) == NULL)
880 {
881 kfree(buff);
882 return -ENOMEM;
883 }
884 // Fill in the command type
885 c->cmd_type = CMD_IOCTL_PEND;
886 // Fill in Command Header
887 c->Header.ReplyQueue = 0; // unused in simple mode
888 if( iocommand.buf_size > 0) // buffer to fill
889 {
890 c->Header.SGList = 1;
891 c->Header.SGTotal= 1;
892 } else // no buffers to fill
893 {
894 c->Header.SGList = 0;
895 c->Header.SGTotal= 0;
896 }
897 c->Header.LUN = iocommand.LUN_info;
898 c->Header.Tag.lower = c->busaddr; // use the kernel address the cmd block for tag
899
900 // Fill in Request block
901 c->Request = iocommand.Request;
902
903 // Fill in the scatter gather information
904 if (iocommand.buf_size > 0 )
905 {
906 temp64.val = pci_map_single( host->pdev, buff,
907 iocommand.buf_size,
908 PCI_DMA_BIDIRECTIONAL);
909 c->SG[0].Addr.lower = temp64.val32.lower;
910 c->SG[0].Addr.upper = temp64.val32.upper;
911 c->SG[0].Len = iocommand.buf_size;
912 c->SG[0].Ext = 0; // we are not chaining
913 }
914 c->waiting = &wait;
915
916 /* Put the request on the tail of the request queue */
917 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
918 addQ(&host->reqQ, c);
919 host->Qdepth++;
920 start_io(host);
921 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
922
923 wait_for_completion(&wait);
924
925 /* unlock the buffers from DMA */
926 temp64.val32.lower = c->SG[0].Addr.lower;
927 temp64.val32.upper = c->SG[0].Addr.upper;
928 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
929 iocommand.buf_size, PCI_DMA_BIDIRECTIONAL);
930
931 /* Copy the error information out */
932 iocommand.error_info = *(c->err_info);
933 if ( copy_to_user(argp, &iocommand, sizeof( IOCTL_Command_struct) ) )
934 {
935 kfree(buff);
936 cmd_free(host, c, 0);
937 return( -EFAULT);
938 }
939
940 if (iocommand.Request.Type.Direction == XFER_READ)
941 {
942 /* Copy the data out of the buffer we created */
943 if (copy_to_user(iocommand.buf, buff, iocommand.buf_size))
944 {
945 kfree(buff);
946 cmd_free(host, c, 0);
947 return -EFAULT;
948 }
949 }
950 kfree(buff);
951 cmd_free(host, c, 0);
952 return(0);
953 }
954 case CCISS_BIG_PASSTHRU: {
955 BIG_IOCTL_Command_struct *ioc;
956 CommandList_struct *c;
957 unsigned char **buff = NULL;
958 int *buff_size = NULL;
959 u64bit temp64;
960 unsigned long flags;
961 BYTE sg_used = 0;
962 int status = 0;
963 int i;
964 DECLARE_COMPLETION(wait);
965 __u32 left;
966 __u32 sz;
967 BYTE __user *data_ptr;
968
969 if (!arg)
970 return -EINVAL;
971 if (!capable(CAP_SYS_RAWIO))
972 return -EPERM;
973 ioc = (BIG_IOCTL_Command_struct *)
974 kmalloc(sizeof(*ioc), GFP_KERNEL);
975 if (!ioc) {
976 status = -ENOMEM;
977 goto cleanup1;
978 }
979 if (copy_from_user(ioc, argp, sizeof(*ioc))) {
980 status = -EFAULT;
981 goto cleanup1;
982 }
983 if ((ioc->buf_size < 1) &&
984 (ioc->Request.Type.Direction != XFER_NONE)) {
985 status = -EINVAL;
986 goto cleanup1;
987 }
988 /* Check kmalloc limits using all SGs */
989 if (ioc->malloc_size > MAX_KMALLOC_SIZE) {
990 status = -EINVAL;
991 goto cleanup1;
992 }
993 if (ioc->buf_size > ioc->malloc_size * MAXSGENTRIES) {
994 status = -EINVAL;
995 goto cleanup1;
996 }
997 buff = (unsigned char **) kmalloc(MAXSGENTRIES *
998 sizeof(char *), GFP_KERNEL);
999 if (!buff) {
1000 status = -ENOMEM;
1001 goto cleanup1;
1002 }
1003 memset(buff, 0, MAXSGENTRIES);
1004 buff_size = (int *) kmalloc(MAXSGENTRIES * sizeof(int),
1005 GFP_KERNEL);
1006 if (!buff_size) {
1007 status = -ENOMEM;
1008 goto cleanup1;
1009 }
1010 left = ioc->buf_size;
1011 data_ptr = ioc->buf;
1012 while (left) {
1013 sz = (left > ioc->malloc_size) ? ioc->malloc_size : left;
1014 buff_size[sg_used] = sz;
1015 buff[sg_used] = kmalloc(sz, GFP_KERNEL);
1016 if (buff[sg_used] == NULL) {
1017 status = -ENOMEM;
1018 goto cleanup1;
1019 }
1020 if (ioc->Request.Type.Direction == XFER_WRITE &&
1021 copy_from_user(buff[sg_used], data_ptr, sz)) {
1022 status = -ENOMEM;
1023 goto cleanup1;
1024 } else {
1025 memset(buff[sg_used], 0, sz);
1026 }
1027 left -= sz;
1028 data_ptr += sz;
1029 sg_used++;
1030 }
1031 if ((c = cmd_alloc(host , 0)) == NULL) {
1032 status = -ENOMEM;
1033 goto cleanup1;
1034 }
1035 c->cmd_type = CMD_IOCTL_PEND;
1036 c->Header.ReplyQueue = 0;
1037
1038 if( ioc->buf_size > 0) {
1039 c->Header.SGList = sg_used;
1040 c->Header.SGTotal= sg_used;
1041 } else {
1042 c->Header.SGList = 0;
1043 c->Header.SGTotal= 0;
1044 }
1045 c->Header.LUN = ioc->LUN_info;
1046 c->Header.Tag.lower = c->busaddr;
1047
1048 c->Request = ioc->Request;
1049 if (ioc->buf_size > 0 ) {
1050 int i;
1051 for(i=0; i<sg_used; i++) {
1052 temp64.val = pci_map_single( host->pdev, buff[i],
1053 buff_size[i],
1054 PCI_DMA_BIDIRECTIONAL);
1055 c->SG[i].Addr.lower = temp64.val32.lower;
1056 c->SG[i].Addr.upper = temp64.val32.upper;
1057 c->SG[i].Len = buff_size[i];
1058 c->SG[i].Ext = 0; /* we are not chaining */
1059 }
1060 }
1061 c->waiting = &wait;
1062 /* Put the request on the tail of the request queue */
1063 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1064 addQ(&host->reqQ, c);
1065 host->Qdepth++;
1066 start_io(host);
1067 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1068 wait_for_completion(&wait);
1069 /* unlock the buffers from DMA */
1070 for(i=0; i<sg_used; i++) {
1071 temp64.val32.lower = c->SG[i].Addr.lower;
1072 temp64.val32.upper = c->SG[i].Addr.upper;
1073 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
1074 buff_size[i], PCI_DMA_BIDIRECTIONAL);
1075 }
1076 /* Copy the error information out */
1077 ioc->error_info = *(c->err_info);
1078 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1079 cmd_free(host, c, 0);
1080 status = -EFAULT;
1081 goto cleanup1;
1082 }
1083 if (ioc->Request.Type.Direction == XFER_READ) {
1084 /* Copy the data out of the buffer we created */
1085 BYTE __user *ptr = ioc->buf;
1086 for(i=0; i< sg_used; i++) {
1087 if (copy_to_user(ptr, buff[i], buff_size[i])) {
1088 cmd_free(host, c, 0);
1089 status = -EFAULT;
1090 goto cleanup1;
1091 }
1092 ptr += buff_size[i];
1093 }
1094 }
1095 cmd_free(host, c, 0);
1096 status = 0;
1097 cleanup1:
1098 if (buff) {
1099 for(i=0; i<sg_used; i++)
1100 kfree(buff[i]);
1101 kfree(buff);
1102 }
1103 kfree(buff_size);
1104 kfree(ioc);
1105 return(status);
1106 }
1107 default:
1108 return -ENOTTY;
1109 }
1110
1111 }
1112
1113 /*
1114 * revalidate_allvol is for online array config utilities. After a
1115 * utility reconfigures the drives in the array, it can use this function
1116 * (through an ioctl) to make the driver zap any previous disk structs for
1117 * that controller and get new ones.
1118 *
1119 * Right now I'm using the getgeometry() function to do this, but this
1120 * function should probably be finer grained and allow you to revalidate one
1121 * particualar logical volume (instead of all of them on a particular
1122 * controller).
1123 */
1124 static int revalidate_allvol(ctlr_info_t *host)
1125 {
1126 int ctlr = host->ctlr, i;
1127 unsigned long flags;
1128
1129 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1130 if (host->usage_count > 1) {
1131 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1132 printk(KERN_WARNING "cciss: Device busy for volume"
1133 " revalidation (usage=%d)\n", host->usage_count);
1134 return -EBUSY;
1135 }
1136 host->usage_count++;
1137 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1138
1139 for(i=0; i< NWD; i++) {
1140 struct gendisk *disk = host->gendisk[i];
1141 if (disk->flags & GENHD_FL_UP)
1142 del_gendisk(disk);
1143 }
1144
1145 /*
1146 * Set the partition and block size structures for all volumes
1147 * on this controller to zero. We will reread all of this data
1148 */
1149 memset(host->drv, 0, sizeof(drive_info_struct)
1150 * CISS_MAX_LUN);
1151 /*
1152 * Tell the array controller not to give us any interrupts while
1153 * we check the new geometry. Then turn interrupts back on when
1154 * we're done.
1155 */
1156 host->access.set_intr_mask(host, CCISS_INTR_OFF);
1157 cciss_getgeometry(ctlr);
1158 host->access.set_intr_mask(host, CCISS_INTR_ON);
1159
1160 /* Loop through each real device */
1161 for (i = 0; i < NWD; i++) {
1162 struct gendisk *disk = host->gendisk[i];
1163 drive_info_struct *drv = &(host->drv[i]);
1164 /* we must register the controller even if no disks exist */
1165 /* this is for the online array utilities */
1166 if (!drv->heads && i)
1167 continue;
1168 blk_queue_hardsect_size(drv->queue, drv->block_size);
1169 set_capacity(disk, drv->nr_blocks);
1170 add_disk(disk);
1171 }
1172 host->usage_count--;
1173 return 0;
1174 }
1175
1176 /* This function will check the usage_count of the drive to be updated/added.
1177 * If the usage_count is zero then the drive information will be updated and
1178 * the disk will be re-registered with the kernel. If not then it will be
1179 * left alone for the next reboot. The exception to this is disk 0 which
1180 * will always be left registered with the kernel since it is also the
1181 * controller node. Any changes to disk 0 will show up on the next
1182 * reboot.
1183 */
1184 static void cciss_update_drive_info(int ctlr, int drv_index)
1185 {
1186 ctlr_info_t *h = hba[ctlr];
1187 struct gendisk *disk;
1188 ReadCapdata_struct *size_buff = NULL;
1189 InquiryData_struct *inq_buff = NULL;
1190 unsigned int block_size;
1191 unsigned int total_size;
1192 unsigned long flags = 0;
1193 int ret = 0;
1194
1195 /* if the disk already exists then deregister it before proceeding*/
1196 if (h->drv[drv_index].raid_level != -1){
1197 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1198 h->drv[drv_index].busy_configuring = 1;
1199 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1200 ret = deregister_disk(h->gendisk[drv_index],
1201 &h->drv[drv_index], 0);
1202 h->drv[drv_index].busy_configuring = 0;
1203 }
1204
1205 /* If the disk is in use return */
1206 if (ret)
1207 return;
1208
1209
1210 /* Get information about the disk and modify the driver sturcture */
1211 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1212 if (size_buff == NULL)
1213 goto mem_msg;
1214 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1215 if (inq_buff == NULL)
1216 goto mem_msg;
1217
1218 cciss_read_capacity(ctlr, drv_index, size_buff, 1,
1219 &total_size, &block_size);
1220 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1221 inq_buff, &h->drv[drv_index]);
1222
1223 ++h->num_luns;
1224 disk = h->gendisk[drv_index];
1225 set_capacity(disk, h->drv[drv_index].nr_blocks);
1226
1227
1228 /* if it's the controller it's already added */
1229 if (drv_index){
1230 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1231
1232 /* Set up queue information */
1233 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1234 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1235
1236 /* This is a hardware imposed limit. */
1237 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1238
1239 /* This is a limit in the driver and could be eliminated. */
1240 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1241
1242 blk_queue_max_sectors(disk->queue, 512);
1243
1244 disk->queue->queuedata = hba[ctlr];
1245
1246 blk_queue_hardsect_size(disk->queue,
1247 hba[ctlr]->drv[drv_index].block_size);
1248
1249 h->drv[drv_index].queue = disk->queue;
1250 add_disk(disk);
1251 }
1252
1253 freeret:
1254 kfree(size_buff);
1255 kfree(inq_buff);
1256 return;
1257 mem_msg:
1258 printk(KERN_ERR "cciss: out of memory\n");
1259 goto freeret;
1260 }
1261
1262 /* This function will find the first index of the controllers drive array
1263 * that has a -1 for the raid_level and will return that index. This is
1264 * where new drives will be added. If the index to be returned is greater
1265 * than the highest_lun index for the controller then highest_lun is set
1266 * to this new index. If there are no available indexes then -1 is returned.
1267 */
1268 static int cciss_find_free_drive_index(int ctlr)
1269 {
1270 int i;
1271
1272 for (i=0; i < CISS_MAX_LUN; i++){
1273 if (hba[ctlr]->drv[i].raid_level == -1){
1274 if (i > hba[ctlr]->highest_lun)
1275 hba[ctlr]->highest_lun = i;
1276 return i;
1277 }
1278 }
1279 return -1;
1280 }
1281
1282 /* This function will add and remove logical drives from the Logical
1283 * drive array of the controller and maintain persistancy of ordering
1284 * so that mount points are preserved until the next reboot. This allows
1285 * for the removal of logical drives in the middle of the drive array
1286 * without a re-ordering of those drives.
1287 * INPUT
1288 * h = The controller to perform the operations on
1289 * del_disk = The disk to remove if specified. If the value given
1290 * is NULL then no disk is removed.
1291 */
1292 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1293 {
1294 int ctlr = h->ctlr;
1295 int num_luns;
1296 ReportLunData_struct *ld_buff = NULL;
1297 drive_info_struct *drv = NULL;
1298 int return_code;
1299 int listlength = 0;
1300 int i;
1301 int drv_found;
1302 int drv_index = 0;
1303 __u32 lunid = 0;
1304 unsigned long flags;
1305
1306 /* Set busy_configuring flag for this operation */
1307 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1308 if (h->num_luns >= CISS_MAX_LUN){
1309 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1310 return -EINVAL;
1311 }
1312
1313 if (h->busy_configuring){
1314 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1315 return -EBUSY;
1316 }
1317 h->busy_configuring = 1;
1318
1319 /* if del_disk is NULL then we are being called to add a new disk
1320 * and update the logical drive table. If it is not NULL then
1321 * we will check if the disk is in use or not.
1322 */
1323 if (del_disk != NULL){
1324 drv = get_drv(del_disk);
1325 drv->busy_configuring = 1;
1326 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1327 return_code = deregister_disk(del_disk, drv, 1);
1328 drv->busy_configuring = 0;
1329 h->busy_configuring = 0;
1330 return return_code;
1331 } else {
1332 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1333 if (!capable(CAP_SYS_RAWIO))
1334 return -EPERM;
1335
1336 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1337 if (ld_buff == NULL)
1338 goto mem_msg;
1339
1340 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1341 sizeof(ReportLunData_struct), 0, 0, 0,
1342 TYPE_CMD);
1343
1344 if (return_code == IO_OK){
1345 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
1346 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
1347 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
1348 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
1349 } else{ /* reading number of logical volumes failed */
1350 printk(KERN_WARNING "cciss: report logical volume"
1351 " command failed\n");
1352 listlength = 0;
1353 goto freeret;
1354 }
1355
1356 num_luns = listlength / 8; /* 8 bytes per entry */
1357 if (num_luns > CISS_MAX_LUN){
1358 num_luns = CISS_MAX_LUN;
1359 printk(KERN_WARNING "cciss: more luns configured"
1360 " on controller than can be handled by"
1361 " this driver.\n");
1362 }
1363
1364 /* Compare controller drive array to drivers drive array.
1365 * Check for updates in the drive information and any new drives
1366 * on the controller.
1367 */
1368 for (i=0; i < num_luns; i++){
1369 int j;
1370
1371 drv_found = 0;
1372
1373 lunid = (0xff &
1374 (unsigned int)(ld_buff->LUN[i][3])) << 24;
1375 lunid |= (0xff &
1376 (unsigned int)(ld_buff->LUN[i][2])) << 16;
1377 lunid |= (0xff &
1378 (unsigned int)(ld_buff->LUN[i][1])) << 8;
1379 lunid |= 0xff &
1380 (unsigned int)(ld_buff->LUN[i][0]);
1381
1382 /* Find if the LUN is already in the drive array
1383 * of the controller. If so then update its info
1384 * if not is use. If it does not exist then find
1385 * the first free index and add it.
1386 */
1387 for (j=0; j <= h->highest_lun; j++){
1388 if (h->drv[j].LunID == lunid){
1389 drv_index = j;
1390 drv_found = 1;
1391 }
1392 }
1393
1394 /* check if the drive was found already in the array */
1395 if (!drv_found){
1396 drv_index = cciss_find_free_drive_index(ctlr);
1397 if (drv_index == -1)
1398 goto freeret;
1399
1400 }
1401 h->drv[drv_index].LunID = lunid;
1402 cciss_update_drive_info(ctlr, drv_index);
1403 } /* end for */
1404 } /* end else */
1405
1406 freeret:
1407 kfree(ld_buff);
1408 h->busy_configuring = 0;
1409 /* We return -1 here to tell the ACU that we have registered/updated
1410 * all of the drives that we can and to keep it from calling us
1411 * additional times.
1412 */
1413 return -1;
1414 mem_msg:
1415 printk(KERN_ERR "cciss: out of memory\n");
1416 goto freeret;
1417 }
1418
1419 /* This function will deregister the disk and it's queue from the
1420 * kernel. It must be called with the controller lock held and the
1421 * drv structures busy_configuring flag set. It's parameters are:
1422 *
1423 * disk = This is the disk to be deregistered
1424 * drv = This is the drive_info_struct associated with the disk to be
1425 * deregistered. It contains information about the disk used
1426 * by the driver.
1427 * clear_all = This flag determines whether or not the disk information
1428 * is going to be completely cleared out and the highest_lun
1429 * reset. Sometimes we want to clear out information about
1430 * the disk in preperation for re-adding it. In this case
1431 * the highest_lun should be left unchanged and the LunID
1432 * should not be cleared.
1433 */
1434 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1435 int clear_all)
1436 {
1437 ctlr_info_t *h = get_host(disk);
1438
1439 if (!capable(CAP_SYS_RAWIO))
1440 return -EPERM;
1441
1442 /* make sure logical volume is NOT is use */
1443 if(clear_all || (h->gendisk[0] == disk)) {
1444 if (drv->usage_count > 1)
1445 return -EBUSY;
1446 }
1447 else
1448 if( drv->usage_count > 0 )
1449 return -EBUSY;
1450
1451 /* invalidate the devices and deregister the disk. If it is disk
1452 * zero do not deregister it but just zero out it's values. This
1453 * allows us to delete disk zero but keep the controller registered.
1454 */
1455 if (h->gendisk[0] != disk){
1456 if (disk->flags & GENHD_FL_UP){
1457 blk_cleanup_queue(disk->queue);
1458 del_gendisk(disk);
1459 drv->queue = NULL;
1460 }
1461 }
1462
1463 --h->num_luns;
1464 /* zero out the disk size info */
1465 drv->nr_blocks = 0;
1466 drv->block_size = 0;
1467 drv->heads = 0;
1468 drv->sectors = 0;
1469 drv->cylinders = 0;
1470 drv->raid_level = -1; /* This can be used as a flag variable to
1471 * indicate that this element of the drive
1472 * array is free.
1473 */
1474
1475 if (clear_all){
1476 /* check to see if it was the last disk */
1477 if (drv == h->drv + h->highest_lun) {
1478 /* if so, find the new hightest lun */
1479 int i, newhighest =-1;
1480 for(i=0; i<h->highest_lun; i++) {
1481 /* if the disk has size > 0, it is available */
1482 if (h->drv[i].heads)
1483 newhighest = i;
1484 }
1485 h->highest_lun = newhighest;
1486 }
1487
1488 drv->LunID = 0;
1489 }
1490 return(0);
1491 }
1492
1493 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
1494 size_t size,
1495 unsigned int use_unit_num, /* 0: address the controller,
1496 1: address logical volume log_unit,
1497 2: periph device address is scsi3addr */
1498 unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr,
1499 int cmd_type)
1500 {
1501 ctlr_info_t *h= hba[ctlr];
1502 u64bit buff_dma_handle;
1503 int status = IO_OK;
1504
1505 c->cmd_type = CMD_IOCTL_PEND;
1506 c->Header.ReplyQueue = 0;
1507 if( buff != NULL) {
1508 c->Header.SGList = 1;
1509 c->Header.SGTotal= 1;
1510 } else {
1511 c->Header.SGList = 0;
1512 c->Header.SGTotal= 0;
1513 }
1514 c->Header.Tag.lower = c->busaddr;
1515
1516 c->Request.Type.Type = cmd_type;
1517 if (cmd_type == TYPE_CMD) {
1518 switch(cmd) {
1519 case CISS_INQUIRY:
1520 /* If the logical unit number is 0 then, this is going
1521 to controller so It's a physical command
1522 mode = 0 target = 0. So we have nothing to write.
1523 otherwise, if use_unit_num == 1,
1524 mode = 1(volume set addressing) target = LUNID
1525 otherwise, if use_unit_num == 2,
1526 mode = 0(periph dev addr) target = scsi3addr */
1527 if (use_unit_num == 1) {
1528 c->Header.LUN.LogDev.VolId=
1529 h->drv[log_unit].LunID;
1530 c->Header.LUN.LogDev.Mode = 1;
1531 } else if (use_unit_num == 2) {
1532 memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8);
1533 c->Header.LUN.LogDev.Mode = 0;
1534 }
1535 /* are we trying to read a vital product page */
1536 if(page_code != 0) {
1537 c->Request.CDB[1] = 0x01;
1538 c->Request.CDB[2] = page_code;
1539 }
1540 c->Request.CDBLen = 6;
1541 c->Request.Type.Attribute = ATTR_SIMPLE;
1542 c->Request.Type.Direction = XFER_READ;
1543 c->Request.Timeout = 0;
1544 c->Request.CDB[0] = CISS_INQUIRY;
1545 c->Request.CDB[4] = size & 0xFF;
1546 break;
1547 case CISS_REPORT_LOG:
1548 case CISS_REPORT_PHYS:
1549 /* Talking to controller so It's a physical command
1550 mode = 00 target = 0. Nothing to write.
1551 */
1552 c->Request.CDBLen = 12;
1553 c->Request.Type.Attribute = ATTR_SIMPLE;
1554 c->Request.Type.Direction = XFER_READ;
1555 c->Request.Timeout = 0;
1556 c->Request.CDB[0] = cmd;
1557 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1558 c->Request.CDB[7] = (size >> 16) & 0xFF;
1559 c->Request.CDB[8] = (size >> 8) & 0xFF;
1560 c->Request.CDB[9] = size & 0xFF;
1561 break;
1562
1563 case CCISS_READ_CAPACITY:
1564 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1565 c->Header.LUN.LogDev.Mode = 1;
1566 c->Request.CDBLen = 10;
1567 c->Request.Type.Attribute = ATTR_SIMPLE;
1568 c->Request.Type.Direction = XFER_READ;
1569 c->Request.Timeout = 0;
1570 c->Request.CDB[0] = cmd;
1571 break;
1572 case CCISS_CACHE_FLUSH:
1573 c->Request.CDBLen = 12;
1574 c->Request.Type.Attribute = ATTR_SIMPLE;
1575 c->Request.Type.Direction = XFER_WRITE;
1576 c->Request.Timeout = 0;
1577 c->Request.CDB[0] = BMIC_WRITE;
1578 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1579 break;
1580 default:
1581 printk(KERN_WARNING
1582 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
1583 return(IO_ERROR);
1584 }
1585 } else if (cmd_type == TYPE_MSG) {
1586 switch (cmd) {
1587 case 0: /* ABORT message */
1588 c->Request.CDBLen = 12;
1589 c->Request.Type.Attribute = ATTR_SIMPLE;
1590 c->Request.Type.Direction = XFER_WRITE;
1591 c->Request.Timeout = 0;
1592 c->Request.CDB[0] = cmd; /* abort */
1593 c->Request.CDB[1] = 0; /* abort a command */
1594 /* buff contains the tag of the command to abort */
1595 memcpy(&c->Request.CDB[4], buff, 8);
1596 break;
1597 case 1: /* RESET message */
1598 c->Request.CDBLen = 12;
1599 c->Request.Type.Attribute = ATTR_SIMPLE;
1600 c->Request.Type.Direction = XFER_WRITE;
1601 c->Request.Timeout = 0;
1602 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1603 c->Request.CDB[0] = cmd; /* reset */
1604 c->Request.CDB[1] = 0x04; /* reset a LUN */
1605 case 3: /* No-Op message */
1606 c->Request.CDBLen = 1;
1607 c->Request.Type.Attribute = ATTR_SIMPLE;
1608 c->Request.Type.Direction = XFER_WRITE;
1609 c->Request.Timeout = 0;
1610 c->Request.CDB[0] = cmd;
1611 break;
1612 default:
1613 printk(KERN_WARNING
1614 "cciss%d: unknown message type %d\n",
1615 ctlr, cmd);
1616 return IO_ERROR;
1617 }
1618 } else {
1619 printk(KERN_WARNING
1620 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1621 return IO_ERROR;
1622 }
1623 /* Fill in the scatter gather information */
1624 if (size > 0) {
1625 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1626 buff, size, PCI_DMA_BIDIRECTIONAL);
1627 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1628 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1629 c->SG[0].Len = size;
1630 c->SG[0].Ext = 0; /* we are not chaining */
1631 }
1632 return status;
1633 }
1634 static int sendcmd_withirq(__u8 cmd,
1635 int ctlr,
1636 void *buff,
1637 size_t size,
1638 unsigned int use_unit_num,
1639 unsigned int log_unit,
1640 __u8 page_code,
1641 int cmd_type)
1642 {
1643 ctlr_info_t *h = hba[ctlr];
1644 CommandList_struct *c;
1645 u64bit buff_dma_handle;
1646 unsigned long flags;
1647 int return_status;
1648 DECLARE_COMPLETION(wait);
1649
1650 if ((c = cmd_alloc(h , 0)) == NULL)
1651 return -ENOMEM;
1652 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1653 log_unit, page_code, NULL, cmd_type);
1654 if (return_status != IO_OK) {
1655 cmd_free(h, c, 0);
1656 return return_status;
1657 }
1658 resend_cmd2:
1659 c->waiting = &wait;
1660
1661 /* Put the request on the tail of the queue and send it */
1662 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1663 addQ(&h->reqQ, c);
1664 h->Qdepth++;
1665 start_io(h);
1666 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1667
1668 wait_for_completion(&wait);
1669
1670 if(c->err_info->CommandStatus != 0)
1671 { /* an error has occurred */
1672 switch(c->err_info->CommandStatus)
1673 {
1674 case CMD_TARGET_STATUS:
1675 printk(KERN_WARNING "cciss: cmd %p has "
1676 " completed with errors\n", c);
1677 if( c->err_info->ScsiStatus)
1678 {
1679 printk(KERN_WARNING "cciss: cmd %p "
1680 "has SCSI Status = %x\n",
1681 c,
1682 c->err_info->ScsiStatus);
1683 }
1684
1685 break;
1686 case CMD_DATA_UNDERRUN:
1687 case CMD_DATA_OVERRUN:
1688 /* expected for inquire and report lun commands */
1689 break;
1690 case CMD_INVALID:
1691 printk(KERN_WARNING "cciss: Cmd %p is "
1692 "reported invalid\n", c);
1693 return_status = IO_ERROR;
1694 break;
1695 case CMD_PROTOCOL_ERR:
1696 printk(KERN_WARNING "cciss: cmd %p has "
1697 "protocol error \n", c);
1698 return_status = IO_ERROR;
1699 break;
1700 case CMD_HARDWARE_ERR:
1701 printk(KERN_WARNING "cciss: cmd %p had "
1702 " hardware error\n", c);
1703 return_status = IO_ERROR;
1704 break;
1705 case CMD_CONNECTION_LOST:
1706 printk(KERN_WARNING "cciss: cmd %p had "
1707 "connection lost\n", c);
1708 return_status = IO_ERROR;
1709 break;
1710 case CMD_ABORTED:
1711 printk(KERN_WARNING "cciss: cmd %p was "
1712 "aborted\n", c);
1713 return_status = IO_ERROR;
1714 break;
1715 case CMD_ABORT_FAILED:
1716 printk(KERN_WARNING "cciss: cmd %p reports "
1717 "abort failed\n", c);
1718 return_status = IO_ERROR;
1719 break;
1720 case CMD_UNSOLICITED_ABORT:
1721 printk(KERN_WARNING
1722 "cciss%d: unsolicited abort %p\n",
1723 ctlr, c);
1724 if (c->retry_count < MAX_CMD_RETRIES) {
1725 printk(KERN_WARNING
1726 "cciss%d: retrying %p\n",
1727 ctlr, c);
1728 c->retry_count++;
1729 /* erase the old error information */
1730 memset(c->err_info, 0,
1731 sizeof(ErrorInfo_struct));
1732 return_status = IO_OK;
1733 INIT_COMPLETION(wait);
1734 goto resend_cmd2;
1735 }
1736 return_status = IO_ERROR;
1737 break;
1738 default:
1739 printk(KERN_WARNING "cciss: cmd %p returned "
1740 "unknown status %x\n", c,
1741 c->err_info->CommandStatus);
1742 return_status = IO_ERROR;
1743 }
1744 }
1745 /* unlock the buffers from DMA */
1746 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1747 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1748 pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val,
1749 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1750 cmd_free(h, c, 0);
1751 return(return_status);
1752
1753 }
1754 static void cciss_geometry_inquiry(int ctlr, int logvol,
1755 int withirq, unsigned int total_size,
1756 unsigned int block_size, InquiryData_struct *inq_buff,
1757 drive_info_struct *drv)
1758 {
1759 int return_code;
1760 memset(inq_buff, 0, sizeof(InquiryData_struct));
1761 if (withirq)
1762 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1763 inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD);
1764 else
1765 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1766 sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD);
1767 if (return_code == IO_OK) {
1768 if(inq_buff->data_byte[8] == 0xFF) {
1769 printk(KERN_WARNING
1770 "cciss: reading geometry failed, volume "
1771 "does not support reading geometry\n");
1772 drv->block_size = block_size;
1773 drv->nr_blocks = total_size;
1774 drv->heads = 255;
1775 drv->sectors = 32; // Sectors per track
1776 drv->cylinders = total_size / 255 / 32;
1777 } else {
1778 unsigned int t;
1779
1780 drv->block_size = block_size;
1781 drv->nr_blocks = total_size;
1782 drv->heads = inq_buff->data_byte[6];
1783 drv->sectors = inq_buff->data_byte[7];
1784 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1785 drv->cylinders += inq_buff->data_byte[5];
1786 drv->raid_level = inq_buff->data_byte[8];
1787 t = drv->heads * drv->sectors;
1788 if (t > 1) {
1789 drv->cylinders = total_size/t;
1790 }
1791 }
1792 } else { /* Get geometry failed */
1793 printk(KERN_WARNING "cciss: reading geometry failed\n");
1794 }
1795 printk(KERN_INFO " heads= %d, sectors= %d, cylinders= %d\n\n",
1796 drv->heads, drv->sectors, drv->cylinders);
1797 }
1798 static void
1799 cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
1800 int withirq, unsigned int *total_size, unsigned int *block_size)
1801 {
1802 int return_code;
1803 memset(buf, 0, sizeof(*buf));
1804 if (withirq)
1805 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1806 ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD);
1807 else
1808 return_code = sendcmd(CCISS_READ_CAPACITY,
1809 ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD);
1810 if (return_code == IO_OK) {
1811 *total_size = be32_to_cpu(*((__be32 *) &buf->total_size[0]))+1;
1812 *block_size = be32_to_cpu(*((__be32 *) &buf->block_size[0]));
1813 } else { /* read capacity command failed */
1814 printk(KERN_WARNING "cciss: read capacity failed\n");
1815 *total_size = 0;
1816 *block_size = BLOCK_SIZE;
1817 }
1818 printk(KERN_INFO " blocks= %u block_size= %d\n",
1819 *total_size, *block_size);
1820 return;
1821 }
1822
1823 static int cciss_revalidate(struct gendisk *disk)
1824 {
1825 ctlr_info_t *h = get_host(disk);
1826 drive_info_struct *drv = get_drv(disk);
1827 int logvol;
1828 int FOUND=0;
1829 unsigned int block_size;
1830 unsigned int total_size;
1831 ReadCapdata_struct *size_buff = NULL;
1832 InquiryData_struct *inq_buff = NULL;
1833
1834 for(logvol=0; logvol < CISS_MAX_LUN; logvol++)
1835 {
1836 if(h->drv[logvol].LunID == drv->LunID) {
1837 FOUND=1;
1838 break;
1839 }
1840 }
1841
1842 if (!FOUND) return 1;
1843
1844 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1845 if (size_buff == NULL)
1846 {
1847 printk(KERN_WARNING "cciss: out of memory\n");
1848 return 1;
1849 }
1850 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1851 if (inq_buff == NULL)
1852 {
1853 printk(KERN_WARNING "cciss: out of memory\n");
1854 kfree(size_buff);
1855 return 1;
1856 }
1857
1858 cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size, &block_size);
1859 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, inq_buff, drv);
1860
1861 blk_queue_hardsect_size(drv->queue, drv->block_size);
1862 set_capacity(disk, drv->nr_blocks);
1863
1864 kfree(size_buff);
1865 kfree(inq_buff);
1866 return 0;
1867 }
1868
1869 /*
1870 * Wait polling for a command to complete.
1871 * The memory mapped FIFO is polled for the completion.
1872 * Used only at init time, interrupts from the HBA are disabled.
1873 */
1874 static unsigned long pollcomplete(int ctlr)
1875 {
1876 unsigned long done;
1877 int i;
1878
1879 /* Wait (up to 20 seconds) for a command to complete */
1880
1881 for (i = 20 * HZ; i > 0; i--) {
1882 done = hba[ctlr]->access.command_completed(hba[ctlr]);
1883 if (done == FIFO_EMPTY)
1884 schedule_timeout_uninterruptible(1);
1885 else
1886 return (done);
1887 }
1888 /* Invalid address to tell caller we ran out of time */
1889 return 1;
1890 }
1891
1892 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
1893 {
1894 /* We get in here if sendcmd() is polling for completions
1895 and gets some command back that it wasn't expecting --
1896 something other than that which it just sent down.
1897 Ordinarily, that shouldn't happen, but it can happen when
1898 the scsi tape stuff gets into error handling mode, and
1899 starts using sendcmd() to try to abort commands and
1900 reset tape drives. In that case, sendcmd may pick up
1901 completions of commands that were sent to logical drives
1902 through the block i/o system, or cciss ioctls completing, etc.
1903 In that case, we need to save those completions for later
1904 processing by the interrupt handler.
1905 */
1906
1907 #ifdef CONFIG_CISS_SCSI_TAPE
1908 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
1909
1910 /* If it's not the scsi tape stuff doing error handling, (abort */
1911 /* or reset) then we don't expect anything weird. */
1912 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
1913 #endif
1914 printk( KERN_WARNING "cciss cciss%d: SendCmd "
1915 "Invalid command list address returned! (%lx)\n",
1916 ctlr, complete);
1917 /* not much we can do. */
1918 #ifdef CONFIG_CISS_SCSI_TAPE
1919 return 1;
1920 }
1921
1922 /* We've sent down an abort or reset, but something else
1923 has completed */
1924 if (srl->ncompletions >= (NR_CMDS + 2)) {
1925 /* Uh oh. No room to save it for later... */
1926 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
1927 "reject list overflow, command lost!\n", ctlr);
1928 return 1;
1929 }
1930 /* Save it for later */
1931 srl->complete[srl->ncompletions] = complete;
1932 srl->ncompletions++;
1933 #endif
1934 return 0;
1935 }
1936
1937 /*
1938 * Send a command to the controller, and wait for it to complete.
1939 * Only used at init time.
1940 */
1941 static int sendcmd(
1942 __u8 cmd,
1943 int ctlr,
1944 void *buff,
1945 size_t size,
1946 unsigned int use_unit_num, /* 0: address the controller,
1947 1: address logical volume log_unit,
1948 2: periph device address is scsi3addr */
1949 unsigned int log_unit,
1950 __u8 page_code,
1951 unsigned char *scsi3addr,
1952 int cmd_type)
1953 {
1954 CommandList_struct *c;
1955 int i;
1956 unsigned long complete;
1957 ctlr_info_t *info_p= hba[ctlr];
1958 u64bit buff_dma_handle;
1959 int status, done = 0;
1960
1961 if ((c = cmd_alloc(info_p, 1)) == NULL) {
1962 printk(KERN_WARNING "cciss: unable to get memory");
1963 return(IO_ERROR);
1964 }
1965 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1966 log_unit, page_code, scsi3addr, cmd_type);
1967 if (status != IO_OK) {
1968 cmd_free(info_p, c, 1);
1969 return status;
1970 }
1971 resend_cmd1:
1972 /*
1973 * Disable interrupt
1974 */
1975 #ifdef CCISS_DEBUG
1976 printk(KERN_DEBUG "cciss: turning intr off\n");
1977 #endif /* CCISS_DEBUG */
1978 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
1979
1980 /* Make sure there is room in the command FIFO */
1981 /* Actually it should be completely empty at this time */
1982 /* unless we are in here doing error handling for the scsi */
1983 /* tape side of the driver. */
1984 for (i = 200000; i > 0; i--)
1985 {
1986 /* if fifo isn't full go */
1987 if (!(info_p->access.fifo_full(info_p)))
1988 {
1989
1990 break;
1991 }
1992 udelay(10);
1993 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
1994 " waiting!\n", ctlr);
1995 }
1996 /*
1997 * Send the cmd
1998 */
1999 info_p->access.submit_command(info_p, c);
2000 done = 0;
2001 do {
2002 complete = pollcomplete(ctlr);
2003
2004 #ifdef CCISS_DEBUG
2005 printk(KERN_DEBUG "cciss: command completed\n");
2006 #endif /* CCISS_DEBUG */
2007
2008 if (complete == 1) {
2009 printk( KERN_WARNING
2010 "cciss cciss%d: SendCmd Timeout out, "
2011 "No command list address returned!\n",
2012 ctlr);
2013 status = IO_ERROR;
2014 done = 1;
2015 break;
2016 }
2017
2018 /* This will need to change for direct lookup completions */
2019 if ( (complete & CISS_ERROR_BIT)
2020 && (complete & ~CISS_ERROR_BIT) == c->busaddr)
2021 {
2022 /* if data overrun or underun on Report command
2023 ignore it
2024 */
2025 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2026 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2027 (c->Request.CDB[0] == CISS_INQUIRY)) &&
2028 ((c->err_info->CommandStatus ==
2029 CMD_DATA_OVERRUN) ||
2030 (c->err_info->CommandStatus ==
2031 CMD_DATA_UNDERRUN)
2032 ))
2033 {
2034 complete = c->busaddr;
2035 } else {
2036 if (c->err_info->CommandStatus ==
2037 CMD_UNSOLICITED_ABORT) {
2038 printk(KERN_WARNING "cciss%d: "
2039 "unsolicited abort %p\n",
2040 ctlr, c);
2041 if (c->retry_count < MAX_CMD_RETRIES) {
2042 printk(KERN_WARNING
2043 "cciss%d: retrying %p\n",
2044 ctlr, c);
2045 c->retry_count++;
2046 /* erase the old error */
2047 /* information */
2048 memset(c->err_info, 0,
2049 sizeof(ErrorInfo_struct));
2050 goto resend_cmd1;
2051 } else {
2052 printk(KERN_WARNING
2053 "cciss%d: retried %p too "
2054 "many times\n", ctlr, c);
2055 status = IO_ERROR;
2056 goto cleanup1;
2057 }
2058 } else if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
2059 printk(KERN_WARNING "cciss%d: command could not be aborted.\n", ctlr);
2060 status = IO_ERROR;
2061 goto cleanup1;
2062 }
2063 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2064 " Error %x \n", ctlr,
2065 c->err_info->CommandStatus);
2066 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2067 " offensive info\n"
2068 " size %x\n num %x value %x\n", ctlr,
2069 c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
2070 c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
2071 c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
2072 status = IO_ERROR;
2073 goto cleanup1;
2074 }
2075 }
2076 /* This will need changing for direct lookup completions */
2077 if (complete != c->busaddr) {
2078 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2079 BUG(); /* we are pretty much hosed if we get here. */
2080 }
2081 continue;
2082 } else
2083 done = 1;
2084 } while (!done);
2085
2086 cleanup1:
2087 /* unlock the data buffer from DMA */
2088 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2089 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2090 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2091 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2092 #ifdef CONFIG_CISS_SCSI_TAPE
2093 /* if we saved some commands for later, process them now. */
2094 if (info_p->scsi_rejects.ncompletions > 0)
2095 do_cciss_intr(0, info_p, NULL);
2096 #endif
2097 cmd_free(info_p, c, 1);
2098 return (status);
2099 }
2100 /*
2101 * Map (physical) PCI mem into (virtual) kernel space
2102 */
2103 static void __iomem *remap_pci_mem(ulong base, ulong size)
2104 {
2105 ulong page_base = ((ulong) base) & PAGE_MASK;
2106 ulong page_offs = ((ulong) base) - page_base;
2107 void __iomem *page_remapped = ioremap(page_base, page_offs+size);
2108
2109 return page_remapped ? (page_remapped + page_offs) : NULL;
2110 }
2111
2112 /*
2113 * Takes jobs of the Q and sends them to the hardware, then puts it on
2114 * the Q to wait for completion.
2115 */
2116 static void start_io( ctlr_info_t *h)
2117 {
2118 CommandList_struct *c;
2119
2120 while(( c = h->reqQ) != NULL )
2121 {
2122 /* can't do anything if fifo is full */
2123 if ((h->access.fifo_full(h))) {
2124 printk(KERN_WARNING "cciss: fifo full\n");
2125 break;
2126 }
2127
2128 /* Get the frist entry from the Request Q */
2129 removeQ(&(h->reqQ), c);
2130 h->Qdepth--;
2131
2132 /* Tell the controller execute command */
2133 h->access.submit_command(h, c);
2134
2135 /* Put job onto the completed Q */
2136 addQ (&(h->cmpQ), c);
2137 }
2138 }
2139
2140 static inline void complete_buffers(struct bio *bio, int status)
2141 {
2142 while (bio) {
2143 struct bio *xbh = bio->bi_next;
2144 int nr_sectors = bio_sectors(bio);
2145
2146 bio->bi_next = NULL;
2147 blk_finished_io(len);
2148 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
2149 bio = xbh;
2150 }
2151
2152 }
2153 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2154 /* Zeros out the error record and then resends the command back */
2155 /* to the controller */
2156 static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c)
2157 {
2158 /* erase the old error information */
2159 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2160
2161 /* add it to software queue and then send it to the controller */
2162 addQ(&(h->reqQ),c);
2163 h->Qdepth++;
2164 if(h->Qdepth > h->maxQsinceinit)
2165 h->maxQsinceinit = h->Qdepth;
2166
2167 start_io(h);
2168 }
2169 /* checks the status of the job and calls complete buffers to mark all
2170 * buffers for the completed job.
2171 */
2172 static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
2173 int timeout)
2174 {
2175 int status = 1;
2176 int i;
2177 int retry_cmd = 0;
2178 u64bit temp64;
2179
2180 if (timeout)
2181 status = 0;
2182
2183 if(cmd->err_info->CommandStatus != 0)
2184 { /* an error has occurred */
2185 switch(cmd->err_info->CommandStatus)
2186 {
2187 unsigned char sense_key;
2188 case CMD_TARGET_STATUS:
2189 status = 0;
2190
2191 if( cmd->err_info->ScsiStatus == 0x02)
2192 {
2193 printk(KERN_WARNING "cciss: cmd %p "
2194 "has CHECK CONDITION "
2195 " byte 2 = 0x%x\n", cmd,
2196 cmd->err_info->SenseInfo[2]
2197 );
2198 /* check the sense key */
2199 sense_key = 0xf &
2200 cmd->err_info->SenseInfo[2];
2201 /* no status or recovered error */
2202 if((sense_key == 0x0) ||
2203 (sense_key == 0x1))
2204 {
2205 status = 1;
2206 }
2207 } else
2208 {
2209 printk(KERN_WARNING "cciss: cmd %p "
2210 "has SCSI Status 0x%x\n",
2211 cmd, cmd->err_info->ScsiStatus);
2212 }
2213 break;
2214 case CMD_DATA_UNDERRUN:
2215 printk(KERN_WARNING "cciss: cmd %p has"
2216 " completed with data underrun "
2217 "reported\n", cmd);
2218 break;
2219 case CMD_DATA_OVERRUN:
2220 printk(KERN_WARNING "cciss: cmd %p has"
2221 " completed with data overrun "
2222 "reported\n", cmd);
2223 break;
2224 case CMD_INVALID:
2225 printk(KERN_WARNING "cciss: cmd %p is "
2226 "reported invalid\n", cmd);
2227 status = 0;
2228 break;
2229 case CMD_PROTOCOL_ERR:
2230 printk(KERN_WARNING "cciss: cmd %p has "
2231 "protocol error \n", cmd);
2232 status = 0;
2233 break;
2234 case CMD_HARDWARE_ERR:
2235 printk(KERN_WARNING "cciss: cmd %p had "
2236 " hardware error\n", cmd);
2237 status = 0;
2238 break;
2239 case CMD_CONNECTION_LOST:
2240 printk(KERN_WARNING "cciss: cmd %p had "
2241 "connection lost\n", cmd);
2242 status=0;
2243 break;
2244 case CMD_ABORTED:
2245 printk(KERN_WARNING "cciss: cmd %p was "
2246 "aborted\n", cmd);
2247 status=0;
2248 break;
2249 case CMD_ABORT_FAILED:
2250 printk(KERN_WARNING "cciss: cmd %p reports "
2251 "abort failed\n", cmd);
2252 status=0;
2253 break;
2254 case CMD_UNSOLICITED_ABORT:
2255 printk(KERN_WARNING "cciss%d: unsolicited "
2256 "abort %p\n", h->ctlr, cmd);
2257 if (cmd->retry_count < MAX_CMD_RETRIES) {
2258 retry_cmd=1;
2259 printk(KERN_WARNING
2260 "cciss%d: retrying %p\n",
2261 h->ctlr, cmd);
2262 cmd->retry_count++;
2263 } else
2264 printk(KERN_WARNING
2265 "cciss%d: %p retried too "
2266 "many times\n", h->ctlr, cmd);
2267 status=0;
2268 break;
2269 case CMD_TIMEOUT:
2270 printk(KERN_WARNING "cciss: cmd %p timedout\n",
2271 cmd);
2272 status=0;
2273 break;
2274 default:
2275 printk(KERN_WARNING "cciss: cmd %p returned "
2276 "unknown status %x\n", cmd,
2277 cmd->err_info->CommandStatus);
2278 status=0;
2279 }
2280 }
2281 /* We need to return this command */
2282 if(retry_cmd) {
2283 resend_cciss_cmd(h,cmd);
2284 return;
2285 }
2286 /* command did not need to be retried */
2287 /* unmap the DMA mapping for all the scatter gather elements */
2288 for(i=0; i<cmd->Header.SGList; i++) {
2289 temp64.val32.lower = cmd->SG[i].Addr.lower;
2290 temp64.val32.upper = cmd->SG[i].Addr.upper;
2291 pci_unmap_page(hba[cmd->ctlr]->pdev,
2292 temp64.val, cmd->SG[i].Len,
2293 (cmd->Request.Type.Direction == XFER_READ) ?
2294 PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
2295 }
2296 complete_buffers(cmd->rq->bio, status);
2297
2298 #ifdef CCISS_DEBUG
2299 printk("Done with %p\n", cmd->rq);
2300 #endif /* CCISS_DEBUG */
2301
2302 end_that_request_last(cmd->rq);
2303 cmd_free(h,cmd,1);
2304 }
2305
2306 /*
2307 * Get a request and submit it to the controller.
2308 */
2309 static void do_cciss_request(request_queue_t *q)
2310 {
2311 ctlr_info_t *h= q->queuedata;
2312 CommandList_struct *c;
2313 int start_blk, seg;
2314 struct request *creq;
2315 u64bit temp64;
2316 struct scatterlist tmp_sg[MAXSGENTRIES];
2317 drive_info_struct *drv;
2318 int i, dir;
2319
2320 /* We call start_io here in case there is a command waiting on the
2321 * queue that has not been sent.
2322 */
2323 if (blk_queue_plugged(q))
2324 goto startio;
2325
2326 queue:
2327 creq = elv_next_request(q);
2328 if (!creq)
2329 goto startio;
2330
2331 if (creq->nr_phys_segments > MAXSGENTRIES)
2332 BUG();
2333
2334 if (( c = cmd_alloc(h, 1)) == NULL)
2335 goto full;
2336
2337 blkdev_dequeue_request(creq);
2338
2339 spin_unlock_irq(q->queue_lock);
2340
2341 c->cmd_type = CMD_RWREQ;
2342 c->rq = creq;
2343
2344 /* fill in the request */
2345 drv = creq->rq_disk->private_data;
2346 c->Header.ReplyQueue = 0; // unused in simple mode
2347 /* got command from pool, so use the command block index instead */
2348 /* for direct lookups. */
2349 /* The first 2 bits are reserved for controller error reporting. */
2350 c->Header.Tag.lower = (c->cmdindex << 3);
2351 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2352 c->Header.LUN.LogDev.VolId= drv->LunID;
2353 c->Header.LUN.LogDev.Mode = 1;
2354 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2355 c->Request.Type.Type = TYPE_CMD; // It is a command.
2356 c->Request.Type.Attribute = ATTR_SIMPLE;
2357 c->Request.Type.Direction =
2358 (rq_data_dir(creq) == READ) ? XFER_READ: XFER_WRITE;
2359 c->Request.Timeout = 0; // Don't time out
2360 c->Request.CDB[0] = (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
2361 start_blk = creq->sector;
2362 #ifdef CCISS_DEBUG
2363 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",(int) creq->sector,
2364 (int) creq->nr_sectors);
2365 #endif /* CCISS_DEBUG */
2366
2367 seg = blk_rq_map_sg(q, creq, tmp_sg);
2368
2369 /* get the DMA records for the setup */
2370 if (c->Request.Type.Direction == XFER_READ)
2371 dir = PCI_DMA_FROMDEVICE;
2372 else
2373 dir = PCI_DMA_TODEVICE;
2374
2375 for (i=0; i<seg; i++)
2376 {
2377 c->SG[i].Len = tmp_sg[i].length;
2378 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2379 tmp_sg[i].offset, tmp_sg[i].length,
2380 dir);
2381 c->SG[i].Addr.lower = temp64.val32.lower;
2382 c->SG[i].Addr.upper = temp64.val32.upper;
2383 c->SG[i].Ext = 0; // we are not chaining
2384 }
2385 /* track how many SG entries we are using */
2386 if( seg > h->maxSG)
2387 h->maxSG = seg;
2388
2389 #ifdef CCISS_DEBUG
2390 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n", creq->nr_sectors, seg);
2391 #endif /* CCISS_DEBUG */
2392
2393 c->Header.SGList = c->Header.SGTotal = seg;
2394 c->Request.CDB[1]= 0;
2395 c->Request.CDB[2]= (start_blk >> 24) & 0xff; //MSB
2396 c->Request.CDB[3]= (start_blk >> 16) & 0xff;
2397 c->Request.CDB[4]= (start_blk >> 8) & 0xff;
2398 c->Request.CDB[5]= start_blk & 0xff;
2399 c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
2400 c->Request.CDB[7]= (creq->nr_sectors >> 8) & 0xff;
2401 c->Request.CDB[8]= creq->nr_sectors & 0xff;
2402 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2403
2404 spin_lock_irq(q->queue_lock);
2405
2406 addQ(&(h->reqQ),c);
2407 h->Qdepth++;
2408 if(h->Qdepth > h->maxQsinceinit)
2409 h->maxQsinceinit = h->Qdepth;
2410
2411 goto queue;
2412 full:
2413 blk_stop_queue(q);
2414 startio:
2415 /* We will already have the driver lock here so not need
2416 * to lock it.
2417 */
2418 start_io(h);
2419 }
2420
2421 static inline unsigned long get_next_completion(ctlr_info_t *h)
2422 {
2423 #ifdef CONFIG_CISS_SCSI_TAPE
2424 /* Any rejects from sendcmd() lying around? Process them first */
2425 if (h->scsi_rejects.ncompletions == 0)
2426 return h->access.command_completed(h);
2427 else {
2428 struct sendcmd_reject_list *srl;
2429 int n;
2430 srl = &h->scsi_rejects;
2431 n = --srl->ncompletions;
2432 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2433 printk("p");
2434 return srl->complete[n];
2435 }
2436 #else
2437 return h->access.command_completed(h);
2438 #endif
2439 }
2440
2441 static inline int interrupt_pending(ctlr_info_t *h)
2442 {
2443 #ifdef CONFIG_CISS_SCSI_TAPE
2444 return ( h->access.intr_pending(h)
2445 || (h->scsi_rejects.ncompletions > 0));
2446 #else
2447 return h->access.intr_pending(h);
2448 #endif
2449 }
2450
2451 static inline long interrupt_not_for_us(ctlr_info_t *h)
2452 {
2453 #ifdef CONFIG_CISS_SCSI_TAPE
2454 return (((h->access.intr_pending(h) == 0) ||
2455 (h->interrupts_enabled == 0))
2456 && (h->scsi_rejects.ncompletions == 0));
2457 #else
2458 return (((h->access.intr_pending(h) == 0) ||
2459 (h->interrupts_enabled == 0)));
2460 #endif
2461 }
2462
2463 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
2464 {
2465 ctlr_info_t *h = dev_id;
2466 CommandList_struct *c;
2467 unsigned long flags;
2468 __u32 a, a1, a2;
2469 int j;
2470 int start_queue = h->next_to_run;
2471
2472 if (interrupt_not_for_us(h))
2473 return IRQ_NONE;
2474 /*
2475 * If there are completed commands in the completion queue,
2476 * we had better do something about it.
2477 */
2478 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2479 while (interrupt_pending(h)) {
2480 while((a = get_next_completion(h)) != FIFO_EMPTY) {
2481 a1 = a;
2482 if ((a & 0x04)) {
2483 a2 = (a >> 3);
2484 if (a2 >= NR_CMDS) {
2485 printk(KERN_WARNING "cciss: controller cciss%d failed, stopping.\n", h->ctlr);
2486 fail_all_cmds(h->ctlr);
2487 return IRQ_HANDLED;
2488 }
2489
2490 c = h->cmd_pool + a2;
2491 a = c->busaddr;
2492
2493 } else {
2494 a &= ~3;
2495 if ((c = h->cmpQ) == NULL) {
2496 printk(KERN_WARNING "cciss: Completion of %08x ignored\n", a1);
2497 continue;
2498 }
2499 while(c->busaddr != a) {
2500 c = c->next;
2501 if (c == h->cmpQ)
2502 break;
2503 }
2504 }
2505 /*
2506 * If we've found the command, take it off the
2507 * completion Q and free it
2508 */
2509 if (c->busaddr == a) {
2510 removeQ(&h->cmpQ, c);
2511 if (c->cmd_type == CMD_RWREQ) {
2512 complete_command(h, c, 0);
2513 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2514 complete(c->waiting);
2515 }
2516 # ifdef CONFIG_CISS_SCSI_TAPE
2517 else if (c->cmd_type == CMD_SCSI)
2518 complete_scsi_command(c, 0, a1);
2519 # endif
2520 continue;
2521 }
2522 }
2523 }
2524
2525 /* check to see if we have maxed out the number of commands that can
2526 * be placed on the queue. If so then exit. We do this check here
2527 * in case the interrupt we serviced was from an ioctl and did not
2528 * free any new commands.
2529 */
2530 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2531 goto cleanup;
2532
2533 /* We have room on the queue for more commands. Now we need to queue
2534 * them up. We will also keep track of the next queue to run so
2535 * that every queue gets a chance to be started first.
2536 */
2537 for (j=0; j < h->highest_lun + 1; j++){
2538 int curr_queue = (start_queue + j) % (h->highest_lun + 1);
2539 /* make sure the disk has been added and the drive is real
2540 * because this can be called from the middle of init_one.
2541 */
2542 if(!(h->drv[curr_queue].queue) ||
2543 !(h->drv[curr_queue].heads))
2544 continue;
2545 blk_start_queue(h->gendisk[curr_queue]->queue);
2546
2547 /* check to see if we have maxed out the number of commands
2548 * that can be placed on the queue.
2549 */
2550 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2551 {
2552 if (curr_queue == start_queue){
2553 h->next_to_run = (start_queue + 1) % (h->highest_lun + 1);
2554 goto cleanup;
2555 } else {
2556 h->next_to_run = curr_queue;
2557 goto cleanup;
2558 }
2559 } else {
2560 curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
2561 }
2562 }
2563
2564 cleanup:
2565 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2566 return IRQ_HANDLED;
2567 }
2568 /*
2569 * We cannot read the structure directly, for portablity we must use
2570 * the io functions.
2571 * This is for debug only.
2572 */
2573 #ifdef CCISS_DEBUG
2574 static void print_cfg_table( CfgTable_struct *tb)
2575 {
2576 int i;
2577 char temp_name[17];
2578
2579 printk("Controller Configuration information\n");
2580 printk("------------------------------------\n");
2581 for(i=0;i<4;i++)
2582 temp_name[i] = readb(&(tb->Signature[i]));
2583 temp_name[4]='\0';
2584 printk(" Signature = %s\n", temp_name);
2585 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
2586 printk(" Transport methods supported = 0x%x\n",
2587 readl(&(tb-> TransportSupport)));
2588 printk(" Transport methods active = 0x%x\n",
2589 readl(&(tb->TransportActive)));
2590 printk(" Requested transport Method = 0x%x\n",
2591 readl(&(tb->HostWrite.TransportRequest)));
2592 printk(" Coalese Interrupt Delay = 0x%x\n",
2593 readl(&(tb->HostWrite.CoalIntDelay)));
2594 printk(" Coalese Interrupt Count = 0x%x\n",
2595 readl(&(tb->HostWrite.CoalIntCount)));
2596 printk(" Max outstanding commands = 0x%d\n",
2597 readl(&(tb->CmdsOutMax)));
2598 printk(" Bus Types = 0x%x\n", readl(&(tb-> BusTypes)));
2599 for(i=0;i<16;i++)
2600 temp_name[i] = readb(&(tb->ServerName[i]));
2601 temp_name[16] = '\0';
2602 printk(" Server Name = %s\n", temp_name);
2603 printk(" Heartbeat Counter = 0x%x\n\n\n",
2604 readl(&(tb->HeartBeat)));
2605 }
2606 #endif /* CCISS_DEBUG */
2607
2608 static void release_io_mem(ctlr_info_t *c)
2609 {
2610 /* if IO mem was not protected do nothing */
2611 if( c->io_mem_addr == 0)
2612 return;
2613 release_region(c->io_mem_addr, c->io_mem_length);
2614 c->io_mem_addr = 0;
2615 c->io_mem_length = 0;
2616 }
2617
2618 static int find_PCI_BAR_index(struct pci_dev *pdev,
2619 unsigned long pci_bar_addr)
2620 {
2621 int i, offset, mem_type, bar_type;
2622 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2623 return 0;
2624 offset = 0;
2625 for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
2626 bar_type = pci_resource_flags(pdev, i) &
2627 PCI_BASE_ADDRESS_SPACE;
2628 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2629 offset += 4;
2630 else {
2631 mem_type = pci_resource_flags(pdev, i) &
2632 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2633 switch (mem_type) {
2634 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2635 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2636 offset += 4; /* 32 bit */
2637 break;
2638 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2639 offset += 8;
2640 break;
2641 default: /* reserved in PCI 2.2 */
2642 printk(KERN_WARNING "Base address is invalid\n");
2643 return -1;
2644 break;
2645 }
2646 }
2647 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2648 return i+1;
2649 }
2650 return -1;
2651 }
2652
2653 static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2654 {
2655 ushort subsystem_vendor_id, subsystem_device_id, command;
2656 __u32 board_id, scratchpad = 0;
2657 __u64 cfg_offset;
2658 __u32 cfg_base_addr;
2659 __u64 cfg_base_addr_index;
2660 int i;
2661
2662 /* check to see if controller has been disabled */
2663 /* BEFORE trying to enable it */
2664 (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
2665 if(!(command & 0x02))
2666 {
2667 printk(KERN_WARNING "cciss: controller appears to be disabled\n");
2668 return(-1);
2669 }
2670
2671 if (pci_enable_device(pdev))
2672 {
2673 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2674 return( -1);
2675 }
2676
2677 subsystem_vendor_id = pdev->subsystem_vendor;
2678 subsystem_device_id = pdev->subsystem_device;
2679 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2680 subsystem_vendor_id);
2681
2682 /* search for our IO range so we can protect it */
2683 for(i=0; i<DEVICE_COUNT_RESOURCE; i++)
2684 {
2685 /* is this an IO range */
2686 if( pci_resource_flags(pdev, i) & 0x01 ) {
2687 c->io_mem_addr = pci_resource_start(pdev, i);
2688 c->io_mem_length = pci_resource_end(pdev, i) -
2689 pci_resource_start(pdev, i) +1;
2690 #ifdef CCISS_DEBUG
2691 printk("IO value found base_addr[%d] %lx %lx\n", i,
2692 c->io_mem_addr, c->io_mem_length);
2693 #endif /* CCISS_DEBUG */
2694 /* register the IO range */
2695 if(!request_region( c->io_mem_addr,
2696 c->io_mem_length, "cciss"))
2697 {
2698 printk(KERN_WARNING "cciss I/O memory range already in use addr=%lx length=%ld\n",
2699 c->io_mem_addr, c->io_mem_length);
2700 c->io_mem_addr= 0;
2701 c->io_mem_length = 0;
2702 }
2703 break;
2704 }
2705 }
2706
2707 #ifdef CCISS_DEBUG
2708 printk("command = %x\n", command);
2709 printk("irq = %x\n", pdev->irq);
2710 printk("board_id = %x\n", board_id);
2711 #endif /* CCISS_DEBUG */
2712
2713 c->intr = pdev->irq;
2714
2715 /*
2716 * Memory base addr is first addr , the second points to the config
2717 * table
2718 */
2719
2720 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2721 #ifdef CCISS_DEBUG
2722 printk("address 0 = %x\n", c->paddr);
2723 #endif /* CCISS_DEBUG */
2724 c->vaddr = remap_pci_mem(c->paddr, 200);
2725
2726 /* Wait for the board to become ready. (PCI hotplug needs this.)
2727 * We poll for up to 120 secs, once per 100ms. */
2728 for (i=0; i < 1200; i++) {
2729 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2730 if (scratchpad == CCISS_FIRMWARE_READY)
2731 break;
2732 set_current_state(TASK_INTERRUPTIBLE);
2733 schedule_timeout(HZ / 10); /* wait 100ms */
2734 }
2735 if (scratchpad != CCISS_FIRMWARE_READY) {
2736 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
2737 return -1;
2738 }
2739
2740 /* get the address index number */
2741 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2742 cfg_base_addr &= (__u32) 0x0000ffff;
2743 #ifdef CCISS_DEBUG
2744 printk("cfg base address = %x\n", cfg_base_addr);
2745 #endif /* CCISS_DEBUG */
2746 cfg_base_addr_index =
2747 find_PCI_BAR_index(pdev, cfg_base_addr);
2748 #ifdef CCISS_DEBUG
2749 printk("cfg base address index = %x\n", cfg_base_addr_index);
2750 #endif /* CCISS_DEBUG */
2751 if (cfg_base_addr_index == -1) {
2752 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2753 release_io_mem(c);
2754 return -1;
2755 }
2756
2757 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2758 #ifdef CCISS_DEBUG
2759 printk("cfg offset = %x\n", cfg_offset);
2760 #endif /* CCISS_DEBUG */
2761 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2762 cfg_base_addr_index) + cfg_offset,
2763 sizeof(CfgTable_struct));
2764 c->board_id = board_id;
2765
2766 #ifdef CCISS_DEBUG
2767 print_cfg_table(c->cfgtable);
2768 #endif /* CCISS_DEBUG */
2769
2770 for(i=0; i<NR_PRODUCTS; i++) {
2771 if (board_id == products[i].board_id) {
2772 c->product_name = products[i].product_name;
2773 c->access = *(products[i].access);
2774 break;
2775 }
2776 }
2777 if (i == NR_PRODUCTS) {
2778 printk(KERN_WARNING "cciss: Sorry, I don't know how"
2779 " to access the Smart Array controller %08lx\n",
2780 (unsigned long)board_id);
2781 return -1;
2782 }
2783 if ( (readb(&c->cfgtable->Signature[0]) != 'C') ||
2784 (readb(&c->cfgtable->Signature[1]) != 'I') ||
2785 (readb(&c->cfgtable->Signature[2]) != 'S') ||
2786 (readb(&c->cfgtable->Signature[3]) != 'S') )
2787 {
2788 printk("Does not appear to be a valid CISS config table\n");
2789 return -1;
2790 }
2791
2792 #ifdef CONFIG_X86
2793 {
2794 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2795 __u32 prefetch;
2796 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
2797 prefetch |= 0x100;
2798 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
2799 }
2800 #endif
2801
2802 #ifdef CCISS_DEBUG
2803 printk("Trying to put board into Simple mode\n");
2804 #endif /* CCISS_DEBUG */
2805 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
2806 /* Update the field, and then ring the doorbell */
2807 writel( CFGTBL_Trans_Simple,
2808 &(c->cfgtable->HostWrite.TransportRequest));
2809 writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
2810
2811 /* under certain very rare conditions, this can take awhile.
2812 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2813 * as we enter this code.) */
2814 for(i=0;i<MAX_CONFIG_WAIT;i++) {
2815 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
2816 break;
2817 /* delay and try again */
2818 set_current_state(TASK_INTERRUPTIBLE);
2819 schedule_timeout(10);
2820 }
2821
2822 #ifdef CCISS_DEBUG
2823 printk(KERN_DEBUG "I counter got to %d %x\n", i, readl(c->vaddr + SA5_DOORBELL));
2824 #endif /* CCISS_DEBUG */
2825 #ifdef CCISS_DEBUG
2826 print_cfg_table(c->cfgtable);
2827 #endif /* CCISS_DEBUG */
2828
2829 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
2830 {
2831 printk(KERN_WARNING "cciss: unable to get board into"
2832 " simple mode\n");
2833 return -1;
2834 }
2835 return 0;
2836
2837 }
2838
2839 /*
2840 * Gets information about the local volumes attached to the controller.
2841 */
2842 static void cciss_getgeometry(int cntl_num)
2843 {
2844 ReportLunData_struct *ld_buff;
2845 ReadCapdata_struct *size_buff;
2846 InquiryData_struct *inq_buff;
2847 int return_code;
2848 int i;
2849 int listlength = 0;
2850 __u32 lunid = 0;
2851 int block_size;
2852 int total_size;
2853
2854 ld_buff = kmalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
2855 if (ld_buff == NULL)
2856 {
2857 printk(KERN_ERR "cciss: out of memory\n");
2858 return;
2859 }
2860 memset(ld_buff, 0, sizeof(ReportLunData_struct));
2861 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
2862 if (size_buff == NULL)
2863 {
2864 printk(KERN_ERR "cciss: out of memory\n");
2865 kfree(ld_buff);
2866 return;
2867 }
2868 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
2869 if (inq_buff == NULL)
2870 {
2871 printk(KERN_ERR "cciss: out of memory\n");
2872 kfree(ld_buff);
2873 kfree(size_buff);
2874 return;
2875 }
2876 /* Get the firmware version */
2877 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
2878 sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD);
2879 if (return_code == IO_OK)
2880 {
2881 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
2882 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
2883 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
2884 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
2885 } else /* send command failed */
2886 {
2887 printk(KERN_WARNING "cciss: unable to determine firmware"
2888 " version of controller\n");
2889 }
2890 /* Get the number of logical volumes */
2891 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
2892 sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD);
2893
2894 if( return_code == IO_OK)
2895 {
2896 #ifdef CCISS_DEBUG
2897 printk("LUN Data\n--------------------------\n");
2898 #endif /* CCISS_DEBUG */
2899
2900 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
2901 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
2902 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
2903 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
2904 } else /* reading number of logical volumes failed */
2905 {
2906 printk(KERN_WARNING "cciss: report logical volume"
2907 " command failed\n");
2908 listlength = 0;
2909 }
2910 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
2911 if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
2912 {
2913 printk(KERN_ERR "ciss: only %d number of logical volumes supported\n",
2914 CISS_MAX_LUN);
2915 hba[cntl_num]->num_luns = CISS_MAX_LUN;
2916 }
2917 #ifdef CCISS_DEBUG
2918 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n", ld_buff->LUNListLength[0],
2919 ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
2920 ld_buff->LUNListLength[3], hba[cntl_num]->num_luns);
2921 #endif /* CCISS_DEBUG */
2922
2923 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns-1;
2924 // for(i=0; i< hba[cntl_num]->num_luns; i++)
2925 for(i=0; i < CISS_MAX_LUN; i++)
2926 {
2927 if (i < hba[cntl_num]->num_luns){
2928 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
2929 << 24;
2930 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
2931 << 16;
2932 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
2933 << 8;
2934 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
2935
2936 hba[cntl_num]->drv[i].LunID = lunid;
2937
2938
2939 #ifdef CCISS_DEBUG
2940 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
2941 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
2942 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
2943 hba[cntl_num]->drv[i].LunID);
2944 #endif /* CCISS_DEBUG */
2945 cciss_read_capacity(cntl_num, i, size_buff, 0,
2946 &total_size, &block_size);
2947 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
2948 block_size, inq_buff, &hba[cntl_num]->drv[i]);
2949 } else {
2950 /* initialize raid_level to indicate a free space */
2951 hba[cntl_num]->drv[i].raid_level = -1;
2952 }
2953 }
2954 kfree(ld_buff);
2955 kfree(size_buff);
2956 kfree(inq_buff);
2957 }
2958
2959 /* Function to find the first free pointer into our hba[] array */
2960 /* Returns -1 if no free entries are left. */
2961 static int alloc_cciss_hba(void)
2962 {
2963 struct gendisk *disk[NWD];
2964 int i, n;
2965 for (n = 0; n < NWD; n++) {
2966 disk[n] = alloc_disk(1 << NWD_SHIFT);
2967 if (!disk[n])
2968 goto out;
2969 }
2970
2971 for(i=0; i< MAX_CTLR; i++) {
2972 if (!hba[i]) {
2973 ctlr_info_t *p;
2974 p = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
2975 if (!p)
2976 goto Enomem;
2977 memset(p, 0, sizeof(ctlr_info_t));
2978 for (n = 0; n < NWD; n++)
2979 p->gendisk[n] = disk[n];
2980 hba[i] = p;
2981 return i;
2982 }
2983 }
2984 printk(KERN_WARNING "cciss: This driver supports a maximum"
2985 " of %d controllers.\n", MAX_CTLR);
2986 goto out;
2987 Enomem:
2988 printk(KERN_ERR "cciss: out of memory.\n");
2989 out:
2990 while (n--)
2991 put_disk(disk[n]);
2992 return -1;
2993 }
2994
2995 static void free_hba(int i)
2996 {
2997 ctlr_info_t *p = hba[i];
2998 int n;
2999
3000 hba[i] = NULL;
3001 for (n = 0; n < NWD; n++)
3002 put_disk(p->gendisk[n]);
3003 kfree(p);
3004 }
3005
3006 /*
3007 * This is it. Find all the controllers and register them. I really hate
3008 * stealing all these major device numbers.
3009 * returns the number of block devices registered.
3010 */
3011 static int __devinit cciss_init_one(struct pci_dev *pdev,
3012 const struct pci_device_id *ent)
3013 {
3014 request_queue_t *q;
3015 int i;
3016 int j;
3017 int rc;
3018
3019 printk(KERN_DEBUG "cciss: Device 0x%x has been found at"
3020 " bus %d dev %d func %d\n",
3021 pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
3022 PCI_FUNC(pdev->devfn));
3023 i = alloc_cciss_hba();
3024 if(i < 0)
3025 return (-1);
3026
3027 hba[i]->busy_initializing = 1;
3028
3029 if (cciss_pci_init(hba[i], pdev) != 0)
3030 goto clean1;
3031
3032 sprintf(hba[i]->devname, "cciss%d", i);
3033 hba[i]->ctlr = i;
3034 hba[i]->pdev = pdev;
3035
3036 /* configure PCI DMA stuff */
3037 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3038 printk("cciss: using DAC cycles\n");
3039 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3040 printk("cciss: not using DAC cycles\n");
3041 else {
3042 printk("cciss: no suitable DMA available\n");
3043 goto clean1;
3044 }
3045
3046 /*
3047 * register with the major number, or get a dynamic major number
3048 * by passing 0 as argument. This is done for greater than
3049 * 8 controller support.
3050 */
3051 if (i < MAX_CTLR_ORIG)
3052 hba[i]->major = MAJOR_NR + i;
3053 rc = register_blkdev(hba[i]->major, hba[i]->devname);
3054 if(rc == -EBUSY || rc == -EINVAL) {
3055 printk(KERN_ERR
3056 "cciss: Unable to get major number %d for %s "
3057 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3058 goto clean1;
3059 }
3060 else {
3061 if (i >= MAX_CTLR_ORIG)
3062 hba[i]->major = rc;
3063 }
3064
3065 /* make sure the board interrupts are off */
3066 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3067 if( request_irq(hba[i]->intr, do_cciss_intr,
3068 SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM,
3069 hba[i]->devname, hba[i])) {
3070 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3071 hba[i]->intr, hba[i]->devname);
3072 goto clean2;
3073 }
3074 hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
3075 hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
3076 hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3077 &(hba[i]->cmd_pool_dhandle));
3078 hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
3079 hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3080 &(hba[i]->errinfo_pool_dhandle));
3081 if((hba[i]->cmd_pool_bits == NULL)
3082 || (hba[i]->cmd_pool == NULL)
3083 || (hba[i]->errinfo_pool == NULL)) {
3084 printk( KERN_ERR "cciss: out of memory");
3085 goto clean4;
3086 }
3087 #ifdef CONFIG_CISS_SCSI_TAPE
3088 hba[i]->scsi_rejects.complete =
3089 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3090 (NR_CMDS + 5), GFP_KERNEL);
3091 if (hba[i]->scsi_rejects.complete == NULL) {
3092 printk( KERN_ERR "cciss: out of memory");
3093 goto clean4;
3094 }
3095 #endif
3096 spin_lock_init(&hba[i]->lock);
3097
3098 /* Initialize the pdev driver private data.
3099 have it point to hba[i]. */
3100 pci_set_drvdata(pdev, hba[i]);
3101 /* command and error info recs zeroed out before
3102 they are used */
3103 memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
3104
3105 #ifdef CCISS_DEBUG
3106 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n",i);
3107 #endif /* CCISS_DEBUG */
3108
3109 cciss_getgeometry(i);
3110
3111 cciss_scsi_setup(i);
3112
3113 /* Turn the interrupts on so we can service requests */
3114 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3115
3116 cciss_procinit(i);
3117 hba[i]->busy_initializing = 0;
3118
3119 for(j=0; j < NWD; j++) { /* mfm */
3120 drive_info_struct *drv = &(hba[i]->drv[j]);
3121 struct gendisk *disk = hba[i]->gendisk[j];
3122
3123 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3124 if (!q) {
3125 printk(KERN_ERR
3126 "cciss: unable to allocate queue for disk %d\n",
3127 j);
3128 break;
3129 }
3130 drv->queue = q;
3131
3132 q->backing_dev_info.ra_pages = READ_AHEAD;
3133 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3134
3135 /* This is a hardware imposed limit. */
3136 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3137
3138 /* This is a limit in the driver and could be eliminated. */
3139 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3140
3141 blk_queue_max_sectors(q, 512);
3142
3143 q->queuedata = hba[i];
3144 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3145 sprintf(disk->devfs_name, "cciss/host%d/target%d", i, j);
3146 disk->major = hba[i]->major;
3147 disk->first_minor = j << NWD_SHIFT;
3148 disk->fops = &cciss_fops;
3149 disk->queue = q;
3150 disk->private_data = drv;
3151 /* we must register the controller even if no disks exist */
3152 /* this is for the online array utilities */
3153 if(!drv->heads && j)
3154 continue;
3155 blk_queue_hardsect_size(q, drv->block_size);
3156 set_capacity(disk, drv->nr_blocks);
3157 add_disk(disk);
3158 }
3159
3160 return(1);
3161
3162 clean4:
3163 #ifdef CONFIG_CISS_SCSI_TAPE
3164 if(hba[i]->scsi_rejects.complete)
3165 kfree(hba[i]->scsi_rejects.complete);
3166 #endif
3167 kfree(hba[i]->cmd_pool_bits);
3168 if(hba[i]->cmd_pool)
3169 pci_free_consistent(hba[i]->pdev,
3170 NR_CMDS * sizeof(CommandList_struct),
3171 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3172 if(hba[i]->errinfo_pool)
3173 pci_free_consistent(hba[i]->pdev,
3174 NR_CMDS * sizeof( ErrorInfo_struct),
3175 hba[i]->errinfo_pool,
3176 hba[i]->errinfo_pool_dhandle);
3177 free_irq(hba[i]->intr, hba[i]);
3178 clean2:
3179 unregister_blkdev(hba[i]->major, hba[i]->devname);
3180 clean1:
3181 release_io_mem(hba[i]);
3182 free_hba(i);
3183 hba[i]->busy_initializing = 0;
3184 return(-1);
3185 }
3186
3187 static void __devexit cciss_remove_one (struct pci_dev *pdev)
3188 {
3189 ctlr_info_t *tmp_ptr;
3190 int i, j;
3191 char flush_buf[4];
3192 int return_code;
3193
3194 if (pci_get_drvdata(pdev) == NULL)
3195 {
3196 printk( KERN_ERR "cciss: Unable to remove device \n");
3197 return;
3198 }
3199 tmp_ptr = pci_get_drvdata(pdev);
3200 i = tmp_ptr->ctlr;
3201 if (hba[i] == NULL)
3202 {
3203 printk(KERN_ERR "cciss: device appears to "
3204 "already be removed \n");
3205 return;
3206 }
3207 /* Turn board interrupts off and send the flush cache command */
3208 /* sendcmd will turn off interrupt, and send the flush...
3209 * To write all data in the battery backed cache to disks */
3210 memset(flush_buf, 0, 4);
3211 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3212 TYPE_CMD);
3213 if(return_code != IO_OK)
3214 {
3215 printk(KERN_WARNING "Error Flushing cache on controller %d\n",
3216 i);
3217 }
3218 free_irq(hba[i]->intr, hba[i]);
3219 pci_set_drvdata(pdev, NULL);
3220 iounmap(hba[i]->vaddr);
3221 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3222 unregister_blkdev(hba[i]->major, hba[i]->devname);
3223 remove_proc_entry(hba[i]->devname, proc_cciss);
3224
3225 /* remove it from the disk list */
3226 for (j = 0; j < NWD; j++) {
3227 struct gendisk *disk = hba[i]->gendisk[j];
3228 if (disk->flags & GENHD_FL_UP) {
3229 del_gendisk(disk);
3230 blk_cleanup_queue(disk->queue);
3231 }
3232 }
3233
3234 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3235 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3236 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3237 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3238 kfree(hba[i]->cmd_pool_bits);
3239 #ifdef CONFIG_CISS_SCSI_TAPE
3240 kfree(hba[i]->scsi_rejects.complete);
3241 #endif
3242 release_io_mem(hba[i]);
3243 free_hba(i);
3244 }
3245
3246 static struct pci_driver cciss_pci_driver = {
3247 .name = "cciss",
3248 .probe = cciss_init_one,
3249 .remove = __devexit_p(cciss_remove_one),
3250 .id_table = cciss_pci_device_id, /* id_table */
3251 };
3252
3253 /*
3254 * This is it. Register the PCI driver information for the cards we control
3255 * the OS will call our registered routines when it finds one of our cards.
3256 */
3257 static int __init cciss_init(void)
3258 {
3259 printk(KERN_INFO DRIVER_NAME "\n");
3260
3261 /* Register for our PCI devices */
3262 return pci_module_init(&cciss_pci_driver);
3263 }
3264
3265 static void __exit cciss_cleanup(void)
3266 {
3267 int i;
3268
3269 pci_unregister_driver(&cciss_pci_driver);
3270 /* double check that all controller entrys have been removed */
3271 for (i=0; i< MAX_CTLR; i++)
3272 {
3273 if (hba[i] != NULL)
3274 {
3275 printk(KERN_WARNING "cciss: had to remove"
3276 " controller %d\n", i);
3277 cciss_remove_one(hba[i]->pdev);
3278 }
3279 }
3280 remove_proc_entry("cciss", proc_root_driver);
3281 }
3282
3283 static void fail_all_cmds(unsigned long ctlr)
3284 {
3285 /* If we get here, the board is apparently dead. */
3286 ctlr_info_t *h = hba[ctlr];
3287 CommandList_struct *c;
3288 unsigned long flags;
3289
3290 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3291 h->alive = 0; /* the controller apparently died... */
3292
3293 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3294
3295 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3296
3297 /* move everything off the request queue onto the completed queue */
3298 while( (c = h->reqQ) != NULL ) {
3299 removeQ(&(h->reqQ), c);
3300 h->Qdepth--;
3301 addQ (&(h->cmpQ), c);
3302 }
3303
3304 /* Now, fail everything on the completed queue with a HW error */
3305 while( (c = h->cmpQ) != NULL ) {
3306 removeQ(&h->cmpQ, c);
3307 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3308 if (c->cmd_type == CMD_RWREQ) {
3309 complete_command(h, c, 0);
3310 } else if (c->cmd_type == CMD_IOCTL_PEND)
3311 complete(c->waiting);
3312 #ifdef CONFIG_CISS_SCSI_TAPE
3313 else if (c->cmd_type == CMD_SCSI)
3314 complete_scsi_command(c, 0, 0);
3315 #endif
3316 }
3317 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3318 return;
3319 }
3320
3321 module_init(cciss_init);
3322 module_exit(cciss_cleanup);
kernel source for telekom puls (alcatel/mediatek)