?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Driver core: convert sound core to use struct device
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / scsi / megaraid.c
blob86099fde1b2a6bc13866835757861e74d1b41d07
1 /*
2 *
3 * Linux MegaRAID device driver
4 *
5 * Copyright (c) 2002 LSI Logic Corporation.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * Copyright (c) 2002 Red Hat, Inc. All rights reserved.
13 * - fixes
14 * - speed-ups (list handling fixes, issued_list, optimizations.)
15 * - lots of cleanups.
16 *
17 * Copyright (c) 2003 Christoph Hellwig <hch@lst.de>
18 * - new-style, hotplug-aware pci probing and scsi registration
19 *
20 * Version : v2.00.4 Mon Nov 14 14:02:43 EST 2005 - Seokmann Ju
21 * <Seokmann.Ju@lsil.com>
22 *
23 * Description: Linux device driver for LSI Logic MegaRAID controller
24 *
25 * Supported controllers: MegaRAID 418, 428, 438, 466, 762, 467, 471, 490, 493
26 * 518, 520, 531, 532
27 *
28 * This driver is supported by LSI Logic, with assistance from Red Hat, Dell,
29 * and others. Please send updates to the mailing list
30 * linux-scsi@vger.kernel.org .
31 *
32 */
33
34 #include <linux/mm.h>
35 #include <linux/fs.h>
36 #include <linux/blkdev.h>
37 #include <asm/uaccess.h>
38 #include <asm/io.h>
39 #include <linux/completion.h>
40 #include <linux/delay.h>
41 #include <linux/proc_fs.h>
42 #include <linux/reboot.h>
43 #include <linux/module.h>
44 #include <linux/list.h>
45 #include <linux/interrupt.h>
46 #include <linux/pci.h>
47 #include <linux/init.h>
48 #include <linux/dma-mapping.h>
49 #include <scsi/scsicam.h>
50
51 #include "scsi.h"
52 #include <scsi/scsi_host.h>
53
54 #include "megaraid.h"
55
56 #define MEGARAID_MODULE_VERSION "2.00.4"
57
58 MODULE_AUTHOR ("sju@lsil.com");
59 MODULE_DESCRIPTION ("LSI Logic MegaRAID legacy driver");
60 MODULE_LICENSE ("GPL");
61 MODULE_VERSION(MEGARAID_MODULE_VERSION);
62
63 static unsigned int max_cmd_per_lun = DEF_CMD_PER_LUN;
64 module_param(max_cmd_per_lun, uint, 0);
65 MODULE_PARM_DESC(max_cmd_per_lun, "Maximum number of commands which can be issued to a single LUN (default=DEF_CMD_PER_LUN=63)");
66
67 static unsigned short int max_sectors_per_io = MAX_SECTORS_PER_IO;
68 module_param(max_sectors_per_io, ushort, 0);
69 MODULE_PARM_DESC(max_sectors_per_io, "Maximum number of sectors per I/O request (default=MAX_SECTORS_PER_IO=128)");
70
71
72 static unsigned short int max_mbox_busy_wait = MBOX_BUSY_WAIT;
73 module_param(max_mbox_busy_wait, ushort, 0);
74 MODULE_PARM_DESC(max_mbox_busy_wait, "Maximum wait for mailbox in microseconds if busy (default=MBOX_BUSY_WAIT=10)");
75
76 #define RDINDOOR(adapter) readl((adapter)->base + 0x20)
77 #define RDOUTDOOR(adapter) readl((adapter)->base + 0x2C)
78 #define WRINDOOR(adapter,value) writel(value, (adapter)->base + 0x20)
79 #define WROUTDOOR(adapter,value) writel(value, (adapter)->base + 0x2C)
80
81 /*
82 * Global variables
83 */
84
85 static int hba_count;
86 static adapter_t *hba_soft_state[MAX_CONTROLLERS];
87 static struct proc_dir_entry *mega_proc_dir_entry;
88
89 /* For controller re-ordering */
90 static struct mega_hbas mega_hbas[MAX_CONTROLLERS];
91
92 /*
93 * The File Operations structure for the serial/ioctl interface of the driver
94 */
95 static struct file_operations megadev_fops = {
96 .owner = THIS_MODULE,
97 .ioctl = megadev_ioctl,
98 .open = megadev_open,
99 };
100
101 /*
102 * Array to structures for storing the information about the controllers. This
103 * information is sent to the user level applications, when they do an ioctl
104 * for this information.
105 */
106 static struct mcontroller mcontroller[MAX_CONTROLLERS];
107
108 /* The current driver version */
109 static u32 driver_ver = 0x02000000;
110
111 /* major number used by the device for character interface */
112 static int major;
113
114 #define IS_RAID_CH(hba, ch) (((hba)->mega_ch_class >> (ch)) & 0x01)
115
116
117 /*
118 * Debug variable to print some diagnostic messages
119 */
120 static int trace_level;
121
122 /**
123 * mega_setup_mailbox()
124 * @adapter - pointer to our soft state
125 *
126 * Allocates a 8 byte aligned memory for the handshake mailbox.
127 */
128 static int
129 mega_setup_mailbox(adapter_t *adapter)
130 {
131 unsigned long align;
132
133 adapter->una_mbox64 = pci_alloc_consistent(adapter->dev,
134 sizeof(mbox64_t), &adapter->una_mbox64_dma);
135
136 if( !adapter->una_mbox64 ) return -1;
137
138 adapter->mbox = &adapter->una_mbox64->mbox;
139
140 adapter->mbox = (mbox_t *)((((unsigned long) adapter->mbox) + 15) &
141 (~0UL ^ 0xFUL));
142
143 adapter->mbox64 = (mbox64_t *)(((unsigned long)adapter->mbox) - 8);
144
145 align = ((void *)adapter->mbox) - ((void *)&adapter->una_mbox64->mbox);
146
147 adapter->mbox_dma = adapter->una_mbox64_dma + 8 + align;
148
149 /*
150 * Register the mailbox if the controller is an io-mapped controller
151 */
152 if( adapter->flag & BOARD_IOMAP ) {
153
154 outb_p(adapter->mbox_dma & 0xFF,
155 adapter->host->io_port + MBOX_PORT0);
156
157 outb_p((adapter->mbox_dma >> 8) & 0xFF,
158 adapter->host->io_port + MBOX_PORT1);
159
160 outb_p((adapter->mbox_dma >> 16) & 0xFF,
161 adapter->host->io_port + MBOX_PORT2);
162
163 outb_p((adapter->mbox_dma >> 24) & 0xFF,
164 adapter->host->io_port + MBOX_PORT3);
165
166 outb_p(ENABLE_MBOX_BYTE,
167 adapter->host->io_port + ENABLE_MBOX_REGION);
168
169 irq_ack(adapter);
170
171 irq_enable(adapter);
172 }
173
174 return 0;
175 }
176
177
178 /*
179 * mega_query_adapter()
180 * @adapter - pointer to our soft state
181 *
182 * Issue the adapter inquiry commands to the controller and find out
183 * information and parameter about the devices attached
184 */
185 static int
186 mega_query_adapter(adapter_t *adapter)
187 {
188 dma_addr_t prod_info_dma_handle;
189 mega_inquiry3 *inquiry3;
190 u8 raw_mbox[sizeof(struct mbox_out)];
191 mbox_t *mbox;
192 int retval;
193
194 /* Initialize adapter inquiry mailbox */
195
196 mbox = (mbox_t *)raw_mbox;
197
198 memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
199 memset(&mbox->m_out, 0, sizeof(raw_mbox));
200
201 /*
202 * Try to issue Inquiry3 command
203 * if not succeeded, then issue MEGA_MBOXCMD_ADAPTERINQ command and
204 * update enquiry3 structure
205 */
206 mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle;
207
208 inquiry3 = (mega_inquiry3 *)adapter->mega_buffer;
209
210 raw_mbox[0] = FC_NEW_CONFIG; /* i.e. mbox->cmd=0xA1 */
211 raw_mbox[2] = NC_SUBOP_ENQUIRY3; /* i.e. 0x0F */
212 raw_mbox[3] = ENQ3_GET_SOLICITED_FULL; /* i.e. 0x02 */
213
214 /* Issue a blocking command to the card */
215 if ((retval = issue_scb_block(adapter, raw_mbox))) {
216 /* the adapter does not support 40ld */
217
218 mraid_ext_inquiry *ext_inq;
219 mraid_inquiry *inq;
220 dma_addr_t dma_handle;
221
222 ext_inq = pci_alloc_consistent(adapter->dev,
223 sizeof(mraid_ext_inquiry), &dma_handle);
224
225 if( ext_inq == NULL ) return -1;
226
227 inq = &ext_inq->raid_inq;
228
229 mbox->m_out.xferaddr = (u32)dma_handle;
230
231 /*issue old 0x04 command to adapter */
232 mbox->m_out.cmd = MEGA_MBOXCMD_ADPEXTINQ;
233
234 issue_scb_block(adapter, raw_mbox);
235
236 /*
237 * update Enquiry3 and ProductInfo structures with
238 * mraid_inquiry structure
239 */
240 mega_8_to_40ld(inq, inquiry3,
241 (mega_product_info *)&adapter->product_info);
242
243 pci_free_consistent(adapter->dev, sizeof(mraid_ext_inquiry),
244 ext_inq, dma_handle);
245
246 } else { /*adapter supports 40ld */
247 adapter->flag |= BOARD_40LD;
248
249 /*
250 * get product_info, which is static information and will be
251 * unchanged
252 */
253 prod_info_dma_handle = pci_map_single(adapter->dev, (void *)
254 &adapter->product_info,
255 sizeof(mega_product_info), PCI_DMA_FROMDEVICE);
256
257 mbox->m_out.xferaddr = prod_info_dma_handle;
258
259 raw_mbox[0] = FC_NEW_CONFIG; /* i.e. mbox->cmd=0xA1 */
260 raw_mbox[2] = NC_SUBOP_PRODUCT_INFO; /* i.e. 0x0E */
261
262 if ((retval = issue_scb_block(adapter, raw_mbox)))
263 printk(KERN_WARNING
264 "megaraid: Product_info cmd failed with error: %d\n",
265 retval);
266
267 pci_unmap_single(adapter->dev, prod_info_dma_handle,
268 sizeof(mega_product_info), PCI_DMA_FROMDEVICE);
269 }
270
271
272 /*
273 * kernel scans the channels from 0 to <= max_channel
274 */
275 adapter->host->max_channel =
276 adapter->product_info.nchannels + NVIRT_CHAN -1;
277
278 adapter->host->max_id = 16; /* max targets per channel */
279
280 adapter->host->max_lun = 7; /* Upto 7 luns for non disk devices */
281
282 adapter->host->cmd_per_lun = max_cmd_per_lun;
283
284 adapter->numldrv = inquiry3->num_ldrv;
285
286 adapter->max_cmds = adapter->product_info.max_commands;
287
288 if(adapter->max_cmds > MAX_COMMANDS)
289 adapter->max_cmds = MAX_COMMANDS;
290
291 adapter->host->can_queue = adapter->max_cmds - 1;
292
293 /*
294 * Get the maximum number of scatter-gather elements supported by this
295 * firmware
296 */
297 mega_get_max_sgl(adapter);
298
299 adapter->host->sg_tablesize = adapter->sglen;
300
301
302 /* use HP firmware and bios version encoding */
303 if (adapter->product_info.subsysvid == HP_SUBSYS_VID) {
304 sprintf (adapter->fw_version, "%c%d%d.%d%d",
305 adapter->product_info.fw_version[2],
306 adapter->product_info.fw_version[1] >> 8,
307 adapter->product_info.fw_version[1] & 0x0f,
308 adapter->product_info.fw_version[0] >> 8,
309 adapter->product_info.fw_version[0] & 0x0f);
310 sprintf (adapter->bios_version, "%c%d%d.%d%d",
311 adapter->product_info.bios_version[2],
312 adapter->product_info.bios_version[1] >> 8,
313 adapter->product_info.bios_version[1] & 0x0f,
314 adapter->product_info.bios_version[0] >> 8,
315 adapter->product_info.bios_version[0] & 0x0f);
316 } else {
317 memcpy(adapter->fw_version,
318 (char *)adapter->product_info.fw_version, 4);
319 adapter->fw_version[4] = 0;
320
321 memcpy(adapter->bios_version,
322 (char *)adapter->product_info.bios_version, 4);
323
324 adapter->bios_version[4] = 0;
325 }
326
327 printk(KERN_NOTICE "megaraid: [%s:%s] detected %d logical drives.\n",
328 adapter->fw_version, adapter->bios_version, adapter->numldrv);
329
330 /*
331 * Do we support extended (>10 bytes) cdbs
332 */
333 adapter->support_ext_cdb = mega_support_ext_cdb(adapter);
334 if (adapter->support_ext_cdb)
335 printk(KERN_NOTICE "megaraid: supports extended CDBs.\n");
336
337
338 return 0;
339 }
340
341 /**
342 * mega_runpendq()
343 * @adapter - pointer to our soft state
344 *
345 * Runs through the list of pending requests.
346 */
347 static inline void
348 mega_runpendq(adapter_t *adapter)
349 {
350 if(!list_empty(&adapter->pending_list))
351 __mega_runpendq(adapter);
352 }
353
354 /*
355 * megaraid_queue()
356 * @scmd - Issue this scsi command
357 * @done - the callback hook into the scsi mid-layer
358 *
359 * The command queuing entry point for the mid-layer.
360 */
361 static int
362 megaraid_queue(Scsi_Cmnd *scmd, void (*done)(Scsi_Cmnd *))
363 {
364 adapter_t *adapter;
365 scb_t *scb;
366 int busy=0;
367 unsigned long flags;
368
369 adapter = (adapter_t *)scmd->device->host->hostdata;
370
371 scmd->scsi_done = done;
372
373
374 /*
375 * Allocate and build a SCB request
376 * busy flag will be set if mega_build_cmd() command could not
377 * allocate scb. We will return non-zero status in that case.
378 * NOTE: scb can be null even though certain commands completed
379 * successfully, e.g., MODE_SENSE and TEST_UNIT_READY, we would
380 * return 0 in that case.
381 */
382
383 spin_lock_irqsave(&adapter->lock, flags);
384 scb = mega_build_cmd(adapter, scmd, &busy);
385 if (!scb)
386 goto out;
387
388 scb->state |= SCB_PENDQ;
389 list_add_tail(&scb->list, &adapter->pending_list);
390
391 /*
392 * Check if the HBA is in quiescent state, e.g., during a
393 * delete logical drive opertion. If it is, don't run
394 * the pending_list.
395 */
396 if (atomic_read(&adapter->quiescent) == 0)
397 mega_runpendq(adapter);
398
399 busy = 0;
400 out:
401 spin_unlock_irqrestore(&adapter->lock, flags);
402 return busy;
403 }
404
405 /**
406 * mega_allocate_scb()
407 * @adapter - pointer to our soft state
408 * @cmd - scsi command from the mid-layer
409 *
410 * Allocate a SCB structure. This is the central structure for controller
411 * commands.
412 */
413 static inline scb_t *
414 mega_allocate_scb(adapter_t *adapter, Scsi_Cmnd *cmd)
415 {
416 struct list_head *head = &adapter->free_list;
417 scb_t *scb;
418
419 /* Unlink command from Free List */
420 if( !list_empty(head) ) {
421
422 scb = list_entry(head->next, scb_t, list);
423
424 list_del_init(head->next);
425
426 scb->state = SCB_ACTIVE;
427 scb->cmd = cmd;
428 scb->dma_type = MEGA_DMA_TYPE_NONE;
429
430 return scb;
431 }
432
433 return NULL;
434 }
435
436 /**
437 * mega_get_ldrv_num()
438 * @adapter - pointer to our soft state
439 * @cmd - scsi mid layer command
440 * @channel - channel on the controller
441 *
442 * Calculate the logical drive number based on the information in scsi command
443 * and the channel number.
444 */
445 static inline int
446 mega_get_ldrv_num(adapter_t *adapter, Scsi_Cmnd *cmd, int channel)
447 {
448 int tgt;
449 int ldrv_num;
450
451 tgt = cmd->device->id;
452
453 if ( tgt > adapter->this_id )
454 tgt--; /* we do not get inquires for initiator id */
455
456 ldrv_num = (channel * 15) + tgt;
457
458
459 /*
460 * If we have a logical drive with boot enabled, project it first
461 */
462 if( adapter->boot_ldrv_enabled ) {
463 if( ldrv_num == 0 ) {
464 ldrv_num = adapter->boot_ldrv;
465 }
466 else {
467 if( ldrv_num <= adapter->boot_ldrv ) {
468 ldrv_num--;
469 }
470 }
471 }
472
473 /*
474 * If "delete logical drive" feature is enabled on this controller.
475 * Do only if at least one delete logical drive operation was done.
476 *
477 * Also, after logical drive deletion, instead of logical drive number,
478 * the value returned should be 0x80+logical drive id.
479 *
480 * These is valid only for IO commands.
481 */
482
483 if (adapter->support_random_del && adapter->read_ldidmap )
484 switch (cmd->cmnd[0]) {
485 case READ_6: /* fall through */
486 case WRITE_6: /* fall through */
487 case READ_10: /* fall through */
488 case WRITE_10:
489 ldrv_num += 0x80;
490 }
491
492 return ldrv_num;
493 }
494
495 /**
496 * mega_build_cmd()
497 * @adapter - pointer to our soft state
498 * @cmd - Prepare using this scsi command
499 * @busy - busy flag if no resources
500 *
501 * Prepares a command and scatter gather list for the controller. This routine
502 * also finds out if the commands is intended for a logical drive or a
503 * physical device and prepares the controller command accordingly.
504 *
505 * We also re-order the logical drives and physical devices based on their
506 * boot settings.
507 */
508 static scb_t *
509 mega_build_cmd(adapter_t *adapter, Scsi_Cmnd *cmd, int *busy)
510 {
511 mega_ext_passthru *epthru;
512 mega_passthru *pthru;
513 scb_t *scb;
514 mbox_t *mbox;
515 long seg;
516 char islogical;
517 int max_ldrv_num;
518 int channel = 0;
519 int target = 0;
520 int ldrv_num = 0; /* logical drive number */
521
522
523 /*
524 * filter the internal and ioctl commands
525 */
526 if((cmd->cmnd[0] == MEGA_INTERNAL_CMD)) {
527 return cmd->request_buffer;
528 }
529
530
531 /*
532 * We know what channels our logical drives are on - mega_find_card()
533 */
534 islogical = adapter->logdrv_chan[cmd->device->channel];
535
536 /*
537 * The theory: If physical drive is chosen for boot, all the physical
538 * devices are exported before the logical drives, otherwise physical
539 * devices are pushed after logical drives, in which case - Kernel sees
540 * the physical devices on virtual channel which is obviously converted
541 * to actual channel on the HBA.
542 */
543 if( adapter->boot_pdrv_enabled ) {
544 if( islogical ) {
545 /* logical channel */
546 channel = cmd->device->channel -
547 adapter->product_info.nchannels;
548 }
549 else {
550 /* this is physical channel */
551 channel = cmd->device->channel;
552 target = cmd->device->id;
553
554 /*
555 * boot from a physical disk, that disk needs to be
556 * exposed first IF both the channels are SCSI, then
557 * booting from the second channel is not allowed.
558 */
559 if( target == 0 ) {
560 target = adapter->boot_pdrv_tgt;
561 }
562 else if( target == adapter->boot_pdrv_tgt ) {
563 target = 0;
564 }
565 }
566 }
567 else {
568 if( islogical ) {
569 /* this is the logical channel */
570 channel = cmd->device->channel;
571 }
572 else {
573 /* physical channel */
574 channel = cmd->device->channel - NVIRT_CHAN;
575 target = cmd->device->id;
576 }
577 }
578
579
580 if(islogical) {
581
582 /* have just LUN 0 for each target on virtual channels */
583 if (cmd->device->lun) {
584 cmd->result = (DID_BAD_TARGET << 16);
585 cmd->scsi_done(cmd);
586 return NULL;
587 }
588
589 ldrv_num = mega_get_ldrv_num(adapter, cmd, channel);
590
591
592 max_ldrv_num = (adapter->flag & BOARD_40LD) ?
593 MAX_LOGICAL_DRIVES_40LD : MAX_LOGICAL_DRIVES_8LD;
594
595 /*
596 * max_ldrv_num increases by 0x80 if some logical drive was
597 * deleted.
598 */
599 if(adapter->read_ldidmap)
600 max_ldrv_num += 0x80;
601
602 if(ldrv_num > max_ldrv_num ) {
603 cmd->result = (DID_BAD_TARGET << 16);
604 cmd->scsi_done(cmd);
605 return NULL;
606 }
607
608 }
609 else {
610 if( cmd->device->lun > 7) {
611 /*
612 * Do not support lun >7 for physically accessed
613 * devices
614 */
615 cmd->result = (DID_BAD_TARGET << 16);
616 cmd->scsi_done(cmd);
617 return NULL;
618 }
619 }
620
621 /*
622 *
623 * Logical drive commands
624 *
625 */
626 if(islogical) {
627 switch (cmd->cmnd[0]) {
628 case TEST_UNIT_READY:
629 #if MEGA_HAVE_CLUSTERING
630 /*
631 * Do we support clustering and is the support enabled
632 * If no, return success always
633 */
634 if( !adapter->has_cluster ) {
635 cmd->result = (DID_OK << 16);
636 cmd->scsi_done(cmd);
637 return NULL;
638 }
639
640 if(!(scb = mega_allocate_scb(adapter, cmd))) {
641 *busy = 1;
642 return NULL;
643 }
644
645 scb->raw_mbox[0] = MEGA_CLUSTER_CMD;
646 scb->raw_mbox[2] = MEGA_RESERVATION_STATUS;
647 scb->raw_mbox[3] = ldrv_num;
648
649 scb->dma_direction = PCI_DMA_NONE;
650
651 return scb;
652 #else
653 cmd->result = (DID_OK << 16);
654 cmd->scsi_done(cmd);
655 return NULL;
656 #endif
657
658 case MODE_SENSE: {
659 char *buf;
660
661 if (cmd->use_sg) {
662 struct scatterlist *sg;
663
664 sg = (struct scatterlist *)cmd->request_buffer;
665 buf = kmap_atomic(sg->page, KM_IRQ0) +
666 sg->offset;
667 } else
668 buf = cmd->request_buffer;
669 memset(buf, 0, cmd->cmnd[4]);
670 if (cmd->use_sg) {
671 struct scatterlist *sg;
672
673 sg = (struct scatterlist *)cmd->request_buffer;
674 kunmap_atomic(buf - sg->offset, KM_IRQ0);
675 }
676 cmd->result = (DID_OK << 16);
677 cmd->scsi_done(cmd);
678 return NULL;
679 }
680
681 case READ_CAPACITY:
682 case INQUIRY:
683
684 if(!(adapter->flag & (1L << cmd->device->channel))) {
685
686 printk(KERN_NOTICE
687 "scsi%d: scanning scsi channel %d ",
688 adapter->host->host_no,
689 cmd->device->channel);
690 printk("for logical drives.\n");
691
692 adapter->flag |= (1L << cmd->device->channel);
693 }
694
695 /* Allocate a SCB and initialize passthru */
696 if(!(scb = mega_allocate_scb(adapter, cmd))) {
697 *busy = 1;
698 return NULL;
699 }
700 pthru = scb->pthru;
701
702 mbox = (mbox_t *)scb->raw_mbox;
703 memset(mbox, 0, sizeof(scb->raw_mbox));
704 memset(pthru, 0, sizeof(mega_passthru));
705
706 pthru->timeout = 0;
707 pthru->ars = 1;
708 pthru->reqsenselen = 14;
709 pthru->islogical = 1;
710 pthru->logdrv = ldrv_num;
711 pthru->cdblen = cmd->cmd_len;
712 memcpy(pthru->cdb, cmd->cmnd, cmd->cmd_len);
713
714 if( adapter->has_64bit_addr ) {
715 mbox->m_out.cmd = MEGA_MBOXCMD_PASSTHRU64;
716 }
717 else {
718 mbox->m_out.cmd = MEGA_MBOXCMD_PASSTHRU;
719 }
720
721 scb->dma_direction = PCI_DMA_FROMDEVICE;
722
723 pthru->numsgelements = mega_build_sglist(adapter, scb,
724 &pthru->dataxferaddr, &pthru->dataxferlen);
725
726 mbox->m_out.xferaddr = scb->pthru_dma_addr;
727
728 return scb;
729
730 case READ_6:
731 case WRITE_6:
732 case READ_10:
733 case WRITE_10:
734 case READ_12:
735 case WRITE_12:
736
737 /* Allocate a SCB and initialize mailbox */
738 if(!(scb = mega_allocate_scb(adapter, cmd))) {
739 *busy = 1;
740 return NULL;
741 }
742 mbox = (mbox_t *)scb->raw_mbox;
743
744 memset(mbox, 0, sizeof(scb->raw_mbox));
745 mbox->m_out.logdrv = ldrv_num;
746
747 /*
748 * A little hack: 2nd bit is zero for all scsi read
749 * commands and is set for all scsi write commands
750 */
751 if( adapter->has_64bit_addr ) {
752 mbox->m_out.cmd = (*cmd->cmnd & 0x02) ?
753 MEGA_MBOXCMD_LWRITE64:
754 MEGA_MBOXCMD_LREAD64 ;
755 }
756 else {
757 mbox->m_out.cmd = (*cmd->cmnd & 0x02) ?
758 MEGA_MBOXCMD_LWRITE:
759 MEGA_MBOXCMD_LREAD ;
760 }
761
762 /*
763 * 6-byte READ(0x08) or WRITE(0x0A) cdb
764 */
765 if( cmd->cmd_len == 6 ) {
766 mbox->m_out.numsectors = (u32) cmd->cmnd[4];
767 mbox->m_out.lba =
768 ((u32)cmd->cmnd[1] << 16) |
769 ((u32)cmd->cmnd[2] << 8) |
770 (u32)cmd->cmnd[3];
771
772 mbox->m_out.lba &= 0x1FFFFF;
773
774 #if MEGA_HAVE_STATS
775 /*
776 * Take modulo 0x80, since the logical drive
777 * number increases by 0x80 when a logical
778 * drive was deleted
779 */
780 if (*cmd->cmnd == READ_6) {
781 adapter->nreads[ldrv_num%0x80]++;
782 adapter->nreadblocks[ldrv_num%0x80] +=
783 mbox->m_out.numsectors;
784 } else {
785 adapter->nwrites[ldrv_num%0x80]++;
786 adapter->nwriteblocks[ldrv_num%0x80] +=
787 mbox->m_out.numsectors;
788 }
789 #endif
790 }
791
792 /*
793 * 10-byte READ(0x28) or WRITE(0x2A) cdb
794 */
795 if( cmd->cmd_len == 10 ) {
796 mbox->m_out.numsectors =
797 (u32)cmd->cmnd[8] |
798 ((u32)cmd->cmnd[7] << 8);
799 mbox->m_out.lba =
800 ((u32)cmd->cmnd[2] << 24) |
801 ((u32)cmd->cmnd[3] << 16) |
802 ((u32)cmd->cmnd[4] << 8) |
803 (u32)cmd->cmnd[5];
804
805 #if MEGA_HAVE_STATS
806 if (*cmd->cmnd == READ_10) {
807 adapter->nreads[ldrv_num%0x80]++;
808 adapter->nreadblocks[ldrv_num%0x80] +=
809 mbox->m_out.numsectors;
810 } else {
811 adapter->nwrites[ldrv_num%0x80]++;
812 adapter->nwriteblocks[ldrv_num%0x80] +=
813 mbox->m_out.numsectors;
814 }
815 #endif
816 }
817
818 /*
819 * 12-byte READ(0xA8) or WRITE(0xAA) cdb
820 */
821 if( cmd->cmd_len == 12 ) {
822 mbox->m_out.lba =
823 ((u32)cmd->cmnd[2] << 24) |
824 ((u32)cmd->cmnd[3] << 16) |
825 ((u32)cmd->cmnd[4] << 8) |
826 (u32)cmd->cmnd[5];
827
828 mbox->m_out.numsectors =
829 ((u32)cmd->cmnd[6] << 24) |
830 ((u32)cmd->cmnd[7] << 16) |
831 ((u32)cmd->cmnd[8] << 8) |
832 (u32)cmd->cmnd[9];
833
834 #if MEGA_HAVE_STATS
835 if (*cmd->cmnd == READ_12) {
836 adapter->nreads[ldrv_num%0x80]++;
837 adapter->nreadblocks[ldrv_num%0x80] +=
838 mbox->m_out.numsectors;
839 } else {
840 adapter->nwrites[ldrv_num%0x80]++;
841 adapter->nwriteblocks[ldrv_num%0x80] +=
842 mbox->m_out.numsectors;
843 }
844 #endif
845 }
846
847 /*
848 * If it is a read command
849 */
850 if( (*cmd->cmnd & 0x0F) == 0x08 ) {
851 scb->dma_direction = PCI_DMA_FROMDEVICE;
852 }
853 else {
854 scb->dma_direction = PCI_DMA_TODEVICE;
855 }
856
857 /* Calculate Scatter-Gather info */
858 mbox->m_out.numsgelements = mega_build_sglist(adapter, scb,
859 (u32 *)&mbox->m_out.xferaddr, (u32 *)&seg);
860
861 return scb;
862
863 #if MEGA_HAVE_CLUSTERING
864 case RESERVE: /* Fall through */
865 case RELEASE:
866
867 /*
868 * Do we support clustering and is the support enabled
869 */
870 if( ! adapter->has_cluster ) {
871
872 cmd->result = (DID_BAD_TARGET << 16);
873 cmd->scsi_done(cmd);
874 return NULL;
875 }
876
877 /* Allocate a SCB and initialize mailbox */
878 if(!(scb = mega_allocate_scb(adapter, cmd))) {
879 *busy = 1;
880 return NULL;
881 }
882
883 scb->raw_mbox[0] = MEGA_CLUSTER_CMD;
884 scb->raw_mbox[2] = ( *cmd->cmnd == RESERVE ) ?
885 MEGA_RESERVE_LD : MEGA_RELEASE_LD;
886
887 scb->raw_mbox[3] = ldrv_num;
888
889 scb->dma_direction = PCI_DMA_NONE;
890
891 return scb;
892 #endif
893
894 default:
895 cmd->result = (DID_BAD_TARGET << 16);
896 cmd->scsi_done(cmd);
897 return NULL;
898 }
899 }
900
901 /*
902 * Passthru drive commands
903 */
904 else {
905 /* Allocate a SCB and initialize passthru */
906 if(!(scb = mega_allocate_scb(adapter, cmd))) {
907 *busy = 1;
908 return NULL;
909 }
910
911 mbox = (mbox_t *)scb->raw_mbox;
912 memset(mbox, 0, sizeof(scb->raw_mbox));
913
914 if( adapter->support_ext_cdb ) {
915
916 epthru = mega_prepare_extpassthru(adapter, scb, cmd,
917 channel, target);
918
919 mbox->m_out.cmd = MEGA_MBOXCMD_EXTPTHRU;
920
921 mbox->m_out.xferaddr = scb->epthru_dma_addr;
922
923 }
924 else {
925
926 pthru = mega_prepare_passthru(adapter, scb, cmd,
927 channel, target);
928
929 /* Initialize mailbox */
930 if( adapter->has_64bit_addr ) {
931 mbox->m_out.cmd = MEGA_MBOXCMD_PASSTHRU64;
932 }
933 else {
934 mbox->m_out.cmd = MEGA_MBOXCMD_PASSTHRU;
935 }
936
937 mbox->m_out.xferaddr = scb->pthru_dma_addr;
938
939 }
940 return scb;
941 }
942 return NULL;
943 }
944
945
946 /**
947 * mega_prepare_passthru()
948 * @adapter - pointer to our soft state
949 * @scb - our scsi control block
950 * @cmd - scsi command from the mid-layer
951 * @channel - actual channel on the controller
952 * @target - actual id on the controller.
953 *
954 * prepare a command for the scsi physical devices.
955 */
956 static mega_passthru *
957 mega_prepare_passthru(adapter_t *adapter, scb_t *scb, Scsi_Cmnd *cmd,
958 int channel, int target)
959 {
960 mega_passthru *pthru;
961
962 pthru = scb->pthru;
963 memset(pthru, 0, sizeof (mega_passthru));
964
965 /* 0=6sec/1=60sec/2=10min/3=3hrs */
966 pthru->timeout = 2;
967
968 pthru->ars = 1;
969 pthru->reqsenselen = 14;
970 pthru->islogical = 0;
971
972 pthru->channel = (adapter->flag & BOARD_40LD) ? 0 : channel;
973
974 pthru->target = (adapter->flag & BOARD_40LD) ?
975 (channel << 4) | target : target;
976
977 pthru->cdblen = cmd->cmd_len;
978 pthru->logdrv = cmd->device->lun;
979
980 memcpy(pthru->cdb, cmd->cmnd, cmd->cmd_len);
981
982 /* Not sure about the direction */
983 scb->dma_direction = PCI_DMA_BIDIRECTIONAL;
984
985 /* Special Code for Handling READ_CAPA/ INQ using bounce buffers */
986 switch (cmd->cmnd[0]) {
987 case INQUIRY:
988 case READ_CAPACITY:
989 if(!(adapter->flag & (1L << cmd->device->channel))) {
990
991 printk(KERN_NOTICE
992 "scsi%d: scanning scsi channel %d [P%d] ",
993 adapter->host->host_no,
994 cmd->device->channel, channel);
995 printk("for physical devices.\n");
996
997 adapter->flag |= (1L << cmd->device->channel);
998 }
999 /* Fall through */
1000 default:
1001 pthru->numsgelements = mega_build_sglist(adapter, scb,
1002 &pthru->dataxferaddr, &pthru->dataxferlen);
1003 break;
1004 }
1005 return pthru;
1006 }
1007
1008
1009 /**
1010 * mega_prepare_extpassthru()
1011 * @adapter - pointer to our soft state
1012 * @scb - our scsi control block
1013 * @cmd - scsi command from the mid-layer
1014 * @channel - actual channel on the controller
1015 * @target - actual id on the controller.
1016 *
1017 * prepare a command for the scsi physical devices. This rountine prepares
1018 * commands for devices which can take extended CDBs (>10 bytes)
1019 */
1020 static mega_ext_passthru *
1021 mega_prepare_extpassthru(adapter_t *adapter, scb_t *scb, Scsi_Cmnd *cmd,
1022 int channel, int target)
1023 {
1024 mega_ext_passthru *epthru;
1025
1026 epthru = scb->epthru;
1027 memset(epthru, 0, sizeof(mega_ext_passthru));
1028
1029 /* 0=6sec/1=60sec/2=10min/3=3hrs */
1030 epthru->timeout = 2;
1031
1032 epthru->ars = 1;
1033 epthru->reqsenselen = 14;
1034 epthru->islogical = 0;
1035
1036 epthru->channel = (adapter->flag & BOARD_40LD) ? 0 : channel;
1037 epthru->target = (adapter->flag & BOARD_40LD) ?
1038 (channel << 4) | target : target;
1039
1040 epthru->cdblen = cmd->cmd_len;
1041 epthru->logdrv = cmd->device->lun;
1042
1043 memcpy(epthru->cdb, cmd->cmnd, cmd->cmd_len);
1044
1045 /* Not sure about the direction */
1046 scb->dma_direction = PCI_DMA_BIDIRECTIONAL;
1047
1048 switch(cmd->cmnd[0]) {
1049 case INQUIRY:
1050 case READ_CAPACITY:
1051 if(!(adapter->flag & (1L << cmd->device->channel))) {
1052
1053 printk(KERN_NOTICE
1054 "scsi%d: scanning scsi channel %d [P%d] ",
1055 adapter->host->host_no,
1056 cmd->device->channel, channel);
1057 printk("for physical devices.\n");
1058
1059 adapter->flag |= (1L << cmd->device->channel);
1060 }
1061 /* Fall through */
1062 default:
1063 epthru->numsgelements = mega_build_sglist(adapter, scb,
1064 &epthru->dataxferaddr, &epthru->dataxferlen);
1065 break;
1066 }
1067
1068 return epthru;
1069 }
1070
1071 static void
1072 __mega_runpendq(adapter_t *adapter)
1073 {
1074 scb_t *scb;
1075 struct list_head *pos, *next;
1076
1077 /* Issue any pending commands to the card */
1078 list_for_each_safe(pos, next, &adapter->pending_list) {
1079
1080 scb = list_entry(pos, scb_t, list);
1081
1082 if( !(scb->state & SCB_ISSUED) ) {
1083
1084 if( issue_scb(adapter, scb) != 0 )
1085 return;
1086 }
1087 }
1088
1089 return;
1090 }
1091
1092
1093 /**
1094 * issue_scb()
1095 * @adapter - pointer to our soft state
1096 * @scb - scsi control block
1097 *
1098 * Post a command to the card if the mailbox is available, otherwise return
1099 * busy. We also take the scb from the pending list if the mailbox is
1100 * available.
1101 */
1102 static int
1103 issue_scb(adapter_t *adapter, scb_t *scb)
1104 {
1105 volatile mbox64_t *mbox64 = adapter->mbox64;
1106 volatile mbox_t *mbox = adapter->mbox;
1107 unsigned int i = 0;
1108
1109 if(unlikely(mbox->m_in.busy)) {
1110 do {
1111 udelay(1);
1112 i++;
1113 } while( mbox->m_in.busy && (i < max_mbox_busy_wait) );
1114
1115 if(mbox->m_in.busy) return -1;
1116 }
1117
1118 /* Copy mailbox data into host structure */
1119 memcpy((char *)&mbox->m_out, (char *)scb->raw_mbox,
1120 sizeof(struct mbox_out));
1121
1122 mbox->m_out.cmdid = scb->idx; /* Set cmdid */
1123 mbox->m_in.busy = 1; /* Set busy */
1124
1125
1126 /*
1127 * Increment the pending queue counter
1128 */
1129 atomic_inc(&adapter->pend_cmds);
1130
1131 switch (mbox->m_out.cmd) {
1132 case MEGA_MBOXCMD_LREAD64:
1133 case MEGA_MBOXCMD_LWRITE64:
1134 case MEGA_MBOXCMD_PASSTHRU64:
1135 case MEGA_MBOXCMD_EXTPTHRU:
1136 mbox64->xfer_segment_lo = mbox->m_out.xferaddr;
1137 mbox64->xfer_segment_hi = 0;
1138 mbox->m_out.xferaddr = 0xFFFFFFFF;
1139 break;
1140 default:
1141 mbox64->xfer_segment_lo = 0;
1142 mbox64->xfer_segment_hi = 0;
1143 }
1144
1145 /*
1146 * post the command
1147 */
1148 scb->state |= SCB_ISSUED;
1149
1150 if( likely(adapter->flag & BOARD_MEMMAP) ) {
1151 mbox->m_in.poll = 0;
1152 mbox->m_in.ack = 0;
1153 WRINDOOR(adapter, adapter->mbox_dma | 0x1);
1154 }
1155 else {
1156 irq_enable(adapter);
1157 issue_command(adapter);
1158 }
1159
1160 return 0;
1161 }
1162
1163 /*
1164 * Wait until the controller's mailbox is available
1165 */
1166 static inline int
1167 mega_busywait_mbox (adapter_t *adapter)
1168 {
1169 if (adapter->mbox->m_in.busy)
1170 return __mega_busywait_mbox(adapter);
1171 return 0;
1172 }
1173
1174 /**
1175 * issue_scb_block()
1176 * @adapter - pointer to our soft state
1177 * @raw_mbox - the mailbox
1178 *
1179 * Issue a scb in synchronous and non-interrupt mode
1180 */
1181 static int
1182 issue_scb_block(adapter_t *adapter, u_char *raw_mbox)
1183 {
1184 volatile mbox64_t *mbox64 = adapter->mbox64;
1185 volatile mbox_t *mbox = adapter->mbox;
1186 u8 byte;
1187
1188 /* Wait until mailbox is free */
1189 if(mega_busywait_mbox (adapter))
1190 goto bug_blocked_mailbox;
1191
1192 /* Copy mailbox data into host structure */
1193 memcpy((char *) mbox, raw_mbox, sizeof(struct mbox_out));
1194 mbox->m_out.cmdid = 0xFE;
1195 mbox->m_in.busy = 1;
1196
1197 switch (raw_mbox[0]) {
1198 case MEGA_MBOXCMD_LREAD64:
1199 case MEGA_MBOXCMD_LWRITE64:
1200 case MEGA_MBOXCMD_PASSTHRU64:
1201 case MEGA_MBOXCMD_EXTPTHRU:
1202 mbox64->xfer_segment_lo = mbox->m_out.xferaddr;
1203 mbox64->xfer_segment_hi = 0;
1204 mbox->m_out.xferaddr = 0xFFFFFFFF;
1205 break;
1206 default:
1207 mbox64->xfer_segment_lo = 0;
1208 mbox64->xfer_segment_hi = 0;
1209 }
1210
1211 if( likely(adapter->flag & BOARD_MEMMAP) ) {
1212 mbox->m_in.poll = 0;
1213 mbox->m_in.ack = 0;
1214 mbox->m_in.numstatus = 0xFF;
1215 mbox->m_in.status = 0xFF;
1216 WRINDOOR(adapter, adapter->mbox_dma | 0x1);
1217
1218 while((volatile u8)mbox->m_in.numstatus == 0xFF)
1219 cpu_relax();
1220
1221 mbox->m_in.numstatus = 0xFF;
1222
1223 while( (volatile u8)mbox->m_in.poll != 0x77 )
1224 cpu_relax();
1225
1226 mbox->m_in.poll = 0;
1227 mbox->m_in.ack = 0x77;
1228
1229 WRINDOOR(adapter, adapter->mbox_dma | 0x2);
1230
1231 while(RDINDOOR(adapter) & 0x2)
1232 cpu_relax();
1233 }
1234 else {
1235 irq_disable(adapter);
1236 issue_command(adapter);
1237
1238 while (!((byte = irq_state(adapter)) & INTR_VALID))
1239 cpu_relax();
1240
1241 set_irq_state(adapter, byte);
1242 irq_enable(adapter);
1243 irq_ack(adapter);
1244 }
1245
1246 return mbox->m_in.status;
1247
1248 bug_blocked_mailbox:
1249 printk(KERN_WARNING "megaraid: Blocked mailbox......!!\n");
1250 udelay (1000);
1251 return -1;
1252 }
1253
1254
1255 /**
1256 * megaraid_isr_iomapped()
1257 * @irq - irq
1258 * @devp - pointer to our soft state
1259 *
1260 * Interrupt service routine for io-mapped controllers.
1261 * Find out if our device is interrupting. If yes, acknowledge the interrupt
1262 * and service the completed commands.
1263 */
1264 static irqreturn_t
1265 megaraid_isr_iomapped(int irq, void *devp)
1266 {
1267 adapter_t *adapter = devp;
1268 unsigned long flags;
1269 u8 status;
1270 u8 nstatus;
1271 u8 completed[MAX_FIRMWARE_STATUS];
1272 u8 byte;
1273 int handled = 0;
1274
1275
1276 /*
1277 * loop till F/W has more commands for us to complete.
1278 */
1279 spin_lock_irqsave(&adapter->lock, flags);
1280
1281 do {
1282 /* Check if a valid interrupt is pending */
1283 byte = irq_state(adapter);
1284 if( (byte & VALID_INTR_BYTE) == 0 ) {
1285 /*
1286 * No more pending commands
1287 */
1288 goto out_unlock;
1289 }
1290 set_irq_state(adapter, byte);
1291
1292 while((nstatus = (volatile u8)adapter->mbox->m_in.numstatus)
1293 == 0xFF)
1294 cpu_relax();
1295 adapter->mbox->m_in.numstatus = 0xFF;
1296
1297 status = adapter->mbox->m_in.status;
1298
1299 /*
1300 * decrement the pending queue counter
1301 */
1302 atomic_sub(nstatus, &adapter->pend_cmds);
1303
1304 memcpy(completed, (void *)adapter->mbox->m_in.completed,
1305 nstatus);
1306
1307 /* Acknowledge interrupt */
1308 irq_ack(adapter);
1309
1310 mega_cmd_done(adapter, completed, nstatus, status);
1311
1312 mega_rundoneq(adapter);
1313
1314 handled = 1;
1315
1316 /* Loop through any pending requests */
1317 if(atomic_read(&adapter->quiescent) == 0) {
1318 mega_runpendq(adapter);
1319 }
1320
1321 } while(1);
1322
1323 out_unlock:
1324
1325 spin_unlock_irqrestore(&adapter->lock, flags);
1326
1327 return IRQ_RETVAL(handled);
1328 }
1329
1330
1331 /**
1332 * megaraid_isr_memmapped()
1333 * @irq - irq
1334 * @devp - pointer to our soft state
1335 *
1336 * Interrupt service routine for memory-mapped controllers.
1337 * Find out if our device is interrupting. If yes, acknowledge the interrupt
1338 * and service the completed commands.
1339 */
1340 static irqreturn_t
1341 megaraid_isr_memmapped(int irq, void *devp)
1342 {
1343 adapter_t *adapter = devp;
1344 unsigned long flags;
1345 u8 status;
1346 u32 dword = 0;
1347 u8 nstatus;
1348 u8 completed[MAX_FIRMWARE_STATUS];
1349 int handled = 0;
1350
1351
1352 /*
1353 * loop till F/W has more commands for us to complete.
1354 */
1355 spin_lock_irqsave(&adapter->lock, flags);
1356
1357 do {
1358 /* Check if a valid interrupt is pending */
1359 dword = RDOUTDOOR(adapter);
1360 if(dword != 0x10001234) {
1361 /*
1362 * No more pending commands
1363 */
1364 goto out_unlock;
1365 }
1366 WROUTDOOR(adapter, 0x10001234);
1367
1368 while((nstatus = (volatile u8)adapter->mbox->m_in.numstatus)
1369 == 0xFF) {
1370 cpu_relax();
1371 }
1372 adapter->mbox->m_in.numstatus = 0xFF;
1373
1374 status = adapter->mbox->m_in.status;
1375
1376 /*
1377 * decrement the pending queue counter
1378 */
1379 atomic_sub(nstatus, &adapter->pend_cmds);
1380
1381 memcpy(completed, (void *)adapter->mbox->m_in.completed,
1382 nstatus);
1383
1384 /* Acknowledge interrupt */
1385 WRINDOOR(adapter, 0x2);
1386
1387 handled = 1;
1388
1389 while( RDINDOOR(adapter) & 0x02 ) cpu_relax();
1390
1391 mega_cmd_done(adapter, completed, nstatus, status);
1392
1393 mega_rundoneq(adapter);
1394
1395 /* Loop through any pending requests */
1396 if(atomic_read(&adapter->quiescent) == 0) {
1397 mega_runpendq(adapter);
1398 }
1399
1400 } while(1);
1401
1402 out_unlock:
1403
1404 spin_unlock_irqrestore(&adapter->lock, flags);
1405
1406 return IRQ_RETVAL(handled);
1407 }
1408 /**
1409 * mega_cmd_done()
1410 * @adapter - pointer to our soft state
1411 * @completed - array of ids of completed commands
1412 * @nstatus - number of completed commands
1413 * @status - status of the last command completed
1414 *
1415 * Complete the comamnds and call the scsi mid-layer callback hooks.
1416 */
1417 static void
1418 mega_cmd_done(adapter_t *adapter, u8 completed[], int nstatus, int status)
1419 {
1420 mega_ext_passthru *epthru = NULL;
1421 struct scatterlist *sgl;
1422 Scsi_Cmnd *cmd = NULL;
1423 mega_passthru *pthru = NULL;
1424 mbox_t *mbox = NULL;
1425 u8 c;
1426 scb_t *scb;
1427 int islogical;
1428 int cmdid;
1429 int i;
1430
1431 /*
1432 * for all the commands completed, call the mid-layer callback routine
1433 * and free the scb.
1434 */
1435 for( i = 0; i < nstatus; i++ ) {
1436
1437 cmdid = completed[i];
1438
1439 if( cmdid == CMDID_INT_CMDS ) { /* internal command */
1440 scb = &adapter->int_scb;
1441 cmd = scb->cmd;
1442 mbox = (mbox_t *)scb->raw_mbox;
1443
1444 /*
1445 * Internal command interface do not fire the extended
1446 * passthru or 64-bit passthru
1447 */
1448 pthru = scb->pthru;
1449
1450 }
1451 else {
1452 scb = &adapter->scb_list[cmdid];
1453
1454 /*
1455 * Make sure f/w has completed a valid command
1456 */
1457 if( !(scb->state & SCB_ISSUED) || scb->cmd == NULL ) {
1458 printk(KERN_CRIT
1459 "megaraid: invalid command ");
1460 printk("Id %d, scb->state:%x, scsi cmd:%p\n",
1461 cmdid, scb->state, scb->cmd);
1462
1463 continue;
1464 }
1465
1466 /*
1467 * Was a abort issued for this command
1468 */
1469 if( scb->state & SCB_ABORT ) {
1470
1471 printk(KERN_WARNING
1472 "megaraid: aborted cmd %lx[%x] complete.\n",
1473 scb->cmd->serial_number, scb->idx);
1474
1475 scb->cmd->result = (DID_ABORT << 16);
1476
1477 list_add_tail(SCSI_LIST(scb->cmd),
1478 &adapter->completed_list);
1479
1480 mega_free_scb(adapter, scb);
1481
1482 continue;
1483 }
1484
1485 /*
1486 * Was a reset issued for this command
1487 */
1488 if( scb->state & SCB_RESET ) {
1489
1490 printk(KERN_WARNING
1491 "megaraid: reset cmd %lx[%x] complete.\n",
1492 scb->cmd->serial_number, scb->idx);
1493
1494 scb->cmd->result = (DID_RESET << 16);
1495
1496 list_add_tail(SCSI_LIST(scb->cmd),
1497 &adapter->completed_list);
1498
1499 mega_free_scb (adapter, scb);
1500
1501 continue;
1502 }
1503
1504 cmd = scb->cmd;
1505 pthru = scb->pthru;
1506 epthru = scb->epthru;
1507 mbox = (mbox_t *)scb->raw_mbox;
1508
1509 #if MEGA_HAVE_STATS
1510 {
1511
1512 int logdrv = mbox->m_out.logdrv;
1513
1514 islogical = adapter->logdrv_chan[cmd->channel];
1515 /*
1516 * Maintain an error counter for the logical drive.
1517 * Some application like SNMP agent need such
1518 * statistics
1519 */
1520 if( status && islogical && (cmd->cmnd[0] == READ_6 ||
1521 cmd->cmnd[0] == READ_10 ||
1522 cmd->cmnd[0] == READ_12)) {
1523 /*
1524 * Logical drive number increases by 0x80 when
1525 * a logical drive is deleted
1526 */
1527 adapter->rd_errors[logdrv%0x80]++;
1528 }
1529
1530 if( status && islogical && (cmd->cmnd[0] == WRITE_6 ||
1531 cmd->cmnd[0] == WRITE_10 ||
1532 cmd->cmnd[0] == WRITE_12)) {
1533 /*
1534 * Logical drive number increases by 0x80 when
1535 * a logical drive is deleted
1536 */
1537 adapter->wr_errors[logdrv%0x80]++;
1538 }
1539
1540 }
1541 #endif
1542 }
1543
1544 /*
1545 * Do not return the presence of hard disk on the channel so,
1546 * inquiry sent, and returned data==hard disk or removable
1547 * hard disk and not logical, request should return failure! -
1548 * PJ
1549 */
1550 islogical = adapter->logdrv_chan[cmd->device->channel];
1551 if( cmd->cmnd[0] == INQUIRY && !islogical ) {
1552
1553 if( cmd->use_sg ) {
1554 sgl = (struct scatterlist *)
1555 cmd->request_buffer;
1556
1557 if( sgl->page ) {
1558 c = *(unsigned char *)
1559 page_address((&sgl[0])->page) +
1560 (&sgl[0])->offset;
1561 }
1562 else {
1563 printk(KERN_WARNING
1564 "megaraid: invalid sg.\n");
1565 c = 0;
1566 }
1567 }
1568 else {
1569 c = *(u8 *)cmd->request_buffer;
1570 }
1571
1572 if(IS_RAID_CH(adapter, cmd->device->channel) &&
1573 ((c & 0x1F ) == TYPE_DISK)) {
1574 status = 0xF0;
1575 }
1576 }
1577
1578 /* clear result; otherwise, success returns corrupt value */
1579 cmd->result = 0;
1580
1581 /* Convert MegaRAID status to Linux error code */
1582 switch (status) {
1583 case 0x00: /* SUCCESS , i.e. SCSI_STATUS_GOOD */
1584 cmd->result |= (DID_OK << 16);
1585 break;
1586
1587 case 0x02: /* ERROR_ABORTED, i.e.
1588 SCSI_STATUS_CHECK_CONDITION */
1589
1590 /* set sense_buffer and result fields */
1591 if( mbox->m_out.cmd == MEGA_MBOXCMD_PASSTHRU ||
1592 mbox->m_out.cmd == MEGA_MBOXCMD_PASSTHRU64 ) {
1593
1594 memcpy(cmd->sense_buffer, pthru->reqsensearea,
1595 14);
1596
1597 cmd->result = (DRIVER_SENSE << 24) |
1598 (DID_OK << 16) |
1599 (CHECK_CONDITION << 1);
1600 }
1601 else {
1602 if (mbox->m_out.cmd == MEGA_MBOXCMD_EXTPTHRU) {
1603
1604 memcpy(cmd->sense_buffer,
1605 epthru->reqsensearea, 14);
1606
1607 cmd->result = (DRIVER_SENSE << 24) |
1608 (DID_OK << 16) |
1609 (CHECK_CONDITION << 1);
1610 } else {
1611 cmd->sense_buffer[0] = 0x70;
1612 cmd->sense_buffer[2] = ABORTED_COMMAND;
1613 cmd->result |= (CHECK_CONDITION << 1);
1614 }
1615 }
1616 break;
1617
1618 case 0x08: /* ERR_DEST_DRIVE_FAILED, i.e.
1619 SCSI_STATUS_BUSY */
1620 cmd->result |= (DID_BUS_BUSY << 16) | status;
1621 break;
1622
1623 default:
1624 #if MEGA_HAVE_CLUSTERING
1625 /*
1626 * If TEST_UNIT_READY fails, we know
1627 * MEGA_RESERVATION_STATUS failed
1628 */
1629 if( cmd->cmnd[0] == TEST_UNIT_READY ) {
1630 cmd->result |= (DID_ERROR << 16) |
1631 (RESERVATION_CONFLICT << 1);
1632 }
1633 else
1634 /*
1635 * Error code returned is 1 if Reserve or Release
1636 * failed or the input parameter is invalid
1637 */
1638 if( status == 1 &&
1639 (cmd->cmnd[0] == RESERVE ||
1640 cmd->cmnd[0] == RELEASE) ) {
1641
1642 cmd->result |= (DID_ERROR << 16) |
1643 (RESERVATION_CONFLICT << 1);
1644 }
1645 else
1646 #endif
1647 cmd->result |= (DID_BAD_TARGET << 16)|status;
1648 }
1649
1650 /*
1651 * Only free SCBs for the commands coming down from the
1652 * mid-layer, not for which were issued internally
1653 *
1654 * For internal command, restore the status returned by the
1655 * firmware so that user can interpret it.
1656 */
1657 if( cmdid == CMDID_INT_CMDS ) { /* internal command */
1658 cmd->result = status;
1659
1660 /*
1661 * Remove the internal command from the pending list
1662 */
1663 list_del_init(&scb->list);
1664 scb->state = SCB_FREE;
1665 }
1666 else {
1667 mega_free_scb(adapter, scb);
1668 }
1669
1670 /* Add Scsi_Command to end of completed queue */
1671 list_add_tail(SCSI_LIST(cmd), &adapter->completed_list);
1672 }
1673 }
1674
1675
1676 /*
1677 * mega_runpendq()
1678 *
1679 * Run through the list of completed requests and finish it
1680 */
1681 static void
1682 mega_rundoneq (adapter_t *adapter)
1683 {
1684 Scsi_Cmnd *cmd;
1685 struct list_head *pos;
1686
1687 list_for_each(pos, &adapter->completed_list) {
1688
1689 struct scsi_pointer* spos = (struct scsi_pointer *)pos;
1690
1691 cmd = list_entry(spos, Scsi_Cmnd, SCp);
1692 cmd->scsi_done(cmd);
1693 }
1694
1695 INIT_LIST_HEAD(&adapter->completed_list);
1696 }
1697
1698
1699 /*
1700 * Free a SCB structure
1701 * Note: We assume the scsi commands associated with this scb is not free yet.
1702 */
1703 static void
1704 mega_free_scb(adapter_t *adapter, scb_t *scb)
1705 {
1706 unsigned long length;
1707
1708 switch( scb->dma_type ) {
1709
1710 case MEGA_DMA_TYPE_NONE:
1711 break;
1712
1713 case MEGA_BULK_DATA:
1714 if (scb->cmd->use_sg == 0)
1715 length = scb->cmd->request_bufflen;
1716 else {
1717 struct scatterlist *sgl =
1718 (struct scatterlist *)scb->cmd->request_buffer;
1719 length = sgl->length;
1720 }
1721 pci_unmap_page(adapter->dev, scb->dma_h_bulkdata,
1722 length, scb->dma_direction);
1723 break;
1724
1725 case MEGA_SGLIST:
1726 pci_unmap_sg(adapter->dev, scb->cmd->request_buffer,
1727 scb->cmd->use_sg, scb->dma_direction);
1728 break;
1729
1730 default:
1731 break;
1732 }
1733
1734 /*
1735 * Remove from the pending list
1736 */
1737 list_del_init(&scb->list);
1738
1739 /* Link the scb back into free list */
1740 scb->state = SCB_FREE;
1741 scb->cmd = NULL;
1742
1743 list_add(&scb->list, &adapter->free_list);
1744 }
1745
1746
1747 static int
1748 __mega_busywait_mbox (adapter_t *adapter)
1749 {
1750 volatile mbox_t *mbox = adapter->mbox;
1751 long counter;
1752
1753 for (counter = 0; counter < 10000; counter++) {
1754 if (!mbox->m_in.busy)
1755 return 0;
1756 udelay(100); yield();
1757 }
1758 return -1; /* give up after 1 second */
1759 }
1760
1761 /*
1762 * Copies data to SGLIST
1763 * Note: For 64 bit cards, we need a minimum of one SG element for read/write
1764 */
1765 static int
1766 mega_build_sglist(adapter_t *adapter, scb_t *scb, u32 *buf, u32 *len)
1767 {
1768 struct scatterlist *sgl;
1769 struct page *page;
1770 unsigned long offset;
1771 unsigned int length;
1772 Scsi_Cmnd *cmd;
1773 int sgcnt;
1774 int idx;
1775
1776 cmd = scb->cmd;
1777
1778 /* Scatter-gather not used */
1779 if( cmd->use_sg == 0 || (cmd->use_sg == 1 &&
1780 !adapter->has_64bit_addr)) {
1781
1782 if (cmd->use_sg == 0) {
1783 page = virt_to_page(cmd->request_buffer);
1784 offset = offset_in_page(cmd->request_buffer);
1785 length = cmd->request_bufflen;
1786 } else {
1787 sgl = (struct scatterlist *)cmd->request_buffer;
1788 page = sgl->page;
1789 offset = sgl->offset;
1790 length = sgl->length;
1791 }
1792
1793 scb->dma_h_bulkdata = pci_map_page(adapter->dev,
1794 page, offset,
1795 length,
1796 scb->dma_direction);
1797 scb->dma_type = MEGA_BULK_DATA;
1798
1799 /*
1800 * We need to handle special 64-bit commands that need a
1801 * minimum of 1 SG
1802 */
1803 if( adapter->has_64bit_addr ) {
1804 scb->sgl64[0].address = scb->dma_h_bulkdata;
1805 scb->sgl64[0].length = length;
1806 *buf = (u32)scb->sgl_dma_addr;
1807 *len = (u32)length;
1808 return 1;
1809 }
1810 else {
1811 *buf = (u32)scb->dma_h_bulkdata;
1812 *len = (u32)length;
1813 }
1814 return 0;
1815 }
1816
1817 sgl = (struct scatterlist *)cmd->request_buffer;
1818
1819 /*
1820 * Copy Scatter-Gather list info into controller structure.
1821 *
1822 * The number of sg elements returned must not exceed our limit
1823 */
1824 sgcnt = pci_map_sg(adapter->dev, sgl, cmd->use_sg,
1825 scb->dma_direction);
1826
1827 scb->dma_type = MEGA_SGLIST;
1828
1829 BUG_ON(sgcnt > adapter->sglen);
1830
1831 *len = 0;
1832
1833 for( idx = 0; idx < sgcnt; idx++, sgl++ ) {
1834
1835 if( adapter->has_64bit_addr ) {
1836 scb->sgl64[idx].address = sg_dma_address(sgl);
1837 *len += scb->sgl64[idx].length = sg_dma_len(sgl);
1838 }
1839 else {
1840 scb->sgl[idx].address = sg_dma_address(sgl);
1841 *len += scb->sgl[idx].length = sg_dma_len(sgl);
1842 }
1843 }
1844
1845 /* Reset pointer and length fields */
1846 *buf = scb->sgl_dma_addr;
1847
1848 /* Return count of SG requests */
1849 return sgcnt;
1850 }
1851
1852
1853 /*
1854 * mega_8_to_40ld()
1855 *
1856 * takes all info in AdapterInquiry structure and puts it into ProductInfo and
1857 * Enquiry3 structures for later use
1858 */
1859 static void
1860 mega_8_to_40ld(mraid_inquiry *inquiry, mega_inquiry3 *enquiry3,
1861 mega_product_info *product_info)
1862 {
1863 int i;
1864
1865 product_info->max_commands = inquiry->adapter_info.max_commands;
1866 enquiry3->rebuild_rate = inquiry->adapter_info.rebuild_rate;
1867 product_info->nchannels = inquiry->adapter_info.nchannels;
1868
1869 for (i = 0; i < 4; i++) {
1870 product_info->fw_version[i] =
1871 inquiry->adapter_info.fw_version[i];
1872
1873 product_info->bios_version[i] =
1874 inquiry->adapter_info.bios_version[i];
1875 }
1876 enquiry3->cache_flush_interval =
1877 inquiry->adapter_info.cache_flush_interval;
1878
1879 product_info->dram_size = inquiry->adapter_info.dram_size;
1880
1881 enquiry3->num_ldrv = inquiry->logdrv_info.num_ldrv;
1882
1883 for (i = 0; i < MAX_LOGICAL_DRIVES_8LD; i++) {
1884 enquiry3->ldrv_size[i] = inquiry->logdrv_info.ldrv_size[i];
1885 enquiry3->ldrv_prop[i] = inquiry->logdrv_info.ldrv_prop[i];
1886 enquiry3->ldrv_state[i] = inquiry->logdrv_info.ldrv_state[i];
1887 }
1888
1889 for (i = 0; i < (MAX_PHYSICAL_DRIVES); i++)
1890 enquiry3->pdrv_state[i] = inquiry->pdrv_info.pdrv_state[i];
1891 }
1892
1893 static inline void
1894 mega_free_sgl(adapter_t *adapter)
1895 {
1896 scb_t *scb;
1897 int i;
1898
1899 for(i = 0; i < adapter->max_cmds; i++) {
1900
1901 scb = &adapter->scb_list[i];
1902
1903 if( scb->sgl64 ) {
1904 pci_free_consistent(adapter->dev,
1905 sizeof(mega_sgl64) * adapter->sglen,
1906 scb->sgl64,
1907 scb->sgl_dma_addr);
1908
1909 scb->sgl64 = NULL;
1910 }
1911
1912 if( scb->pthru ) {
1913 pci_free_consistent(adapter->dev, sizeof(mega_passthru),
1914 scb->pthru, scb->pthru_dma_addr);
1915
1916 scb->pthru = NULL;
1917 }
1918
1919 if( scb->epthru ) {
1920 pci_free_consistent(adapter->dev,
1921 sizeof(mega_ext_passthru),
1922 scb->epthru, scb->epthru_dma_addr);
1923
1924 scb->epthru = NULL;
1925 }
1926
1927 }
1928 }
1929
1930
1931 /*
1932 * Get information about the card/driver
1933 */
1934 const char *
1935 megaraid_info(struct Scsi_Host *host)
1936 {
1937 static char buffer[512];
1938 adapter_t *adapter;
1939
1940 adapter = (adapter_t *)host->hostdata;
1941
1942 sprintf (buffer,
1943 "LSI Logic MegaRAID %s %d commands %d targs %d chans %d luns",
1944 adapter->fw_version, adapter->product_info.max_commands,
1945 adapter->host->max_id, adapter->host->max_channel,
1946 adapter->host->max_lun);
1947 return buffer;
1948 }
1949
1950 /*
1951 * Abort a previous SCSI request. Only commands on the pending list can be
1952 * aborted. All the commands issued to the F/W must complete.
1953 */
1954 static int
1955 megaraid_abort(Scsi_Cmnd *cmd)
1956 {
1957 adapter_t *adapter;
1958 int rval;
1959
1960 adapter = (adapter_t *)cmd->device->host->hostdata;
1961
1962 rval = megaraid_abort_and_reset(adapter, cmd, SCB_ABORT);
1963
1964 /*
1965 * This is required here to complete any completed requests
1966 * to be communicated over to the mid layer.
1967 */
1968 mega_rundoneq(adapter);
1969
1970 return rval;
1971 }
1972
1973
1974 static int
1975 megaraid_reset(struct scsi_cmnd *cmd)
1976 {
1977 adapter_t *adapter;
1978 megacmd_t mc;
1979 int rval;
1980
1981 adapter = (adapter_t *)cmd->device->host->hostdata;
1982
1983 #if MEGA_HAVE_CLUSTERING
1984 mc.cmd = MEGA_CLUSTER_CMD;
1985 mc.opcode = MEGA_RESET_RESERVATIONS;
1986
1987 if( mega_internal_command(adapter, &mc, NULL) != 0 ) {
1988 printk(KERN_WARNING
1989 "megaraid: reservation reset failed.\n");
1990 }
1991 else {
1992 printk(KERN_INFO "megaraid: reservation reset.\n");
1993 }
1994 #endif
1995
1996 spin_lock_irq(&adapter->lock);
1997
1998 rval = megaraid_abort_and_reset(adapter, cmd, SCB_RESET);
1999
2000 /*
2001 * This is required here to complete any completed requests
2002 * to be communicated over to the mid layer.
2003 */
2004 mega_rundoneq(adapter);
2005 spin_unlock_irq(&adapter->lock);
2006
2007 return rval;
2008 }
2009
2010 /**
2011 * megaraid_abort_and_reset()
2012 * @adapter - megaraid soft state
2013 * @cmd - scsi command to be aborted or reset
2014 * @aor - abort or reset flag
2015 *
2016 * Try to locate the scsi command in the pending queue. If found and is not
2017 * issued to the controller, abort/reset it. Otherwise return failure
2018 */
2019 static int
2020 megaraid_abort_and_reset(adapter_t *adapter, Scsi_Cmnd *cmd, int aor)
2021 {
2022 struct list_head *pos, *next;
2023 scb_t *scb;
2024
2025 printk(KERN_WARNING "megaraid: %s-%lx cmd=%x <c=%d t=%d l=%d>\n",
2026 (aor == SCB_ABORT)? "ABORTING":"RESET", cmd->serial_number,
2027 cmd->cmnd[0], cmd->device->channel,
2028 cmd->device->id, cmd->device->lun);
2029
2030 if(list_empty(&adapter->pending_list))
2031 return FALSE;
2032
2033 list_for_each_safe(pos, next, &adapter->pending_list) {
2034
2035 scb = list_entry(pos, scb_t, list);
2036
2037 if (scb->cmd == cmd) { /* Found command */
2038
2039 scb->state |= aor;
2040
2041 /*
2042 * Check if this command has firmare owenership. If
2043 * yes, we cannot reset this command. Whenever, f/w
2044 * completes this command, we will return appropriate
2045 * status from ISR.
2046 */
2047 if( scb->state & SCB_ISSUED ) {
2048
2049 printk(KERN_WARNING
2050 "megaraid: %s-%lx[%x], fw owner.\n",
2051 (aor==SCB_ABORT) ? "ABORTING":"RESET",
2052 cmd->serial_number, scb->idx);
2053
2054 return FALSE;
2055 }
2056 else {
2057
2058 /*
2059 * Not yet issued! Remove from the pending
2060 * list
2061 */
2062 printk(KERN_WARNING
2063 "megaraid: %s-%lx[%x], driver owner.\n",
2064 (aor==SCB_ABORT) ? "ABORTING":"RESET",
2065 cmd->serial_number, scb->idx);
2066
2067 mega_free_scb(adapter, scb);
2068
2069 if( aor == SCB_ABORT ) {
2070 cmd->result = (DID_ABORT << 16);
2071 }
2072 else {
2073 cmd->result = (DID_RESET << 16);
2074 }
2075
2076 list_add_tail(SCSI_LIST(cmd),
2077 &adapter->completed_list);
2078
2079 return TRUE;
2080 }
2081 }
2082 }
2083
2084 return FALSE;
2085 }
2086
2087 static inline int
2088 make_local_pdev(adapter_t *adapter, struct pci_dev **pdev)
2089 {
2090 *pdev = kmalloc(sizeof(struct pci_dev), GFP_KERNEL);
2091
2092 if( *pdev == NULL ) return -1;
2093
2094 memcpy(*pdev, adapter->dev, sizeof(struct pci_dev));
2095
2096 if( pci_set_dma_mask(*pdev, DMA_32BIT_MASK) != 0 ) {
2097 kfree(*pdev);
2098 return -1;
2099 }
2100
2101 return 0;
2102 }
2103
2104 static inline void
2105 free_local_pdev(struct pci_dev *pdev)
2106 {
2107 kfree(pdev);
2108 }
2109
2110 /**
2111 * mega_allocate_inquiry()
2112 * @dma_handle - handle returned for dma address
2113 * @pdev - handle to pci device
2114 *
2115 * allocates memory for inquiry structure
2116 */
2117 static inline void *
2118 mega_allocate_inquiry(dma_addr_t *dma_handle, struct pci_dev *pdev)
2119 {
2120 return pci_alloc_consistent(pdev, sizeof(mega_inquiry3), dma_handle);
2121 }
2122
2123
2124 static inline void
2125 mega_free_inquiry(void *inquiry, dma_addr_t dma_handle, struct pci_dev *pdev)
2126 {
2127 pci_free_consistent(pdev, sizeof(mega_inquiry3), inquiry, dma_handle);
2128 }
2129
2130
2131 #ifdef CONFIG_PROC_FS
2132 /* Following code handles /proc fs */
2133
2134 #define CREATE_READ_PROC(string, func) create_proc_read_entry(string, \
2135 S_IRUSR | S_IFREG, \
2136 controller_proc_dir_entry, \
2137 func, adapter)
2138
2139 /**
2140 * mega_create_proc_entry()
2141 * @index - index in soft state array
2142 * @parent - parent node for this /proc entry
2143 *
2144 * Creates /proc entries for our controllers.
2145 */
2146 static void
2147 mega_create_proc_entry(int index, struct proc_dir_entry *parent)
2148 {
2149 struct proc_dir_entry *controller_proc_dir_entry = NULL;
2150 u8 string[64] = { 0 };
2151 adapter_t *adapter = hba_soft_state[index];
2152
2153 sprintf(string, "hba%d", adapter->host->host_no);
2154
2155 controller_proc_dir_entry =
2156 adapter->controller_proc_dir_entry = proc_mkdir(string, parent);
2157
2158 if(!controller_proc_dir_entry) {
2159 printk(KERN_WARNING "\nmegaraid: proc_mkdir failed\n");
2160 return;
2161 }
2162 adapter->proc_read = CREATE_READ_PROC("config", proc_read_config);
2163 adapter->proc_stat = CREATE_READ_PROC("stat", proc_read_stat);
2164 adapter->proc_mbox = CREATE_READ_PROC("mailbox", proc_read_mbox);
2165 #if MEGA_HAVE_ENH_PROC
2166 adapter->proc_rr = CREATE_READ_PROC("rebuild-rate", proc_rebuild_rate);
2167 adapter->proc_battery = CREATE_READ_PROC("battery-status",
2168 proc_battery);
2169
2170 /*
2171 * Display each physical drive on its channel
2172 */
2173 adapter->proc_pdrvstat[0] = CREATE_READ_PROC("diskdrives-ch0",
2174 proc_pdrv_ch0);
2175 adapter->proc_pdrvstat[1] = CREATE_READ_PROC("diskdrives-ch1",
2176 proc_pdrv_ch1);
2177 adapter->proc_pdrvstat[2] = CREATE_READ_PROC("diskdrives-ch2",
2178 proc_pdrv_ch2);
2179 adapter->proc_pdrvstat[3] = CREATE_READ_PROC("diskdrives-ch3",
2180 proc_pdrv_ch3);
2181
2182 /*
2183 * Display a set of up to 10 logical drive through each of following
2184 * /proc entries
2185 */
2186 adapter->proc_rdrvstat[0] = CREATE_READ_PROC("raiddrives-0-9",
2187 proc_rdrv_10);
2188 adapter->proc_rdrvstat[1] = CREATE_READ_PROC("raiddrives-10-19",
2189 proc_rdrv_20);
2190 adapter->proc_rdrvstat[2] = CREATE_READ_PROC("raiddrives-20-29",
2191 proc_rdrv_30);
2192 adapter->proc_rdrvstat[3] = CREATE_READ_PROC("raiddrives-30-39",
2193 proc_rdrv_40);
2194 #endif
2195 }
2196
2197
2198 /**
2199 * proc_read_config()
2200 * @page - buffer to write the data in
2201 * @start - where the actual data has been written in page
2202 * @offset - same meaning as the read system call
2203 * @count - same meaning as the read system call
2204 * @eof - set if no more data needs to be returned
2205 * @data - pointer to our soft state
2206 *
2207 * Display configuration information about the controller.
2208 */
2209 static int
2210 proc_read_config(char *page, char **start, off_t offset, int count, int *eof,
2211 void *data)
2212 {
2213
2214 adapter_t *adapter = (adapter_t *)data;
2215 int len = 0;
2216
2217 len += sprintf(page+len, "%s", MEGARAID_VERSION);
2218
2219 if(adapter->product_info.product_name[0])
2220 len += sprintf(page+len, "%s\n",
2221 adapter->product_info.product_name);
2222
2223 len += sprintf(page+len, "Controller Type: ");
2224
2225 if( adapter->flag & BOARD_MEMMAP ) {
2226 len += sprintf(page+len,
2227 "438/466/467/471/493/518/520/531/532\n");
2228 }
2229 else {
2230 len += sprintf(page+len,
2231 "418/428/434\n");
2232 }
2233
2234 if(adapter->flag & BOARD_40LD) {
2235 len += sprintf(page+len,
2236 "Controller Supports 40 Logical Drives\n");
2237 }
2238
2239 if(adapter->flag & BOARD_64BIT) {
2240 len += sprintf(page+len,
2241 "Controller capable of 64-bit memory addressing\n");
2242 }
2243 if( adapter->has_64bit_addr ) {
2244 len += sprintf(page+len,
2245 "Controller using 64-bit memory addressing\n");
2246 }
2247 else {
2248 len += sprintf(page+len,
2249 "Controller is not using 64-bit memory addressing\n");
2250 }
2251
2252 len += sprintf(page+len, "Base = %08lx, Irq = %d, ", adapter->base,
2253 adapter->host->irq);
2254
2255 len += sprintf(page+len, "Logical Drives = %d, Channels = %d\n",
2256 adapter->numldrv, adapter->product_info.nchannels);
2257
2258 len += sprintf(page+len, "Version =%s:%s, DRAM = %dMb\n",
2259 adapter->fw_version, adapter->bios_version,
2260 adapter->product_info.dram_size);
2261
2262 len += sprintf(page+len,
2263 "Controller Queue Depth = %d, Driver Queue Depth = %d\n",
2264 adapter->product_info.max_commands, adapter->max_cmds);
2265
2266 len += sprintf(page+len, "support_ext_cdb = %d\n",
2267 adapter->support_ext_cdb);
2268 len += sprintf(page+len, "support_random_del = %d\n",
2269 adapter->support_random_del);
2270 len += sprintf(page+len, "boot_ldrv_enabled = %d\n",
2271 adapter->boot_ldrv_enabled);
2272 len += sprintf(page+len, "boot_ldrv = %d\n",
2273 adapter->boot_ldrv);
2274 len += sprintf(page+len, "boot_pdrv_enabled = %d\n",
2275 adapter->boot_pdrv_enabled);
2276 len += sprintf(page+len, "boot_pdrv_ch = %d\n",
2277 adapter->boot_pdrv_ch);
2278 len += sprintf(page+len, "boot_pdrv_tgt = %d\n",
2279 adapter->boot_pdrv_tgt);
2280 len += sprintf(page+len, "quiescent = %d\n",
2281 atomic_read(&adapter->quiescent));
2282 len += sprintf(page+len, "has_cluster = %d\n",
2283 adapter->has_cluster);
2284
2285 len += sprintf(page+len, "\nModule Parameters:\n");
2286 len += sprintf(page+len, "max_cmd_per_lun = %d\n",
2287 max_cmd_per_lun);
2288 len += sprintf(page+len, "max_sectors_per_io = %d\n",
2289 max_sectors_per_io);
2290
2291 *eof = 1;
2292
2293 return len;
2294 }
2295
2296
2297
2298 /**
2299 * proc_read_stat()
2300 * @page - buffer to write the data in
2301 * @start - where the actual data has been written in page
2302 * @offset - same meaning as the read system call
2303 * @count - same meaning as the read system call
2304 * @eof - set if no more data needs to be returned
2305 * @data - pointer to our soft state
2306 *
2307 * Diaplay statistical information about the I/O activity.
2308 */
2309 static int
2310 proc_read_stat(char *page, char **start, off_t offset, int count, int *eof,
2311 void *data)
2312 {
2313 adapter_t *adapter;
2314 int len;
2315 int i;
2316
2317 i = 0; /* avoid compilation warnings */
2318 len = 0;
2319 adapter = (adapter_t *)data;
2320
2321 len = sprintf(page, "Statistical Information for this controller\n");
2322 len += sprintf(page+len, "pend_cmds = %d\n",
2323 atomic_read(&adapter->pend_cmds));
2324 #if MEGA_HAVE_STATS
2325 for(i = 0; i < adapter->numldrv; i++) {
2326 len += sprintf(page+len, "Logical Drive %d:\n", i);
2327
2328 len += sprintf(page+len,
2329 "\tReads Issued = %lu, Writes Issued = %lu\n",
2330 adapter->nreads[i], adapter->nwrites[i]);
2331
2332 len += sprintf(page+len,
2333 "\tSectors Read = %lu, Sectors Written = %lu\n",
2334 adapter->nreadblocks[i], adapter->nwriteblocks[i]);
2335
2336 len += sprintf(page+len,
2337 "\tRead errors = %lu, Write errors = %lu\n\n",
2338 adapter->rd_errors[i], adapter->wr_errors[i]);
2339 }
2340 #else
2341 len += sprintf(page+len,
2342 "IO and error counters not compiled in driver.\n");
2343 #endif
2344
2345 *eof = 1;
2346
2347 return len;
2348 }
2349
2350
2351 /**
2352 * proc_read_mbox()
2353 * @page - buffer to write the data in
2354 * @start - where the actual data has been written in page
2355 * @offset - same meaning as the read system call
2356 * @count - same meaning as the read system call
2357 * @eof - set if no more data needs to be returned
2358 * @data - pointer to our soft state
2359 *
2360 * Display mailbox information for the last command issued. This information
2361 * is good for debugging.
2362 */
2363 static int
2364 proc_read_mbox(char *page, char **start, off_t offset, int count, int *eof,
2365 void *data)
2366 {
2367
2368 adapter_t *adapter = (adapter_t *)data;
2369 volatile mbox_t *mbox = adapter->mbox;
2370 int len = 0;
2371
2372 len = sprintf(page, "Contents of Mail Box Structure\n");
2373 len += sprintf(page+len, " Fw Command = 0x%02x\n",
2374 mbox->m_out.cmd);
2375 len += sprintf(page+len, " Cmd Sequence = 0x%02x\n",
2376 mbox->m_out.cmdid);
2377 len += sprintf(page+len, " No of Sectors= %04d\n",
2378 mbox->m_out.numsectors);
2379 len += sprintf(page+len, " LBA = 0x%02x\n",
2380 mbox->m_out.lba);
2381 len += sprintf(page+len, " DTA = 0x%08x\n",
2382 mbox->m_out.xferaddr);
2383 len += sprintf(page+len, " Logical Drive= 0x%02x\n",
2384 mbox->m_out.logdrv);
2385 len += sprintf(page+len, " No of SG Elmt= 0x%02x\n",
2386 mbox->m_out.numsgelements);
2387 len += sprintf(page+len, " Busy = %01x\n",
2388 mbox->m_in.busy);
2389 len += sprintf(page+len, " Status = 0x%02x\n",
2390 mbox->m_in.status);
2391
2392 *eof = 1;
2393
2394 return len;
2395 }
2396
2397
2398 /**
2399 * proc_rebuild_rate()
2400 * @page - buffer to write the data in
2401 * @start - where the actual data has been written in page
2402 * @offset - same meaning as the read system call
2403 * @count - same meaning as the read system call
2404 * @eof - set if no more data needs to be returned
2405 * @data - pointer to our soft state
2406 *
2407 * Display current rebuild rate
2408 */
2409 static int
2410 proc_rebuild_rate(char *page, char **start, off_t offset, int count, int *eof,
2411 void *data)
2412 {
2413 adapter_t *adapter = (adapter_t *)data;
2414 dma_addr_t dma_handle;
2415 caddr_t inquiry;
2416 struct pci_dev *pdev;
2417 int len = 0;
2418
2419 if( make_local_pdev(adapter, &pdev) != 0 ) {
2420 *eof = 1;
2421 return len;
2422 }
2423
2424 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL ) {
2425 free_local_pdev(pdev);
2426 *eof = 1;
2427 return len;
2428 }
2429
2430 if( mega_adapinq(adapter, dma_handle) != 0 ) {
2431
2432 len = sprintf(page, "Adapter inquiry failed.\n");
2433
2434 printk(KERN_WARNING "megaraid: inquiry failed.\n");
2435
2436 mega_free_inquiry(inquiry, dma_handle, pdev);
2437
2438 free_local_pdev(pdev);
2439
2440 *eof = 1;
2441
2442 return len;
2443 }
2444
2445 if( adapter->flag & BOARD_40LD ) {
2446 len = sprintf(page, "Rebuild Rate: [%d%%]\n",
2447 ((mega_inquiry3 *)inquiry)->rebuild_rate);
2448 }
2449 else {
2450 len = sprintf(page, "Rebuild Rate: [%d%%]\n",
2451 ((mraid_ext_inquiry *)
2452 inquiry)->raid_inq.adapter_info.rebuild_rate);
2453 }
2454
2455
2456 mega_free_inquiry(inquiry, dma_handle, pdev);
2457
2458 free_local_pdev(pdev);
2459
2460 *eof = 1;
2461
2462 return len;
2463 }
2464
2465
2466 /**
2467 * proc_battery()
2468 * @page - buffer to write the data in
2469 * @start - where the actual data has been written in page
2470 * @offset - same meaning as the read system call
2471 * @count - same meaning as the read system call
2472 * @eof - set if no more data needs to be returned
2473 * @data - pointer to our soft state
2474 *
2475 * Display information about the battery module on the controller.
2476 */
2477 static int
2478 proc_battery(char *page, char **start, off_t offset, int count, int *eof,
2479 void *data)
2480 {
2481 adapter_t *adapter = (adapter_t *)data;
2482 dma_addr_t dma_handle;
2483 caddr_t inquiry;
2484 struct pci_dev *pdev;
2485 u8 battery_status = 0;
2486 char str[256];
2487 int len = 0;
2488
2489 if( make_local_pdev(adapter, &pdev) != 0 ) {
2490 *eof = 1;
2491 return len;
2492 }
2493
2494 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL ) {
2495 free_local_pdev(pdev);
2496 *eof = 1;
2497 return len;
2498 }
2499
2500 if( mega_adapinq(adapter, dma_handle) != 0 ) {
2501
2502 len = sprintf(page, "Adapter inquiry failed.\n");
2503
2504 printk(KERN_WARNING "megaraid: inquiry failed.\n");
2505
2506 mega_free_inquiry(inquiry, dma_handle, pdev);
2507
2508 free_local_pdev(pdev);
2509
2510 *eof = 1;
2511
2512 return len;
2513 }
2514
2515 if( adapter->flag & BOARD_40LD ) {
2516 battery_status = ((mega_inquiry3 *)inquiry)->battery_status;
2517 }
2518 else {
2519 battery_status = ((mraid_ext_inquiry *)inquiry)->
2520 raid_inq.adapter_info.battery_status;
2521 }
2522
2523 /*
2524 * Decode the battery status
2525 */
2526 sprintf(str, "Battery Status:[%d]", battery_status);
2527
2528 if(battery_status == MEGA_BATT_CHARGE_DONE)
2529 strcat(str, " Charge Done");
2530
2531 if(battery_status & MEGA_BATT_MODULE_MISSING)
2532 strcat(str, " Module Missing");
2533
2534 if(battery_status & MEGA_BATT_LOW_VOLTAGE)
2535 strcat(str, " Low Voltage");
2536
2537 if(battery_status & MEGA_BATT_TEMP_HIGH)
2538 strcat(str, " Temperature High");
2539
2540 if(battery_status & MEGA_BATT_PACK_MISSING)
2541 strcat(str, " Pack Missing");
2542
2543 if(battery_status & MEGA_BATT_CHARGE_INPROG)
2544 strcat(str, " Charge In-progress");
2545
2546 if(battery_status & MEGA_BATT_CHARGE_FAIL)
2547 strcat(str, " Charge Fail");
2548
2549 if(battery_status & MEGA_BATT_CYCLES_EXCEEDED)
2550 strcat(str, " Cycles Exceeded");
2551
2552 len = sprintf(page, "%s\n", str);
2553
2554
2555 mega_free_inquiry(inquiry, dma_handle, pdev);
2556
2557 free_local_pdev(pdev);
2558
2559 *eof = 1;
2560
2561 return len;
2562 }
2563
2564
2565 /**
2566 * proc_pdrv_ch0()
2567 * @page - buffer to write the data in
2568 * @start - where the actual data has been written in page
2569 * @offset - same meaning as the read system call
2570 * @count - same meaning as the read system call
2571 * @eof - set if no more data needs to be returned
2572 * @data - pointer to our soft state
2573 *
2574 * Display information about the physical drives on physical channel 0.
2575 */
2576 static int
2577 proc_pdrv_ch0(char *page, char **start, off_t offset, int count, int *eof,
2578 void *data)
2579 {
2580 adapter_t *adapter = (adapter_t *)data;
2581
2582 *eof = 1;
2583
2584 return (proc_pdrv(adapter, page, 0));
2585 }
2586
2587
2588 /**
2589 * proc_pdrv_ch1()
2590 * @page - buffer to write the data in
2591 * @start - where the actual data has been written in page
2592 * @offset - same meaning as the read system call
2593 * @count - same meaning as the read system call
2594 * @eof - set if no more data needs to be returned
2595 * @data - pointer to our soft state
2596 *
2597 * Display information about the physical drives on physical channel 1.
2598 */
2599 static int
2600 proc_pdrv_ch1(char *page, char **start, off_t offset, int count, int *eof,
2601 void *data)
2602 {
2603 adapter_t *adapter = (adapter_t *)data;
2604
2605 *eof = 1;
2606
2607 return (proc_pdrv(adapter, page, 1));
2608 }
2609
2610
2611 /**
2612 * proc_pdrv_ch2()
2613 * @page - buffer to write the data in
2614 * @start - where the actual data has been written in page
2615 * @offset - same meaning as the read system call
2616 * @count - same meaning as the read system call
2617 * @eof - set if no more data needs to be returned
2618 * @data - pointer to our soft state
2619 *
2620 * Display information about the physical drives on physical channel 2.
2621 */
2622 static int
2623 proc_pdrv_ch2(char *page, char **start, off_t offset, int count, int *eof,
2624 void *data)
2625 {
2626 adapter_t *adapter = (adapter_t *)data;
2627
2628 *eof = 1;
2629
2630 return (proc_pdrv(adapter, page, 2));
2631 }
2632
2633
2634 /**
2635 * proc_pdrv_ch3()
2636 * @page - buffer to write the data in
2637 * @start - where the actual data has been written in page
2638 * @offset - same meaning as the read system call
2639 * @count - same meaning as the read system call
2640 * @eof - set if no more data needs to be returned
2641 * @data - pointer to our soft state
2642 *
2643 * Display information about the physical drives on physical channel 3.
2644 */
2645 static int
2646 proc_pdrv_ch3(char *page, char **start, off_t offset, int count, int *eof,
2647 void *data)
2648 {
2649 adapter_t *adapter = (adapter_t *)data;
2650
2651 *eof = 1;
2652
2653 return (proc_pdrv(adapter, page, 3));
2654 }
2655
2656
2657 /**
2658 * proc_pdrv()
2659 * @page - buffer to write the data in
2660 * @adapter - pointer to our soft state
2661 *
2662 * Display information about the physical drives.
2663 */
2664 static int
2665 proc_pdrv(adapter_t *adapter, char *page, int channel)
2666 {
2667 dma_addr_t dma_handle;
2668 char *scsi_inq;
2669 dma_addr_t scsi_inq_dma_handle;
2670 caddr_t inquiry;
2671 struct pci_dev *pdev;
2672 u8 *pdrv_state;
2673 u8 state;
2674 int tgt;
2675 int max_channels;
2676 int len = 0;
2677 char str[80];
2678 int i;
2679
2680 if( make_local_pdev(adapter, &pdev) != 0 ) {
2681 return len;
2682 }
2683
2684 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL ) {
2685 goto free_pdev;
2686 }
2687
2688 if( mega_adapinq(adapter, dma_handle) != 0 ) {
2689 len = sprintf(page, "Adapter inquiry failed.\n");
2690
2691 printk(KERN_WARNING "megaraid: inquiry failed.\n");
2692
2693 goto free_inquiry;
2694 }
2695
2696
2697 scsi_inq = pci_alloc_consistent(pdev, 256, &scsi_inq_dma_handle);
2698
2699 if( scsi_inq == NULL ) {
2700 len = sprintf(page, "memory not available for scsi inq.\n");
2701
2702 goto free_inquiry;
2703 }
2704
2705 if( adapter->flag & BOARD_40LD ) {
2706 pdrv_state = ((mega_inquiry3 *)inquiry)->pdrv_state;
2707 }
2708 else {
2709 pdrv_state = ((mraid_ext_inquiry *)inquiry)->
2710 raid_inq.pdrv_info.pdrv_state;
2711 }
2712
2713 max_channels = adapter->product_info.nchannels;
2714
2715 if( channel >= max_channels ) {
2716 goto free_pci;
2717 }
2718
2719 for( tgt = 0; tgt <= MAX_TARGET; tgt++ ) {
2720
2721 i = channel*16 + tgt;
2722
2723 state = *(pdrv_state + i);
2724
2725 switch( state & 0x0F ) {
2726
2727 case PDRV_ONLINE:
2728 sprintf(str,
2729 "Channel:%2d Id:%2d State: Online",
2730 channel, tgt);
2731 break;
2732
2733 case PDRV_FAILED:
2734 sprintf(str,
2735 "Channel:%2d Id:%2d State: Failed",
2736 channel, tgt);
2737 break;
2738
2739 case PDRV_RBLD:
2740 sprintf(str,
2741 "Channel:%2d Id:%2d State: Rebuild",
2742 channel, tgt);
2743 break;
2744
2745 case PDRV_HOTSPARE:
2746 sprintf(str,
2747 "Channel:%2d Id:%2d State: Hot spare",
2748 channel, tgt);
2749 break;
2750
2751 default:
2752 sprintf(str,
2753 "Channel:%2d Id:%2d State: Un-configured",
2754 channel, tgt);
2755 break;
2756
2757 }
2758
2759 /*
2760 * This interface displays inquiries for disk drives
2761 * only. Inquries for logical drives and non-disk
2762 * devices are available through /proc/scsi/scsi
2763 */
2764 memset(scsi_inq, 0, 256);
2765 if( mega_internal_dev_inquiry(adapter, channel, tgt,
2766 scsi_inq_dma_handle) ||
2767 (scsi_inq[0] & 0x1F) != TYPE_DISK ) {
2768 continue;
2769 }
2770
2771 /*
2772 * Check for overflow. We print less than 240
2773 * characters for inquiry
2774 */
2775 if( (len + 240) >= PAGE_SIZE ) break;
2776
2777 len += sprintf(page+len, "%s.\n", str);
2778
2779 len += mega_print_inquiry(page+len, scsi_inq);
2780 }
2781
2782 free_pci:
2783 pci_free_consistent(pdev, 256, scsi_inq, scsi_inq_dma_handle);
2784 free_inquiry:
2785 mega_free_inquiry(inquiry, dma_handle, pdev);
2786 free_pdev:
2787 free_local_pdev(pdev);
2788
2789 return len;
2790 }
2791
2792
2793 /*
2794 * Display scsi inquiry
2795 */
2796 static int
2797 mega_print_inquiry(char *page, char *scsi_inq)
2798 {
2799 int len = 0;
2800 int i;
2801
2802 len = sprintf(page, " Vendor: ");
2803 for( i = 8; i < 16; i++ ) {
2804 len += sprintf(page+len, "%c", scsi_inq[i]);
2805 }
2806
2807 len += sprintf(page+len, " Model: ");
2808
2809 for( i = 16; i < 32; i++ ) {
2810 len += sprintf(page+len, "%c", scsi_inq[i]);
2811 }
2812
2813 len += sprintf(page+len, " Rev: ");
2814
2815 for( i = 32; i < 36; i++ ) {
2816 len += sprintf(page+len, "%c", scsi_inq[i]);
2817 }
2818
2819 len += sprintf(page+len, "\n");
2820
2821 i = scsi_inq[0] & 0x1f;
2822
2823 len += sprintf(page+len, " Type: %s ", scsi_device_type(i));
2824
2825 len += sprintf(page+len,
2826 " ANSI SCSI revision: %02x", scsi_inq[2] & 0x07);
2827
2828 if( (scsi_inq[2] & 0x07) == 1 && (scsi_inq[3] & 0x0f) == 1 )
2829 len += sprintf(page+len, " CCS\n");
2830 else
2831 len += sprintf(page+len, "\n");
2832
2833 return len;
2834 }
2835
2836
2837 /**
2838 * proc_rdrv_10()
2839 * @page - buffer to write the data in
2840 * @start - where the actual data has been written in page
2841 * @offset - same meaning as the read system call
2842 * @count - same meaning as the read system call
2843 * @eof - set if no more data needs to be returned
2844 * @data - pointer to our soft state
2845 *
2846 * Display real time information about the logical drives 0 through 9.
2847 */
2848 static int
2849 proc_rdrv_10(char *page, char **start, off_t offset, int count, int *eof,
2850 void *data)
2851 {
2852 adapter_t *adapter = (adapter_t *)data;
2853
2854 *eof = 1;
2855
2856 return (proc_rdrv(adapter, page, 0, 9));
2857 }
2858
2859
2860 /**
2861 * proc_rdrv_20()
2862 * @page - buffer to write the data in
2863 * @start - where the actual data has been written in page
2864 * @offset - same meaning as the read system call
2865 * @count - same meaning as the read system call
2866 * @eof - set if no more data needs to be returned
2867 * @data - pointer to our soft state
2868 *
2869 * Display real time information about the logical drives 0 through 9.
2870 */
2871 static int
2872 proc_rdrv_20(char *page, char **start, off_t offset, int count, int *eof,
2873 void *data)
2874 {
2875 adapter_t *adapter = (adapter_t *)data;
2876
2877 *eof = 1;
2878
2879 return (proc_rdrv(adapter, page, 10, 19));
2880 }
2881
2882
2883 /**
2884 * proc_rdrv_30()
2885 * @page - buffer to write the data in
2886 * @start - where the actual data has been written in page
2887 * @offset - same meaning as the read system call
2888 * @count - same meaning as the read system call
2889 * @eof - set if no more data needs to be returned
2890 * @data - pointer to our soft state
2891 *
2892 * Display real time information about the logical drives 0 through 9.
2893 */
2894 static int
2895 proc_rdrv_30(char *page, char **start, off_t offset, int count, int *eof,
2896 void *data)
2897 {
2898 adapter_t *adapter = (adapter_t *)data;
2899
2900 *eof = 1;
2901
2902 return (proc_rdrv(adapter, page, 20, 29));
2903 }
2904
2905
2906 /**
2907 * proc_rdrv_40()
2908 * @page - buffer to write the data in
2909 * @start - where the actual data has been written in page
2910 * @offset - same meaning as the read system call
2911 * @count - same meaning as the read system call
2912 * @eof - set if no more data needs to be returned
2913 * @data - pointer to our soft state
2914 *
2915 * Display real time information about the logical drives 0 through 9.
2916 */
2917 static int
2918 proc_rdrv_40(char *page, char **start, off_t offset, int count, int *eof,
2919 void *data)
2920 {
2921 adapter_t *adapter = (adapter_t *)data;
2922
2923 *eof = 1;
2924
2925 return (proc_rdrv(adapter, page, 30, 39));
2926 }
2927
2928
2929 /**
2930 * proc_rdrv()
2931 * @page - buffer to write the data in
2932 * @adapter - pointer to our soft state
2933 * @start - starting logical drive to display
2934 * @end - ending logical drive to display
2935 *
2936 * We do not print the inquiry information since its already available through
2937 * /proc/scsi/scsi interface
2938 */
2939 static int
2940 proc_rdrv(adapter_t *adapter, char *page, int start, int end )
2941 {
2942 dma_addr_t dma_handle;
2943 logdrv_param *lparam;
2944 megacmd_t mc;
2945 char *disk_array;
2946 dma_addr_t disk_array_dma_handle;
2947 caddr_t inquiry;
2948 struct pci_dev *pdev;
2949 u8 *rdrv_state;
2950 int num_ldrv;
2951 u32 array_sz;
2952 int len = 0;
2953 int i;
2954
2955 if( make_local_pdev(adapter, &pdev) != 0 ) {
2956 return len;
2957 }
2958
2959 if( (inquiry = mega_allocate_inquiry(&dma_handle, pdev)) == NULL ) {
2960 free_local_pdev(pdev);
2961 return len;
2962 }
2963
2964 if( mega_adapinq(adapter, dma_handle) != 0 ) {
2965
2966 len = sprintf(page, "Adapter inquiry failed.\n");
2967
2968 printk(KERN_WARNING "megaraid: inquiry failed.\n");
2969
2970 mega_free_inquiry(inquiry, dma_handle, pdev);
2971
2972 free_local_pdev(pdev);
2973
2974 return len;
2975 }
2976
2977 memset(&mc, 0, sizeof(megacmd_t));
2978
2979 if( adapter->flag & BOARD_40LD ) {
2980 array_sz = sizeof(disk_array_40ld);
2981
2982 rdrv_state = ((mega_inquiry3 *)inquiry)->ldrv_state;
2983
2984 num_ldrv = ((mega_inquiry3 *)inquiry)->num_ldrv;
2985 }
2986 else {
2987 array_sz = sizeof(disk_array_8ld);
2988
2989 rdrv_state = ((mraid_ext_inquiry *)inquiry)->
2990 raid_inq.logdrv_info.ldrv_state;
2991
2992 num_ldrv = ((mraid_ext_inquiry *)inquiry)->
2993 raid_inq.logdrv_info.num_ldrv;
2994 }
2995
2996 disk_array = pci_alloc_consistent(pdev, array_sz,
2997 &disk_array_dma_handle);
2998
2999 if( disk_array == NULL ) {
3000 len = sprintf(page, "memory not available.\n");
3001
3002 mega_free_inquiry(inquiry, dma_handle, pdev);
3003
3004 free_local_pdev(pdev);
3005
3006 return len;
3007 }
3008
3009 mc.xferaddr = (u32)disk_array_dma_handle;
3010
3011 if( adapter->flag & BOARD_40LD ) {
3012 mc.cmd = FC_NEW_CONFIG;
3013 mc.opcode = OP_DCMD_READ_CONFIG;
3014
3015 if( mega_internal_command(adapter, &mc, NULL) ) {
3016
3017 len = sprintf(page, "40LD read config failed.\n");
3018
3019 mega_free_inquiry(inquiry, dma_handle, pdev);
3020
3021 pci_free_consistent(pdev, array_sz, disk_array,
3022 disk_array_dma_handle);
3023
3024 free_local_pdev(pdev);
3025
3026 return len;
3027 }
3028
3029 }
3030 else {
3031 mc.cmd = NEW_READ_CONFIG_8LD;
3032
3033 if( mega_internal_command(adapter, &mc, NULL) ) {
3034
3035 mc.cmd = READ_CONFIG_8LD;
3036
3037 if( mega_internal_command(adapter, &mc,
3038 NULL) ){
3039
3040 len = sprintf(page,
3041 "8LD read config failed.\n");
3042
3043 mega_free_inquiry(inquiry, dma_handle, pdev);
3044
3045 pci_free_consistent(pdev, array_sz,
3046 disk_array,
3047 disk_array_dma_handle);
3048
3049 free_local_pdev(pdev);
3050
3051 return len;
3052 }
3053 }
3054 }
3055
3056 for( i = start; i < ( (end+1 < num_ldrv) ? end+1 : num_ldrv ); i++ ) {
3057
3058 if( adapter->flag & BOARD_40LD ) {
3059 lparam =
3060 &((disk_array_40ld *)disk_array)->ldrv[i].lparam;
3061 }
3062 else {
3063 lparam =
3064 &((disk_array_8ld *)disk_array)->ldrv[i].lparam;
3065 }
3066
3067 /*
3068 * Check for overflow. We print less than 240 characters for
3069 * information about each logical drive.
3070 */
3071 if( (len + 240) >= PAGE_SIZE ) break;
3072
3073 len += sprintf(page+len, "Logical drive:%2d:, ", i);
3074
3075 switch( rdrv_state[i] & 0x0F ) {
3076 case RDRV_OFFLINE:
3077 len += sprintf(page+len, "state: offline");
3078 break;
3079
3080 case RDRV_DEGRADED:
3081 len += sprintf(page+len, "state: degraded");
3082 break;
3083
3084 case RDRV_OPTIMAL:
3085 len += sprintf(page+len, "state: optimal");
3086 break;
3087
3088 case RDRV_DELETED:
3089 len += sprintf(page+len, "state: deleted");
3090 break;
3091
3092 default:
3093 len += sprintf(page+len, "state: unknown");
3094 break;
3095 }
3096
3097 /*
3098 * Check if check consistency or initialization is going on
3099 * for this logical drive.
3100 */
3101 if( (rdrv_state[i] & 0xF0) == 0x20 ) {
3102 len += sprintf(page+len,
3103 ", check-consistency in progress");
3104 }
3105 else if( (rdrv_state[i] & 0xF0) == 0x10 ) {
3106 len += sprintf(page+len,
3107 ", initialization in progress");
3108 }
3109
3110 len += sprintf(page+len, "\n");
3111
3112 len += sprintf(page+len, "Span depth:%3d, ",
3113 lparam->span_depth);
3114
3115 len += sprintf(page+len, "RAID level:%3d, ",
3116 lparam->level);
3117
3118 len += sprintf(page+len, "Stripe size:%3d, ",
3119 lparam->stripe_sz ? lparam->stripe_sz/2: 128);
3120
3121 len += sprintf(page+len, "Row size:%3d\n",
3122 lparam->row_size);
3123
3124
3125 len += sprintf(page+len, "Read Policy: ");
3126
3127 switch(lparam->read_ahead) {
3128
3129 case NO_READ_AHEAD:
3130 len += sprintf(page+len, "No read ahead, ");
3131 break;
3132
3133 case READ_AHEAD:
3134 len += sprintf(page+len, "Read ahead, ");
3135 break;
3136
3137 case ADAP_READ_AHEAD:
3138 len += sprintf(page+len, "Adaptive, ");
3139 break;
3140
3141 }
3142
3143 len += sprintf(page+len, "Write Policy: ");
3144
3145 switch(lparam->write_mode) {
3146
3147 case WRMODE_WRITE_THRU:
3148 len += sprintf(page+len, "Write thru, ");
3149 break;
3150
3151 case WRMODE_WRITE_BACK:
3152 len += sprintf(page+len, "Write back, ");
3153 break;
3154 }
3155
3156 len += sprintf(page+len, "Cache Policy: ");
3157
3158 switch(lparam->direct_io) {
3159
3160 case CACHED_IO:
3161 len += sprintf(page+len, "Cached IO\n\n");
3162 break;
3163
3164 case DIRECT_IO:
3165 len += sprintf(page+len, "Direct IO\n\n");
3166 break;
3167 }
3168 }
3169
3170 mega_free_inquiry(inquiry, dma_handle, pdev);
3171
3172 pci_free_consistent(pdev, array_sz, disk_array,
3173 disk_array_dma_handle);
3174
3175 free_local_pdev(pdev);
3176
3177 return len;
3178 }
3179
3180 #endif
3181
3182
3183 /**
3184 * megaraid_biosparam()
3185 *
3186 * Return the disk geometry for a particular disk
3187 */
3188 static int
3189 megaraid_biosparam(struct scsi_device *sdev, struct block_device *bdev,
3190 sector_t capacity, int geom[])
3191 {
3192 adapter_t *adapter;
3193 unsigned char *bh;
3194 int heads;
3195 int sectors;
3196 int cylinders;
3197 int rval;
3198
3199 /* Get pointer to host config structure */
3200 adapter = (adapter_t *)sdev->host->hostdata;
3201
3202 if (IS_RAID_CH(adapter, sdev->channel)) {
3203 /* Default heads (64) & sectors (32) */
3204 heads = 64;
3205 sectors = 32;
3206 cylinders = (ulong)capacity / (heads * sectors);
3207
3208 /*
3209 * Handle extended translation size for logical drives
3210 * > 1Gb
3211 */
3212 if ((ulong)capacity >= 0x200000) {
3213 heads = 255;
3214 sectors = 63;
3215 cylinders = (ulong)capacity / (heads * sectors);
3216 }
3217
3218 /* return result */
3219 geom[0] = heads;
3220 geom[1] = sectors;
3221 geom[2] = cylinders;
3222 }
3223 else {
3224 bh = scsi_bios_ptable(bdev);
3225
3226 if( bh ) {
3227 rval = scsi_partsize(bh, capacity,
3228 &geom[2], &geom[0], &geom[1]);
3229 kfree(bh);
3230 if( rval != -1 )
3231 return rval;
3232 }
3233
3234 printk(KERN_INFO
3235 "megaraid: invalid partition on this disk on channel %d\n",
3236 sdev->channel);
3237
3238 /* Default heads (64) & sectors (32) */
3239 heads = 64;
3240 sectors = 32;
3241 cylinders = (ulong)capacity / (heads * sectors);
3242
3243 /* Handle extended translation size for logical drives > 1Gb */
3244 if ((ulong)capacity >= 0x200000) {
3245 heads = 255;
3246 sectors = 63;
3247 cylinders = (ulong)capacity / (heads * sectors);
3248 }
3249
3250 /* return result */
3251 geom[0] = heads;
3252 geom[1] = sectors;
3253 geom[2] = cylinders;
3254 }
3255
3256 return 0;
3257 }
3258
3259 /**
3260 * mega_init_scb()
3261 * @adapter - pointer to our soft state
3262 *
3263 * Allocate memory for the various pointers in the scb structures:
3264 * scatter-gather list pointer, passthru and extended passthru structure
3265 * pointers.
3266 */
3267 static int
3268 mega_init_scb(adapter_t *adapter)
3269 {
3270 scb_t *scb;
3271 int i;
3272
3273 for( i = 0; i < adapter->max_cmds; i++ ) {
3274
3275 scb = &adapter->scb_list[i];
3276
3277 scb->sgl64 = NULL;
3278 scb->sgl = NULL;
3279 scb->pthru = NULL;
3280 scb->epthru = NULL;
3281 }
3282
3283 for( i = 0; i < adapter->max_cmds; i++ ) {
3284
3285 scb = &adapter->scb_list[i];
3286
3287 scb->idx = i;
3288
3289 scb->sgl64 = pci_alloc_consistent(adapter->dev,
3290 sizeof(mega_sgl64) * adapter->sglen,
3291 &scb->sgl_dma_addr);
3292
3293 scb->sgl = (mega_sglist *)scb->sgl64;
3294
3295 if( !scb->sgl ) {
3296 printk(KERN_WARNING "RAID: Can't allocate sglist.\n");
3297 mega_free_sgl(adapter);
3298 return -1;
3299 }
3300
3301 scb->pthru = pci_alloc_consistent(adapter->dev,
3302 sizeof(mega_passthru),
3303 &scb->pthru_dma_addr);
3304
3305 if( !scb->pthru ) {
3306 printk(KERN_WARNING "RAID: Can't allocate passthru.\n");
3307 mega_free_sgl(adapter);
3308 return -1;
3309 }
3310
3311 scb->epthru = pci_alloc_consistent(adapter->dev,
3312 sizeof(mega_ext_passthru),
3313 &scb->epthru_dma_addr);
3314
3315 if( !scb->epthru ) {
3316 printk(KERN_WARNING
3317 "Can't allocate extended passthru.\n");
3318 mega_free_sgl(adapter);
3319 return -1;
3320 }
3321
3322
3323 scb->dma_type = MEGA_DMA_TYPE_NONE;
3324
3325 /*
3326 * Link to free list
3327 * lock not required since we are loading the driver, so no
3328 * commands possible right now.
3329 */
3330 scb->state = SCB_FREE;
3331 scb->cmd = NULL;
3332 list_add(&scb->list, &adapter->free_list);
3333 }
3334
3335 return 0;
3336 }
3337
3338
3339 /**
3340 * megadev_open()
3341 * @inode - unused
3342 * @filep - unused
3343 *
3344 * Routines for the character/ioctl interface to the driver. Find out if this
3345 * is a valid open. If yes, increment the module use count so that it cannot
3346 * be unloaded.
3347 */
3348 static int
3349 megadev_open (struct inode *inode, struct file *filep)
3350 {
3351 /*
3352 * Only allow superuser to access private ioctl interface
3353 */
3354 if( !capable(CAP_SYS_ADMIN) ) return -EACCES;
3355
3356 return 0;
3357 }
3358
3359
3360 /**
3361 * megadev_ioctl()
3362 * @inode - Our device inode
3363 * @filep - unused
3364 * @cmd - ioctl command
3365 * @arg - user buffer
3366 *
3367 * ioctl entry point for our private ioctl interface. We move the data in from
3368 * the user space, prepare the command (if necessary, convert the old MIMD
3369 * ioctl to new ioctl command), and issue a synchronous command to the
3370 * controller.
3371 */
3372 static int
3373 megadev_ioctl(struct inode *inode, struct file *filep, unsigned int cmd,
3374 unsigned long arg)
3375 {
3376 adapter_t *adapter;
3377 nitioctl_t uioc;
3378 int adapno;
3379 int rval;
3380 mega_passthru __user *upthru; /* user address for passthru */
3381 mega_passthru *pthru; /* copy user passthru here */
3382 dma_addr_t pthru_dma_hndl;
3383 void *data = NULL; /* data to be transferred */
3384 dma_addr_t data_dma_hndl; /* dma handle for data xfer area */
3385 megacmd_t mc;
3386 megastat_t __user *ustats;
3387 int num_ldrv;
3388 u32 uxferaddr = 0;
3389 struct pci_dev *pdev;
3390
3391 ustats = NULL; /* avoid compilation warnings */
3392 num_ldrv = 0;
3393
3394 /*
3395 * Make sure only USCSICMD are issued through this interface.
3396 * MIMD application would still fire different command.
3397 */
3398 if( (_IOC_TYPE(cmd) != MEGAIOC_MAGIC) && (cmd != USCSICMD) ) {
3399 return -EINVAL;
3400 }
3401
3402 /*
3403 * Check and convert a possible MIMD command to NIT command.
3404 * mega_m_to_n() copies the data from the user space, so we do not
3405 * have to do it here.
3406 * NOTE: We will need some user address to copyout the data, therefore
3407 * the inteface layer will also provide us with the required user
3408 * addresses.
3409 */
3410 memset(&uioc, 0, sizeof(nitioctl_t));
3411 if( (rval = mega_m_to_n( (void __user *)arg, &uioc)) != 0 )
3412 return rval;
3413
3414
3415 switch( uioc.opcode ) {
3416
3417 case GET_DRIVER_VER:
3418 if( put_user(driver_ver, (u32 __user *)uioc.uioc_uaddr) )
3419 return (-EFAULT);
3420
3421 break;
3422
3423 case GET_N_ADAP:
3424 if( put_user(hba_count, (u32 __user *)uioc.uioc_uaddr) )
3425 return (-EFAULT);
3426
3427 /*
3428 * Shucks. MIMD interface returns a positive value for number
3429 * of adapters. TODO: Change it to return 0 when there is no
3430 * applicatio using mimd interface.
3431 */
3432 return hba_count;
3433
3434 case GET_ADAP_INFO:
3435
3436 /*
3437 * Which adapter
3438 */
3439 if( (adapno = GETADAP(uioc.adapno)) >= hba_count )
3440 return (-ENODEV);
3441
3442 if( copy_to_user(uioc.uioc_uaddr, mcontroller+adapno,
3443 sizeof(struct mcontroller)) )
3444 return (-EFAULT);
3445 break;
3446
3447 #if MEGA_HAVE_STATS
3448
3449 case GET_STATS:
3450 /*
3451 * Which adapter
3452 */
3453 if( (adapno = GETADAP(uioc.adapno)) >= hba_count )
3454 return (-ENODEV);
3455
3456 adapter = hba_soft_state[adapno];
3457
3458 ustats = uioc.uioc_uaddr;
3459
3460 if( copy_from_user(&num_ldrv, &ustats->num_ldrv, sizeof(int)) )
3461 return (-EFAULT);
3462
3463 /*
3464 * Check for the validity of the logical drive number
3465 */
3466 if( num_ldrv >= MAX_LOGICAL_DRIVES_40LD ) return -EINVAL;
3467
3468 if( copy_to_user(ustats->nreads, adapter->nreads,
3469 num_ldrv*sizeof(u32)) )
3470 return -EFAULT;
3471
3472 if( copy_to_user(ustats->nreadblocks, adapter->nreadblocks,
3473 num_ldrv*sizeof(u32)) )
3474 return -EFAULT;
3475
3476 if( copy_to_user(ustats->nwrites, adapter->nwrites,
3477 num_ldrv*sizeof(u32)) )
3478 return -EFAULT;
3479
3480 if( copy_to_user(ustats->nwriteblocks, adapter->nwriteblocks,
3481 num_ldrv*sizeof(u32)) )
3482 return -EFAULT;
3483
3484 if( copy_to_user(ustats->rd_errors, adapter->rd_errors,
3485 num_ldrv*sizeof(u32)) )
3486 return -EFAULT;
3487
3488 if( copy_to_user(ustats->wr_errors, adapter->wr_errors,
3489 num_ldrv*sizeof(u32)) )
3490 return -EFAULT;
3491
3492 return 0;
3493
3494 #endif
3495 case MBOX_CMD:
3496
3497 /*
3498 * Which adapter
3499 */
3500 if( (adapno = GETADAP(uioc.adapno)) >= hba_count )
3501 return (-ENODEV);
3502
3503 adapter = hba_soft_state[adapno];
3504
3505 /*
3506 * Deletion of logical drive is a special case. The adapter
3507 * should be quiescent before this command is issued.
3508 */
3509 if( uioc.uioc_rmbox[0] == FC_DEL_LOGDRV &&
3510 uioc.uioc_rmbox[2] == OP_DEL_LOGDRV ) {
3511
3512 /*
3513 * Do we support this feature
3514 */
3515 if( !adapter->support_random_del ) {
3516 printk(KERN_WARNING "megaraid: logdrv ");
3517 printk("delete on non-supporting F/W.\n");
3518
3519 return (-EINVAL);
3520 }
3521
3522 rval = mega_del_logdrv( adapter, uioc.uioc_rmbox[3] );
3523
3524 if( rval == 0 ) {
3525 memset(&mc, 0, sizeof(megacmd_t));
3526
3527 mc.status = rval;
3528
3529 rval = mega_n_to_m((void __user *)arg, &mc);
3530 }
3531
3532 return rval;
3533 }
3534 /*
3535 * This interface only support the regular passthru commands.
3536 * Reject extended passthru and 64-bit passthru
3537 */
3538 if( uioc.uioc_rmbox[0] == MEGA_MBOXCMD_PASSTHRU64 ||
3539 uioc.uioc_rmbox[0] == MEGA_MBOXCMD_EXTPTHRU ) {
3540
3541 printk(KERN_WARNING "megaraid: rejected passthru.\n");
3542
3543 return (-EINVAL);
3544 }
3545
3546 /*
3547 * For all internal commands, the buffer must be allocated in
3548 * <4GB address range
3549 */
3550 if( make_local_pdev(adapter, &pdev) != 0 )
3551 return -EIO;
3552
3553 /* Is it a passthru command or a DCMD */
3554 if( uioc.uioc_rmbox[0] == MEGA_MBOXCMD_PASSTHRU ) {
3555 /* Passthru commands */
3556
3557 pthru = pci_alloc_consistent(pdev,
3558 sizeof(mega_passthru),
3559 &pthru_dma_hndl);
3560
3561 if( pthru == NULL ) {
3562 free_local_pdev(pdev);
3563 return (-ENOMEM);
3564 }
3565
3566 /*
3567 * The user passthru structure
3568 */
3569 upthru = (mega_passthru __user *)MBOX(uioc)->xferaddr;
3570
3571 /*
3572 * Copy in the user passthru here.
3573 */
3574 if( copy_from_user(pthru, upthru,
3575 sizeof(mega_passthru)) ) {
3576
3577 pci_free_consistent(pdev,
3578 sizeof(mega_passthru), pthru,
3579 pthru_dma_hndl);
3580
3581 free_local_pdev(pdev);
3582
3583 return (-EFAULT);
3584 }
3585
3586 /*
3587 * Is there a data transfer
3588 */
3589 if( pthru->dataxferlen ) {
3590 data = pci_alloc_consistent(pdev,
3591 pthru->dataxferlen,
3592 &data_dma_hndl);
3593
3594 if( data == NULL ) {
3595 pci_free_consistent(pdev,
3596 sizeof(mega_passthru),
3597 pthru,
3598 pthru_dma_hndl);
3599
3600 free_local_pdev(pdev);
3601
3602 return (-ENOMEM);
3603 }
3604
3605 /*
3606 * Save the user address and point the kernel
3607 * address at just allocated memory
3608 */
3609 uxferaddr = pthru->dataxferaddr;
3610 pthru->dataxferaddr = data_dma_hndl;
3611 }
3612
3613
3614 /*
3615 * Is data coming down-stream
3616 */
3617 if( pthru->dataxferlen && (uioc.flags & UIOC_WR) ) {
3618 /*
3619 * Get the user data
3620 */
3621 if( copy_from_user(data, (char __user *)uxferaddr,
3622 pthru->dataxferlen) ) {
3623 rval = (-EFAULT);
3624 goto freemem_and_return;
3625 }
3626 }
3627
3628 memset(&mc, 0, sizeof(megacmd_t));
3629
3630 mc.cmd = MEGA_MBOXCMD_PASSTHRU;
3631 mc.xferaddr = (u32)pthru_dma_hndl;
3632
3633 /*
3634 * Issue the command
3635 */
3636 mega_internal_command(adapter, &mc, pthru);
3637
3638 rval = mega_n_to_m((void __user *)arg, &mc);
3639
3640 if( rval ) goto freemem_and_return;
3641
3642
3643 /*
3644 * Is data going up-stream
3645 */
3646 if( pthru->dataxferlen && (uioc.flags & UIOC_RD) ) {
3647 if( copy_to_user((char __user *)uxferaddr, data,
3648 pthru->dataxferlen) ) {
3649 rval = (-EFAULT);
3650 }
3651 }
3652
3653 /*
3654 * Send the request sense data also, irrespective of
3655 * whether the user has asked for it or not.
3656 */
3657 if (copy_to_user(upthru->reqsensearea,
3658 pthru->reqsensearea, 14))
3659 rval = -EFAULT;
3660
3661 freemem_and_return:
3662 if( pthru->dataxferlen ) {
3663 pci_free_consistent(pdev,
3664 pthru->dataxferlen, data,
3665 data_dma_hndl);
3666 }
3667
3668 pci_free_consistent(pdev, sizeof(mega_passthru),
3669 pthru, pthru_dma_hndl);
3670
3671 free_local_pdev(pdev);
3672
3673 return rval;
3674 }
3675 else {
3676 /* DCMD commands */
3677
3678 /*
3679 * Is there a data transfer
3680 */
3681 if( uioc.xferlen ) {
3682 data = pci_alloc_consistent(pdev,
3683 uioc.xferlen, &data_dma_hndl);
3684
3685 if( data == NULL ) {
3686 free_local_pdev(pdev);
3687 return (-ENOMEM);
3688 }
3689
3690 uxferaddr = MBOX(uioc)->xferaddr;
3691 }
3692
3693 /*
3694 * Is data coming down-stream
3695 */
3696 if( uioc.xferlen && (uioc.flags & UIOC_WR) ) {
3697 /*
3698 * Get the user data
3699 */
3700 if( copy_from_user(data, (char __user *)uxferaddr,
3701 uioc.xferlen) ) {
3702
3703 pci_free_consistent(pdev,
3704 uioc.xferlen,
3705 data, data_dma_hndl);
3706
3707 free_local_pdev(pdev);
3708
3709 return (-EFAULT);
3710 }
3711 }
3712
3713 memcpy(&mc, MBOX(uioc), sizeof(megacmd_t));
3714
3715 mc.xferaddr = (u32)data_dma_hndl;
3716
3717 /*
3718 * Issue the command
3719 */
3720 mega_internal_command(adapter, &mc, NULL);
3721
3722 rval = mega_n_to_m((void __user *)arg, &mc);
3723
3724 if( rval ) {
3725 if( uioc.xferlen ) {
3726 pci_free_consistent(pdev,
3727 uioc.xferlen, data,
3728 data_dma_hndl);
3729 }
3730
3731 free_local_pdev(pdev);
3732
3733 return rval;
3734 }
3735
3736 /*
3737 * Is data going up-stream
3738 */
3739 if( uioc.xferlen && (uioc.flags & UIOC_RD) ) {
3740 if( copy_to_user((char __user *)uxferaddr, data,
3741 uioc.xferlen) ) {
3742
3743 rval = (-EFAULT);
3744 }
3745 }
3746
3747 if( uioc.xferlen ) {
3748 pci_free_consistent(pdev,
3749 uioc.xferlen, data,
3750 data_dma_hndl);
3751 }
3752
3753 free_local_pdev(pdev);
3754
3755 return rval;
3756 }
3757
3758 default:
3759 return (-EINVAL);
3760 }
3761
3762 return 0;
3763 }
3764
3765 /**
3766 * mega_m_to_n()
3767 * @arg - user address
3768 * @uioc - new ioctl structure
3769 *
3770 * A thin layer to convert older mimd interface ioctl structure to NIT ioctl
3771 * structure
3772 *
3773 * Converts the older mimd ioctl structure to newer NIT structure
3774 */
3775 static int
3776 mega_m_to_n(void __user *arg, nitioctl_t *uioc)
3777 {
3778 struct uioctl_t uioc_mimd;
3779 char signature[8] = {0};
3780 u8 opcode;
3781 u8 subopcode;
3782
3783
3784 /*
3785 * check is the application conforms to NIT. We do not have to do much
3786 * in that case.
3787 * We exploit the fact that the signature is stored in the very
3788 * begining of the structure.
3789 */
3790
3791 if( copy_from_user(signature, arg, 7) )
3792 return (-EFAULT);
3793
3794 if( memcmp(signature, "MEGANIT", 7) == 0 ) {
3795
3796 /*
3797 * NOTE NOTE: The nit ioctl is still under flux because of
3798 * change of mailbox definition, in HPE. No applications yet
3799 * use this interface and let's not have applications use this
3800 * interface till the new specifitions are in place.
3801 */
3802 return -EINVAL;
3803 #if 0
3804 if( copy_from_user(uioc, arg, sizeof(nitioctl_t)) )
3805 return (-EFAULT);
3806 return 0;
3807 #endif
3808 }
3809
3810 /*
3811 * Else assume we have mimd uioctl_t as arg. Convert to nitioctl_t
3812 *
3813 * Get the user ioctl structure
3814 */
3815 if( copy_from_user(&uioc_mimd, arg, sizeof(struct uioctl_t)) )
3816 return (-EFAULT);
3817
3818
3819 /*
3820 * Get the opcode and subopcode for the commands
3821 */
3822 opcode = uioc_mimd.ui.fcs.opcode;
3823 subopcode = uioc_mimd.ui.fcs.subopcode;
3824
3825 switch (opcode) {
3826 case 0x82:
3827
3828 switch (subopcode) {
3829
3830 case MEGAIOC_QDRVRVER: /* Query driver version */
3831 uioc->opcode = GET_DRIVER_VER;
3832 uioc->uioc_uaddr = uioc_mimd.data;
3833 break;
3834
3835 case MEGAIOC_QNADAP: /* Get # of adapters */
3836 uioc->opcode = GET_N_ADAP;
3837 uioc->uioc_uaddr = uioc_mimd.data;
3838 break;
3839
3840 case MEGAIOC_QADAPINFO: /* Get adapter information */
3841 uioc->opcode = GET_ADAP_INFO;
3842 uioc->adapno = uioc_mimd.ui.fcs.adapno;
3843 uioc->uioc_uaddr = uioc_mimd.data;
3844 break;
3845
3846 default:
3847 return(-EINVAL);
3848 }
3849
3850 break;
3851
3852
3853 case 0x81:
3854
3855 uioc->opcode = MBOX_CMD;
3856 uioc->adapno = uioc_mimd.ui.fcs.adapno;
3857
3858 memcpy(uioc->uioc_rmbox, uioc_mimd.mbox, 18);
3859
3860 uioc->xferlen = uioc_mimd.ui.fcs.length;
3861
3862 if( uioc_mimd.outlen ) uioc->flags = UIOC_RD;
3863 if( uioc_mimd.inlen ) uioc->flags |= UIOC_WR;
3864
3865 break;
3866
3867 case 0x80:
3868
3869 uioc->opcode = MBOX_CMD;
3870 uioc->adapno = uioc_mimd.ui.fcs.adapno;
3871
3872 memcpy(uioc->uioc_rmbox, uioc_mimd.mbox, 18);
3873
3874 /*
3875 * Choose the xferlen bigger of input and output data
3876 */
3877 uioc->xferlen = uioc_mimd.outlen > uioc_mimd.inlen ?
3878 uioc_mimd.outlen : uioc_mimd.inlen;
3879
3880 if( uioc_mimd.outlen ) uioc->flags = UIOC_RD;
3881 if( uioc_mimd.inlen ) uioc->flags |= UIOC_WR;
3882
3883 break;
3884
3885 default:
3886 return (-EINVAL);
3887
3888 }
3889
3890 return 0;
3891 }
3892
3893 /*
3894 * mega_n_to_m()
3895 * @arg - user address
3896 * @mc - mailbox command
3897 *
3898 * Updates the status information to the application, depending on application
3899 * conforms to older mimd ioctl interface or newer NIT ioctl interface
3900 */
3901 static int
3902 mega_n_to_m(void __user *arg, megacmd_t *mc)
3903 {
3904 nitioctl_t __user *uiocp;
3905 megacmd_t __user *umc;
3906 mega_passthru __user *upthru;
3907 struct uioctl_t __user *uioc_mimd;
3908 char signature[8] = {0};
3909
3910 /*
3911 * check is the application conforms to NIT.
3912 */
3913 if( copy_from_user(signature, arg, 7) )
3914 return -EFAULT;
3915
3916 if( memcmp(signature, "MEGANIT", 7) == 0 ) {
3917
3918 uiocp = arg;
3919
3920 if( put_user(mc->status, (u8 __user *)&MBOX_P(uiocp)->status) )
3921 return (-EFAULT);
3922
3923 if( mc->cmd == MEGA_MBOXCMD_PASSTHRU ) {
3924
3925 umc = MBOX_P(uiocp);
3926
3927 if (get_user(upthru, (mega_passthru __user * __user *)&umc->xferaddr))
3928 return -EFAULT;
3929
3930 if( put_user(mc->status, (u8 __user *)&upthru->scsistatus))
3931 return (-EFAULT);
3932 }
3933 }
3934 else {
3935 uioc_mimd = arg;
3936
3937 if( put_user(mc->status, (u8 __user *)&uioc_mimd->mbox[17]) )
3938 return (-EFAULT);
3939
3940 if( mc->cmd == MEGA_MBOXCMD_PASSTHRU ) {
3941
3942 umc = (megacmd_t __user *)uioc_mimd->mbox;
3943
3944 if (get_user(upthru, (mega_passthru __user * __user *)&umc->xferaddr))
3945 return (-EFAULT);
3946
3947 if( put_user(mc->status, (u8 __user *)&upthru->scsistatus) )
3948 return (-EFAULT);
3949 }
3950 }
3951
3952 return 0;
3953 }
3954
3955
3956 /*
3957 * MEGARAID 'FW' commands.
3958 */
3959
3960 /**
3961 * mega_is_bios_enabled()
3962 * @adapter - pointer to our soft state
3963 *
3964 * issue command to find out if the BIOS is enabled for this controller
3965 */
3966 static int
3967 mega_is_bios_enabled(adapter_t *adapter)
3968 {
3969 unsigned char raw_mbox[sizeof(struct mbox_out)];
3970 mbox_t *mbox;
3971 int ret;
3972
3973 mbox = (mbox_t *)raw_mbox;
3974
3975 memset(&mbox->m_out, 0, sizeof(raw_mbox));
3976
3977 memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
3978
3979 mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle;
3980
3981 raw_mbox[0] = IS_BIOS_ENABLED;
3982 raw_mbox[2] = GET_BIOS;
3983
3984
3985 ret = issue_scb_block(adapter, raw_mbox);
3986
3987 return *(char *)adapter->mega_buffer;
3988 }
3989
3990
3991 /**
3992 * mega_enum_raid_scsi()
3993 * @adapter - pointer to our soft state
3994 *
3995 * Find out what channels are RAID/SCSI. This information is used to
3996 * differentiate the virtual channels and physical channels and to support
3997 * ROMB feature and non-disk devices.
3998 */
3999 static void
4000 mega_enum_raid_scsi(adapter_t *adapter)
4001 {
4002 unsigned char raw_mbox[sizeof(struct mbox_out)];
4003 mbox_t *mbox;
4004 int i;
4005
4006 mbox = (mbox_t *)raw_mbox;
4007
4008 memset(&mbox->m_out, 0, sizeof(raw_mbox));
4009
4010 /*
4011 * issue command to find out what channels are raid/scsi
4012 */
4013 raw_mbox[0] = CHNL_CLASS;
4014 raw_mbox[2] = GET_CHNL_CLASS;
4015
4016 memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
4017
4018 mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle;
4019
4020 /*
4021 * Non-ROMB firmware fail this command, so all channels
4022 * must be shown RAID
4023 */
4024 adapter->mega_ch_class = 0xFF;
4025
4026 if(!issue_scb_block(adapter, raw_mbox)) {
4027 adapter->mega_ch_class = *((char *)adapter->mega_buffer);
4028
4029 }
4030
4031 for( i = 0; i < adapter->product_info.nchannels; i++ ) {
4032 if( (adapter->mega_ch_class >> i) & 0x01 ) {
4033 printk(KERN_INFO "megaraid: channel[%d] is raid.\n",
4034 i);
4035 }
4036 else {
4037 printk(KERN_INFO "megaraid: channel[%d] is scsi.\n",
4038 i);
4039 }
4040 }
4041
4042 return;
4043 }
4044
4045
4046 /**
4047 * mega_get_boot_drv()
4048 * @adapter - pointer to our soft state
4049 *
4050 * Find out which device is the boot device. Note, any logical drive or any
4051 * phyical device (e.g., a CDROM) can be designated as a boot device.
4052 */
4053 static void
4054 mega_get_boot_drv(adapter_t *adapter)
4055 {
4056 struct private_bios_data *prv_bios_data;
4057 unsigned char raw_mbox[sizeof(struct mbox_out)];
4058 mbox_t *mbox;
4059 u16 cksum = 0;
4060 u8 *cksum_p;
4061 u8 boot_pdrv;
4062 int i;
4063
4064 mbox = (mbox_t *)raw_mbox;
4065
4066 memset(&mbox->m_out, 0, sizeof(raw_mbox));
4067
4068 raw_mbox[0] = BIOS_PVT_DATA;
4069 raw_mbox[2] = GET_BIOS_PVT_DATA;
4070
4071 memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
4072
4073 mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle;
4074
4075 adapter->boot_ldrv_enabled = 0;
4076 adapter->boot_ldrv = 0;
4077
4078 adapter->boot_pdrv_enabled = 0;
4079 adapter->boot_pdrv_ch = 0;
4080 adapter->boot_pdrv_tgt = 0;
4081
4082 if(issue_scb_block(adapter, raw_mbox) == 0) {
4083 prv_bios_data =
4084 (struct private_bios_data *)adapter->mega_buffer;
4085
4086 cksum = 0;
4087 cksum_p = (char *)prv_bios_data;
4088 for (i = 0; i < 14; i++ ) {
4089 cksum += (u16)(*cksum_p++);
4090 }
4091
4092 if (prv_bios_data->cksum == (u16)(0-cksum) ) {
4093
4094 /*
4095 * If MSB is set, a physical drive is set as boot
4096 * device
4097 */
4098 if( prv_bios_data->boot_drv & 0x80 ) {
4099 adapter->boot_pdrv_enabled = 1;
4100 boot_pdrv = prv_bios_data->boot_drv & 0x7F;
4101 adapter->boot_pdrv_ch = boot_pdrv / 16;
4102 adapter->boot_pdrv_tgt = boot_pdrv % 16;
4103 }
4104 else {
4105 adapter->boot_ldrv_enabled = 1;
4106 adapter->boot_ldrv = prv_bios_data->boot_drv;
4107 }
4108 }
4109 }
4110
4111 }
4112
4113 /**
4114 * mega_support_random_del()
4115 * @adapter - pointer to our soft state
4116 *
4117 * Find out if this controller supports random deletion and addition of
4118 * logical drives
4119 */
4120 static int
4121 mega_support_random_del(adapter_t *adapter)
4122 {
4123 unsigned char raw_mbox[sizeof(struct mbox_out)];
4124 mbox_t *mbox;
4125 int rval;
4126
4127 mbox = (mbox_t *)raw_mbox;
4128
4129 memset(&mbox->m_out, 0, sizeof(raw_mbox));
4130
4131 /*
4132 * issue command
4133 */
4134 raw_mbox[0] = FC_DEL_LOGDRV;
4135 raw_mbox[2] = OP_SUP_DEL_LOGDRV;
4136
4137 rval = issue_scb_block(adapter, raw_mbox);
4138
4139 return !rval;
4140 }
4141
4142
4143 /**
4144 * mega_support_ext_cdb()
4145 * @adapter - pointer to our soft state
4146 *
4147 * Find out if this firmware support cdblen > 10
4148 */
4149 static int
4150 mega_support_ext_cdb(adapter_t *adapter)
4151 {
4152 unsigned char raw_mbox[sizeof(struct mbox_out)];
4153 mbox_t *mbox;
4154 int rval;
4155
4156 mbox = (mbox_t *)raw_mbox;
4157
4158 memset(&mbox->m_out, 0, sizeof(raw_mbox));
4159 /*
4160 * issue command to find out if controller supports extended CDBs.
4161 */
4162 raw_mbox[0] = 0xA4;
4163 raw_mbox[2] = 0x16;
4164
4165 rval = issue_scb_block(adapter, raw_mbox);
4166
4167 return !rval;
4168 }
4169
4170
4171 /**
4172 * mega_del_logdrv()
4173 * @adapter - pointer to our soft state
4174 * @logdrv - logical drive to be deleted
4175 *
4176 * Delete the specified logical drive. It is the responsibility of the user
4177 * app to let the OS know about this operation.
4178 */
4179 static int
4180 mega_del_logdrv(adapter_t *adapter, int logdrv)
4181 {
4182 unsigned long flags;
4183 scb_t *scb;
4184 int rval;
4185
4186 /*
4187 * Stop sending commands to the controller, queue them internally.
4188 * When deletion is complete, ISR will flush the queue.
4189 */
4190 atomic_set(&adapter->quiescent, 1);
4191
4192 /*
4193 * Wait till all the issued commands are complete and there are no
4194 * commands in the pending queue
4195 */
4196 while (atomic_read(&adapter->pend_cmds) > 0 ||
4197 !list_empty(&adapter->pending_list))
4198 msleep(1000); /* sleep for 1s */
4199
4200 rval = mega_do_del_logdrv(adapter, logdrv);
4201
4202 spin_lock_irqsave(&adapter->lock, flags);
4203
4204 /*
4205 * If delete operation was successful, add 0x80 to the logical drive
4206 * ids for commands in the pending queue.
4207 */
4208 if (adapter->read_ldidmap) {
4209 struct list_head *pos;
4210 list_for_each(pos, &adapter->pending_list) {
4211 scb = list_entry(pos, scb_t, list);
4212 if (scb->pthru->logdrv < 0x80 )
4213 scb->pthru->logdrv += 0x80;
4214 }
4215 }
4216
4217 atomic_set(&adapter->quiescent, 0);
4218
4219 mega_runpendq(adapter);
4220
4221 spin_unlock_irqrestore(&adapter->lock, flags);
4222
4223 return rval;
4224 }
4225
4226
4227 static int
4228 mega_do_del_logdrv(adapter_t *adapter, int logdrv)
4229 {
4230 megacmd_t mc;
4231 int rval;
4232
4233 memset( &mc, 0, sizeof(megacmd_t));
4234
4235 mc.cmd = FC_DEL_LOGDRV;
4236 mc.opcode = OP_DEL_LOGDRV;
4237 mc.subopcode = logdrv;
4238
4239 rval = mega_internal_command(adapter, &mc, NULL);
4240
4241 /* log this event */
4242 if(rval) {
4243 printk(KERN_WARNING "megaraid: Delete LD-%d failed.", logdrv);
4244 return rval;
4245 }
4246
4247 /*
4248 * After deleting first logical drive, the logical drives must be
4249 * addressed by adding 0x80 to the logical drive id.
4250 */
4251 adapter->read_ldidmap = 1;
4252
4253 return rval;
4254 }
4255
4256
4257 /**
4258 * mega_get_max_sgl()
4259 * @adapter - pointer to our soft state
4260 *
4261 * Find out the maximum number of scatter-gather elements supported by this
4262 * version of the firmware
4263 */
4264 static void
4265 mega_get_max_sgl(adapter_t *adapter)
4266 {
4267 unsigned char raw_mbox[sizeof(struct mbox_out)];
4268 mbox_t *mbox;
4269
4270 mbox = (mbox_t *)raw_mbox;
4271
4272 memset(mbox, 0, sizeof(raw_mbox));
4273
4274 memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
4275
4276 mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle;
4277
4278 raw_mbox[0] = MAIN_MISC_OPCODE;
4279 raw_mbox[2] = GET_MAX_SG_SUPPORT;
4280
4281
4282 if( issue_scb_block(adapter, raw_mbox) ) {
4283 /*
4284 * f/w does not support this command. Choose the default value
4285 */
4286 adapter->sglen = MIN_SGLIST;
4287 }
4288 else {
4289 adapter->sglen = *((char *)adapter->mega_buffer);
4290
4291 /*
4292 * Make sure this is not more than the resources we are
4293 * planning to allocate
4294 */
4295 if ( adapter->sglen > MAX_SGLIST )
4296 adapter->sglen = MAX_SGLIST;
4297 }
4298
4299 return;
4300 }
4301
4302
4303 /**
4304 * mega_support_cluster()
4305 * @adapter - pointer to our soft state
4306 *
4307 * Find out if this firmware support cluster calls.
4308 */
4309 static int
4310 mega_support_cluster(adapter_t *adapter)
4311 {
4312 unsigned char raw_mbox[sizeof(struct mbox_out)];
4313 mbox_t *mbox;
4314
4315 mbox = (mbox_t *)raw_mbox;
4316
4317 memset(mbox, 0, sizeof(raw_mbox));
4318
4319 memset((void *)adapter->mega_buffer, 0, MEGA_BUFFER_SIZE);
4320
4321 mbox->m_out.xferaddr = (u32)adapter->buf_dma_handle;
4322
4323 /*
4324 * Try to get the initiator id. This command will succeed iff the
4325 * clustering is available on this HBA.
4326 */
4327 raw_mbox[0] = MEGA_GET_TARGET_ID;
4328
4329 if( issue_scb_block(adapter, raw_mbox) == 0 ) {
4330
4331 /*
4332 * Cluster support available. Get the initiator target id.
4333 * Tell our id to mid-layer too.
4334 */
4335 adapter->this_id = *(u32 *)adapter->mega_buffer;
4336 adapter->host->this_id = adapter->this_id;
4337
4338 return 1;
4339 }
4340
4341 return 0;
4342 }
4343
4344
4345 /**
4346 * mega_adapinq()
4347 * @adapter - pointer to our soft state
4348 * @dma_handle - DMA address of the buffer
4349 *
4350 * Issue internal comamnds while interrupts are available.
4351 * We only issue direct mailbox commands from within the driver. ioctl()
4352 * interface using these routines can issue passthru commands.
4353 */
4354 static int
4355 mega_adapinq(adapter_t *adapter, dma_addr_t dma_handle)
4356 {
4357 megacmd_t mc;
4358
4359 memset(&mc, 0, sizeof(megacmd_t));
4360
4361 if( adapter->flag & BOARD_40LD ) {
4362 mc.cmd = FC_NEW_CONFIG;
4363 mc.opcode = NC_SUBOP_ENQUIRY3;
4364 mc.subopcode = ENQ3_GET_SOLICITED_FULL;
4365 }
4366 else {
4367 mc.cmd = MEGA_MBOXCMD_ADPEXTINQ;
4368 }
4369
4370 mc.xferaddr = (u32)dma_handle;
4371
4372 if ( mega_internal_command(adapter, &mc, NULL) != 0 ) {
4373 return -1;
4374 }
4375
4376 return 0;
4377 }
4378
4379
4380 /** mega_internal_dev_inquiry()
4381 * @adapter - pointer to our soft state
4382 * @ch - channel for this device
4383 * @tgt - ID of this device
4384 * @buf_dma_handle - DMA address of the buffer
4385 *
4386 * Issue the scsi inquiry for the specified device.
4387 */
4388 static int
4389 mega_internal_dev_inquiry(adapter_t *adapter, u8 ch, u8 tgt,
4390 dma_addr_t buf_dma_handle)
4391 {
4392 mega_passthru *pthru;
4393 dma_addr_t pthru_dma_handle;
4394 megacmd_t mc;
4395 int rval;
4396 struct pci_dev *pdev;
4397
4398
4399 /*
4400 * For all internal commands, the buffer must be allocated in <4GB
4401 * address range
4402 */
4403 if( make_local_pdev(adapter, &pdev) != 0 ) return -1;
4404
4405 pthru = pci_alloc_consistent(pdev, sizeof(mega_passthru),
4406 &pthru_dma_handle);
4407
4408 if( pthru == NULL ) {
4409 free_local_pdev(pdev);
4410 return -1;
4411 }
4412
4413 pthru->timeout = 2;
4414 pthru->ars = 1;
4415 pthru->reqsenselen = 14;
4416 pthru->islogical = 0;
4417
4418 pthru->channel = (adapter->flag & BOARD_40LD) ? 0 : ch;
4419
4420 pthru->target = (adapter->flag & BOARD_40LD) ? (ch << 4)|tgt : tgt;
4421
4422 pthru->cdblen = 6;
4423
4424 pthru->cdb[0] = INQUIRY;
4425 pthru->cdb[1] = 0;
4426 pthru->cdb[2] = 0;
4427 pthru->cdb[3] = 0;
4428 pthru->cdb[4] = 255;
4429 pthru->cdb[5] = 0;
4430
4431
4432 pthru->dataxferaddr = (u32)buf_dma_handle;
4433 pthru->dataxferlen = 256;
4434
4435 memset(&mc, 0, sizeof(megacmd_t));
4436
4437 mc.cmd = MEGA_MBOXCMD_PASSTHRU;
4438 mc.xferaddr = (u32)pthru_dma_handle;
4439
4440 rval = mega_internal_command(adapter, &mc, pthru);
4441
4442 pci_free_consistent(pdev, sizeof(mega_passthru), pthru,
4443 pthru_dma_handle);
4444
4445 free_local_pdev(pdev);
4446
4447 return rval;
4448 }
4449
4450
4451 /**
4452 * mega_internal_command()
4453 * @adapter - pointer to our soft state
4454 * @mc - the mailbox command
4455 * @pthru - Passthru structure for DCDB commands
4456 *
4457 * Issue the internal commands in interrupt mode.
4458 * The last argument is the address of the passthru structure if the command
4459 * to be fired is a passthru command
4460 *
4461 * lockscope specifies whether the caller has already acquired the lock. Of
4462 * course, the caller must know which lock we are talking about.
4463 *
4464 * Note: parameter 'pthru' is null for non-passthru commands.
4465 */
4466 static int
4467 mega_internal_command(adapter_t *adapter, megacmd_t *mc, mega_passthru *pthru)
4468 {
4469 Scsi_Cmnd *scmd;
4470 struct scsi_device *sdev;
4471 scb_t *scb;
4472 int rval;
4473
4474 /*
4475 * The internal commands share one command id and hence are
4476 * serialized. This is so because we want to reserve maximum number of
4477 * available command ids for the I/O commands.
4478 */
4479 mutex_lock(&adapter->int_mtx);
4480
4481 scb = &adapter->int_scb;
4482 memset(scb, 0, sizeof(scb_t));
4483
4484 scmd = &adapter->int_scmd;
4485 memset(scmd, 0, sizeof(Scsi_Cmnd));
4486
4487 sdev = kmalloc(sizeof(struct scsi_device), GFP_KERNEL);
4488 memset(sdev, 0, sizeof(struct scsi_device));
4489 scmd->device = sdev;
4490
4491 scmd->device->host = adapter->host;
4492 scmd->request_buffer = (void *)scb;
4493 scmd->cmnd[0] = MEGA_INTERNAL_CMD;
4494
4495 scb->state |= SCB_ACTIVE;
4496 scb->cmd = scmd;
4497
4498 memcpy(scb->raw_mbox, mc, sizeof(megacmd_t));
4499
4500 /*
4501 * Is it a passthru command
4502 */
4503 if( mc->cmd == MEGA_MBOXCMD_PASSTHRU ) {
4504
4505 scb->pthru = pthru;
4506 }
4507
4508 scb->idx = CMDID_INT_CMDS;
4509
4510 megaraid_queue(scmd, mega_internal_done);
4511
4512 wait_for_completion(&adapter->int_waitq);
4513
4514 rval = scmd->result;
4515 mc->status = scmd->result;
4516 kfree(sdev);
4517
4518 /*
4519 * Print a debug message for all failed commands. Applications can use
4520 * this information.
4521 */
4522 if( scmd->result && trace_level ) {
4523 printk("megaraid: cmd [%x, %x, %x] status:[%x]\n",
4524 mc->cmd, mc->opcode, mc->subopcode, scmd->result);
4525 }
4526
4527 mutex_unlock(&adapter->int_mtx);
4528
4529 return rval;
4530 }
4531
4532
4533 /**
4534 * mega_internal_done()
4535 * @scmd - internal scsi command
4536 *
4537 * Callback routine for internal commands.
4538 */
4539 static void
4540 mega_internal_done(Scsi_Cmnd *scmd)
4541 {
4542 adapter_t *adapter;
4543
4544 adapter = (adapter_t *)scmd->device->host->hostdata;
4545
4546 complete(&adapter->int_waitq);
4547
4548 }
4549
4550
4551 static struct scsi_host_template megaraid_template = {
4552 .module = THIS_MODULE,
4553 .name = "MegaRAID",
4554 .proc_name = "megaraid_legacy",
4555 .info = megaraid_info,
4556 .queuecommand = megaraid_queue,
4557 .bios_param = megaraid_biosparam,
4558 .max_sectors = MAX_SECTORS_PER_IO,
4559 .can_queue = MAX_COMMANDS,
4560 .this_id = DEFAULT_INITIATOR_ID,
4561 .sg_tablesize = MAX_SGLIST,
4562 .cmd_per_lun = DEF_CMD_PER_LUN,
4563 .use_clustering = ENABLE_CLUSTERING,
4564 .eh_abort_handler = megaraid_abort,
4565 .eh_device_reset_handler = megaraid_reset,
4566 .eh_bus_reset_handler = megaraid_reset,
4567 .eh_host_reset_handler = megaraid_reset,
4568 };
4569
4570 static int __devinit
4571 megaraid_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4572 {
4573 struct Scsi_Host *host;
4574 adapter_t *adapter;
4575 unsigned long mega_baseport, tbase, flag = 0;
4576 u16 subsysid, subsysvid;
4577 u8 pci_bus, pci_dev_func;
4578 int irq, i, j;
4579 int error = -ENODEV;
4580
4581 if (pci_enable_device(pdev))
4582 goto out;
4583 pci_set_master(pdev);
4584
4585 pci_bus = pdev->bus->number;
4586 pci_dev_func = pdev->devfn;
4587
4588 /*
4589 * The megaraid3 stuff reports the ID of the Intel part which is not
4590 * remotely specific to the megaraid
4591 */
4592 if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
4593 u16 magic;
4594 /*
4595 * Don't fall over the Compaq management cards using the same
4596 * PCI identifier
4597 */
4598 if (pdev->subsystem_vendor == PCI_VENDOR_ID_COMPAQ &&
4599 pdev->subsystem_device == 0xC000)
4600 return -ENODEV;
4601 /* Now check the magic signature byte */
4602 pci_read_config_word(pdev, PCI_CONF_AMISIG, &magic);
4603 if (magic != HBA_SIGNATURE_471 && magic != HBA_SIGNATURE)
4604 return -ENODEV;
4605 /* Ok it is probably a megaraid */
4606 }
4607
4608 /*
4609 * For these vendor and device ids, signature offsets are not
4610 * valid and 64 bit is implicit
4611 */
4612 if (id->driver_data & BOARD_64BIT)
4613 flag |= BOARD_64BIT;
4614 else {
4615 u32 magic64;
4616
4617 pci_read_config_dword(pdev, PCI_CONF_AMISIG64, &magic64);
4618 if (magic64 == HBA_SIGNATURE_64BIT)
4619 flag |= BOARD_64BIT;
4620 }
4621
4622 subsysvid = pdev->subsystem_vendor;
4623 subsysid = pdev->subsystem_device;
4624
4625 printk(KERN_NOTICE "megaraid: found 0x%4.04x:0x%4.04x:bus %d:",
4626 id->vendor, id->device, pci_bus);
4627
4628 printk("slot %d:func %d\n",
4629 PCI_SLOT(pci_dev_func), PCI_FUNC(pci_dev_func));
4630
4631 /* Read the base port and IRQ from PCI */
4632 mega_baseport = pci_resource_start(pdev, 0);
4633 irq = pdev->irq;
4634
4635 tbase = mega_baseport;
4636 if (pci_resource_flags(pdev, 0) & IORESOURCE_MEM) {
4637 flag |= BOARD_MEMMAP;
4638
4639 if (!request_mem_region(mega_baseport, 128, "megaraid")) {
4640 printk(KERN_WARNING "megaraid: mem region busy!\n");
4641 goto out_disable_device;
4642 }
4643
4644 mega_baseport = (unsigned long)ioremap(mega_baseport, 128);
4645 if (!mega_baseport) {
4646 printk(KERN_WARNING
4647 "megaraid: could not map hba memory\n");
4648 goto out_release_region;
4649 }
4650 } else {
4651 flag |= BOARD_IOMAP;
4652 mega_baseport += 0x10;
4653
4654 if (!request_region(mega_baseport, 16, "megaraid"))
4655 goto out_disable_device;
4656 }
4657
4658 /* Initialize SCSI Host structure */
4659 host = scsi_host_alloc(&megaraid_template, sizeof(adapter_t));
4660 if (!host)
4661 goto out_iounmap;
4662
4663 adapter = (adapter_t *)host->hostdata;
4664 memset(adapter, 0, sizeof(adapter_t));
4665
4666 printk(KERN_NOTICE
4667 "scsi%d:Found MegaRAID controller at 0x%lx, IRQ:%d\n",
4668 host->host_no, mega_baseport, irq);
4669
4670 adapter->base = mega_baseport;
4671
4672 INIT_LIST_HEAD(&adapter->free_list);
4673 INIT_LIST_HEAD(&adapter->pending_list);
4674 INIT_LIST_HEAD(&adapter->completed_list);
4675
4676 adapter->flag = flag;
4677 spin_lock_init(&adapter->lock);
4678
4679 host->cmd_per_lun = max_cmd_per_lun;
4680 host->max_sectors = max_sectors_per_io;
4681
4682 adapter->dev = pdev;
4683 adapter->host = host;
4684
4685 adapter->host->irq = irq;
4686
4687 if (flag & BOARD_MEMMAP)
4688 adapter->host->base = tbase;
4689 else {
4690 adapter->host->io_port = tbase;
4691 adapter->host->n_io_port = 16;
4692 }
4693
4694 adapter->host->unique_id = (pci_bus << 8) | pci_dev_func;
4695
4696 /*
4697 * Allocate buffer to issue internal commands.
4698 */
4699 adapter->mega_buffer = pci_alloc_consistent(adapter->dev,
4700 MEGA_BUFFER_SIZE, &adapter->buf_dma_handle);
4701 if (!adapter->mega_buffer) {
4702 printk(KERN_WARNING "megaraid: out of RAM.\n");
4703 goto out_host_put;
4704 }
4705
4706 adapter->scb_list = kmalloc(sizeof(scb_t) * MAX_COMMANDS, GFP_KERNEL);
4707 if (!adapter->scb_list) {
4708 printk(KERN_WARNING "megaraid: out of RAM.\n");
4709 goto out_free_cmd_buffer;
4710 }
4711
4712 if (request_irq(irq, (adapter->flag & BOARD_MEMMAP) ?
4713 megaraid_isr_memmapped : megaraid_isr_iomapped,
4714 IRQF_SHARED, "megaraid", adapter)) {
4715 printk(KERN_WARNING
4716 "megaraid: Couldn't register IRQ %d!\n", irq);
4717 goto out_free_scb_list;
4718 }
4719
4720 if (mega_setup_mailbox(adapter))
4721 goto out_free_irq;
4722
4723 if (mega_query_adapter(adapter))
4724 goto out_free_mbox;
4725
4726 /*
4727 * Have checks for some buggy f/w
4728 */
4729 if ((subsysid == 0x1111) && (subsysvid == 0x1111)) {
4730 /*
4731 * Which firmware
4732 */
4733 if (!strcmp(adapter->fw_version, "3.00") ||
4734 !strcmp(adapter->fw_version, "3.01")) {
4735
4736 printk( KERN_WARNING
4737 "megaraid: Your card is a Dell PERC "
4738 "2/SC RAID controller with "
4739 "firmware\nmegaraid: 3.00 or 3.01. "
4740 "This driver is known to have "
4741 "corruption issues\nmegaraid: with "
4742 "those firmware versions on this "
4743 "specific card. In order\nmegaraid: "
4744 "to protect your data, please upgrade "
4745 "your firmware to version\nmegaraid: "
4746 "3.10 or later, available from the "
4747 "Dell Technical Support web\n"
4748 "megaraid: site at\nhttp://support."
4749 "dell.com/us/en/filelib/download/"
4750 "index.asp?fileid=2940\n"
4751 );
4752 }
4753 }
4754
4755 /*
4756 * If we have a HP 1M(0x60E7)/2M(0x60E8) controller with
4757 * firmware H.01.07, H.01.08, and H.01.09 disable 64 bit
4758 * support, since this firmware cannot handle 64 bit
4759 * addressing
4760 */
4761 if ((subsysvid == HP_SUBSYS_VID) &&
4762 ((subsysid == 0x60E7) || (subsysid == 0x60E8))) {
4763 /*
4764 * which firmware
4765 */
4766 if (!strcmp(adapter->fw_version, "H01.07") ||
4767 !strcmp(adapter->fw_version, "H01.08") ||
4768 !strcmp(adapter->fw_version, "H01.09") ) {
4769 printk(KERN_WARNING
4770 "megaraid: Firmware H.01.07, "
4771 "H.01.08, and H.01.09 on 1M/2M "
4772 "controllers\n"
4773 "megaraid: do not support 64 bit "
4774 "addressing.\nmegaraid: DISABLING "
4775 "64 bit support.\n");
4776 adapter->flag &= ~BOARD_64BIT;
4777 }
4778 }
4779
4780 if (mega_is_bios_enabled(adapter))
4781 mega_hbas[hba_count].is_bios_enabled = 1;
4782 mega_hbas[hba_count].hostdata_addr = adapter;
4783
4784 /*
4785 * Find out which channel is raid and which is scsi. This is
4786 * for ROMB support.
4787 */
4788 mega_enum_raid_scsi(adapter);
4789
4790 /*
4791 * Find out if a logical drive is set as the boot drive. If
4792 * there is one, will make that as the first logical drive.
4793 * ROMB: Do we have to boot from a physical drive. Then all
4794 * the physical drives would appear before the logical disks.
4795 * Else, all the physical drives would be exported to the mid
4796 * layer after logical drives.
4797 */
4798 mega_get_boot_drv(adapter);
4799
4800 if (adapter->boot_pdrv_enabled) {
4801 j = adapter->product_info.nchannels;
4802 for( i = 0; i < j; i++ )
4803 adapter->logdrv_chan[i] = 0;
4804 for( i = j; i < NVIRT_CHAN + j; i++ )
4805 adapter->logdrv_chan[i] = 1;
4806 } else {
4807 for (i = 0; i < NVIRT_CHAN; i++)
4808 adapter->logdrv_chan[i] = 1;
4809 for (i = NVIRT_CHAN; i < MAX_CHANNELS+NVIRT_CHAN; i++)
4810 adapter->logdrv_chan[i] = 0;
4811 adapter->mega_ch_class <<= NVIRT_CHAN;
4812 }
4813
4814 /*
4815 * Do we support random deletion and addition of logical
4816 * drives
4817 */
4818 adapter->read_ldidmap = 0; /* set it after first logdrv
4819 delete cmd */
4820 adapter->support_random_del = mega_support_random_del(adapter);
4821
4822 /* Initialize SCBs */
4823 if (mega_init_scb(adapter))
4824 goto out_free_mbox;
4825
4826 /*
4827 * Reset the pending commands counter
4828 */
4829 atomic_set(&adapter->pend_cmds, 0);
4830
4831 /*
4832 * Reset the adapter quiescent flag
4833 */
4834 atomic_set(&adapter->quiescent, 0);
4835
4836 hba_soft_state[hba_count] = adapter;
4837
4838 /*
4839 * Fill in the structure which needs to be passed back to the
4840 * application when it does an ioctl() for controller related
4841 * information.
4842 */
4843 i = hba_count;
4844
4845 mcontroller[i].base = mega_baseport;
4846 mcontroller[i].irq = irq;
4847 mcontroller[i].numldrv = adapter->numldrv;
4848 mcontroller[i].pcibus = pci_bus;
4849 mcontroller[i].pcidev = id->device;
4850 mcontroller[i].pcifun = PCI_FUNC (pci_dev_func);
4851 mcontroller[i].pciid = -1;
4852 mcontroller[i].pcivendor = id->vendor;
4853 mcontroller[i].pcislot = PCI_SLOT(pci_dev_func);
4854 mcontroller[i].uid = (pci_bus << 8) | pci_dev_func;
4855
4856
4857 /* Set the Mode of addressing to 64 bit if we can */
4858 if ((adapter->flag & BOARD_64BIT) && (sizeof(dma_addr_t) == 8)) {
4859 pci_set_dma_mask(pdev, DMA_64BIT_MASK);
4860 adapter->has_64bit_addr = 1;
4861 } else {
4862 pci_set_dma_mask(pdev, DMA_32BIT_MASK);
4863 adapter->has_64bit_addr = 0;
4864 }
4865
4866 mutex_init(&adapter->int_mtx);
4867 init_completion(&adapter->int_waitq);
4868
4869 adapter->this_id = DEFAULT_INITIATOR_ID;
4870 adapter->host->this_id = DEFAULT_INITIATOR_ID;
4871
4872 #if MEGA_HAVE_CLUSTERING
4873 /*
4874 * Is cluster support enabled on this controller
4875 * Note: In a cluster the HBAs ( the initiators ) will have
4876 * different target IDs and we cannot assume it to be 7. Call
4877 * to mega_support_cluster() will get the target ids also if
4878 * the cluster support is available
4879 */
4880 adapter->has_cluster = mega_support_cluster(adapter);
4881 if (adapter->has_cluster) {
4882 printk(KERN_NOTICE
4883 "megaraid: Cluster driver, initiator id:%d\n",
4884 adapter->this_id);
4885 }
4886 #endif
4887
4888 pci_set_drvdata(pdev, host);
4889
4890 mega_create_proc_entry(hba_count, mega_proc_dir_entry);
4891
4892 error = scsi_add_host(host, &pdev->dev);
4893 if (error)
4894 goto out_free_mbox;
4895
4896 scsi_scan_host(host);
4897 hba_count++;
4898 return 0;
4899
4900 out_free_mbox:
4901 pci_free_consistent(adapter->dev, sizeof(mbox64_t),
4902 adapter->una_mbox64, adapter->una_mbox64_dma);
4903 out_free_irq:
4904 free_irq(adapter->host->irq, adapter);
4905 out_free_scb_list:
4906 kfree(adapter->scb_list);
4907 out_free_cmd_buffer:
4908 pci_free_consistent(adapter->dev, MEGA_BUFFER_SIZE,
4909 adapter->mega_buffer, adapter->buf_dma_handle);
4910 out_host_put:
4911 scsi_host_put(host);
4912 out_iounmap:
4913 if (flag & BOARD_MEMMAP)
4914 iounmap((void *)mega_baseport);
4915 out_release_region:
4916 if (flag & BOARD_MEMMAP)
4917 release_mem_region(tbase, 128);
4918 else
4919 release_region(mega_baseport, 16);
4920 out_disable_device:
4921 pci_disable_device(pdev);
4922 out:
4923 return error;
4924 }
4925
4926 static void
4927 __megaraid_shutdown(adapter_t *adapter)
4928 {
4929 u_char raw_mbox[sizeof(struct mbox_out)];
4930 mbox_t *mbox = (mbox_t *)raw_mbox;
4931 int i;
4932
4933 /* Flush adapter cache */
4934 memset(&mbox->m_out, 0, sizeof(raw_mbox));
4935 raw_mbox[0] = FLUSH_ADAPTER;
4936
4937 free_irq(adapter->host->irq, adapter);
4938
4939 /* Issue a blocking (interrupts disabled) command to the card */
4940 issue_scb_block(adapter, raw_mbox);
4941
4942 /* Flush disks cache */
4943 memset(&mbox->m_out, 0, sizeof(raw_mbox));
4944 raw_mbox[0] = FLUSH_SYSTEM;
4945
4946 /* Issue a blocking (interrupts disabled) command to the card */
4947 issue_scb_block(adapter, raw_mbox);
4948
4949 if (atomic_read(&adapter->pend_cmds) > 0)
4950 printk(KERN_WARNING "megaraid: pending commands!!\n");
4951
4952 /*
4953 * Have a delibrate delay to make sure all the caches are
4954 * actually flushed.
4955 */
4956 for (i = 0; i <= 10; i++)
4957 mdelay(1000);
4958 }
4959
4960 static void
4961 megaraid_remove_one(struct pci_dev *pdev)
4962 {
4963 struct Scsi_Host *host = pci_get_drvdata(pdev);
4964 adapter_t *adapter = (adapter_t *)host->hostdata;
4965 char buf[12] = { 0 };
4966
4967 scsi_remove_host(host);
4968
4969 __megaraid_shutdown(adapter);
4970
4971 /* Free our resources */
4972 if (adapter->flag & BOARD_MEMMAP) {
4973 iounmap((void *)adapter->base);
4974 release_mem_region(adapter->host->base, 128);
4975 } else
4976 release_region(adapter->base, 16);
4977
4978 mega_free_sgl(adapter);
4979
4980 #ifdef CONFIG_PROC_FS
4981 if (adapter->controller_proc_dir_entry) {
4982 remove_proc_entry("stat", adapter->controller_proc_dir_entry);
4983 remove_proc_entry("config",
4984 adapter->controller_proc_dir_entry);
4985 remove_proc_entry("mailbox",
4986 adapter->controller_proc_dir_entry);
4987 #if MEGA_HAVE_ENH_PROC
4988 remove_proc_entry("rebuild-rate",
4989 adapter->controller_proc_dir_entry);
4990 remove_proc_entry("battery-status",
4991 adapter->controller_proc_dir_entry);
4992
4993 remove_proc_entry("diskdrives-ch0",
4994 adapter->controller_proc_dir_entry);
4995 remove_proc_entry("diskdrives-ch1",
4996 adapter->controller_proc_dir_entry);
4997 remove_proc_entry("diskdrives-ch2",
4998 adapter->controller_proc_dir_entry);
4999 remove_proc_entry("diskdrives-ch3",
5000 adapter->controller_proc_dir_entry);
5001
5002 remove_proc_entry("raiddrives-0-9",
5003 adapter->controller_proc_dir_entry);
5004 remove_proc_entry("raiddrives-10-19",
5005 adapter->controller_proc_dir_entry);
5006 remove_proc_entry("raiddrives-20-29",
5007 adapter->controller_proc_dir_entry);
5008 remove_proc_entry("raiddrives-30-39",
5009 adapter->controller_proc_dir_entry);
5010 #endif
5011 sprintf(buf, "hba%d", adapter->host->host_no);
5012 remove_proc_entry(buf, mega_proc_dir_entry);
5013 }
5014 #endif
5015
5016 pci_free_consistent(adapter->dev, MEGA_BUFFER_SIZE,
5017 adapter->mega_buffer, adapter->buf_dma_handle);
5018 kfree(adapter->scb_list);
5019 pci_free_consistent(adapter->dev, sizeof(mbox64_t),
5020 adapter->una_mbox64, adapter->una_mbox64_dma);
5021
5022 scsi_host_put(host);
5023 pci_disable_device(pdev);
5024
5025 hba_count--;
5026 }
5027
5028 static void
5029 megaraid_shutdown(struct pci_dev *pdev)
5030 {
5031 struct Scsi_Host *host = pci_get_drvdata(pdev);
5032 adapter_t *adapter = (adapter_t *)host->hostdata;
5033
5034 __megaraid_shutdown(adapter);
5035 }
5036
5037 static struct pci_device_id megaraid_pci_tbl[] = {
5038 {PCI_VENDOR_ID_AMI, PCI_DEVICE_ID_AMI_MEGARAID,
5039 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
5040 {PCI_VENDOR_ID_AMI, PCI_DEVICE_ID_AMI_MEGARAID2,
5041 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
5042 {PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_AMI_MEGARAID3,
5043 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
5044 {0,}
5045 };
5046 MODULE_DEVICE_TABLE(pci, megaraid_pci_tbl);
5047
5048 static struct pci_driver megaraid_pci_driver = {
5049 .name = "megaraid_legacy",
5050 .id_table = megaraid_pci_tbl,
5051 .probe = megaraid_probe_one,
5052 .remove = __devexit_p(megaraid_remove_one),
5053 .shutdown = megaraid_shutdown,
5054 };
5055
5056 static int __init megaraid_init(void)
5057 {
5058 int error;
5059
5060 if ((max_cmd_per_lun <= 0) || (max_cmd_per_lun > MAX_CMD_PER_LUN))
5061 max_cmd_per_lun = MAX_CMD_PER_LUN;
5062 if (max_mbox_busy_wait > MBOX_BUSY_WAIT)
5063 max_mbox_busy_wait = MBOX_BUSY_WAIT;
5064
5065 #ifdef CONFIG_PROC_FS
5066 mega_proc_dir_entry = proc_mkdir("megaraid", &proc_root);
5067 if (!mega_proc_dir_entry) {
5068 printk(KERN_WARNING
5069 "megaraid: failed to create megaraid root\n");
5070 }
5071 #endif
5072 error = pci_module_init(&megaraid_pci_driver);
5073 if (error) {
5074 #ifdef CONFIG_PROC_FS
5075 remove_proc_entry("megaraid", &proc_root);
5076 #endif
5077 return error;
5078 }
5079
5080 /*
5081 * Register the driver as a character device, for applications
5082 * to access it for ioctls.
5083 * First argument (major) to register_chrdev implies a dynamic
5084 * major number allocation.
5085 */
5086 major = register_chrdev(0, "megadev_legacy", &megadev_fops);
5087 if (!major) {
5088 printk(KERN_WARNING
5089 "megaraid: failed to register char device\n");
5090 }
5091
5092 return 0;
5093 }
5094
5095 static void __exit megaraid_exit(void)
5096 {
5097 /*
5098 * Unregister the character device interface to the driver.
5099 */
5100 unregister_chrdev(major, "megadev_legacy");
5101
5102 pci_unregister_driver(&megaraid_pci_driver);
5103
5104 #ifdef CONFIG_PROC_FS
5105 remove_proc_entry("megaraid", &proc_root);
5106 #endif
5107 }
5108
5109 module_init(megaraid_init);
5110 module_exit(megaraid_exit);
5111
5112 /* vi: set ts=8 sw=8 tw=78: */
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree