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