projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master'
[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 if (copy_from_user(buff[sg_used], data_ptr, sz)) {
1022 status = -ENOMEM;
1023 goto cleanup1;
1024 }
1025 } else {
1026 memset(buff[sg_used], 0, sz);
1027 }
1028 left -= sz;
1029 data_ptr += sz;
1030 sg_used++;
1031 }
1032 if ((c = cmd_alloc(host , 0)) == NULL) {
1033 status = -ENOMEM;
1034 goto cleanup1;
1035 }
1036 c->cmd_type = CMD_IOCTL_PEND;
1037 c->Header.ReplyQueue = 0;
1038
1039 if( ioc->buf_size > 0) {
1040 c->Header.SGList = sg_used;
1041 c->Header.SGTotal= sg_used;
1042 } else {
1043 c->Header.SGList = 0;
1044 c->Header.SGTotal= 0;
1045 }
1046 c->Header.LUN = ioc->LUN_info;
1047 c->Header.Tag.lower = c->busaddr;
1048
1049 c->Request = ioc->Request;
1050 if (ioc->buf_size > 0 ) {
1051 int i;
1052 for(i=0; i<sg_used; i++) {
1053 temp64.val = pci_map_single( host->pdev, buff[i],
1054 buff_size[i],
1055 PCI_DMA_BIDIRECTIONAL);
1056 c->SG[i].Addr.lower = temp64.val32.lower;
1057 c->SG[i].Addr.upper = temp64.val32.upper;
1058 c->SG[i].Len = buff_size[i];
1059 c->SG[i].Ext = 0; /* we are not chaining */
1060 }
1061 }
1062 c->waiting = &wait;
1063 /* Put the request on the tail of the request queue */
1064 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1065 addQ(&host->reqQ, c);
1066 host->Qdepth++;
1067 start_io(host);
1068 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1069 wait_for_completion(&wait);
1070 /* unlock the buffers from DMA */
1071 for(i=0; i<sg_used; i++) {
1072 temp64.val32.lower = c->SG[i].Addr.lower;
1073 temp64.val32.upper = c->SG[i].Addr.upper;
1074 pci_unmap_single( host->pdev, (dma_addr_t) temp64.val,
1075 buff_size[i], PCI_DMA_BIDIRECTIONAL);
1076 }
1077 /* Copy the error information out */
1078 ioc->error_info = *(c->err_info);
1079 if (copy_to_user(argp, ioc, sizeof(*ioc))) {
1080 cmd_free(host, c, 0);
1081 status = -EFAULT;
1082 goto cleanup1;
1083 }
1084 if (ioc->Request.Type.Direction == XFER_READ) {
1085 /* Copy the data out of the buffer we created */
1086 BYTE __user *ptr = ioc->buf;
1087 for(i=0; i< sg_used; i++) {
1088 if (copy_to_user(ptr, buff[i], buff_size[i])) {
1089 cmd_free(host, c, 0);
1090 status = -EFAULT;
1091 goto cleanup1;
1092 }
1093 ptr += buff_size[i];
1094 }
1095 }
1096 cmd_free(host, c, 0);
1097 status = 0;
1098 cleanup1:
1099 if (buff) {
1100 for(i=0; i<sg_used; i++)
1101 kfree(buff[i]);
1102 kfree(buff);
1103 }
1104 kfree(buff_size);
1105 kfree(ioc);
1106 return(status);
1107 }
1108 default:
1109 return -ENOTTY;
1110 }
1111
1112 }
1113
1114 /*
1115 * revalidate_allvol is for online array config utilities. After a
1116 * utility reconfigures the drives in the array, it can use this function
1117 * (through an ioctl) to make the driver zap any previous disk structs for
1118 * that controller and get new ones.
1119 *
1120 * Right now I'm using the getgeometry() function to do this, but this
1121 * function should probably be finer grained and allow you to revalidate one
1122 * particualar logical volume (instead of all of them on a particular
1123 * controller).
1124 */
1125 static int revalidate_allvol(ctlr_info_t *host)
1126 {
1127 int ctlr = host->ctlr, i;
1128 unsigned long flags;
1129
1130 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1131 if (host->usage_count > 1) {
1132 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1133 printk(KERN_WARNING "cciss: Device busy for volume"
1134 " revalidation (usage=%d)\n", host->usage_count);
1135 return -EBUSY;
1136 }
1137 host->usage_count++;
1138 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1139
1140 for(i=0; i< NWD; i++) {
1141 struct gendisk *disk = host->gendisk[i];
1142 if (disk) {
1143 request_queue_t *q = disk->queue;
1144
1145 if (disk->flags & GENHD_FL_UP)
1146 del_gendisk(disk);
1147 if (q)
1148 blk_cleanup_queue(q);
1149 }
1150 }
1151
1152 /*
1153 * Set the partition and block size structures for all volumes
1154 * on this controller to zero. We will reread all of this data
1155 */
1156 memset(host->drv, 0, sizeof(drive_info_struct)
1157 * CISS_MAX_LUN);
1158 /*
1159 * Tell the array controller not to give us any interrupts while
1160 * we check the new geometry. Then turn interrupts back on when
1161 * we're done.
1162 */
1163 host->access.set_intr_mask(host, CCISS_INTR_OFF);
1164 cciss_getgeometry(ctlr);
1165 host->access.set_intr_mask(host, CCISS_INTR_ON);
1166
1167 /* Loop through each real device */
1168 for (i = 0; i < NWD; i++) {
1169 struct gendisk *disk = host->gendisk[i];
1170 drive_info_struct *drv = &(host->drv[i]);
1171 /* we must register the controller even if no disks exist */
1172 /* this is for the online array utilities */
1173 if (!drv->heads && i)
1174 continue;
1175 blk_queue_hardsect_size(drv->queue, drv->block_size);
1176 set_capacity(disk, drv->nr_blocks);
1177 add_disk(disk);
1178 }
1179 host->usage_count--;
1180 return 0;
1181 }
1182
1183 /* This function will check the usage_count of the drive to be updated/added.
1184 * If the usage_count is zero then the drive information will be updated and
1185 * the disk will be re-registered with the kernel. If not then it will be
1186 * left alone for the next reboot. The exception to this is disk 0 which
1187 * will always be left registered with the kernel since it is also the
1188 * controller node. Any changes to disk 0 will show up on the next
1189 * reboot.
1190 */
1191 static void cciss_update_drive_info(int ctlr, int drv_index)
1192 {
1193 ctlr_info_t *h = hba[ctlr];
1194 struct gendisk *disk;
1195 ReadCapdata_struct *size_buff = NULL;
1196 InquiryData_struct *inq_buff = NULL;
1197 unsigned int block_size;
1198 unsigned int total_size;
1199 unsigned long flags = 0;
1200 int ret = 0;
1201
1202 /* if the disk already exists then deregister it before proceeding*/
1203 if (h->drv[drv_index].raid_level != -1){
1204 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1205 h->drv[drv_index].busy_configuring = 1;
1206 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1207 ret = deregister_disk(h->gendisk[drv_index],
1208 &h->drv[drv_index], 0);
1209 h->drv[drv_index].busy_configuring = 0;
1210 }
1211
1212 /* If the disk is in use return */
1213 if (ret)
1214 return;
1215
1216
1217 /* Get information about the disk and modify the driver sturcture */
1218 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1219 if (size_buff == NULL)
1220 goto mem_msg;
1221 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1222 if (inq_buff == NULL)
1223 goto mem_msg;
1224
1225 cciss_read_capacity(ctlr, drv_index, size_buff, 1,
1226 &total_size, &block_size);
1227 cciss_geometry_inquiry(ctlr, drv_index, 1, total_size, block_size,
1228 inq_buff, &h->drv[drv_index]);
1229
1230 ++h->num_luns;
1231 disk = h->gendisk[drv_index];
1232 set_capacity(disk, h->drv[drv_index].nr_blocks);
1233
1234
1235 /* if it's the controller it's already added */
1236 if (drv_index){
1237 disk->queue = blk_init_queue(do_cciss_request, &h->lock);
1238
1239 /* Set up queue information */
1240 disk->queue->backing_dev_info.ra_pages = READ_AHEAD;
1241 blk_queue_bounce_limit(disk->queue, hba[ctlr]->pdev->dma_mask);
1242
1243 /* This is a hardware imposed limit. */
1244 blk_queue_max_hw_segments(disk->queue, MAXSGENTRIES);
1245
1246 /* This is a limit in the driver and could be eliminated. */
1247 blk_queue_max_phys_segments(disk->queue, MAXSGENTRIES);
1248
1249 blk_queue_max_sectors(disk->queue, 512);
1250
1251 disk->queue->queuedata = hba[ctlr];
1252
1253 blk_queue_hardsect_size(disk->queue,
1254 hba[ctlr]->drv[drv_index].block_size);
1255
1256 h->drv[drv_index].queue = disk->queue;
1257 add_disk(disk);
1258 }
1259
1260 freeret:
1261 kfree(size_buff);
1262 kfree(inq_buff);
1263 return;
1264 mem_msg:
1265 printk(KERN_ERR "cciss: out of memory\n");
1266 goto freeret;
1267 }
1268
1269 /* This function will find the first index of the controllers drive array
1270 * that has a -1 for the raid_level and will return that index. This is
1271 * where new drives will be added. If the index to be returned is greater
1272 * than the highest_lun index for the controller then highest_lun is set
1273 * to this new index. If there are no available indexes then -1 is returned.
1274 */
1275 static int cciss_find_free_drive_index(int ctlr)
1276 {
1277 int i;
1278
1279 for (i=0; i < CISS_MAX_LUN; i++){
1280 if (hba[ctlr]->drv[i].raid_level == -1){
1281 if (i > hba[ctlr]->highest_lun)
1282 hba[ctlr]->highest_lun = i;
1283 return i;
1284 }
1285 }
1286 return -1;
1287 }
1288
1289 /* This function will add and remove logical drives from the Logical
1290 * drive array of the controller and maintain persistancy of ordering
1291 * so that mount points are preserved until the next reboot. This allows
1292 * for the removal of logical drives in the middle of the drive array
1293 * without a re-ordering of those drives.
1294 * INPUT
1295 * h = The controller to perform the operations on
1296 * del_disk = The disk to remove if specified. If the value given
1297 * is NULL then no disk is removed.
1298 */
1299 static int rebuild_lun_table(ctlr_info_t *h, struct gendisk *del_disk)
1300 {
1301 int ctlr = h->ctlr;
1302 int num_luns;
1303 ReportLunData_struct *ld_buff = NULL;
1304 drive_info_struct *drv = NULL;
1305 int return_code;
1306 int listlength = 0;
1307 int i;
1308 int drv_found;
1309 int drv_index = 0;
1310 __u32 lunid = 0;
1311 unsigned long flags;
1312
1313 /* Set busy_configuring flag for this operation */
1314 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
1315 if (h->num_luns >= CISS_MAX_LUN){
1316 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1317 return -EINVAL;
1318 }
1319
1320 if (h->busy_configuring){
1321 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1322 return -EBUSY;
1323 }
1324 h->busy_configuring = 1;
1325
1326 /* if del_disk is NULL then we are being called to add a new disk
1327 * and update the logical drive table. If it is not NULL then
1328 * we will check if the disk is in use or not.
1329 */
1330 if (del_disk != NULL){
1331 drv = get_drv(del_disk);
1332 drv->busy_configuring = 1;
1333 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1334 return_code = deregister_disk(del_disk, drv, 1);
1335 drv->busy_configuring = 0;
1336 h->busy_configuring = 0;
1337 return return_code;
1338 } else {
1339 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
1340 if (!capable(CAP_SYS_RAWIO))
1341 return -EPERM;
1342
1343 ld_buff = kzalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
1344 if (ld_buff == NULL)
1345 goto mem_msg;
1346
1347 return_code = sendcmd_withirq(CISS_REPORT_LOG, ctlr, ld_buff,
1348 sizeof(ReportLunData_struct), 0, 0, 0,
1349 TYPE_CMD);
1350
1351 if (return_code == IO_OK){
1352 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
1353 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
1354 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
1355 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
1356 } else{ /* reading number of logical volumes failed */
1357 printk(KERN_WARNING "cciss: report logical volume"
1358 " command failed\n");
1359 listlength = 0;
1360 goto freeret;
1361 }
1362
1363 num_luns = listlength / 8; /* 8 bytes per entry */
1364 if (num_luns > CISS_MAX_LUN){
1365 num_luns = CISS_MAX_LUN;
1366 printk(KERN_WARNING "cciss: more luns configured"
1367 " on controller than can be handled by"
1368 " this driver.\n");
1369 }
1370
1371 /* Compare controller drive array to drivers drive array.
1372 * Check for updates in the drive information and any new drives
1373 * on the controller.
1374 */
1375 for (i=0; i < num_luns; i++){
1376 int j;
1377
1378 drv_found = 0;
1379
1380 lunid = (0xff &
1381 (unsigned int)(ld_buff->LUN[i][3])) << 24;
1382 lunid |= (0xff &
1383 (unsigned int)(ld_buff->LUN[i][2])) << 16;
1384 lunid |= (0xff &
1385 (unsigned int)(ld_buff->LUN[i][1])) << 8;
1386 lunid |= 0xff &
1387 (unsigned int)(ld_buff->LUN[i][0]);
1388
1389 /* Find if the LUN is already in the drive array
1390 * of the controller. If so then update its info
1391 * if not is use. If it does not exist then find
1392 * the first free index and add it.
1393 */
1394 for (j=0; j <= h->highest_lun; j++){
1395 if (h->drv[j].LunID == lunid){
1396 drv_index = j;
1397 drv_found = 1;
1398 }
1399 }
1400
1401 /* check if the drive was found already in the array */
1402 if (!drv_found){
1403 drv_index = cciss_find_free_drive_index(ctlr);
1404 if (drv_index == -1)
1405 goto freeret;
1406
1407 }
1408 h->drv[drv_index].LunID = lunid;
1409 cciss_update_drive_info(ctlr, drv_index);
1410 } /* end for */
1411 } /* end else */
1412
1413 freeret:
1414 kfree(ld_buff);
1415 h->busy_configuring = 0;
1416 /* We return -1 here to tell the ACU that we have registered/updated
1417 * all of the drives that we can and to keep it from calling us
1418 * additional times.
1419 */
1420 return -1;
1421 mem_msg:
1422 printk(KERN_ERR "cciss: out of memory\n");
1423 goto freeret;
1424 }
1425
1426 /* This function will deregister the disk and it's queue from the
1427 * kernel. It must be called with the controller lock held and the
1428 * drv structures busy_configuring flag set. It's parameters are:
1429 *
1430 * disk = This is the disk to be deregistered
1431 * drv = This is the drive_info_struct associated with the disk to be
1432 * deregistered. It contains information about the disk used
1433 * by the driver.
1434 * clear_all = This flag determines whether or not the disk information
1435 * is going to be completely cleared out and the highest_lun
1436 * reset. Sometimes we want to clear out information about
1437 * the disk in preperation for re-adding it. In this case
1438 * the highest_lun should be left unchanged and the LunID
1439 * should not be cleared.
1440 */
1441 static int deregister_disk(struct gendisk *disk, drive_info_struct *drv,
1442 int clear_all)
1443 {
1444 ctlr_info_t *h = get_host(disk);
1445
1446 if (!capable(CAP_SYS_RAWIO))
1447 return -EPERM;
1448
1449 /* make sure logical volume is NOT is use */
1450 if(clear_all || (h->gendisk[0] == disk)) {
1451 if (drv->usage_count > 1)
1452 return -EBUSY;
1453 }
1454 else
1455 if( drv->usage_count > 0 )
1456 return -EBUSY;
1457
1458 /* invalidate the devices and deregister the disk. If it is disk
1459 * zero do not deregister it but just zero out it's values. This
1460 * allows us to delete disk zero but keep the controller registered.
1461 */
1462 if (h->gendisk[0] != disk){
1463 if (disk) {
1464 request_queue_t *q = disk->queue;
1465 if (disk->flags & GENHD_FL_UP)
1466 del_gendisk(disk);
1467 if (q)
1468 blk_cleanup_queue(q);
1469 }
1470 }
1471
1472 --h->num_luns;
1473 /* zero out the disk size info */
1474 drv->nr_blocks = 0;
1475 drv->block_size = 0;
1476 drv->heads = 0;
1477 drv->sectors = 0;
1478 drv->cylinders = 0;
1479 drv->raid_level = -1; /* This can be used as a flag variable to
1480 * indicate that this element of the drive
1481 * array is free.
1482 */
1483
1484 if (clear_all){
1485 /* check to see if it was the last disk */
1486 if (drv == h->drv + h->highest_lun) {
1487 /* if so, find the new hightest lun */
1488 int i, newhighest =-1;
1489 for(i=0; i<h->highest_lun; i++) {
1490 /* if the disk has size > 0, it is available */
1491 if (h->drv[i].heads)
1492 newhighest = i;
1493 }
1494 h->highest_lun = newhighest;
1495 }
1496
1497 drv->LunID = 0;
1498 }
1499 return(0);
1500 }
1501
1502 static int fill_cmd(CommandList_struct *c, __u8 cmd, int ctlr, void *buff,
1503 size_t size,
1504 unsigned int use_unit_num, /* 0: address the controller,
1505 1: address logical volume log_unit,
1506 2: periph device address is scsi3addr */
1507 unsigned int log_unit, __u8 page_code, unsigned char *scsi3addr,
1508 int cmd_type)
1509 {
1510 ctlr_info_t *h= hba[ctlr];
1511 u64bit buff_dma_handle;
1512 int status = IO_OK;
1513
1514 c->cmd_type = CMD_IOCTL_PEND;
1515 c->Header.ReplyQueue = 0;
1516 if( buff != NULL) {
1517 c->Header.SGList = 1;
1518 c->Header.SGTotal= 1;
1519 } else {
1520 c->Header.SGList = 0;
1521 c->Header.SGTotal= 0;
1522 }
1523 c->Header.Tag.lower = c->busaddr;
1524
1525 c->Request.Type.Type = cmd_type;
1526 if (cmd_type == TYPE_CMD) {
1527 switch(cmd) {
1528 case CISS_INQUIRY:
1529 /* If the logical unit number is 0 then, this is going
1530 to controller so It's a physical command
1531 mode = 0 target = 0. So we have nothing to write.
1532 otherwise, if use_unit_num == 1,
1533 mode = 1(volume set addressing) target = LUNID
1534 otherwise, if use_unit_num == 2,
1535 mode = 0(periph dev addr) target = scsi3addr */
1536 if (use_unit_num == 1) {
1537 c->Header.LUN.LogDev.VolId=
1538 h->drv[log_unit].LunID;
1539 c->Header.LUN.LogDev.Mode = 1;
1540 } else if (use_unit_num == 2) {
1541 memcpy(c->Header.LUN.LunAddrBytes,scsi3addr,8);
1542 c->Header.LUN.LogDev.Mode = 0;
1543 }
1544 /* are we trying to read a vital product page */
1545 if(page_code != 0) {
1546 c->Request.CDB[1] = 0x01;
1547 c->Request.CDB[2] = page_code;
1548 }
1549 c->Request.CDBLen = 6;
1550 c->Request.Type.Attribute = ATTR_SIMPLE;
1551 c->Request.Type.Direction = XFER_READ;
1552 c->Request.Timeout = 0;
1553 c->Request.CDB[0] = CISS_INQUIRY;
1554 c->Request.CDB[4] = size & 0xFF;
1555 break;
1556 case CISS_REPORT_LOG:
1557 case CISS_REPORT_PHYS:
1558 /* Talking to controller so It's a physical command
1559 mode = 00 target = 0. Nothing to write.
1560 */
1561 c->Request.CDBLen = 12;
1562 c->Request.Type.Attribute = ATTR_SIMPLE;
1563 c->Request.Type.Direction = XFER_READ;
1564 c->Request.Timeout = 0;
1565 c->Request.CDB[0] = cmd;
1566 c->Request.CDB[6] = (size >> 24) & 0xFF; //MSB
1567 c->Request.CDB[7] = (size >> 16) & 0xFF;
1568 c->Request.CDB[8] = (size >> 8) & 0xFF;
1569 c->Request.CDB[9] = size & 0xFF;
1570 break;
1571
1572 case CCISS_READ_CAPACITY:
1573 c->Header.LUN.LogDev.VolId = h->drv[log_unit].LunID;
1574 c->Header.LUN.LogDev.Mode = 1;
1575 c->Request.CDBLen = 10;
1576 c->Request.Type.Attribute = ATTR_SIMPLE;
1577 c->Request.Type.Direction = XFER_READ;
1578 c->Request.Timeout = 0;
1579 c->Request.CDB[0] = cmd;
1580 break;
1581 case CCISS_CACHE_FLUSH:
1582 c->Request.CDBLen = 12;
1583 c->Request.Type.Attribute = ATTR_SIMPLE;
1584 c->Request.Type.Direction = XFER_WRITE;
1585 c->Request.Timeout = 0;
1586 c->Request.CDB[0] = BMIC_WRITE;
1587 c->Request.CDB[6] = BMIC_CACHE_FLUSH;
1588 break;
1589 default:
1590 printk(KERN_WARNING
1591 "cciss%d: Unknown Command 0x%c\n", ctlr, cmd);
1592 return(IO_ERROR);
1593 }
1594 } else if (cmd_type == TYPE_MSG) {
1595 switch (cmd) {
1596 case 0: /* ABORT message */
1597 c->Request.CDBLen = 12;
1598 c->Request.Type.Attribute = ATTR_SIMPLE;
1599 c->Request.Type.Direction = XFER_WRITE;
1600 c->Request.Timeout = 0;
1601 c->Request.CDB[0] = cmd; /* abort */
1602 c->Request.CDB[1] = 0; /* abort a command */
1603 /* buff contains the tag of the command to abort */
1604 memcpy(&c->Request.CDB[4], buff, 8);
1605 break;
1606 case 1: /* RESET message */
1607 c->Request.CDBLen = 12;
1608 c->Request.Type.Attribute = ATTR_SIMPLE;
1609 c->Request.Type.Direction = XFER_WRITE;
1610 c->Request.Timeout = 0;
1611 memset(&c->Request.CDB[0], 0, sizeof(c->Request.CDB));
1612 c->Request.CDB[0] = cmd; /* reset */
1613 c->Request.CDB[1] = 0x04; /* reset a LUN */
1614 case 3: /* No-Op message */
1615 c->Request.CDBLen = 1;
1616 c->Request.Type.Attribute = ATTR_SIMPLE;
1617 c->Request.Type.Direction = XFER_WRITE;
1618 c->Request.Timeout = 0;
1619 c->Request.CDB[0] = cmd;
1620 break;
1621 default:
1622 printk(KERN_WARNING
1623 "cciss%d: unknown message type %d\n",
1624 ctlr, cmd);
1625 return IO_ERROR;
1626 }
1627 } else {
1628 printk(KERN_WARNING
1629 "cciss%d: unknown command type %d\n", ctlr, cmd_type);
1630 return IO_ERROR;
1631 }
1632 /* Fill in the scatter gather information */
1633 if (size > 0) {
1634 buff_dma_handle.val = (__u64) pci_map_single(h->pdev,
1635 buff, size, PCI_DMA_BIDIRECTIONAL);
1636 c->SG[0].Addr.lower = buff_dma_handle.val32.lower;
1637 c->SG[0].Addr.upper = buff_dma_handle.val32.upper;
1638 c->SG[0].Len = size;
1639 c->SG[0].Ext = 0; /* we are not chaining */
1640 }
1641 return status;
1642 }
1643 static int sendcmd_withirq(__u8 cmd,
1644 int ctlr,
1645 void *buff,
1646 size_t size,
1647 unsigned int use_unit_num,
1648 unsigned int log_unit,
1649 __u8 page_code,
1650 int cmd_type)
1651 {
1652 ctlr_info_t *h = hba[ctlr];
1653 CommandList_struct *c;
1654 u64bit buff_dma_handle;
1655 unsigned long flags;
1656 int return_status;
1657 DECLARE_COMPLETION(wait);
1658
1659 if ((c = cmd_alloc(h , 0)) == NULL)
1660 return -ENOMEM;
1661 return_status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1662 log_unit, page_code, NULL, cmd_type);
1663 if (return_status != IO_OK) {
1664 cmd_free(h, c, 0);
1665 return return_status;
1666 }
1667 resend_cmd2:
1668 c->waiting = &wait;
1669
1670 /* Put the request on the tail of the queue and send it */
1671 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
1672 addQ(&h->reqQ, c);
1673 h->Qdepth++;
1674 start_io(h);
1675 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
1676
1677 wait_for_completion(&wait);
1678
1679 if(c->err_info->CommandStatus != 0)
1680 { /* an error has occurred */
1681 switch(c->err_info->CommandStatus)
1682 {
1683 case CMD_TARGET_STATUS:
1684 printk(KERN_WARNING "cciss: cmd %p has "
1685 " completed with errors\n", c);
1686 if( c->err_info->ScsiStatus)
1687 {
1688 printk(KERN_WARNING "cciss: cmd %p "
1689 "has SCSI Status = %x\n",
1690 c,
1691 c->err_info->ScsiStatus);
1692 }
1693
1694 break;
1695 case CMD_DATA_UNDERRUN:
1696 case CMD_DATA_OVERRUN:
1697 /* expected for inquire and report lun commands */
1698 break;
1699 case CMD_INVALID:
1700 printk(KERN_WARNING "cciss: Cmd %p is "
1701 "reported invalid\n", c);
1702 return_status = IO_ERROR;
1703 break;
1704 case CMD_PROTOCOL_ERR:
1705 printk(KERN_WARNING "cciss: cmd %p has "
1706 "protocol error \n", c);
1707 return_status = IO_ERROR;
1708 break;
1709 case CMD_HARDWARE_ERR:
1710 printk(KERN_WARNING "cciss: cmd %p had "
1711 " hardware error\n", c);
1712 return_status = IO_ERROR;
1713 break;
1714 case CMD_CONNECTION_LOST:
1715 printk(KERN_WARNING "cciss: cmd %p had "
1716 "connection lost\n", c);
1717 return_status = IO_ERROR;
1718 break;
1719 case CMD_ABORTED:
1720 printk(KERN_WARNING "cciss: cmd %p was "
1721 "aborted\n", c);
1722 return_status = IO_ERROR;
1723 break;
1724 case CMD_ABORT_FAILED:
1725 printk(KERN_WARNING "cciss: cmd %p reports "
1726 "abort failed\n", c);
1727 return_status = IO_ERROR;
1728 break;
1729 case CMD_UNSOLICITED_ABORT:
1730 printk(KERN_WARNING
1731 "cciss%d: unsolicited abort %p\n",
1732 ctlr, c);
1733 if (c->retry_count < MAX_CMD_RETRIES) {
1734 printk(KERN_WARNING
1735 "cciss%d: retrying %p\n",
1736 ctlr, c);
1737 c->retry_count++;
1738 /* erase the old error information */
1739 memset(c->err_info, 0,
1740 sizeof(ErrorInfo_struct));
1741 return_status = IO_OK;
1742 INIT_COMPLETION(wait);
1743 goto resend_cmd2;
1744 }
1745 return_status = IO_ERROR;
1746 break;
1747 default:
1748 printk(KERN_WARNING "cciss: cmd %p returned "
1749 "unknown status %x\n", c,
1750 c->err_info->CommandStatus);
1751 return_status = IO_ERROR;
1752 }
1753 }
1754 /* unlock the buffers from DMA */
1755 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
1756 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
1757 pci_unmap_single( h->pdev, (dma_addr_t) buff_dma_handle.val,
1758 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
1759 cmd_free(h, c, 0);
1760 return(return_status);
1761
1762 }
1763 static void cciss_geometry_inquiry(int ctlr, int logvol,
1764 int withirq, unsigned int total_size,
1765 unsigned int block_size, InquiryData_struct *inq_buff,
1766 drive_info_struct *drv)
1767 {
1768 int return_code;
1769 memset(inq_buff, 0, sizeof(InquiryData_struct));
1770 if (withirq)
1771 return_code = sendcmd_withirq(CISS_INQUIRY, ctlr,
1772 inq_buff, sizeof(*inq_buff), 1, logvol ,0xC1, TYPE_CMD);
1773 else
1774 return_code = sendcmd(CISS_INQUIRY, ctlr, inq_buff,
1775 sizeof(*inq_buff), 1, logvol ,0xC1, NULL, TYPE_CMD);
1776 if (return_code == IO_OK) {
1777 if(inq_buff->data_byte[8] == 0xFF) {
1778 printk(KERN_WARNING
1779 "cciss: reading geometry failed, volume "
1780 "does not support reading geometry\n");
1781 drv->block_size = block_size;
1782 drv->nr_blocks = total_size;
1783 drv->heads = 255;
1784 drv->sectors = 32; // Sectors per track
1785 drv->cylinders = total_size / 255 / 32;
1786 } else {
1787 unsigned int t;
1788
1789 drv->block_size = block_size;
1790 drv->nr_blocks = total_size;
1791 drv->heads = inq_buff->data_byte[6];
1792 drv->sectors = inq_buff->data_byte[7];
1793 drv->cylinders = (inq_buff->data_byte[4] & 0xff) << 8;
1794 drv->cylinders += inq_buff->data_byte[5];
1795 drv->raid_level = inq_buff->data_byte[8];
1796 t = drv->heads * drv->sectors;
1797 if (t > 1) {
1798 drv->cylinders = total_size/t;
1799 }
1800 }
1801 } else { /* Get geometry failed */
1802 printk(KERN_WARNING "cciss: reading geometry failed\n");
1803 }
1804 printk(KERN_INFO " heads= %d, sectors= %d, cylinders= %d\n\n",
1805 drv->heads, drv->sectors, drv->cylinders);
1806 }
1807 static void
1808 cciss_read_capacity(int ctlr, int logvol, ReadCapdata_struct *buf,
1809 int withirq, unsigned int *total_size, unsigned int *block_size)
1810 {
1811 int return_code;
1812 memset(buf, 0, sizeof(*buf));
1813 if (withirq)
1814 return_code = sendcmd_withirq(CCISS_READ_CAPACITY,
1815 ctlr, buf, sizeof(*buf), 1, logvol, 0, TYPE_CMD);
1816 else
1817 return_code = sendcmd(CCISS_READ_CAPACITY,
1818 ctlr, buf, sizeof(*buf), 1, logvol, 0, NULL, TYPE_CMD);
1819 if (return_code == IO_OK) {
1820 *total_size = be32_to_cpu(*((__be32 *) &buf->total_size[0]))+1;
1821 *block_size = be32_to_cpu(*((__be32 *) &buf->block_size[0]));
1822 } else { /* read capacity command failed */
1823 printk(KERN_WARNING "cciss: read capacity failed\n");
1824 *total_size = 0;
1825 *block_size = BLOCK_SIZE;
1826 }
1827 printk(KERN_INFO " blocks= %u block_size= %d\n",
1828 *total_size, *block_size);
1829 return;
1830 }
1831
1832 static int cciss_revalidate(struct gendisk *disk)
1833 {
1834 ctlr_info_t *h = get_host(disk);
1835 drive_info_struct *drv = get_drv(disk);
1836 int logvol;
1837 int FOUND=0;
1838 unsigned int block_size;
1839 unsigned int total_size;
1840 ReadCapdata_struct *size_buff = NULL;
1841 InquiryData_struct *inq_buff = NULL;
1842
1843 for(logvol=0; logvol < CISS_MAX_LUN; logvol++)
1844 {
1845 if(h->drv[logvol].LunID == drv->LunID) {
1846 FOUND=1;
1847 break;
1848 }
1849 }
1850
1851 if (!FOUND) return 1;
1852
1853 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
1854 if (size_buff == NULL)
1855 {
1856 printk(KERN_WARNING "cciss: out of memory\n");
1857 return 1;
1858 }
1859 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
1860 if (inq_buff == NULL)
1861 {
1862 printk(KERN_WARNING "cciss: out of memory\n");
1863 kfree(size_buff);
1864 return 1;
1865 }
1866
1867 cciss_read_capacity(h->ctlr, logvol, size_buff, 1, &total_size, &block_size);
1868 cciss_geometry_inquiry(h->ctlr, logvol, 1, total_size, block_size, inq_buff, drv);
1869
1870 blk_queue_hardsect_size(drv->queue, drv->block_size);
1871 set_capacity(disk, drv->nr_blocks);
1872
1873 kfree(size_buff);
1874 kfree(inq_buff);
1875 return 0;
1876 }
1877
1878 /*
1879 * Wait polling for a command to complete.
1880 * The memory mapped FIFO is polled for the completion.
1881 * Used only at init time, interrupts from the HBA are disabled.
1882 */
1883 static unsigned long pollcomplete(int ctlr)
1884 {
1885 unsigned long done;
1886 int i;
1887
1888 /* Wait (up to 20 seconds) for a command to complete */
1889
1890 for (i = 20 * HZ; i > 0; i--) {
1891 done = hba[ctlr]->access.command_completed(hba[ctlr]);
1892 if (done == FIFO_EMPTY)
1893 schedule_timeout_uninterruptible(1);
1894 else
1895 return (done);
1896 }
1897 /* Invalid address to tell caller we ran out of time */
1898 return 1;
1899 }
1900
1901 static int add_sendcmd_reject(__u8 cmd, int ctlr, unsigned long complete)
1902 {
1903 /* We get in here if sendcmd() is polling for completions
1904 and gets some command back that it wasn't expecting --
1905 something other than that which it just sent down.
1906 Ordinarily, that shouldn't happen, but it can happen when
1907 the scsi tape stuff gets into error handling mode, and
1908 starts using sendcmd() to try to abort commands and
1909 reset tape drives. In that case, sendcmd may pick up
1910 completions of commands that were sent to logical drives
1911 through the block i/o system, or cciss ioctls completing, etc.
1912 In that case, we need to save those completions for later
1913 processing by the interrupt handler.
1914 */
1915
1916 #ifdef CONFIG_CISS_SCSI_TAPE
1917 struct sendcmd_reject_list *srl = &hba[ctlr]->scsi_rejects;
1918
1919 /* If it's not the scsi tape stuff doing error handling, (abort */
1920 /* or reset) then we don't expect anything weird. */
1921 if (cmd != CCISS_RESET_MSG && cmd != CCISS_ABORT_MSG) {
1922 #endif
1923 printk( KERN_WARNING "cciss cciss%d: SendCmd "
1924 "Invalid command list address returned! (%lx)\n",
1925 ctlr, complete);
1926 /* not much we can do. */
1927 #ifdef CONFIG_CISS_SCSI_TAPE
1928 return 1;
1929 }
1930
1931 /* We've sent down an abort or reset, but something else
1932 has completed */
1933 if (srl->ncompletions >= (NR_CMDS + 2)) {
1934 /* Uh oh. No room to save it for later... */
1935 printk(KERN_WARNING "cciss%d: Sendcmd: Invalid command addr, "
1936 "reject list overflow, command lost!\n", ctlr);
1937 return 1;
1938 }
1939 /* Save it for later */
1940 srl->complete[srl->ncompletions] = complete;
1941 srl->ncompletions++;
1942 #endif
1943 return 0;
1944 }
1945
1946 /*
1947 * Send a command to the controller, and wait for it to complete.
1948 * Only used at init time.
1949 */
1950 static int sendcmd(
1951 __u8 cmd,
1952 int ctlr,
1953 void *buff,
1954 size_t size,
1955 unsigned int use_unit_num, /* 0: address the controller,
1956 1: address logical volume log_unit,
1957 2: periph device address is scsi3addr */
1958 unsigned int log_unit,
1959 __u8 page_code,
1960 unsigned char *scsi3addr,
1961 int cmd_type)
1962 {
1963 CommandList_struct *c;
1964 int i;
1965 unsigned long complete;
1966 ctlr_info_t *info_p= hba[ctlr];
1967 u64bit buff_dma_handle;
1968 int status, done = 0;
1969
1970 if ((c = cmd_alloc(info_p, 1)) == NULL) {
1971 printk(KERN_WARNING "cciss: unable to get memory");
1972 return(IO_ERROR);
1973 }
1974 status = fill_cmd(c, cmd, ctlr, buff, size, use_unit_num,
1975 log_unit, page_code, scsi3addr, cmd_type);
1976 if (status != IO_OK) {
1977 cmd_free(info_p, c, 1);
1978 return status;
1979 }
1980 resend_cmd1:
1981 /*
1982 * Disable interrupt
1983 */
1984 #ifdef CCISS_DEBUG
1985 printk(KERN_DEBUG "cciss: turning intr off\n");
1986 #endif /* CCISS_DEBUG */
1987 info_p->access.set_intr_mask(info_p, CCISS_INTR_OFF);
1988
1989 /* Make sure there is room in the command FIFO */
1990 /* Actually it should be completely empty at this time */
1991 /* unless we are in here doing error handling for the scsi */
1992 /* tape side of the driver. */
1993 for (i = 200000; i > 0; i--)
1994 {
1995 /* if fifo isn't full go */
1996 if (!(info_p->access.fifo_full(info_p)))
1997 {
1998
1999 break;
2000 }
2001 udelay(10);
2002 printk(KERN_WARNING "cciss cciss%d: SendCmd FIFO full,"
2003 " waiting!\n", ctlr);
2004 }
2005 /*
2006 * Send the cmd
2007 */
2008 info_p->access.submit_command(info_p, c);
2009 done = 0;
2010 do {
2011 complete = pollcomplete(ctlr);
2012
2013 #ifdef CCISS_DEBUG
2014 printk(KERN_DEBUG "cciss: command completed\n");
2015 #endif /* CCISS_DEBUG */
2016
2017 if (complete == 1) {
2018 printk( KERN_WARNING
2019 "cciss cciss%d: SendCmd Timeout out, "
2020 "No command list address returned!\n",
2021 ctlr);
2022 status = IO_ERROR;
2023 done = 1;
2024 break;
2025 }
2026
2027 /* This will need to change for direct lookup completions */
2028 if ( (complete & CISS_ERROR_BIT)
2029 && (complete & ~CISS_ERROR_BIT) == c->busaddr)
2030 {
2031 /* if data overrun or underun on Report command
2032 ignore it
2033 */
2034 if (((c->Request.CDB[0] == CISS_REPORT_LOG) ||
2035 (c->Request.CDB[0] == CISS_REPORT_PHYS) ||
2036 (c->Request.CDB[0] == CISS_INQUIRY)) &&
2037 ((c->err_info->CommandStatus ==
2038 CMD_DATA_OVERRUN) ||
2039 (c->err_info->CommandStatus ==
2040 CMD_DATA_UNDERRUN)
2041 ))
2042 {
2043 complete = c->busaddr;
2044 } else {
2045 if (c->err_info->CommandStatus ==
2046 CMD_UNSOLICITED_ABORT) {
2047 printk(KERN_WARNING "cciss%d: "
2048 "unsolicited abort %p\n",
2049 ctlr, c);
2050 if (c->retry_count < MAX_CMD_RETRIES) {
2051 printk(KERN_WARNING
2052 "cciss%d: retrying %p\n",
2053 ctlr, c);
2054 c->retry_count++;
2055 /* erase the old error */
2056 /* information */
2057 memset(c->err_info, 0,
2058 sizeof(ErrorInfo_struct));
2059 goto resend_cmd1;
2060 } else {
2061 printk(KERN_WARNING
2062 "cciss%d: retried %p too "
2063 "many times\n", ctlr, c);
2064 status = IO_ERROR;
2065 goto cleanup1;
2066 }
2067 } else if (c->err_info->CommandStatus == CMD_UNABORTABLE) {
2068 printk(KERN_WARNING "cciss%d: command could not be aborted.\n", ctlr);
2069 status = IO_ERROR;
2070 goto cleanup1;
2071 }
2072 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2073 " Error %x \n", ctlr,
2074 c->err_info->CommandStatus);
2075 printk(KERN_WARNING "ciss ciss%d: sendcmd"
2076 " offensive info\n"
2077 " size %x\n num %x value %x\n", ctlr,
2078 c->err_info->MoreErrInfo.Invalid_Cmd.offense_size,
2079 c->err_info->MoreErrInfo.Invalid_Cmd.offense_num,
2080 c->err_info->MoreErrInfo.Invalid_Cmd.offense_value);
2081 status = IO_ERROR;
2082 goto cleanup1;
2083 }
2084 }
2085 /* This will need changing for direct lookup completions */
2086 if (complete != c->busaddr) {
2087 if (add_sendcmd_reject(cmd, ctlr, complete) != 0) {
2088 BUG(); /* we are pretty much hosed if we get here. */
2089 }
2090 continue;
2091 } else
2092 done = 1;
2093 } while (!done);
2094
2095 cleanup1:
2096 /* unlock the data buffer from DMA */
2097 buff_dma_handle.val32.lower = c->SG[0].Addr.lower;
2098 buff_dma_handle.val32.upper = c->SG[0].Addr.upper;
2099 pci_unmap_single(info_p->pdev, (dma_addr_t) buff_dma_handle.val,
2100 c->SG[0].Len, PCI_DMA_BIDIRECTIONAL);
2101 #ifdef CONFIG_CISS_SCSI_TAPE
2102 /* if we saved some commands for later, process them now. */
2103 if (info_p->scsi_rejects.ncompletions > 0)
2104 do_cciss_intr(0, info_p, NULL);
2105 #endif
2106 cmd_free(info_p, c, 1);
2107 return (status);
2108 }
2109 /*
2110 * Map (physical) PCI mem into (virtual) kernel space
2111 */
2112 static void __iomem *remap_pci_mem(ulong base, ulong size)
2113 {
2114 ulong page_base = ((ulong) base) & PAGE_MASK;
2115 ulong page_offs = ((ulong) base) - page_base;
2116 void __iomem *page_remapped = ioremap(page_base, page_offs+size);
2117
2118 return page_remapped ? (page_remapped + page_offs) : NULL;
2119 }
2120
2121 /*
2122 * Takes jobs of the Q and sends them to the hardware, then puts it on
2123 * the Q to wait for completion.
2124 */
2125 static void start_io( ctlr_info_t *h)
2126 {
2127 CommandList_struct *c;
2128
2129 while(( c = h->reqQ) != NULL )
2130 {
2131 /* can't do anything if fifo is full */
2132 if ((h->access.fifo_full(h))) {
2133 printk(KERN_WARNING "cciss: fifo full\n");
2134 break;
2135 }
2136
2137 /* Get the frist entry from the Request Q */
2138 removeQ(&(h->reqQ), c);
2139 h->Qdepth--;
2140
2141 /* Tell the controller execute command */
2142 h->access.submit_command(h, c);
2143
2144 /* Put job onto the completed Q */
2145 addQ (&(h->cmpQ), c);
2146 }
2147 }
2148
2149 static inline void complete_buffers(struct bio *bio, int status)
2150 {
2151 while (bio) {
2152 struct bio *xbh = bio->bi_next;
2153 int nr_sectors = bio_sectors(bio);
2154
2155 bio->bi_next = NULL;
2156 blk_finished_io(len);
2157 bio_endio(bio, nr_sectors << 9, status ? 0 : -EIO);
2158 bio = xbh;
2159 }
2160
2161 }
2162 /* Assumes that CCISS_LOCK(h->ctlr) is held. */
2163 /* Zeros out the error record and then resends the command back */
2164 /* to the controller */
2165 static inline void resend_cciss_cmd( ctlr_info_t *h, CommandList_struct *c)
2166 {
2167 /* erase the old error information */
2168 memset(c->err_info, 0, sizeof(ErrorInfo_struct));
2169
2170 /* add it to software queue and then send it to the controller */
2171 addQ(&(h->reqQ),c);
2172 h->Qdepth++;
2173 if(h->Qdepth > h->maxQsinceinit)
2174 h->maxQsinceinit = h->Qdepth;
2175
2176 start_io(h);
2177 }
2178 /* checks the status of the job and calls complete buffers to mark all
2179 * buffers for the completed job.
2180 */
2181 static inline void complete_command( ctlr_info_t *h, CommandList_struct *cmd,
2182 int timeout)
2183 {
2184 int status = 1;
2185 int i;
2186 int retry_cmd = 0;
2187 u64bit temp64;
2188
2189 if (timeout)
2190 status = 0;
2191
2192 if(cmd->err_info->CommandStatus != 0)
2193 { /* an error has occurred */
2194 switch(cmd->err_info->CommandStatus)
2195 {
2196 unsigned char sense_key;
2197 case CMD_TARGET_STATUS:
2198 status = 0;
2199
2200 if( cmd->err_info->ScsiStatus == 0x02)
2201 {
2202 printk(KERN_WARNING "cciss: cmd %p "
2203 "has CHECK CONDITION "
2204 " byte 2 = 0x%x\n", cmd,
2205 cmd->err_info->SenseInfo[2]
2206 );
2207 /* check the sense key */
2208 sense_key = 0xf &
2209 cmd->err_info->SenseInfo[2];
2210 /* no status or recovered error */
2211 if((sense_key == 0x0) ||
2212 (sense_key == 0x1))
2213 {
2214 status = 1;
2215 }
2216 } else
2217 {
2218 printk(KERN_WARNING "cciss: cmd %p "
2219 "has SCSI Status 0x%x\n",
2220 cmd, cmd->err_info->ScsiStatus);
2221 }
2222 break;
2223 case CMD_DATA_UNDERRUN:
2224 printk(KERN_WARNING "cciss: cmd %p has"
2225 " completed with data underrun "
2226 "reported\n", cmd);
2227 break;
2228 case CMD_DATA_OVERRUN:
2229 printk(KERN_WARNING "cciss: cmd %p has"
2230 " completed with data overrun "
2231 "reported\n", cmd);
2232 break;
2233 case CMD_INVALID:
2234 printk(KERN_WARNING "cciss: cmd %p is "
2235 "reported invalid\n", cmd);
2236 status = 0;
2237 break;
2238 case CMD_PROTOCOL_ERR:
2239 printk(KERN_WARNING "cciss: cmd %p has "
2240 "protocol error \n", cmd);
2241 status = 0;
2242 break;
2243 case CMD_HARDWARE_ERR:
2244 printk(KERN_WARNING "cciss: cmd %p had "
2245 " hardware error\n", cmd);
2246 status = 0;
2247 break;
2248 case CMD_CONNECTION_LOST:
2249 printk(KERN_WARNING "cciss: cmd %p had "
2250 "connection lost\n", cmd);
2251 status=0;
2252 break;
2253 case CMD_ABORTED:
2254 printk(KERN_WARNING "cciss: cmd %p was "
2255 "aborted\n", cmd);
2256 status=0;
2257 break;
2258 case CMD_ABORT_FAILED:
2259 printk(KERN_WARNING "cciss: cmd %p reports "
2260 "abort failed\n", cmd);
2261 status=0;
2262 break;
2263 case CMD_UNSOLICITED_ABORT:
2264 printk(KERN_WARNING "cciss%d: unsolicited "
2265 "abort %p\n", h->ctlr, cmd);
2266 if (cmd->retry_count < MAX_CMD_RETRIES) {
2267 retry_cmd=1;
2268 printk(KERN_WARNING
2269 "cciss%d: retrying %p\n",
2270 h->ctlr, cmd);
2271 cmd->retry_count++;
2272 } else
2273 printk(KERN_WARNING
2274 "cciss%d: %p retried too "
2275 "many times\n", h->ctlr, cmd);
2276 status=0;
2277 break;
2278 case CMD_TIMEOUT:
2279 printk(KERN_WARNING "cciss: cmd %p timedout\n",
2280 cmd);
2281 status=0;
2282 break;
2283 default:
2284 printk(KERN_WARNING "cciss: cmd %p returned "
2285 "unknown status %x\n", cmd,
2286 cmd->err_info->CommandStatus);
2287 status=0;
2288 }
2289 }
2290 /* We need to return this command */
2291 if(retry_cmd) {
2292 resend_cciss_cmd(h,cmd);
2293 return;
2294 }
2295 /* command did not need to be retried */
2296 /* unmap the DMA mapping for all the scatter gather elements */
2297 for(i=0; i<cmd->Header.SGList; i++) {
2298 temp64.val32.lower = cmd->SG[i].Addr.lower;
2299 temp64.val32.upper = cmd->SG[i].Addr.upper;
2300 pci_unmap_page(hba[cmd->ctlr]->pdev,
2301 temp64.val, cmd->SG[i].Len,
2302 (cmd->Request.Type.Direction == XFER_READ) ?
2303 PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE);
2304 }
2305 complete_buffers(cmd->rq->bio, status);
2306
2307 #ifdef CCISS_DEBUG
2308 printk("Done with %p\n", cmd->rq);
2309 #endif /* CCISS_DEBUG */
2310
2311 end_that_request_last(cmd->rq);
2312 cmd_free(h,cmd,1);
2313 }
2314
2315 /*
2316 * Get a request and submit it to the controller.
2317 */
2318 static void do_cciss_request(request_queue_t *q)
2319 {
2320 ctlr_info_t *h= q->queuedata;
2321 CommandList_struct *c;
2322 int start_blk, seg;
2323 struct request *creq;
2324 u64bit temp64;
2325 struct scatterlist tmp_sg[MAXSGENTRIES];
2326 drive_info_struct *drv;
2327 int i, dir;
2328
2329 /* We call start_io here in case there is a command waiting on the
2330 * queue that has not been sent.
2331 */
2332 if (blk_queue_plugged(q))
2333 goto startio;
2334
2335 queue:
2336 creq = elv_next_request(q);
2337 if (!creq)
2338 goto startio;
2339
2340 if (creq->nr_phys_segments > MAXSGENTRIES)
2341 BUG();
2342
2343 if (( c = cmd_alloc(h, 1)) == NULL)
2344 goto full;
2345
2346 blkdev_dequeue_request(creq);
2347
2348 spin_unlock_irq(q->queue_lock);
2349
2350 c->cmd_type = CMD_RWREQ;
2351 c->rq = creq;
2352
2353 /* fill in the request */
2354 drv = creq->rq_disk->private_data;
2355 c->Header.ReplyQueue = 0; // unused in simple mode
2356 /* got command from pool, so use the command block index instead */
2357 /* for direct lookups. */
2358 /* The first 2 bits are reserved for controller error reporting. */
2359 c->Header.Tag.lower = (c->cmdindex << 3);
2360 c->Header.Tag.lower |= 0x04; /* flag for direct lookup. */
2361 c->Header.LUN.LogDev.VolId= drv->LunID;
2362 c->Header.LUN.LogDev.Mode = 1;
2363 c->Request.CDBLen = 10; // 12 byte commands not in FW yet;
2364 c->Request.Type.Type = TYPE_CMD; // It is a command.
2365 c->Request.Type.Attribute = ATTR_SIMPLE;
2366 c->Request.Type.Direction =
2367 (rq_data_dir(creq) == READ) ? XFER_READ: XFER_WRITE;
2368 c->Request.Timeout = 0; // Don't time out
2369 c->Request.CDB[0] = (rq_data_dir(creq) == READ) ? CCISS_READ : CCISS_WRITE;
2370 start_blk = creq->sector;
2371 #ifdef CCISS_DEBUG
2372 printk(KERN_DEBUG "ciss: sector =%d nr_sectors=%d\n",(int) creq->sector,
2373 (int) creq->nr_sectors);
2374 #endif /* CCISS_DEBUG */
2375
2376 seg = blk_rq_map_sg(q, creq, tmp_sg);
2377
2378 /* get the DMA records for the setup */
2379 if (c->Request.Type.Direction == XFER_READ)
2380 dir = PCI_DMA_FROMDEVICE;
2381 else
2382 dir = PCI_DMA_TODEVICE;
2383
2384 for (i=0; i<seg; i++)
2385 {
2386 c->SG[i].Len = tmp_sg[i].length;
2387 temp64.val = (__u64) pci_map_page(h->pdev, tmp_sg[i].page,
2388 tmp_sg[i].offset, tmp_sg[i].length,
2389 dir);
2390 c->SG[i].Addr.lower = temp64.val32.lower;
2391 c->SG[i].Addr.upper = temp64.val32.upper;
2392 c->SG[i].Ext = 0; // we are not chaining
2393 }
2394 /* track how many SG entries we are using */
2395 if( seg > h->maxSG)
2396 h->maxSG = seg;
2397
2398 #ifdef CCISS_DEBUG
2399 printk(KERN_DEBUG "cciss: Submitting %d sectors in %d segments\n", creq->nr_sectors, seg);
2400 #endif /* CCISS_DEBUG */
2401
2402 c->Header.SGList = c->Header.SGTotal = seg;
2403 c->Request.CDB[1]= 0;
2404 c->Request.CDB[2]= (start_blk >> 24) & 0xff; //MSB
2405 c->Request.CDB[3]= (start_blk >> 16) & 0xff;
2406 c->Request.CDB[4]= (start_blk >> 8) & 0xff;
2407 c->Request.CDB[5]= start_blk & 0xff;
2408 c->Request.CDB[6]= 0; // (sect >> 24) & 0xff; MSB
2409 c->Request.CDB[7]= (creq->nr_sectors >> 8) & 0xff;
2410 c->Request.CDB[8]= creq->nr_sectors & 0xff;
2411 c->Request.CDB[9] = c->Request.CDB[11] = c->Request.CDB[12] = 0;
2412
2413 spin_lock_irq(q->queue_lock);
2414
2415 addQ(&(h->reqQ),c);
2416 h->Qdepth++;
2417 if(h->Qdepth > h->maxQsinceinit)
2418 h->maxQsinceinit = h->Qdepth;
2419
2420 goto queue;
2421 full:
2422 blk_stop_queue(q);
2423 startio:
2424 /* We will already have the driver lock here so not need
2425 * to lock it.
2426 */
2427 start_io(h);
2428 }
2429
2430 static inline unsigned long get_next_completion(ctlr_info_t *h)
2431 {
2432 #ifdef CONFIG_CISS_SCSI_TAPE
2433 /* Any rejects from sendcmd() lying around? Process them first */
2434 if (h->scsi_rejects.ncompletions == 0)
2435 return h->access.command_completed(h);
2436 else {
2437 struct sendcmd_reject_list *srl;
2438 int n;
2439 srl = &h->scsi_rejects;
2440 n = --srl->ncompletions;
2441 /* printk("cciss%d: processing saved reject\n", h->ctlr); */
2442 printk("p");
2443 return srl->complete[n];
2444 }
2445 #else
2446 return h->access.command_completed(h);
2447 #endif
2448 }
2449
2450 static inline int interrupt_pending(ctlr_info_t *h)
2451 {
2452 #ifdef CONFIG_CISS_SCSI_TAPE
2453 return ( h->access.intr_pending(h)
2454 || (h->scsi_rejects.ncompletions > 0));
2455 #else
2456 return h->access.intr_pending(h);
2457 #endif
2458 }
2459
2460 static inline long interrupt_not_for_us(ctlr_info_t *h)
2461 {
2462 #ifdef CONFIG_CISS_SCSI_TAPE
2463 return (((h->access.intr_pending(h) == 0) ||
2464 (h->interrupts_enabled == 0))
2465 && (h->scsi_rejects.ncompletions == 0));
2466 #else
2467 return (((h->access.intr_pending(h) == 0) ||
2468 (h->interrupts_enabled == 0)));
2469 #endif
2470 }
2471
2472 static irqreturn_t do_cciss_intr(int irq, void *dev_id, struct pt_regs *regs)
2473 {
2474 ctlr_info_t *h = dev_id;
2475 CommandList_struct *c;
2476 unsigned long flags;
2477 __u32 a, a1, a2;
2478 int j;
2479 int start_queue = h->next_to_run;
2480
2481 if (interrupt_not_for_us(h))
2482 return IRQ_NONE;
2483 /*
2484 * If there are completed commands in the completion queue,
2485 * we had better do something about it.
2486 */
2487 spin_lock_irqsave(CCISS_LOCK(h->ctlr), flags);
2488 while (interrupt_pending(h)) {
2489 while((a = get_next_completion(h)) != FIFO_EMPTY) {
2490 a1 = a;
2491 if ((a & 0x04)) {
2492 a2 = (a >> 3);
2493 if (a2 >= NR_CMDS) {
2494 printk(KERN_WARNING "cciss: controller cciss%d failed, stopping.\n", h->ctlr);
2495 fail_all_cmds(h->ctlr);
2496 return IRQ_HANDLED;
2497 }
2498
2499 c = h->cmd_pool + a2;
2500 a = c->busaddr;
2501
2502 } else {
2503 a &= ~3;
2504 if ((c = h->cmpQ) == NULL) {
2505 printk(KERN_WARNING "cciss: Completion of %08x ignored\n", a1);
2506 continue;
2507 }
2508 while(c->busaddr != a) {
2509 c = c->next;
2510 if (c == h->cmpQ)
2511 break;
2512 }
2513 }
2514 /*
2515 * If we've found the command, take it off the
2516 * completion Q and free it
2517 */
2518 if (c->busaddr == a) {
2519 removeQ(&h->cmpQ, c);
2520 if (c->cmd_type == CMD_RWREQ) {
2521 complete_command(h, c, 0);
2522 } else if (c->cmd_type == CMD_IOCTL_PEND) {
2523 complete(c->waiting);
2524 }
2525 # ifdef CONFIG_CISS_SCSI_TAPE
2526 else if (c->cmd_type == CMD_SCSI)
2527 complete_scsi_command(c, 0, a1);
2528 # endif
2529 continue;
2530 }
2531 }
2532 }
2533
2534 /* check to see if we have maxed out the number of commands that can
2535 * be placed on the queue. If so then exit. We do this check here
2536 * in case the interrupt we serviced was from an ioctl and did not
2537 * free any new commands.
2538 */
2539 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2540 goto cleanup;
2541
2542 /* We have room on the queue for more commands. Now we need to queue
2543 * them up. We will also keep track of the next queue to run so
2544 * that every queue gets a chance to be started first.
2545 */
2546 for (j=0; j < h->highest_lun + 1; j++){
2547 int curr_queue = (start_queue + j) % (h->highest_lun + 1);
2548 /* make sure the disk has been added and the drive is real
2549 * because this can be called from the middle of init_one.
2550 */
2551 if(!(h->drv[curr_queue].queue) ||
2552 !(h->drv[curr_queue].heads))
2553 continue;
2554 blk_start_queue(h->gendisk[curr_queue]->queue);
2555
2556 /* check to see if we have maxed out the number of commands
2557 * that can be placed on the queue.
2558 */
2559 if ((find_first_zero_bit(h->cmd_pool_bits, NR_CMDS)) == NR_CMDS)
2560 {
2561 if (curr_queue == start_queue){
2562 h->next_to_run = (start_queue + 1) % (h->highest_lun + 1);
2563 goto cleanup;
2564 } else {
2565 h->next_to_run = curr_queue;
2566 goto cleanup;
2567 }
2568 } else {
2569 curr_queue = (curr_queue + 1) % (h->highest_lun + 1);
2570 }
2571 }
2572
2573 cleanup:
2574 spin_unlock_irqrestore(CCISS_LOCK(h->ctlr), flags);
2575 return IRQ_HANDLED;
2576 }
2577 /*
2578 * We cannot read the structure directly, for portablity we must use
2579 * the io functions.
2580 * This is for debug only.
2581 */
2582 #ifdef CCISS_DEBUG
2583 static void print_cfg_table( CfgTable_struct *tb)
2584 {
2585 int i;
2586 char temp_name[17];
2587
2588 printk("Controller Configuration information\n");
2589 printk("------------------------------------\n");
2590 for(i=0;i<4;i++)
2591 temp_name[i] = readb(&(tb->Signature[i]));
2592 temp_name[4]='\0';
2593 printk(" Signature = %s\n", temp_name);
2594 printk(" Spec Number = %d\n", readl(&(tb->SpecValence)));
2595 printk(" Transport methods supported = 0x%x\n",
2596 readl(&(tb-> TransportSupport)));
2597 printk(" Transport methods active = 0x%x\n",
2598 readl(&(tb->TransportActive)));
2599 printk(" Requested transport Method = 0x%x\n",
2600 readl(&(tb->HostWrite.TransportRequest)));
2601 printk(" Coalese Interrupt Delay = 0x%x\n",
2602 readl(&(tb->HostWrite.CoalIntDelay)));
2603 printk(" Coalese Interrupt Count = 0x%x\n",
2604 readl(&(tb->HostWrite.CoalIntCount)));
2605 printk(" Max outstanding commands = 0x%d\n",
2606 readl(&(tb->CmdsOutMax)));
2607 printk(" Bus Types = 0x%x\n", readl(&(tb-> BusTypes)));
2608 for(i=0;i<16;i++)
2609 temp_name[i] = readb(&(tb->ServerName[i]));
2610 temp_name[16] = '\0';
2611 printk(" Server Name = %s\n", temp_name);
2612 printk(" Heartbeat Counter = 0x%x\n\n\n",
2613 readl(&(tb->HeartBeat)));
2614 }
2615 #endif /* CCISS_DEBUG */
2616
2617 static void release_io_mem(ctlr_info_t *c)
2618 {
2619 /* if IO mem was not protected do nothing */
2620 if( c->io_mem_addr == 0)
2621 return;
2622 release_region(c->io_mem_addr, c->io_mem_length);
2623 c->io_mem_addr = 0;
2624 c->io_mem_length = 0;
2625 }
2626
2627 static int find_PCI_BAR_index(struct pci_dev *pdev,
2628 unsigned long pci_bar_addr)
2629 {
2630 int i, offset, mem_type, bar_type;
2631 if (pci_bar_addr == PCI_BASE_ADDRESS_0) /* looking for BAR zero? */
2632 return 0;
2633 offset = 0;
2634 for (i=0; i<DEVICE_COUNT_RESOURCE; i++) {
2635 bar_type = pci_resource_flags(pdev, i) &
2636 PCI_BASE_ADDRESS_SPACE;
2637 if (bar_type == PCI_BASE_ADDRESS_SPACE_IO)
2638 offset += 4;
2639 else {
2640 mem_type = pci_resource_flags(pdev, i) &
2641 PCI_BASE_ADDRESS_MEM_TYPE_MASK;
2642 switch (mem_type) {
2643 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2644 case PCI_BASE_ADDRESS_MEM_TYPE_1M:
2645 offset += 4; /* 32 bit */
2646 break;
2647 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2648 offset += 8;
2649 break;
2650 default: /* reserved in PCI 2.2 */
2651 printk(KERN_WARNING "Base address is invalid\n");
2652 return -1;
2653 break;
2654 }
2655 }
2656 if (offset == pci_bar_addr - PCI_BASE_ADDRESS_0)
2657 return i+1;
2658 }
2659 return -1;
2660 }
2661
2662 static int cciss_pci_init(ctlr_info_t *c, struct pci_dev *pdev)
2663 {
2664 ushort subsystem_vendor_id, subsystem_device_id, command;
2665 __u32 board_id, scratchpad = 0;
2666 __u64 cfg_offset;
2667 __u32 cfg_base_addr;
2668 __u64 cfg_base_addr_index;
2669 int i;
2670
2671 /* check to see if controller has been disabled */
2672 /* BEFORE trying to enable it */
2673 (void) pci_read_config_word(pdev, PCI_COMMAND,&command);
2674 if(!(command & 0x02))
2675 {
2676 printk(KERN_WARNING "cciss: controller appears to be disabled\n");
2677 return(-1);
2678 }
2679
2680 if (pci_enable_device(pdev))
2681 {
2682 printk(KERN_ERR "cciss: Unable to Enable PCI device\n");
2683 return( -1);
2684 }
2685
2686 subsystem_vendor_id = pdev->subsystem_vendor;
2687 subsystem_device_id = pdev->subsystem_device;
2688 board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
2689 subsystem_vendor_id);
2690
2691 /* search for our IO range so we can protect it */
2692 for(i=0; i<DEVICE_COUNT_RESOURCE; i++)
2693 {
2694 /* is this an IO range */
2695 if( pci_resource_flags(pdev, i) & 0x01 ) {
2696 c->io_mem_addr = pci_resource_start(pdev, i);
2697 c->io_mem_length = pci_resource_end(pdev, i) -
2698 pci_resource_start(pdev, i) +1;
2699 #ifdef CCISS_DEBUG
2700 printk("IO value found base_addr[%d] %lx %lx\n", i,
2701 c->io_mem_addr, c->io_mem_length);
2702 #endif /* CCISS_DEBUG */
2703 /* register the IO range */
2704 if(!request_region( c->io_mem_addr,
2705 c->io_mem_length, "cciss"))
2706 {
2707 printk(KERN_WARNING "cciss I/O memory range already in use addr=%lx length=%ld\n",
2708 c->io_mem_addr, c->io_mem_length);
2709 c->io_mem_addr= 0;
2710 c->io_mem_length = 0;
2711 }
2712 break;
2713 }
2714 }
2715
2716 #ifdef CCISS_DEBUG
2717 printk("command = %x\n", command);
2718 printk("irq = %x\n", pdev->irq);
2719 printk("board_id = %x\n", board_id);
2720 #endif /* CCISS_DEBUG */
2721
2722 c->intr = pdev->irq;
2723
2724 /*
2725 * Memory base addr is first addr , the second points to the config
2726 * table
2727 */
2728
2729 c->paddr = pci_resource_start(pdev, 0); /* addressing mode bits already removed */
2730 #ifdef CCISS_DEBUG
2731 printk("address 0 = %x\n", c->paddr);
2732 #endif /* CCISS_DEBUG */
2733 c->vaddr = remap_pci_mem(c->paddr, 200);
2734
2735 /* Wait for the board to become ready. (PCI hotplug needs this.)
2736 * We poll for up to 120 secs, once per 100ms. */
2737 for (i=0; i < 1200; i++) {
2738 scratchpad = readl(c->vaddr + SA5_SCRATCHPAD_OFFSET);
2739 if (scratchpad == CCISS_FIRMWARE_READY)
2740 break;
2741 set_current_state(TASK_INTERRUPTIBLE);
2742 schedule_timeout(HZ / 10); /* wait 100ms */
2743 }
2744 if (scratchpad != CCISS_FIRMWARE_READY) {
2745 printk(KERN_WARNING "cciss: Board not ready. Timed out.\n");
2746 return -1;
2747 }
2748
2749 /* get the address index number */
2750 cfg_base_addr = readl(c->vaddr + SA5_CTCFG_OFFSET);
2751 cfg_base_addr &= (__u32) 0x0000ffff;
2752 #ifdef CCISS_DEBUG
2753 printk("cfg base address = %x\n", cfg_base_addr);
2754 #endif /* CCISS_DEBUG */
2755 cfg_base_addr_index =
2756 find_PCI_BAR_index(pdev, cfg_base_addr);
2757 #ifdef CCISS_DEBUG
2758 printk("cfg base address index = %x\n", cfg_base_addr_index);
2759 #endif /* CCISS_DEBUG */
2760 if (cfg_base_addr_index == -1) {
2761 printk(KERN_WARNING "cciss: Cannot find cfg_base_addr_index\n");
2762 release_io_mem(c);
2763 return -1;
2764 }
2765
2766 cfg_offset = readl(c->vaddr + SA5_CTMEM_OFFSET);
2767 #ifdef CCISS_DEBUG
2768 printk("cfg offset = %x\n", cfg_offset);
2769 #endif /* CCISS_DEBUG */
2770 c->cfgtable = remap_pci_mem(pci_resource_start(pdev,
2771 cfg_base_addr_index) + cfg_offset,
2772 sizeof(CfgTable_struct));
2773 c->board_id = board_id;
2774
2775 #ifdef CCISS_DEBUG
2776 print_cfg_table(c->cfgtable);
2777 #endif /* CCISS_DEBUG */
2778
2779 for(i=0; i<NR_PRODUCTS; i++) {
2780 if (board_id == products[i].board_id) {
2781 c->product_name = products[i].product_name;
2782 c->access = *(products[i].access);
2783 break;
2784 }
2785 }
2786 if (i == NR_PRODUCTS) {
2787 printk(KERN_WARNING "cciss: Sorry, I don't know how"
2788 " to access the Smart Array controller %08lx\n",
2789 (unsigned long)board_id);
2790 return -1;
2791 }
2792 if ( (readb(&c->cfgtable->Signature[0]) != 'C') ||
2793 (readb(&c->cfgtable->Signature[1]) != 'I') ||
2794 (readb(&c->cfgtable->Signature[2]) != 'S') ||
2795 (readb(&c->cfgtable->Signature[3]) != 'S') )
2796 {
2797 printk("Does not appear to be a valid CISS config table\n");
2798 return -1;
2799 }
2800
2801 #ifdef CONFIG_X86
2802 {
2803 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
2804 __u32 prefetch;
2805 prefetch = readl(&(c->cfgtable->SCSI_Prefetch));
2806 prefetch |= 0x100;
2807 writel(prefetch, &(c->cfgtable->SCSI_Prefetch));
2808 }
2809 #endif
2810
2811 #ifdef CCISS_DEBUG
2812 printk("Trying to put board into Simple mode\n");
2813 #endif /* CCISS_DEBUG */
2814 c->max_commands = readl(&(c->cfgtable->CmdsOutMax));
2815 /* Update the field, and then ring the doorbell */
2816 writel( CFGTBL_Trans_Simple,
2817 &(c->cfgtable->HostWrite.TransportRequest));
2818 writel( CFGTBL_ChangeReq, c->vaddr + SA5_DOORBELL);
2819
2820 /* under certain very rare conditions, this can take awhile.
2821 * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
2822 * as we enter this code.) */
2823 for(i=0;i<MAX_CONFIG_WAIT;i++) {
2824 if (!(readl(c->vaddr + SA5_DOORBELL) & CFGTBL_ChangeReq))
2825 break;
2826 /* delay and try again */
2827 set_current_state(TASK_INTERRUPTIBLE);
2828 schedule_timeout(10);
2829 }
2830
2831 #ifdef CCISS_DEBUG
2832 printk(KERN_DEBUG "I counter got to %d %x\n", i, readl(c->vaddr + SA5_DOORBELL));
2833 #endif /* CCISS_DEBUG */
2834 #ifdef CCISS_DEBUG
2835 print_cfg_table(c->cfgtable);
2836 #endif /* CCISS_DEBUG */
2837
2838 if (!(readl(&(c->cfgtable->TransportActive)) & CFGTBL_Trans_Simple))
2839 {
2840 printk(KERN_WARNING "cciss: unable to get board into"
2841 " simple mode\n");
2842 return -1;
2843 }
2844 return 0;
2845
2846 }
2847
2848 /*
2849 * Gets information about the local volumes attached to the controller.
2850 */
2851 static void cciss_getgeometry(int cntl_num)
2852 {
2853 ReportLunData_struct *ld_buff;
2854 ReadCapdata_struct *size_buff;
2855 InquiryData_struct *inq_buff;
2856 int return_code;
2857 int i;
2858 int listlength = 0;
2859 __u32 lunid = 0;
2860 int block_size;
2861 int total_size;
2862
2863 ld_buff = kmalloc(sizeof(ReportLunData_struct), GFP_KERNEL);
2864 if (ld_buff == NULL)
2865 {
2866 printk(KERN_ERR "cciss: out of memory\n");
2867 return;
2868 }
2869 memset(ld_buff, 0, sizeof(ReportLunData_struct));
2870 size_buff = kmalloc(sizeof( ReadCapdata_struct), GFP_KERNEL);
2871 if (size_buff == NULL)
2872 {
2873 printk(KERN_ERR "cciss: out of memory\n");
2874 kfree(ld_buff);
2875 return;
2876 }
2877 inq_buff = kmalloc(sizeof( InquiryData_struct), GFP_KERNEL);
2878 if (inq_buff == NULL)
2879 {
2880 printk(KERN_ERR "cciss: out of memory\n");
2881 kfree(ld_buff);
2882 kfree(size_buff);
2883 return;
2884 }
2885 /* Get the firmware version */
2886 return_code = sendcmd(CISS_INQUIRY, cntl_num, inq_buff,
2887 sizeof(InquiryData_struct), 0, 0 ,0, NULL, TYPE_CMD);
2888 if (return_code == IO_OK)
2889 {
2890 hba[cntl_num]->firm_ver[0] = inq_buff->data_byte[32];
2891 hba[cntl_num]->firm_ver[1] = inq_buff->data_byte[33];
2892 hba[cntl_num]->firm_ver[2] = inq_buff->data_byte[34];
2893 hba[cntl_num]->firm_ver[3] = inq_buff->data_byte[35];
2894 } else /* send command failed */
2895 {
2896 printk(KERN_WARNING "cciss: unable to determine firmware"
2897 " version of controller\n");
2898 }
2899 /* Get the number of logical volumes */
2900 return_code = sendcmd(CISS_REPORT_LOG, cntl_num, ld_buff,
2901 sizeof(ReportLunData_struct), 0, 0, 0, NULL, TYPE_CMD);
2902
2903 if( return_code == IO_OK)
2904 {
2905 #ifdef CCISS_DEBUG
2906 printk("LUN Data\n--------------------------\n");
2907 #endif /* CCISS_DEBUG */
2908
2909 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[0])) << 24;
2910 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[1])) << 16;
2911 listlength |= (0xff & (unsigned int)(ld_buff->LUNListLength[2])) << 8;
2912 listlength |= 0xff & (unsigned int)(ld_buff->LUNListLength[3]);
2913 } else /* reading number of logical volumes failed */
2914 {
2915 printk(KERN_WARNING "cciss: report logical volume"
2916 " command failed\n");
2917 listlength = 0;
2918 }
2919 hba[cntl_num]->num_luns = listlength / 8; // 8 bytes pre entry
2920 if (hba[cntl_num]->num_luns > CISS_MAX_LUN)
2921 {
2922 printk(KERN_ERR "ciss: only %d number of logical volumes supported\n",
2923 CISS_MAX_LUN);
2924 hba[cntl_num]->num_luns = CISS_MAX_LUN;
2925 }
2926 #ifdef CCISS_DEBUG
2927 printk(KERN_DEBUG "Length = %x %x %x %x = %d\n", ld_buff->LUNListLength[0],
2928 ld_buff->LUNListLength[1], ld_buff->LUNListLength[2],
2929 ld_buff->LUNListLength[3], hba[cntl_num]->num_luns);
2930 #endif /* CCISS_DEBUG */
2931
2932 hba[cntl_num]->highest_lun = hba[cntl_num]->num_luns-1;
2933 // for(i=0; i< hba[cntl_num]->num_luns; i++)
2934 for(i=0; i < CISS_MAX_LUN; i++)
2935 {
2936 if (i < hba[cntl_num]->num_luns){
2937 lunid = (0xff & (unsigned int)(ld_buff->LUN[i][3]))
2938 << 24;
2939 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][2]))
2940 << 16;
2941 lunid |= (0xff & (unsigned int)(ld_buff->LUN[i][1]))
2942 << 8;
2943 lunid |= 0xff & (unsigned int)(ld_buff->LUN[i][0]);
2944
2945 hba[cntl_num]->drv[i].LunID = lunid;
2946
2947
2948 #ifdef CCISS_DEBUG
2949 printk(KERN_DEBUG "LUN[%d]: %x %x %x %x = %x\n", i,
2950 ld_buff->LUN[i][0], ld_buff->LUN[i][1],
2951 ld_buff->LUN[i][2], ld_buff->LUN[i][3],
2952 hba[cntl_num]->drv[i].LunID);
2953 #endif /* CCISS_DEBUG */
2954 cciss_read_capacity(cntl_num, i, size_buff, 0,
2955 &total_size, &block_size);
2956 cciss_geometry_inquiry(cntl_num, i, 0, total_size,
2957 block_size, inq_buff, &hba[cntl_num]->drv[i]);
2958 } else {
2959 /* initialize raid_level to indicate a free space */
2960 hba[cntl_num]->drv[i].raid_level = -1;
2961 }
2962 }
2963 kfree(ld_buff);
2964 kfree(size_buff);
2965 kfree(inq_buff);
2966 }
2967
2968 /* Function to find the first free pointer into our hba[] array */
2969 /* Returns -1 if no free entries are left. */
2970 static int alloc_cciss_hba(void)
2971 {
2972 struct gendisk *disk[NWD];
2973 int i, n;
2974 for (n = 0; n < NWD; n++) {
2975 disk[n] = alloc_disk(1 << NWD_SHIFT);
2976 if (!disk[n])
2977 goto out;
2978 }
2979
2980 for(i=0; i< MAX_CTLR; i++) {
2981 if (!hba[i]) {
2982 ctlr_info_t *p;
2983 p = kmalloc(sizeof(ctlr_info_t), GFP_KERNEL);
2984 if (!p)
2985 goto Enomem;
2986 memset(p, 0, sizeof(ctlr_info_t));
2987 for (n = 0; n < NWD; n++)
2988 p->gendisk[n] = disk[n];
2989 hba[i] = p;
2990 return i;
2991 }
2992 }
2993 printk(KERN_WARNING "cciss: This driver supports a maximum"
2994 " of %d controllers.\n", MAX_CTLR);
2995 goto out;
2996 Enomem:
2997 printk(KERN_ERR "cciss: out of memory.\n");
2998 out:
2999 while (n--)
3000 put_disk(disk[n]);
3001 return -1;
3002 }
3003
3004 static void free_hba(int i)
3005 {
3006 ctlr_info_t *p = hba[i];
3007 int n;
3008
3009 hba[i] = NULL;
3010 for (n = 0; n < NWD; n++)
3011 put_disk(p->gendisk[n]);
3012 kfree(p);
3013 }
3014
3015 /*
3016 * This is it. Find all the controllers and register them. I really hate
3017 * stealing all these major device numbers.
3018 * returns the number of block devices registered.
3019 */
3020 static int __devinit cciss_init_one(struct pci_dev *pdev,
3021 const struct pci_device_id *ent)
3022 {
3023 request_queue_t *q;
3024 int i;
3025 int j;
3026 int rc;
3027
3028 printk(KERN_DEBUG "cciss: Device 0x%x has been found at"
3029 " bus %d dev %d func %d\n",
3030 pdev->device, pdev->bus->number, PCI_SLOT(pdev->devfn),
3031 PCI_FUNC(pdev->devfn));
3032 i = alloc_cciss_hba();
3033 if(i < 0)
3034 return (-1);
3035
3036 hba[i]->busy_initializing = 1;
3037
3038 if (cciss_pci_init(hba[i], pdev) != 0)
3039 goto clean1;
3040
3041 sprintf(hba[i]->devname, "cciss%d", i);
3042 hba[i]->ctlr = i;
3043 hba[i]->pdev = pdev;
3044
3045 /* configure PCI DMA stuff */
3046 if (!pci_set_dma_mask(pdev, DMA_64BIT_MASK))
3047 printk("cciss: using DAC cycles\n");
3048 else if (!pci_set_dma_mask(pdev, DMA_32BIT_MASK))
3049 printk("cciss: not using DAC cycles\n");
3050 else {
3051 printk("cciss: no suitable DMA available\n");
3052 goto clean1;
3053 }
3054
3055 /*
3056 * register with the major number, or get a dynamic major number
3057 * by passing 0 as argument. This is done for greater than
3058 * 8 controller support.
3059 */
3060 if (i < MAX_CTLR_ORIG)
3061 hba[i]->major = MAJOR_NR + i;
3062 rc = register_blkdev(hba[i]->major, hba[i]->devname);
3063 if(rc == -EBUSY || rc == -EINVAL) {
3064 printk(KERN_ERR
3065 "cciss: Unable to get major number %d for %s "
3066 "on hba %d\n", hba[i]->major, hba[i]->devname, i);
3067 goto clean1;
3068 }
3069 else {
3070 if (i >= MAX_CTLR_ORIG)
3071 hba[i]->major = rc;
3072 }
3073
3074 /* make sure the board interrupts are off */
3075 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_OFF);
3076 if( request_irq(hba[i]->intr, do_cciss_intr,
3077 SA_INTERRUPT | SA_SHIRQ | SA_SAMPLE_RANDOM,
3078 hba[i]->devname, hba[i])) {
3079 printk(KERN_ERR "cciss: Unable to get irq %d for %s\n",
3080 hba[i]->intr, hba[i]->devname);
3081 goto clean2;
3082 }
3083 hba[i]->cmd_pool_bits = kmalloc(((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long), GFP_KERNEL);
3084 hba[i]->cmd_pool = (CommandList_struct *)pci_alloc_consistent(
3085 hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3086 &(hba[i]->cmd_pool_dhandle));
3087 hba[i]->errinfo_pool = (ErrorInfo_struct *)pci_alloc_consistent(
3088 hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3089 &(hba[i]->errinfo_pool_dhandle));
3090 if((hba[i]->cmd_pool_bits == NULL)
3091 || (hba[i]->cmd_pool == NULL)
3092 || (hba[i]->errinfo_pool == NULL)) {
3093 printk( KERN_ERR "cciss: out of memory");
3094 goto clean4;
3095 }
3096 #ifdef CONFIG_CISS_SCSI_TAPE
3097 hba[i]->scsi_rejects.complete =
3098 kmalloc(sizeof(hba[i]->scsi_rejects.complete[0]) *
3099 (NR_CMDS + 5), GFP_KERNEL);
3100 if (hba[i]->scsi_rejects.complete == NULL) {
3101 printk( KERN_ERR "cciss: out of memory");
3102 goto clean4;
3103 }
3104 #endif
3105 spin_lock_init(&hba[i]->lock);
3106
3107 /* Initialize the pdev driver private data.
3108 have it point to hba[i]. */
3109 pci_set_drvdata(pdev, hba[i]);
3110 /* command and error info recs zeroed out before
3111 they are used */
3112 memset(hba[i]->cmd_pool_bits, 0, ((NR_CMDS+BITS_PER_LONG-1)/BITS_PER_LONG)*sizeof(unsigned long));
3113
3114 #ifdef CCISS_DEBUG
3115 printk(KERN_DEBUG "Scanning for drives on controller cciss%d\n",i);
3116 #endif /* CCISS_DEBUG */
3117
3118 cciss_getgeometry(i);
3119
3120 cciss_scsi_setup(i);
3121
3122 /* Turn the interrupts on so we can service requests */
3123 hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
3124
3125 cciss_procinit(i);
3126 hba[i]->busy_initializing = 0;
3127
3128 for(j=0; j < NWD; j++) { /* mfm */
3129 drive_info_struct *drv = &(hba[i]->drv[j]);
3130 struct gendisk *disk = hba[i]->gendisk[j];
3131
3132 q = blk_init_queue(do_cciss_request, &hba[i]->lock);
3133 if (!q) {
3134 printk(KERN_ERR
3135 "cciss: unable to allocate queue for disk %d\n",
3136 j);
3137 break;
3138 }
3139 drv->queue = q;
3140
3141 q->backing_dev_info.ra_pages = READ_AHEAD;
3142 blk_queue_bounce_limit(q, hba[i]->pdev->dma_mask);
3143
3144 /* This is a hardware imposed limit. */
3145 blk_queue_max_hw_segments(q, MAXSGENTRIES);
3146
3147 /* This is a limit in the driver and could be eliminated. */
3148 blk_queue_max_phys_segments(q, MAXSGENTRIES);
3149
3150 blk_queue_max_sectors(q, 512);
3151
3152 q->queuedata = hba[i];
3153 sprintf(disk->disk_name, "cciss/c%dd%d", i, j);
3154 sprintf(disk->devfs_name, "cciss/host%d/target%d", i, j);
3155 disk->major = hba[i]->major;
3156 disk->first_minor = j << NWD_SHIFT;
3157 disk->fops = &cciss_fops;
3158 disk->queue = q;
3159 disk->private_data = drv;
3160 /* we must register the controller even if no disks exist */
3161 /* this is for the online array utilities */
3162 if(!drv->heads && j)
3163 continue;
3164 blk_queue_hardsect_size(q, drv->block_size);
3165 set_capacity(disk, drv->nr_blocks);
3166 add_disk(disk);
3167 }
3168
3169 return(1);
3170
3171 clean4:
3172 #ifdef CONFIG_CISS_SCSI_TAPE
3173 if(hba[i]->scsi_rejects.complete)
3174 kfree(hba[i]->scsi_rejects.complete);
3175 #endif
3176 kfree(hba[i]->cmd_pool_bits);
3177 if(hba[i]->cmd_pool)
3178 pci_free_consistent(hba[i]->pdev,
3179 NR_CMDS * sizeof(CommandList_struct),
3180 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3181 if(hba[i]->errinfo_pool)
3182 pci_free_consistent(hba[i]->pdev,
3183 NR_CMDS * sizeof( ErrorInfo_struct),
3184 hba[i]->errinfo_pool,
3185 hba[i]->errinfo_pool_dhandle);
3186 free_irq(hba[i]->intr, hba[i]);
3187 clean2:
3188 unregister_blkdev(hba[i]->major, hba[i]->devname);
3189 clean1:
3190 release_io_mem(hba[i]);
3191 free_hba(i);
3192 hba[i]->busy_initializing = 0;
3193 return(-1);
3194 }
3195
3196 static void __devexit cciss_remove_one (struct pci_dev *pdev)
3197 {
3198 ctlr_info_t *tmp_ptr;
3199 int i, j;
3200 char flush_buf[4];
3201 int return_code;
3202
3203 if (pci_get_drvdata(pdev) == NULL)
3204 {
3205 printk( KERN_ERR "cciss: Unable to remove device \n");
3206 return;
3207 }
3208 tmp_ptr = pci_get_drvdata(pdev);
3209 i = tmp_ptr->ctlr;
3210 if (hba[i] == NULL)
3211 {
3212 printk(KERN_ERR "cciss: device appears to "
3213 "already be removed \n");
3214 return;
3215 }
3216 /* Turn board interrupts off and send the flush cache command */
3217 /* sendcmd will turn off interrupt, and send the flush...
3218 * To write all data in the battery backed cache to disks */
3219 memset(flush_buf, 0, 4);
3220 return_code = sendcmd(CCISS_CACHE_FLUSH, i, flush_buf, 4, 0, 0, 0, NULL,
3221 TYPE_CMD);
3222 if(return_code != IO_OK)
3223 {
3224 printk(KERN_WARNING "Error Flushing cache on controller %d\n",
3225 i);
3226 }
3227 free_irq(hba[i]->intr, hba[i]);
3228 pci_set_drvdata(pdev, NULL);
3229 iounmap(hba[i]->vaddr);
3230 cciss_unregister_scsi(i); /* unhook from SCSI subsystem */
3231 unregister_blkdev(hba[i]->major, hba[i]->devname);
3232 remove_proc_entry(hba[i]->devname, proc_cciss);
3233
3234 /* remove it from the disk list */
3235 for (j = 0; j < NWD; j++) {
3236 struct gendisk *disk = hba[i]->gendisk[j];
3237 if (disk) {
3238 request_queue_t *q = disk->queue;
3239
3240 if (disk->flags & GENHD_FL_UP)
3241 del_gendisk(disk);
3242 if (q)
3243 blk_cleanup_queue(q);
3244 }
3245 }
3246
3247 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof(CommandList_struct),
3248 hba[i]->cmd_pool, hba[i]->cmd_pool_dhandle);
3249 pci_free_consistent(hba[i]->pdev, NR_CMDS * sizeof( ErrorInfo_struct),
3250 hba[i]->errinfo_pool, hba[i]->errinfo_pool_dhandle);
3251 kfree(hba[i]->cmd_pool_bits);
3252 #ifdef CONFIG_CISS_SCSI_TAPE
3253 kfree(hba[i]->scsi_rejects.complete);
3254 #endif
3255 release_io_mem(hba[i]);
3256 free_hba(i);
3257 }
3258
3259 static struct pci_driver cciss_pci_driver = {
3260 .name = "cciss",
3261 .probe = cciss_init_one,
3262 .remove = __devexit_p(cciss_remove_one),
3263 .id_table = cciss_pci_device_id, /* id_table */
3264 };
3265
3266 /*
3267 * This is it. Register the PCI driver information for the cards we control
3268 * the OS will call our registered routines when it finds one of our cards.
3269 */
3270 static int __init cciss_init(void)
3271 {
3272 printk(KERN_INFO DRIVER_NAME "\n");
3273
3274 /* Register for our PCI devices */
3275 return pci_module_init(&cciss_pci_driver);
3276 }
3277
3278 static void __exit cciss_cleanup(void)
3279 {
3280 int i;
3281
3282 pci_unregister_driver(&cciss_pci_driver);
3283 /* double check that all controller entrys have been removed */
3284 for (i=0; i< MAX_CTLR; i++)
3285 {
3286 if (hba[i] != NULL)
3287 {
3288 printk(KERN_WARNING "cciss: had to remove"
3289 " controller %d\n", i);
3290 cciss_remove_one(hba[i]->pdev);
3291 }
3292 }
3293 remove_proc_entry("cciss", proc_root_driver);
3294 }
3295
3296 static void fail_all_cmds(unsigned long ctlr)
3297 {
3298 /* If we get here, the board is apparently dead. */
3299 ctlr_info_t *h = hba[ctlr];
3300 CommandList_struct *c;
3301 unsigned long flags;
3302
3303 printk(KERN_WARNING "cciss%d: controller not responding.\n", h->ctlr);
3304 h->alive = 0; /* the controller apparently died... */
3305
3306 spin_lock_irqsave(CCISS_LOCK(ctlr), flags);
3307
3308 pci_disable_device(h->pdev); /* Make sure it is really dead. */
3309
3310 /* move everything off the request queue onto the completed queue */
3311 while( (c = h->reqQ) != NULL ) {
3312 removeQ(&(h->reqQ), c);
3313 h->Qdepth--;
3314 addQ (&(h->cmpQ), c);
3315 }
3316
3317 /* Now, fail everything on the completed queue with a HW error */
3318 while( (c = h->cmpQ) != NULL ) {
3319 removeQ(&h->cmpQ, c);
3320 c->err_info->CommandStatus = CMD_HARDWARE_ERR;
3321 if (c->cmd_type == CMD_RWREQ) {
3322 complete_command(h, c, 0);
3323 } else if (c->cmd_type == CMD_IOCTL_PEND)
3324 complete(c->waiting);
3325 #ifdef CONFIG_CISS_SCSI_TAPE
3326 else if (c->cmd_type == CMD_SCSI)
3327 complete_scsi_command(c, 0, 0);
3328 #endif
3329 }
3330 spin_unlock_irqrestore(CCISS_LOCK(ctlr), flags);
3331 return;
3332 }
3333
3334 module_init(cciss_init);
3335 module_exit(cciss_cleanup);
kernel source for telekom puls (alcatel/mediatek)