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