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