arcmsr_hba.c 125 KB
Newer Older
1 2 3 4
/*
*******************************************************************************
**        O.S   : Linux
**   FILE NAME  : arcmsr_hba.c
5 6
**        BY    : Nick Cheng, C.L. Huang
**   Description: SCSI RAID Device Driver for Areca RAID Controller
7
*******************************************************************************
8
** Copyright (C) 2002 - 2014, Areca Technology Corporation All rights reserved
9 10
**
**     Web site: www.areca.com.tw
11
**       E-mail: support@areca.com.tw
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License version 2 as
** published by the Free Software Foundation.
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
*******************************************************************************
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
** 1. Redistributions of source code must retain the above copyright
**    notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
**    notice, this list of conditions and the following disclaimer in the
**    documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
**    derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES(INCLUDING,BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION)HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE)ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************
** For history of changes, see Documentation/scsi/ChangeLog.arcmsr
**     Firmware Specification, see Documentation/scsi/arcmsr_spec.txt
*******************************************************************************
*/
#include <linux/module.h>
#include <linux/reboot.h>
#include <linux/spinlock.h>
#include <linux/pci_ids.h>
#include <linux/interrupt.h>
#include <linux/moduleparam.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
#include <linux/timer.h>
58
#include <linux/slab.h>
59
#include <linux/pci.h>
60
#include <linux/aer.h>
61
#include <linux/circ_buf.h>
62 63 64 65 66 67 68 69 70 71 72
#include <asm/dma.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsicam.h>
#include "arcmsr.h"
73 74
MODULE_AUTHOR("Nick Cheng, C.L. Huang <support@areca.com.tw>");
MODULE_DESCRIPTION("Areca ARC11xx/12xx/16xx/188x SAS/SATA RAID Controller Driver");
75 76
MODULE_LICENSE("Dual BSD/GPL");
MODULE_VERSION(ARCMSR_DRIVER_VERSION);
77 78 79 80

#define	ARCMSR_SLEEPTIME	10
#define	ARCMSR_RETRYCOUNT	12

81
static wait_queue_head_t wait_q;
82 83 84
static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb,
					struct scsi_cmnd *cmd);
static int arcmsr_iop_confirm(struct AdapterControlBlock *acb);
85 86 87
static int arcmsr_abort(struct scsi_cmnd *);
static int arcmsr_bus_reset(struct scsi_cmnd *);
static int arcmsr_bios_param(struct scsi_device *sdev,
88
		struct block_device *bdev, sector_t capacity, int *info);
Jeff Garzik's avatar
Jeff Garzik committed
89
static int arcmsr_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
90 91
static int arcmsr_probe(struct pci_dev *pdev,
				const struct pci_device_id *id);
92 93
static int arcmsr_suspend(struct pci_dev *pdev, pm_message_t state);
static int arcmsr_resume(struct pci_dev *pdev);
94 95 96 97
static void arcmsr_remove(struct pci_dev *pdev);
static void arcmsr_shutdown(struct pci_dev *pdev);
static void arcmsr_iop_init(struct AdapterControlBlock *acb);
static void arcmsr_free_ccb_pool(struct AdapterControlBlock *acb);
98
static u32 arcmsr_disable_outbound_ints(struct AdapterControlBlock *acb);
99 100
static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb,
	u32 intmask_org);
101
static void arcmsr_stop_adapter_bgrb(struct AdapterControlBlock *acb);
102 103
static void arcmsr_hbaA_flush_cache(struct AdapterControlBlock *acb);
static void arcmsr_hbaB_flush_cache(struct AdapterControlBlock *acb);
104
static void arcmsr_request_device_map(unsigned long pacb);
105 106 107
static void arcmsr_hbaA_request_device_map(struct AdapterControlBlock *acb);
static void arcmsr_hbaB_request_device_map(struct AdapterControlBlock *acb);
static void arcmsr_hbaC_request_device_map(struct AdapterControlBlock *acb);
108
static void arcmsr_message_isr_bh_fn(struct work_struct *work);
109
static bool arcmsr_get_firmware_spec(struct AdapterControlBlock *acb);
110
static void arcmsr_start_adapter_bgrb(struct AdapterControlBlock *acb);
111
static void arcmsr_hbaC_message_isr(struct AdapterControlBlock *pACB);
112
static void arcmsr_hbaD_message_isr(struct AdapterControlBlock *acb);
113
static void arcmsr_hardware_reset(struct AdapterControlBlock *acb);
114 115
static const char *arcmsr_info(struct Scsi_Host *);
static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb);
116
static void arcmsr_free_irq(struct pci_dev *, struct AdapterControlBlock *);
117
static int arcmsr_adjust_disk_queue_depth(struct scsi_device *sdev, int queue_depth)
118 119 120
{
	if (queue_depth > ARCMSR_MAX_CMD_PERLUN)
		queue_depth = ARCMSR_MAX_CMD_PERLUN;
121
	return scsi_change_queue_depth(sdev, queue_depth);
122 123 124 125
}

static struct scsi_host_template arcmsr_scsi_host_template = {
	.module			= THIS_MODULE,
126
	.name			= "Areca SAS/SATA RAID driver",
127 128
	.info			= arcmsr_info,
	.queuecommand		= arcmsr_queue_command,
129
	.eh_abort_handler		= arcmsr_abort,
130 131 132
	.eh_bus_reset_handler	= arcmsr_bus_reset,
	.bios_param		= arcmsr_bios_param,
	.change_queue_depth	= arcmsr_adjust_disk_queue_depth,
133
	.can_queue		= ARCMSR_MAX_OUTSTANDING_CMD,
134 135 136
	.this_id			= ARCMSR_SCSI_INITIATOR_ID,
	.sg_tablesize	        	= ARCMSR_DEFAULT_SG_ENTRIES, 
	.max_sectors    	    	= ARCMSR_MAX_XFER_SECTORS_C, 
137 138 139
	.cmd_per_lun		= ARCMSR_MAX_CMD_PERLUN,
	.use_clustering		= ENABLE_CLUSTERING,
	.shost_attrs		= arcmsr_host_attrs,
140
	.no_write_same		= 1,
141
};
142

143
static struct pci_device_id arcmsr_device_id_table[] = {
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1110),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1120),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1130),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1160),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1170),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1200),
		.driver_data = ACB_ADAPTER_TYPE_B},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1201),
		.driver_data = ACB_ADAPTER_TYPE_B},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1202),
		.driver_data = ACB_ADAPTER_TYPE_B},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1210),
		.driver_data = ACB_ADAPTER_TYPE_A},
162 163
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1214),
		.driver_data = ACB_ADAPTER_TYPE_D},
164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1220),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1230),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1260),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1270),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1280),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1380),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1381),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1680),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1681),
		.driver_data = ACB_ADAPTER_TYPE_A},
	{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1880),
		.driver_data = ACB_ADAPTER_TYPE_C},
184 185 186
	{0, 0}, /* Terminating entry */
};
MODULE_DEVICE_TABLE(pci, arcmsr_device_id_table);
187

188 189
static struct pci_driver arcmsr_pci_driver = {
	.name			= "arcmsr",
190
	.id_table			= arcmsr_device_id_table,
191 192
	.probe			= arcmsr_probe,
	.remove			= arcmsr_remove,
193 194
	.suspend		= arcmsr_suspend,
	.resume			= arcmsr_resume,
195
	.shutdown		= arcmsr_shutdown,
196
};
197 198 199 200
/*
****************************************************************************
****************************************************************************
*/
201

202
static void arcmsr_free_mu(struct AdapterControlBlock *acb)
203 204
{
	switch (acb->adapter_type) {
205 206
	case ACB_ADAPTER_TYPE_B:
	case ACB_ADAPTER_TYPE_D: {
207 208 209
		dma_free_coherent(&acb->pdev->dev, acb->roundup_ccbsize,
			acb->dma_coherent2, acb->dma_coherent_handle2);
		break;
210 211 212 213 214 215 216
	}
	}
}

static bool arcmsr_remap_pciregion(struct AdapterControlBlock *acb)
{
	struct pci_dev *pdev = acb->pdev;
217
	switch (acb->adapter_type){
218
	case ACB_ADAPTER_TYPE_A:{
219
		acb->pmuA = ioremap(pci_resource_start(pdev,0), pci_resource_len(pdev,0));
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
		if (!acb->pmuA) {
			printk(KERN_NOTICE "arcmsr%d: memory mapping region fail \n", acb->host->host_no);
			return false;
		}
		break;
	}
	case ACB_ADAPTER_TYPE_B:{
		void __iomem *mem_base0, *mem_base1;
		mem_base0 = ioremap(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
		if (!mem_base0) {
			printk(KERN_NOTICE "arcmsr%d: memory mapping region fail \n", acb->host->host_no);
			return false;
		}
		mem_base1 = ioremap(pci_resource_start(pdev, 2), pci_resource_len(pdev, 2));
		if (!mem_base1) {
			iounmap(mem_base0);
			printk(KERN_NOTICE "arcmsr%d: memory mapping region fail \n", acb->host->host_no);
			return false;
		}
		acb->mem_base0 = mem_base0;
		acb->mem_base1 = mem_base1;
241 242 243 244 245 246 247 248 249 250 251 252 253
		break;
	}
	case ACB_ADAPTER_TYPE_C:{
		acb->pmuC = ioremap_nocache(pci_resource_start(pdev, 1), pci_resource_len(pdev, 1));
		if (!acb->pmuC) {
			printk(KERN_NOTICE "arcmsr%d: memory mapping region fail \n", acb->host->host_no);
			return false;
		}
		if (readl(&acb->pmuC->outbound_doorbell) & ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE) {
			writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR, &acb->pmuC->outbound_doorbell_clear);/*clear interrupt*/
			return true;
		}
		break;
254
	}
255 256 257 258 259 260 261
	case ACB_ADAPTER_TYPE_D: {
		void __iomem *mem_base0;
		unsigned long addr, range, flags;

		addr = (unsigned long)pci_resource_start(pdev, 0);
		range = pci_resource_len(pdev, 0);
		flags = pci_resource_flags(pdev, 0);
262
		mem_base0 = ioremap(addr, range);
263 264 265 266 267 268 269 270
		if (!mem_base0) {
			pr_notice("arcmsr%d: memory mapping region fail\n",
				acb->host->host_no);
			return false;
		}
		acb->mem_base0 = mem_base0;
		break;
		}
271 272 273 274 275 276 277
	}
	return true;
}

static void arcmsr_unmap_pciregion(struct AdapterControlBlock *acb)
{
	switch (acb->adapter_type) {
278 279 280 281 282 283 284 285 286 287 288 289 290
	case ACB_ADAPTER_TYPE_A:{
		iounmap(acb->pmuA);
	}
	break;
	case ACB_ADAPTER_TYPE_B:{
		iounmap(acb->mem_base0);
		iounmap(acb->mem_base1);
	}

	break;
	case ACB_ADAPTER_TYPE_C:{
		iounmap(acb->pmuC);
	}
291 292 293 294
	break;
	case ACB_ADAPTER_TYPE_D:
		iounmap(acb->mem_base0);
		break;
295 296 297
	}
}

298
static irqreturn_t arcmsr_do_interrupt(int irq, void *dev_id)
299 300
{
	irqreturn_t handle_state;
301
	struct AdapterControlBlock *acb = dev_id;
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334

	handle_state = arcmsr_interrupt(acb);
	return handle_state;
}

static int arcmsr_bios_param(struct scsi_device *sdev,
		struct block_device *bdev, sector_t capacity, int *geom)
{
	int ret, heads, sectors, cylinders, total_capacity;
	unsigned char *buffer;/* return copy of block device's partition table */

	buffer = scsi_bios_ptable(bdev);
	if (buffer) {
		ret = scsi_partsize(buffer, capacity, &geom[2], &geom[0], &geom[1]);
		kfree(buffer);
		if (ret != -1)
			return ret;
	}
	total_capacity = capacity;
	heads = 64;
	sectors = 32;
	cylinders = total_capacity / (heads * sectors);
	if (cylinders > 1024) {
		heads = 255;
		sectors = 63;
		cylinders = total_capacity / (heads * sectors);
	}
	geom[0] = heads;
	geom[1] = sectors;
	geom[2] = cylinders;
	return 0;
}

335
static uint8_t arcmsr_hbaA_wait_msgint_ready(struct AdapterControlBlock *acb)
336 337
{
	struct MessageUnit_A __iomem *reg = acb->pmuA;
338 339 340 341 342 343 344 345 346 347 348
	int i;

	for (i = 0; i < 2000; i++) {
		if (readl(&reg->outbound_intstatus) &
				ARCMSR_MU_OUTBOUND_MESSAGE0_INT) {
			writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT,
				&reg->outbound_intstatus);
			return true;
		}
		msleep(10);
	} /* max 20 seconds */
349

350
	return false;
351 352
}

353
static uint8_t arcmsr_hbaB_wait_msgint_ready(struct AdapterControlBlock *acb)
354
{
355
	struct MessageUnit_B *reg = acb->pmuB;
356 357 358 359 360 361 362 363 364 365 366 367 368
	int i;

	for (i = 0; i < 2000; i++) {
		if (readl(reg->iop2drv_doorbell)
			& ARCMSR_IOP2DRV_MESSAGE_CMD_DONE) {
			writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN,
					reg->iop2drv_doorbell);
			writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT,
					reg->drv2iop_doorbell);
			return true;
		}
		msleep(10);
	} /* max 20 seconds */
369

370
	return false;
371 372
}

373
static uint8_t arcmsr_hbaC_wait_msgint_ready(struct AdapterControlBlock *pACB)
374
{
375
	struct MessageUnit_C __iomem *phbcmu = pACB->pmuC;
376 377 378 379 380 381 382 383 384 385 386 387
	int i;

	for (i = 0; i < 2000; i++) {
		if (readl(&phbcmu->outbound_doorbell)
				& ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE) {
			writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR,
				&phbcmu->outbound_doorbell_clear); /*clear interrupt*/
			return true;
		}
		msleep(10);
	} /* max 20 seconds */

388 389
	return false;
}
390

391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
static bool arcmsr_hbaD_wait_msgint_ready(struct AdapterControlBlock *pACB)
{
	struct MessageUnit_D *reg = pACB->pmuD;
	int i;

	for (i = 0; i < 2000; i++) {
		if (readl(reg->outbound_doorbell)
			& ARCMSR_ARC1214_IOP2DRV_MESSAGE_CMD_DONE) {
			writel(ARCMSR_ARC1214_IOP2DRV_MESSAGE_CMD_DONE,
				reg->outbound_doorbell);
			return true;
		}
		msleep(10);
	} /* max 20 seconds */
	return false;
}

408
static void arcmsr_hbaA_flush_cache(struct AdapterControlBlock *acb)
409 410 411 412 413
{
	struct MessageUnit_A __iomem *reg = acb->pmuA;
	int retry_count = 30;
	writel(ARCMSR_INBOUND_MESG0_FLUSH_CACHE, &reg->inbound_msgaddr0);
	do {
414
		if (arcmsr_hbaA_wait_msgint_ready(acb))
415 416 417 418 419 420 421 422 423
			break;
		else {
			retry_count--;
			printk(KERN_NOTICE "arcmsr%d: wait 'flush adapter cache' \
			timeout, retry count down = %d \n", acb->host->host_no, retry_count);
		}
	} while (retry_count != 0);
}

424
static void arcmsr_hbaB_flush_cache(struct AdapterControlBlock *acb)
425 426 427 428 429
{
	struct MessageUnit_B *reg = acb->pmuB;
	int retry_count = 30;
	writel(ARCMSR_MESSAGE_FLUSH_CACHE, reg->drv2iop_doorbell);
	do {
430
		if (arcmsr_hbaB_wait_msgint_ready(acb))
431 432 433 434 435 436 437 438 439
			break;
		else {
			retry_count--;
			printk(KERN_NOTICE "arcmsr%d: wait 'flush adapter cache' \
			timeout,retry count down = %d \n", acb->host->host_no, retry_count);
		}
	} while (retry_count != 0);
}

440
static void arcmsr_hbaC_flush_cache(struct AdapterControlBlock *pACB)
441
{
442
	struct MessageUnit_C __iomem *reg = pACB->pmuC;
443 444 445 446
	int retry_count = 30;/* enlarge wait flush adapter cache time: 10 minute */
	writel(ARCMSR_INBOUND_MESG0_FLUSH_CACHE, &reg->inbound_msgaddr0);
	writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &reg->inbound_doorbell);
	do {
447
		if (arcmsr_hbaC_wait_msgint_ready(pACB)) {
448 449 450 451 452 453 454 455 456
			break;
		} else {
			retry_count--;
			printk(KERN_NOTICE "arcmsr%d: wait 'flush adapter cache' \
			timeout,retry count down = %d \n", pACB->host->host_no, retry_count);
		}
	} while (retry_count != 0);
	return;
}
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474

static void arcmsr_hbaD_flush_cache(struct AdapterControlBlock *pACB)
{
	int retry_count = 15;
	struct MessageUnit_D *reg = pACB->pmuD;

	writel(ARCMSR_INBOUND_MESG0_FLUSH_CACHE, reg->inbound_msgaddr0);
	do {
		if (arcmsr_hbaD_wait_msgint_ready(pACB))
			break;

		retry_count--;
		pr_notice("arcmsr%d: wait 'flush adapter "
			"cache' timeout, retry count down = %d\n",
			pACB->host->host_no, retry_count);
	} while (retry_count != 0);
}

475 476
static void arcmsr_flush_adapter_cache(struct AdapterControlBlock *acb)
{
477
	switch (acb->adapter_type) {
478

479
	case ACB_ADAPTER_TYPE_A: {
480
		arcmsr_hbaA_flush_cache(acb);
481 482
		}
		break;
483

484
	case ACB_ADAPTER_TYPE_B: {
485
		arcmsr_hbaB_flush_cache(acb);
486
		}
487 488
		break;
	case ACB_ADAPTER_TYPE_C: {
489
		arcmsr_hbaC_flush_cache(acb);
490
		}
491 492 493 494
		break;
	case ACB_ADAPTER_TYPE_D:
		arcmsr_hbaD_flush_cache(acb);
		break;
495 496
	}
}
497

498 499
static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
{
500 501 502 503 504 505
	struct pci_dev *pdev = acb->pdev;
	void *dma_coherent;
	dma_addr_t dma_coherent_handle;
	struct CommandControlBlock *ccb_tmp;
	int i = 0, j = 0;
	dma_addr_t cdb_phyaddr;
506
	unsigned long roundup_ccbsize;
507 508 509
	unsigned long max_xfer_len;
	unsigned long max_sg_entrys;
	uint32_t  firm_config_version;
510

511 512 513 514 515 516 517 518 519
	for (i = 0; i < ARCMSR_MAX_TARGETID; i++)
		for (j = 0; j < ARCMSR_MAX_TARGETLUN; j++)
			acb->devstate[i][j] = ARECA_RAID_GONE;

	max_xfer_len = ARCMSR_MAX_XFER_LEN;
	max_sg_entrys = ARCMSR_DEFAULT_SG_ENTRIES;
	firm_config_version = acb->firm_cfg_version;
	if((firm_config_version & 0xFF) >= 3){
		max_xfer_len = (ARCMSR_CDB_SG_PAGE_LENGTH << ((firm_config_version >> 8) & 0xFF)) * 1024;/* max 4M byte */
520
		max_sg_entrys = (max_xfer_len/4096);
521 522 523 524
	}
	acb->host->max_sectors = max_xfer_len/512;
	acb->host->sg_tablesize = max_sg_entrys;
	roundup_ccbsize = roundup(sizeof(struct CommandControlBlock) + (max_sg_entrys - 1) * sizeof(struct SG64ENTRY), 32);
525
	acb->uncache_size = roundup_ccbsize * ARCMSR_MAX_FREECCB_NUM;
526 527
	dma_coherent = dma_alloc_coherent(&pdev->dev, acb->uncache_size, &dma_coherent_handle, GFP_KERNEL);
	if(!dma_coherent){
528
		printk(KERN_NOTICE "arcmsr%d: dma_alloc_coherent got error\n", acb->host->host_no);
529 530 531 532 533 534 535 536 537
		return -ENOMEM;
	}
	acb->dma_coherent = dma_coherent;
	acb->dma_coherent_handle = dma_coherent_handle;
	memset(dma_coherent, 0, acb->uncache_size);
	ccb_tmp = dma_coherent;
	acb->vir2phy_offset = (unsigned long)dma_coherent - (unsigned long)dma_coherent_handle;
	for(i = 0; i < ARCMSR_MAX_FREECCB_NUM; i++){
		cdb_phyaddr = dma_coherent_handle + offsetof(struct CommandControlBlock, arcmsr_cdb);
538 539 540 541 542 543 544 545 546 547
		switch (acb->adapter_type) {
		case ACB_ADAPTER_TYPE_A:
		case ACB_ADAPTER_TYPE_B:
			ccb_tmp->cdb_phyaddr = cdb_phyaddr >> 5;
			break;
		case ACB_ADAPTER_TYPE_C:
		case ACB_ADAPTER_TYPE_D:
			ccb_tmp->cdb_phyaddr = cdb_phyaddr;
			break;
		}
548 549 550 551 552 553
		acb->pccb_pool[i] = ccb_tmp;
		ccb_tmp->acb = acb;
		INIT_LIST_HEAD(&ccb_tmp->list);
		list_add_tail(&ccb_tmp->list, &acb->ccb_free_list);
		ccb_tmp = (struct CommandControlBlock *)((unsigned long)ccb_tmp + roundup_ccbsize);
		dma_coherent_handle = dma_coherent_handle + roundup_ccbsize;
554
	}
555 556
	return 0;
}
557

558 559
static void arcmsr_message_isr_bh_fn(struct work_struct *work) 
{
560 561 562 563 564 565 566 567 568
	struct AdapterControlBlock *acb = container_of(work,
		struct AdapterControlBlock, arcmsr_do_message_isr_bh);
	char *acb_dev_map = (char *)acb->device_map;
	uint32_t __iomem *signature = NULL;
	char __iomem *devicemap = NULL;
	int target, lun;
	struct scsi_device *psdev;
	char diff, temp;

569
	switch (acb->adapter_type) {
570 571
	case ACB_ADAPTER_TYPE_A: {
		struct MessageUnit_A __iomem *reg  = acb->pmuA;
572

573 574
		signature = (uint32_t __iomem *)(&reg->message_rwbuffer[0]);
		devicemap = (char __iomem *)(&reg->message_rwbuffer[21]);
575
		break;
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
	}
	case ACB_ADAPTER_TYPE_B: {
		struct MessageUnit_B *reg  = acb->pmuB;

		signature = (uint32_t __iomem *)(&reg->message_rwbuffer[0]);
		devicemap = (char __iomem *)(&reg->message_rwbuffer[21]);
		break;
	}
	case ACB_ADAPTER_TYPE_C: {
		struct MessageUnit_C __iomem *reg  = acb->pmuC;

		signature = (uint32_t __iomem *)(&reg->msgcode_rwbuffer[0]);
		devicemap = (char __iomem *)(&reg->msgcode_rwbuffer[21]);
		break;
	}
591 592 593 594 595 596 597
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg  = acb->pmuD;

		signature = (uint32_t __iomem *)(&reg->msgcode_rwbuffer[0]);
		devicemap = (char __iomem *)(&reg->msgcode_rwbuffer[21]);
		break;
	}
598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620
	}
	atomic_inc(&acb->rq_map_token);
	if (readl(signature) != ARCMSR_SIGNATURE_GET_CONFIG)
		return;
	for (target = 0; target < ARCMSR_MAX_TARGETID - 1;
		target++) {
		temp = readb(devicemap);
		diff = (*acb_dev_map) ^ temp;
		if (diff != 0) {
			*acb_dev_map = temp;
			for (lun = 0; lun < ARCMSR_MAX_TARGETLUN;
				lun++) {
				if ((diff & 0x01) == 1 &&
					(temp & 0x01) == 1) {
					scsi_add_device(acb->host,
						0, target, lun);
				} else if ((diff & 0x01) == 1
					&& (temp & 0x01) == 0) {
					psdev = scsi_device_lookup(acb->host,
						0, target, lun);
					if (psdev != NULL) {
						scsi_remove_device(psdev);
						scsi_device_put(psdev);
621 622
					}
				}
623 624
				temp >>= 1;
				diff >>= 1;
625 626
			}
		}
627 628
		devicemap++;
		acb_dev_map++;
629 630
	}
}
631

632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
static int
arcmsr_request_irq(struct pci_dev *pdev, struct AdapterControlBlock *acb)
{
	int	i, j, r;
	struct msix_entry entries[ARCMST_NUM_MSIX_VECTORS];

	for (i = 0; i < ARCMST_NUM_MSIX_VECTORS; i++)
		entries[i].entry = i;
	r = pci_enable_msix_range(pdev, entries, 1, ARCMST_NUM_MSIX_VECTORS);
	if (r < 0)
		goto msi_int;
	acb->msix_vector_count = r;
	for (i = 0; i < r; i++) {
		if (request_irq(entries[i].vector,
			arcmsr_do_interrupt, 0, "arcmsr", acb)) {
			pr_warn("arcmsr%d: request_irq =%d failed!\n",
				acb->host->host_no, entries[i].vector);
			for (j = 0 ; j < i ; j++)
				free_irq(entries[j].vector, acb);
			pci_disable_msix(pdev);
			goto msi_int;
		}
		acb->entries[i] = entries[i];
	}
	acb->acb_flags |= ACB_F_MSIX_ENABLED;
	pr_info("arcmsr%d: msi-x enabled\n", acb->host->host_no);
	return SUCCESS;
msi_int:
	if (pci_enable_msi_exact(pdev, 1) < 0)
		goto legacy_int;
	if (request_irq(pdev->irq, arcmsr_do_interrupt,
		IRQF_SHARED, "arcmsr", acb)) {
		pr_warn("arcmsr%d: request_irq =%d failed!\n",
			acb->host->host_no, pdev->irq);
		pci_disable_msi(pdev);
		goto legacy_int;
	}
	acb->acb_flags |= ACB_F_MSI_ENABLED;
	pr_info("arcmsr%d: msi enabled\n", acb->host->host_no);
	return SUCCESS;
legacy_int:
	if (request_irq(pdev->irq, arcmsr_do_interrupt,
		IRQF_SHARED, "arcmsr", acb)) {
		pr_warn("arcmsr%d: request_irq = %d failed!\n",
			acb->host->host_no, pdev->irq);
		return FAILED;
	}
	return SUCCESS;
}

682
static int arcmsr_probe(struct pci_dev *pdev, const struct pci_device_id *id)
683 684 685
{
	struct Scsi_Host *host;
	struct AdapterControlBlock *acb;
686
	uint8_t bus,dev_fun;
687 688
	int error;
	error = pci_enable_device(pdev);
689
	if(error){
690 691 692
		return -ENODEV;
	}
	host = scsi_host_alloc(&arcmsr_scsi_host_template, sizeof(struct AdapterControlBlock));
693 694
	if(!host){
    		goto pci_disable_dev;
695
	}
696
	error = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
697
	if(error){
698
		error = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
699
		if(error){
700 701 702
			printk(KERN_WARNING
			       "scsi%d: No suitable DMA mask available\n",
			       host->host_no);
703
			goto scsi_host_release;
704 705
		}
	}
706
	init_waitqueue_head(&wait_q);
707 708
	bus = pdev->bus->number;
	dev_fun = pdev->devfn;
709
	acb = (struct AdapterControlBlock *) host->hostdata;
710
	memset(acb,0,sizeof(struct AdapterControlBlock));
711
	acb->pdev = pdev;
712
	acb->host = host;
713
	host->max_lun = ARCMSR_MAX_TARGETLUN;
714 715
	host->max_id = ARCMSR_MAX_TARGETID;		/*16:8*/
	host->max_cmd_len = 16;	 			/*this is issue of 64bit LBA ,over 2T byte*/
716
	host->can_queue = ARCMSR_MAX_OUTSTANDING_CMD;
717
	host->cmd_per_lun = ARCMSR_MAX_CMD_PERLUN;	    
718 719
	host->this_id = ARCMSR_SCSI_INITIATOR_ID;
	host->unique_id = (bus << 8) | dev_fun;
720 721
	pci_set_drvdata(pdev, host);
	pci_set_master(pdev);
722
	error = pci_request_regions(pdev, "arcmsr");
723
	if(error){
724
		goto scsi_host_release;
725
	}
726 727
	spin_lock_init(&acb->eh_lock);
	spin_lock_init(&acb->ccblist_lock);
728 729
	spin_lock_init(&acb->postq_lock);
	spin_lock_init(&acb->doneq_lock);
730 731
	spin_lock_init(&acb->rqbuffer_lock);
	spin_lock_init(&acb->wqbuffer_lock);
732
	acb->acb_flags |= (ACB_F_MESSAGE_WQBUFFER_CLEARED |
733 734
			ACB_F_MESSAGE_RQBUFFER_CLEARED |
			ACB_F_MESSAGE_WQBUFFER_READED);
735 736
	acb->acb_flags &= ~ACB_F_SCSISTOPADAPTER;
	INIT_LIST_HEAD(&acb->ccb_free_list);
737
	acb->adapter_type = id->driver_data;
738
	error = arcmsr_remap_pciregion(acb);
739
	if(!error){
740 741 742
		goto pci_release_regs;
	}
	error = arcmsr_get_firmware_spec(acb);
743
	if(!error){
744 745
		goto unmap_pci_region;
	}
746
	error = arcmsr_alloc_ccb_pool(acb);
747
	if(error){
748 749
		goto free_hbb_mu;
	}
750
	error = scsi_add_host(host, &pdev->dev);
751
	if(error){
752
		goto free_ccb_pool;
753
	}
754
	if (arcmsr_request_irq(pdev, acb) == FAILED)
755
		goto scsi_host_remove;
756
	arcmsr_iop_init(acb);
757
	INIT_WORK(&acb->arcmsr_do_message_isr_bh, arcmsr_message_isr_bh_fn);
758
	atomic_set(&acb->rq_map_token, 16);
759 760
	atomic_set(&acb->ante_token_value, 16);
	acb->fw_flag = FW_NORMAL;
761
	init_timer(&acb->eternal_timer);
762
	acb->eternal_timer.expires = jiffies + msecs_to_jiffies(6 * HZ);
763 764 765
	acb->eternal_timer.data = (unsigned long) acb;
	acb->eternal_timer.function = &arcmsr_request_device_map;
	add_timer(&acb->eternal_timer);
766
	if(arcmsr_alloc_sysfs_attr(acb))
767
		goto out_free_sysfs;
768
	scsi_scan_host(host);
769
	return 0;
770
out_free_sysfs:
771 772
	del_timer_sync(&acb->eternal_timer);
	flush_work(&acb->arcmsr_do_message_isr_bh);
773 774
	arcmsr_stop_adapter_bgrb(acb);
	arcmsr_flush_adapter_cache(acb);
775 776 777 778
	arcmsr_free_irq(pdev, acb);
scsi_host_remove:
	scsi_remove_host(host);
free_ccb_pool:
779
	arcmsr_free_ccb_pool(acb);
780
free_hbb_mu:
781
	arcmsr_free_mu(acb);
782 783 784
unmap_pci_region:
	arcmsr_unmap_pciregion(acb);
pci_release_regs:
785
	pci_release_regions(pdev);
786
scsi_host_release:
787
	scsi_host_put(host);
788
pci_disable_dev:
789
	pci_disable_device(pdev);
790
	return -ENODEV;
791 792
}

793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
static void arcmsr_free_irq(struct pci_dev *pdev,
		struct AdapterControlBlock *acb)
{
	int i;

	if (acb->acb_flags & ACB_F_MSI_ENABLED) {
		free_irq(pdev->irq, acb);
		pci_disable_msi(pdev);
	} else if (acb->acb_flags & ACB_F_MSIX_ENABLED) {
		for (i = 0; i < acb->msix_vector_count; i++)
			free_irq(acb->entries[i].vector, acb);
		pci_disable_msix(pdev);
	} else
		free_irq(pdev->irq, acb);
}

809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
static int arcmsr_suspend(struct pci_dev *pdev, pm_message_t state)
{
	uint32_t intmask_org;
	struct Scsi_Host *host = pci_get_drvdata(pdev);
	struct AdapterControlBlock *acb =
		(struct AdapterControlBlock *)host->hostdata;

	intmask_org = arcmsr_disable_outbound_ints(acb);
	arcmsr_free_irq(pdev, acb);
	del_timer_sync(&acb->eternal_timer);
	flush_work(&acb->arcmsr_do_message_isr_bh);
	arcmsr_stop_adapter_bgrb(acb);
	arcmsr_flush_adapter_cache(acb);
	pci_set_drvdata(pdev, host);
	pci_save_state(pdev);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, pci_choose_state(pdev, state));
	return 0;
}

static int arcmsr_resume(struct pci_dev *pdev)
{
	int error;
	struct Scsi_Host *host = pci_get_drvdata(pdev);
	struct AdapterControlBlock *acb =
		(struct AdapterControlBlock *)host->hostdata;

	pci_set_power_state(pdev, PCI_D0);
	pci_enable_wake(pdev, PCI_D0, 0);
	pci_restore_state(pdev);
	if (pci_enable_device(pdev)) {
		pr_warn("%s: pci_enable_device error\n", __func__);
		return -ENODEV;
	}
	error = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
	if (error) {
		error = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
		if (error) {
			pr_warn("scsi%d: No suitable DMA mask available\n",
			       host->host_no);
			goto controller_unregister;
		}
	}
	pci_set_master(pdev);
	if (arcmsr_request_irq(pdev, acb) == FAILED)
		goto controller_stop;
	arcmsr_iop_init(acb);
	INIT_WORK(&acb->arcmsr_do_message_isr_bh, arcmsr_message_isr_bh_fn);
	atomic_set(&acb->rq_map_token, 16);
	atomic_set(&acb->ante_token_value, 16);
	acb->fw_flag = FW_NORMAL;
	init_timer(&acb->eternal_timer);
	acb->eternal_timer.expires = jiffies + msecs_to_jiffies(6 * HZ);
	acb->eternal_timer.data = (unsigned long) acb;
	acb->eternal_timer.function = &arcmsr_request_device_map;
	add_timer(&acb->eternal_timer);
	return 0;
controller_stop:
	arcmsr_stop_adapter_bgrb(acb);
	arcmsr_flush_adapter_cache(acb);
controller_unregister:
	scsi_remove_host(host);
	arcmsr_free_ccb_pool(acb);
	arcmsr_unmap_pciregion(acb);
	pci_release_regions(pdev);
	scsi_host_put(host);
	pci_disable_device(pdev);
	return -ENODEV;
}

879
static uint8_t arcmsr_hbaA_abort_allcmd(struct AdapterControlBlock *acb)
880
{
Al Viro's avatar
Al Viro committed
881
	struct MessageUnit_A __iomem *reg = acb->pmuA;
882
	writel(ARCMSR_INBOUND_MESG0_ABORT_CMD, &reg->inbound_msgaddr0);
883
	if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
884
		printk(KERN_NOTICE
885
			"arcmsr%d: wait 'abort all outstanding command' timeout\n"
886
			, acb->host->host_no);
887
		return false;
888
	}
889
	return true;
890 891
}

892
static uint8_t arcmsr_hbaB_abort_allcmd(struct AdapterControlBlock *acb)
893
{
Al Viro's avatar
Al Viro committed
894
	struct MessageUnit_B *reg = acb->pmuB;
895

896
	writel(ARCMSR_MESSAGE_ABORT_CMD, reg->drv2iop_doorbell);
897
	if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
898
		printk(KERN_NOTICE
899
			"arcmsr%d: wait 'abort all outstanding command' timeout\n"
900
			, acb->host->host_no);
901
		return false;
902
	}
903 904
	return true;
}
905
static uint8_t arcmsr_hbaC_abort_allcmd(struct AdapterControlBlock *pACB)
906
{
907
	struct MessageUnit_C __iomem *reg = pACB->pmuC;
908 909
	writel(ARCMSR_INBOUND_MESG0_ABORT_CMD, &reg->inbound_msgaddr0);
	writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &reg->inbound_doorbell);
910
	if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
911
		printk(KERN_NOTICE
912
			"arcmsr%d: wait 'abort all outstanding command' timeout\n"
913 914 915 916
			, pACB->host->host_no);
		return false;
	}
	return true;
917
}
918 919 920 921 922 923 924 925 926 927 928 929 930 931

static uint8_t arcmsr_hbaD_abort_allcmd(struct AdapterControlBlock *pACB)
{
	struct MessageUnit_D *reg = pACB->pmuD;

	writel(ARCMSR_INBOUND_MESG0_ABORT_CMD, reg->inbound_msgaddr0);
	if (!arcmsr_hbaD_wait_msgint_ready(pACB)) {
		pr_notice("arcmsr%d: wait 'abort all outstanding "
			"command' timeout\n", pACB->host->host_no);
		return false;
	}
	return true;
}

932
static uint8_t arcmsr_abort_allcmd(struct AdapterControlBlock *acb)
933
{
934
	uint8_t rtnval = 0;
935 936
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A: {
937
		rtnval = arcmsr_hbaA_abort_allcmd(acb);
938 939 940 941
		}
		break;

	case ACB_ADAPTER_TYPE_B: {
942
		rtnval = arcmsr_hbaB_abort_allcmd(acb);
943
		}
944 945 946
		break;

	case ACB_ADAPTER_TYPE_C: {
947
		rtnval = arcmsr_hbaC_abort_allcmd(acb);
948
		}
949 950 951 952 953
		break;

	case ACB_ADAPTER_TYPE_D:
		rtnval = arcmsr_hbaD_abort_allcmd(acb);
		break;
954
	}
955
	return rtnval;
956 957
}

958 959 960 961
static void arcmsr_pci_unmap_dma(struct CommandControlBlock *ccb)
{
	struct scsi_cmnd *pcmd = ccb->pcmd;

962
	scsi_dma_unmap(pcmd);
963
}
964

965
static void arcmsr_ccb_complete(struct CommandControlBlock *ccb)
966 967 968
{
	struct AdapterControlBlock *acb = ccb->acb;
	struct scsi_cmnd *pcmd = ccb->pcmd;
969 970
	unsigned long flags;
	atomic_dec(&acb->ccboutstandingcount);
971 972
	arcmsr_pci_unmap_dma(ccb);
	ccb->startdone = ARCMSR_CCB_DONE;
973
	spin_lock_irqsave(&acb->ccblist_lock, flags);
974
	list_add_tail(&ccb->list, &acb->ccb_free_list);
975
	spin_unlock_irqrestore(&acb->ccblist_lock, flags);
976 977 978
	pcmd->scsi_done(pcmd);
}

979 980 981 982 983 984 985 986
static void arcmsr_report_sense_info(struct CommandControlBlock *ccb)
{

	struct scsi_cmnd *pcmd = ccb->pcmd;
	struct SENSE_DATA *sensebuffer = (struct SENSE_DATA *)pcmd->sense_buffer;
	pcmd->result = DID_OK << 16;
	if (sensebuffer) {
		int sense_data_length =
987 988 989
			sizeof(struct SENSE_DATA) < SCSI_SENSE_BUFFERSIZE
			? sizeof(struct SENSE_DATA) : SCSI_SENSE_BUFFERSIZE;
		memset(sensebuffer, 0, SCSI_SENSE_BUFFERSIZE);
990 991 992 993 994 995 996 997 998
		memcpy(sensebuffer, ccb->arcmsr_cdb.SenseData, sense_data_length);
		sensebuffer->ErrorCode = SCSI_SENSE_CURRENT_ERRORS;
		sensebuffer->Valid = 1;
	}
}

static u32 arcmsr_disable_outbound_ints(struct AdapterControlBlock *acb)
{
	u32 orig_mask = 0;
999
	switch (acb->adapter_type) {	
1000
	case ACB_ADAPTER_TYPE_A : {
Al Viro's avatar
Al Viro committed
1001
		struct MessageUnit_A __iomem *reg = acb->pmuA;
1002
		orig_mask = readl(&reg->outbound_intmask);
1003 1004 1005 1006 1007
		writel(orig_mask|ARCMSR_MU_OUTBOUND_ALL_INTMASKENABLE, \
						&reg->outbound_intmask);
		}
		break;
	case ACB_ADAPTER_TYPE_B : {
Al Viro's avatar
Al Viro committed
1008
		struct MessageUnit_B *reg = acb->pmuB;
1009 1010
		orig_mask = readl(reg->iop2drv_doorbell_mask);
		writel(0, reg->iop2drv_doorbell_mask);
1011 1012
		}
		break;
1013
	case ACB_ADAPTER_TYPE_C:{
1014
		struct MessageUnit_C __iomem *reg = acb->pmuC;
1015 1016 1017 1018 1019
		/* disable all outbound interrupt */
		orig_mask = readl(&reg->host_int_mask); /* disable outbound message0 int */
		writel(orig_mask|ARCMSR_HBCMU_ALL_INTMASKENABLE, &reg->host_int_mask);
		}
		break;
1020 1021 1022 1023 1024 1025
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg = acb->pmuD;
		/* disable all outbound interrupt */
		writel(ARCMSR_ARC1214_ALL_INT_DISABLE, reg->pcief0_int_enable);
		}
		break;
1026 1027 1028 1029
	}
	return orig_mask;
}

1030 1031
static void arcmsr_report_ccb_state(struct AdapterControlBlock *acb, 
			struct CommandControlBlock *ccb, bool error)
1032 1033 1034 1035
{
	uint8_t id, lun;
	id = ccb->pcmd->device->id;
	lun = ccb->pcmd->device->lun;
1036
	if (!error) {
1037 1038
		if (acb->devstate[id][lun] == ARECA_RAID_GONE)
			acb->devstate[id][lun] = ARECA_RAID_GOOD;
1039 1040
		ccb->pcmd->result = DID_OK << 16;
		arcmsr_ccb_complete(ccb);
1041
	}else{
1042 1043 1044 1045
		switch (ccb->arcmsr_cdb.DeviceStatus) {
		case ARCMSR_DEV_SELECT_TIMEOUT: {
			acb->devstate[id][lun] = ARECA_RAID_GONE;
			ccb->pcmd->result = DID_NO_CONNECT << 16;
1046
			arcmsr_ccb_complete(ccb);
1047 1048 1049 1050 1051 1052 1053 1054
			}
			break;

		case ARCMSR_DEV_ABORTED:

		case ARCMSR_DEV_INIT_FAIL: {
			acb->devstate[id][lun] = ARECA_RAID_GONE;
			ccb->pcmd->result = DID_BAD_TARGET << 16;
1055
			arcmsr_ccb_complete(ccb);
1056 1057 1058 1059 1060 1061
			}
			break;

		case ARCMSR_DEV_CHECK_CONDITION: {
			acb->devstate[id][lun] = ARECA_RAID_GOOD;
			arcmsr_report_sense_info(ccb);
1062
			arcmsr_ccb_complete(ccb);
1063 1064 1065 1066
			}
			break;

		default:
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
			printk(KERN_NOTICE
				"arcmsr%d: scsi id = %d lun = %d isr get command error done, \
				but got unknown DeviceStatus = 0x%x \n"
				, acb->host->host_no
				, id
				, lun
				, ccb->arcmsr_cdb.DeviceStatus);
				acb->devstate[id][lun] = ARECA_RAID_GONE;
				ccb->pcmd->result = DID_NO_CONNECT << 16;
				arcmsr_ccb_complete(ccb);
1077 1078 1079 1080 1081
			break;
		}
	}
}

1082
static void arcmsr_drain_donequeue(struct AdapterControlBlock *acb, struct CommandControlBlock *pCCB, bool error)
1083
{
1084
	int id, lun;
1085 1086 1087
	if ((pCCB->acb != acb) || (pCCB->startdone != ARCMSR_CCB_START)) {
		if (pCCB->startdone == ARCMSR_CCB_ABORTED) {
			struct scsi_cmnd *abortcmd = pCCB->pcmd;
1088
			if (abortcmd) {
1089
				id = abortcmd->device->id;
1090
				lun = abortcmd->device->lun;				
1091
				abortcmd->result |= DID_ABORT << 16;
1092 1093 1094
				arcmsr_ccb_complete(pCCB);
				printk(KERN_NOTICE "arcmsr%d: pCCB ='0x%p' isr got aborted command \n",
				acb->host->host_no, pCCB);
1095
			}
1096
			return;
1097 1098 1099 1100 1101 1102 1103
		}
		printk(KERN_NOTICE "arcmsr%d: isr get an illegal ccb command \
				done acb = '0x%p'"
				"ccb = '0x%p' ccbacb = '0x%p' startdone = 0x%x"
				" ccboutstandingcount = %d \n"
				, acb->host->host_no
				, acb
1104 1105 1106
				, pCCB
				, pCCB->acb
				, pCCB->startdone
1107
				, atomic_read(&acb->ccboutstandingcount));
1108
		  return;
1109
	}
1110
	arcmsr_report_ccb_state(acb, pCCB, error);
1111 1112 1113 1114 1115
}

static void arcmsr_done4abort_postqueue(struct AdapterControlBlock *acb)
{
	int i = 0;
1116
	uint32_t flag_ccb, ccb_cdb_phy;
1117 1118 1119
	struct ARCMSR_CDB *pARCMSR_CDB;
	bool error;
	struct CommandControlBlock *pCCB;
1120 1121 1122
	switch (acb->adapter_type) {

	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
1123
		struct MessageUnit_A __iomem *reg = acb->pmuA;
1124
		uint32_t outbound_intstatus;
Al Viro's avatar
Al Viro committed
1125
		outbound_intstatus = readl(&reg->outbound_intstatus) &
1126 1127 1128
					acb->outbound_int_enable;
		/*clear and abort all outbound posted Q*/
		writel(outbound_intstatus, &reg->outbound_intstatus);/*clear interrupt*/
1129
		while(((flag_ccb = readl(&reg->outbound_queueport)) != 0xFFFFFFFF)
1130
				&& (i++ < ARCMSR_MAX_OUTSTANDING_CMD)) {
1131 1132 1133 1134
			pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset + (flag_ccb << 5));/*frame must be 32 bytes aligned*/
			pCCB = container_of(pARCMSR_CDB, struct CommandControlBlock, arcmsr_cdb);
			error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE0) ? true : false;
			arcmsr_drain_donequeue(acb, pCCB, error);
1135 1136 1137 1138 1139
		}
		}
		break;

	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
1140
		struct MessageUnit_B *reg = acb->pmuB;
1141
		/*clear all outbound posted Q*/
1142
		writel(ARCMSR_DOORBELL_INT_CLEAR_PATTERN, reg->iop2drv_doorbell); /* clear doorbell interrupt */
1143
		for (i = 0; i < ARCMSR_MAX_HBB_POSTQUEUE; i++) {
1144 1145 1146
			flag_ccb = reg->done_qbuffer[i];
			if (flag_ccb != 0) {
				reg->done_qbuffer[i] = 0;
1147 1148 1149 1150
				pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset+(flag_ccb << 5));/*frame must be 32 bytes aligned*/
				pCCB = container_of(pARCMSR_CDB, struct CommandControlBlock, arcmsr_cdb);
				error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE0) ? true : false;
				arcmsr_drain_donequeue(acb, pCCB, error);
1151
			}
1152
			reg->post_qbuffer[i] = 0;
1153 1154 1155 1156 1157
		}
		reg->doneq_index = 0;
		reg->postq_index = 0;
		}
		break;
1158
	case ACB_ADAPTER_TYPE_C: {
1159
		struct MessageUnit_C __iomem *reg = acb->pmuC;
1160 1161 1162 1163 1164 1165 1166 1167 1168
		while ((readl(&reg->host_int_status) & ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR) && (i++ < ARCMSR_MAX_OUTSTANDING_CMD)) {
			/*need to do*/
			flag_ccb = readl(&reg->outbound_queueport_low);
			ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
			pARCMSR_CDB = (struct  ARCMSR_CDB *)(acb->vir2phy_offset+ccb_cdb_phy);/*frame must be 32 bytes aligned*/
			pCCB = container_of(pARCMSR_CDB, struct CommandControlBlock, arcmsr_cdb);
			error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE1) ? true : false;
			arcmsr_drain_donequeue(acb, pCCB, error);
		}
1169 1170 1171 1172
		}
		break;
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D  *pmu = acb->pmuD;
1173 1174 1175
		uint32_t outbound_write_pointer;
		uint32_t doneq_index, index_stripped, addressLow, residual, toggle;
		unsigned long flags;
1176 1177 1178

		residual = atomic_read(&acb->ccboutstandingcount);
		for (i = 0; i < residual; i++) {
1179 1180 1181 1182 1183
			spin_lock_irqsave(&acb->doneq_lock, flags);
			outbound_write_pointer =
				pmu->done_qbuffer[0].addressLow + 1;
			doneq_index = pmu->doneq_index;
			if ((doneq_index & 0xFFF) !=
1184
				(outbound_write_pointer & 0xFFF)) {
1185 1186 1187 1188 1189
				toggle = doneq_index & 0x4000;
				index_stripped = (doneq_index & 0xFFF) + 1;
				index_stripped %= ARCMSR_MAX_ARC1214_DONEQUEUE;
				pmu->doneq_index = index_stripped ? (index_stripped | toggle) :
					((toggle ^ 0x4000) + 1);
1190
				doneq_index = pmu->doneq_index;
1191
				spin_unlock_irqrestore(&acb->doneq_lock, flags);
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204
				addressLow = pmu->done_qbuffer[doneq_index &
					0xFFF].addressLow;
				ccb_cdb_phy = (addressLow & 0xFFFFFFF0);
				pARCMSR_CDB = (struct  ARCMSR_CDB *)
					(acb->vir2phy_offset + ccb_cdb_phy);
				pCCB = container_of(pARCMSR_CDB,
					struct CommandControlBlock, arcmsr_cdb);
				error = (addressLow &
					ARCMSR_CCBREPLY_FLAG_ERROR_MODE1) ?
					true : false;
				arcmsr_drain_donequeue(acb, pCCB, error);
				writel(doneq_index,
					pmu->outboundlist_read_pointer);
1205 1206 1207
			} else {
				spin_unlock_irqrestore(&acb->doneq_lock, flags);
				mdelay(10);
1208 1209 1210 1211 1212 1213
			}
		}
		pmu->postq_index = 0;
		pmu->doneq_index = 0x40FF;
		}
		break;
1214 1215
	}
}
1216

1217 1218 1219 1220 1221 1222 1223 1224
static void arcmsr_remove(struct pci_dev *pdev)
{
	struct Scsi_Host *host = pci_get_drvdata(pdev);
	struct AdapterControlBlock *acb =
		(struct AdapterControlBlock *) host->hostdata;
	int poll_count = 0;
	arcmsr_free_sysfs_attr(acb);
	scsi_remove_host(host);
1225
	flush_work(&acb->arcmsr_do_message_isr_bh);
1226 1227
	del_timer_sync(&acb->eternal_timer);
	arcmsr_disable_outbound_ints(acb);
1228
	arcmsr_stop_adapter_bgrb(acb);
1229
	arcmsr_flush_adapter_cache(acb);	
1230 1231 1232
	acb->acb_flags |= ACB_F_SCSISTOPADAPTER;
	acb->acb_flags &= ~ACB_F_IOP_INITED;

1233
	for (poll_count = 0; poll_count < ARCMSR_MAX_OUTSTANDING_CMD; poll_count++){
1234 1235
		if (!atomic_read(&acb->ccboutstandingcount))
			break;
1236
		arcmsr_interrupt(acb);/* FIXME: need spinlock */
1237 1238 1239 1240 1241 1242 1243
		msleep(25);
	}

	if (atomic_read(&acb->ccboutstandingcount)) {
		int i;

		arcmsr_abort_allcmd(acb);
1244
		arcmsr_done4abort_postqueue(acb);
1245 1246 1247 1248 1249
		for (i = 0; i < ARCMSR_MAX_FREECCB_NUM; i++) {
			struct CommandControlBlock *ccb = acb->pccb_pool[i];
			if (ccb->startdone == ARCMSR_CCB_START) {
				ccb->startdone = ARCMSR_CCB_ABORTED;
				ccb->pcmd->result = DID_ABORT << 16;
1250
				arcmsr_ccb_complete(ccb);
1251 1252 1253
			}
		}
	}
1254
	arcmsr_free_irq(pdev, acb);
1255
	arcmsr_free_ccb_pool(acb);
1256
	arcmsr_free_mu(acb);
1257
	arcmsr_unmap_pciregion(acb);
1258
	pci_release_regions(pdev);
1259
	scsi_host_put(host);
1260 1261 1262 1263 1264 1265 1266 1267
	pci_disable_device(pdev);
}

static void arcmsr_shutdown(struct pci_dev *pdev)
{
	struct Scsi_Host *host = pci_get_drvdata(pdev);
	struct AdapterControlBlock *acb =
		(struct AdapterControlBlock *)host->hostdata;
1268 1269
	del_timer_sync(&acb->eternal_timer);
	arcmsr_disable_outbound_ints(acb);
1270
	arcmsr_free_irq(pdev, acb);
1271
	flush_work(&acb->arcmsr_do_message_isr_bh);
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
	arcmsr_stop_adapter_bgrb(acb);
	arcmsr_flush_adapter_cache(acb);
}

static int arcmsr_module_init(void)
{
	int error = 0;
	error = pci_register_driver(&arcmsr_pci_driver);
	return error;
}

static void arcmsr_module_exit(void)
{
	pci_unregister_driver(&arcmsr_pci_driver);
}
module_init(arcmsr_module_init);
module_exit(arcmsr_module_exit);

1290
static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb,
1291
						u32 intmask_org)
1292 1293
{
	u32 mask;
1294
	switch (acb->adapter_type) {
1295

1296
	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
1297
		struct MessageUnit_A __iomem *reg = acb->pmuA;
1298
		mask = intmask_org & ~(ARCMSR_MU_OUTBOUND_POSTQUEUE_INTMASKENABLE |
1299 1300
			     ARCMSR_MU_OUTBOUND_DOORBELL_INTMASKENABLE|
			     ARCMSR_MU_OUTBOUND_MESSAGE0_INTMASKENABLE);
1301 1302 1303 1304
		writel(mask, &reg->outbound_intmask);
		acb->outbound_int_enable = ~(intmask_org & mask) & 0x000000ff;
		}
		break;
1305

1306
	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
1307
		struct MessageUnit_B *reg = acb->pmuB;
1308 1309 1310 1311
		mask = intmask_org | (ARCMSR_IOP2DRV_DATA_WRITE_OK |
			ARCMSR_IOP2DRV_DATA_READ_OK |
			ARCMSR_IOP2DRV_CDB_DONE |
			ARCMSR_IOP2DRV_MESSAGE_CMD_DONE);
1312
		writel(mask, reg->iop2drv_doorbell_mask);
1313 1314
		acb->outbound_int_enable = (intmask_org | mask) & 0x0000000f;
		}
1315 1316
		break;
	case ACB_ADAPTER_TYPE_C: {
1317
		struct MessageUnit_C __iomem *reg = acb->pmuC;
1318 1319 1320 1321
		mask = ~(ARCMSR_HBCMU_UTILITY_A_ISR_MASK | ARCMSR_HBCMU_OUTBOUND_DOORBELL_ISR_MASK|ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR_MASK);
		writel(intmask_org & mask, &reg->host_int_mask);
		acb->outbound_int_enable = ~(intmask_org & mask) & 0x0000000f;
		}
1322 1323 1324 1325 1326 1327 1328 1329
		break;
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg = acb->pmuD;

		mask = ARCMSR_ARC1214_ALL_INT_ENABLE;
		writel(intmask_org | mask, reg->pcief0_int_enable);
		break;
		}
1330 1331 1332
	}
}

1333
static int arcmsr_build_ccb(struct AdapterControlBlock *acb,
1334
	struct CommandControlBlock *ccb, struct scsi_cmnd *pcmd)
1335
{
1336 1337
	struct ARCMSR_CDB *arcmsr_cdb = (struct ARCMSR_CDB *)&ccb->arcmsr_cdb;
	int8_t *psge = (int8_t *)&arcmsr_cdb->u;
Al Viro's avatar
Al Viro committed
1338
	__le32 address_lo, address_hi;
1339
	int arccdbsize = 0x30;
1340
	__le32 length = 0;
1341
	int i;
1342
	struct scatterlist *sg;
1343
	int nseg;
1344
	ccb->pcmd = pcmd;
1345
	memset(arcmsr_cdb, 0, sizeof(struct ARCMSR_CDB));
1346 1347 1348
	arcmsr_cdb->TargetID = pcmd->device->id;
	arcmsr_cdb->LUN = pcmd->device->lun;
	arcmsr_cdb->Function = 1;
1349
	arcmsr_cdb->msgContext = 0;
1350
	memcpy(arcmsr_cdb->Cdb, pcmd->cmnd, pcmd->cmd_len);
1351 1352

	nseg = scsi_dma_map(pcmd);
1353
	if (unlikely(nseg > acb->host->sg_tablesize || nseg < 0))
1354
		return FAILED;
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368
	scsi_for_each_sg(pcmd, sg, nseg, i) {
		/* Get the physical address of the current data pointer */
		length = cpu_to_le32(sg_dma_len(sg));
		address_lo = cpu_to_le32(dma_addr_lo32(sg_dma_address(sg)));
		address_hi = cpu_to_le32(dma_addr_hi32(sg_dma_address(sg)));
		if (address_hi == 0) {
			struct SG32ENTRY *pdma_sg = (struct SG32ENTRY *)psge;

			pdma_sg->address = address_lo;
			pdma_sg->length = length;
			psge += sizeof (struct SG32ENTRY);
			arccdbsize += sizeof (struct SG32ENTRY);
		} else {
			struct SG64ENTRY *pdma_sg = (struct SG64ENTRY *)psge;
1369

1370 1371 1372 1373 1374
			pdma_sg->addresshigh = address_hi;
			pdma_sg->address = address_lo;
			pdma_sg->length = length|cpu_to_le32(IS_SG64_ADDR);
			psge += sizeof (struct SG64ENTRY);
			arccdbsize += sizeof (struct SG64ENTRY);
1375
		}
1376 1377 1378
	}
	arcmsr_cdb->sgcount = (uint8_t)nseg;
	arcmsr_cdb->DataLength = scsi_bufflen(pcmd);
1379
	arcmsr_cdb->msgPages = arccdbsize/0x100 + (arccdbsize % 0x100 ? 1 : 0);
1380 1381
	if ( arccdbsize > 256)
		arcmsr_cdb->Flags |= ARCMSR_CDB_FLAG_SGL_BSIZE;
1382
	if (pcmd->sc_data_direction == DMA_TO_DEVICE)
1383
		arcmsr_cdb->Flags |= ARCMSR_CDB_FLAG_WRITE;
1384
	ccb->arc_cdb_size = arccdbsize;
1385
	return SUCCESS;
1386 1387 1388 1389
}

static void arcmsr_post_ccb(struct AdapterControlBlock *acb, struct CommandControlBlock *ccb)
{
1390
	uint32_t cdb_phyaddr = ccb->cdb_phyaddr;
1391 1392 1393
	struct ARCMSR_CDB *arcmsr_cdb = (struct ARCMSR_CDB *)&ccb->arcmsr_cdb;
	atomic_inc(&acb->ccboutstandingcount);
	ccb->startdone = ARCMSR_CCB_START;
1394 1395
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
1396
		struct MessageUnit_A __iomem *reg = acb->pmuA;
1397 1398

		if (arcmsr_cdb->Flags & ARCMSR_CDB_FLAG_SGL_BSIZE)
1399
			writel(cdb_phyaddr | ARCMSR_CCBPOST_FLAG_SGL_BSIZE,
1400
			&reg->inbound_queueport);
1401 1402
		else
			writel(cdb_phyaddr, &reg->inbound_queueport);
1403
		break;
1404
	}
1405

1406
	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
1407
		struct MessageUnit_B *reg = acb->pmuB;
1408
		uint32_t ending_index, index = reg->postq_index;
1409

1410
		ending_index = ((index + 1) % ARCMSR_MAX_HBB_POSTQUEUE);
1411
		reg->post_qbuffer[ending_index] = 0;
1412
		if (arcmsr_cdb->Flags & ARCMSR_CDB_FLAG_SGL_BSIZE) {
1413 1414
			reg->post_qbuffer[index] =
				cdb_phyaddr | ARCMSR_CCBPOST_FLAG_SGL_BSIZE;
1415
		} else {
1416
			reg->post_qbuffer[index] = cdb_phyaddr;
1417 1418 1419 1420
		}
		index++;
		index %= ARCMSR_MAX_HBB_POSTQUEUE;/*if last index number set it to 0 */
		reg->postq_index = index;
1421
		writel(ARCMSR_DRV2IOP_CDB_POSTED, reg->drv2iop_doorbell);
1422
		}
1423
		break;
1424
	case ACB_ADAPTER_TYPE_C: {
1425
		struct MessageUnit_C __iomem *phbcmu = acb->pmuC;
1426 1427 1428
		uint32_t ccb_post_stamp, arc_cdb_size;

		arc_cdb_size = (ccb->arc_cdb_size > 0x300) ? 0x300 : ccb->arc_cdb_size;
1429
		ccb_post_stamp = (cdb_phyaddr | ((arc_cdb_size - 1) >> 6) | 1);
1430 1431 1432 1433 1434 1435 1436
		if (acb->cdb_phyaddr_hi32) {
			writel(acb->cdb_phyaddr_hi32, &phbcmu->inbound_queueport_high);
			writel(ccb_post_stamp, &phbcmu->inbound_queueport_low);
		} else {
			writel(ccb_post_stamp, &phbcmu->inbound_queueport_low);
		}
		}
1437 1438 1439 1440
		break;
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D  *pmu = acb->pmuD;
		u16 index_stripped;
1441
		u16 postq_index, toggle;
1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
		unsigned long flags;
		struct InBound_SRB *pinbound_srb;

		spin_lock_irqsave(&acb->postq_lock, flags);
		postq_index = pmu->postq_index;
		pinbound_srb = (struct InBound_SRB *)&(pmu->post_qbuffer[postq_index & 0xFF]);
		pinbound_srb->addressHigh = dma_addr_hi32(cdb_phyaddr);
		pinbound_srb->addressLow = dma_addr_lo32(cdb_phyaddr);
		pinbound_srb->length = ccb->arc_cdb_size >> 2;
		arcmsr_cdb->msgContext = dma_addr_lo32(cdb_phyaddr);
1452 1453 1454 1455 1456
		toggle = postq_index & 0x4000;
		index_stripped = postq_index + 1;
		index_stripped &= (ARCMSR_MAX_ARC1214_POSTQUEUE - 1);
		pmu->postq_index = index_stripped ? (index_stripped | toggle) :
			(toggle ^ 0x4000);
1457 1458 1459 1460
		writel(postq_index, pmu->inboundlist_write_pointer);
		spin_unlock_irqrestore(&acb->postq_lock, flags);
		break;
		}
1461 1462 1463
	}
}

1464
static void arcmsr_hbaA_stop_bgrb(struct AdapterControlBlock *acb)
1465
{
Al Viro's avatar
Al Viro committed
1466
	struct MessageUnit_A __iomem *reg = acb->pmuA;
1467 1468
	acb->acb_flags &= ~ACB_F_MSG_START_BGRB;
	writel(ARCMSR_INBOUND_MESG0_STOP_BGRB, &reg->inbound_msgaddr0);
1469
	if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
1470
		printk(KERN_NOTICE
1471
			"arcmsr%d: wait 'stop adapter background rebulid' timeout\n"
1472 1473 1474 1475
			, acb->host->host_no);
	}
}

1476
static void arcmsr_hbaB_stop_bgrb(struct AdapterControlBlock *acb)
1477
{
Al Viro's avatar
Al Viro committed
1478
	struct MessageUnit_B *reg = acb->pmuB;
1479
	acb->acb_flags &= ~ACB_F_MSG_START_BGRB;
1480
	writel(ARCMSR_MESSAGE_STOP_BGRB, reg->drv2iop_doorbell);
1481

1482
	if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
1483
		printk(KERN_NOTICE
1484
			"arcmsr%d: wait 'stop adapter background rebulid' timeout\n"
1485
			, acb->host->host_no);
1486 1487 1488
	}
}

1489
static void arcmsr_hbaC_stop_bgrb(struct AdapterControlBlock *pACB)
1490
{
1491
	struct MessageUnit_C __iomem *reg = pACB->pmuC;
1492 1493 1494
	pACB->acb_flags &= ~ACB_F_MSG_START_BGRB;
	writel(ARCMSR_INBOUND_MESG0_STOP_BGRB, &reg->inbound_msgaddr0);
	writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &reg->inbound_doorbell);
1495
	if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
1496
		printk(KERN_NOTICE
1497
			"arcmsr%d: wait 'stop adapter background rebulid' timeout\n"
1498 1499 1500 1501
			, pACB->host->host_no);
	}
	return;
}
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513

static void arcmsr_hbaD_stop_bgrb(struct AdapterControlBlock *pACB)
{
	struct MessageUnit_D *reg = pACB->pmuD;

	pACB->acb_flags &= ~ACB_F_MSG_START_BGRB;
	writel(ARCMSR_INBOUND_MESG0_STOP_BGRB, reg->inbound_msgaddr0);
	if (!arcmsr_hbaD_wait_msgint_ready(pACB))
		pr_notice("arcmsr%d: wait 'stop adapter background rebulid' "
			"timeout\n", pACB->host->host_no);
}

1514 1515 1516 1517
static void arcmsr_stop_adapter_bgrb(struct AdapterControlBlock *acb)
{
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A: {
1518
		arcmsr_hbaA_stop_bgrb(acb);
1519 1520 1521 1522
		}
		break;

	case ACB_ADAPTER_TYPE_B: {
1523
		arcmsr_hbaB_stop_bgrb(acb);
1524 1525
		}
		break;
1526
	case ACB_ADAPTER_TYPE_C: {
1527
		arcmsr_hbaC_stop_bgrb(acb);
1528
		}
1529 1530 1531 1532
		break;
	case ACB_ADAPTER_TYPE_D:
		arcmsr_hbaD_stop_bgrb(acb);
		break;
1533
	}
1534 1535 1536 1537
}

static void arcmsr_free_ccb_pool(struct AdapterControlBlock *acb)
{
1538
	dma_free_coherent(&acb->pdev->dev, acb->uncache_size, acb->dma_coherent, acb->dma_coherent_handle);
1539 1540
}

1541
static void arcmsr_iop_message_read(struct AdapterControlBlock *acb)
1542
{
1543 1544
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
1545
		struct MessageUnit_A __iomem *reg = acb->pmuA;
1546 1547 1548
		writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK, &reg->inbound_doorbell);
		}
		break;
1549

1550
	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
1551
		struct MessageUnit_B *reg = acb->pmuB;
1552
		writel(ARCMSR_DRV2IOP_DATA_READ_OK, reg->drv2iop_doorbell);
1553
		}
1554
		break;
1555 1556
	case ACB_ADAPTER_TYPE_C: {
		struct MessageUnit_C __iomem *reg = acb->pmuC;
1557

1558 1559
		writel(ARCMSR_HBCMU_DRV2IOP_DATA_READ_OK, &reg->inbound_doorbell);
		}
1560 1561 1562 1563 1564 1565 1566
		break;
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg = acb->pmuD;
		writel(ARCMSR_ARC1214_DRV2IOP_DATA_OUT_READ,
			reg->inbound_doorbell);
		}
		break;
1567
	}
1568 1569 1570 1571 1572 1573
}

static void arcmsr_iop_message_wrote(struct AdapterControlBlock *acb)
{
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
1574
		struct MessageUnit_A __iomem *reg = acb->pmuA;
1575
		/*
1576 1577
		** push inbound doorbell tell iop, driver data write ok
		** and wait reply on next hwinterrupt for next Qbuffer post
1578
		*/
1579 1580 1581 1582 1583
		writel(ARCMSR_INBOUND_DRIVER_DATA_WRITE_OK, &reg->inbound_doorbell);
		}
		break;

	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
1584
		struct MessageUnit_B *reg = acb->pmuB;
1585 1586 1587 1588
		/*
		** push inbound doorbell tell iop, driver data write ok
		** and wait reply on next hwinterrupt for next Qbuffer post
		*/
1589
		writel(ARCMSR_DRV2IOP_DATA_WRITE_OK, reg->drv2iop_doorbell);
1590 1591
		}
		break;
1592 1593 1594 1595 1596 1597 1598 1599 1600
	case ACB_ADAPTER_TYPE_C: {
		struct MessageUnit_C __iomem *reg = acb->pmuC;
		/*
		** push inbound doorbell tell iop, driver data write ok
		** and wait reply on next hwinterrupt for next Qbuffer post
		*/
		writel(ARCMSR_HBCMU_DRV2IOP_DATA_WRITE_OK, &reg->inbound_doorbell);
		}
		break;
1601 1602 1603 1604 1605 1606
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg = acb->pmuD;
		writel(ARCMSR_ARC1214_DRV2IOP_DATA_IN_READY,
			reg->inbound_doorbell);
		}
		break;
1607 1608 1609
	}
}

Al Viro's avatar
Al Viro committed
1610
struct QBUFFER __iomem *arcmsr_get_iop_rqbuffer(struct AdapterControlBlock *acb)
1611
{
1612
	struct QBUFFER __iomem *qbuffer = NULL;
1613 1614 1615
	switch (acb->adapter_type) {

	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
1616 1617
		struct MessageUnit_A __iomem *reg = acb->pmuA;
		qbuffer = (struct QBUFFER __iomem *)&reg->message_rbuffer;
1618 1619 1620 1621
		}
		break;

	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
1622
		struct MessageUnit_B *reg = acb->pmuB;
1623
		qbuffer = (struct QBUFFER __iomem *)reg->message_rbuffer;
1624 1625
		}
		break;
1626
	case ACB_ADAPTER_TYPE_C: {
1627
		struct MessageUnit_C __iomem *phbcmu = acb->pmuC;
1628 1629
		qbuffer = (struct QBUFFER __iomem *)&phbcmu->message_rbuffer;
		}
1630 1631 1632 1633 1634 1635
		break;
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg = acb->pmuD;
		qbuffer = (struct QBUFFER __iomem *)reg->message_rbuffer;
		}
		break;
1636 1637 1638 1639
	}
	return qbuffer;
}

Al Viro's avatar
Al Viro committed
1640
static struct QBUFFER __iomem *arcmsr_get_iop_wqbuffer(struct AdapterControlBlock *acb)
1641
{
1642
	struct QBUFFER __iomem *pqbuffer = NULL;
1643 1644 1645
	switch (acb->adapter_type) {

	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
1646 1647
		struct MessageUnit_A __iomem *reg = acb->pmuA;
		pqbuffer = (struct QBUFFER __iomem *) &reg->message_wbuffer;
1648 1649 1650 1651
		}
		break;

	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
1652
		struct MessageUnit_B  *reg = acb->pmuB;
1653
		pqbuffer = (struct QBUFFER __iomem *)reg->message_wbuffer;
1654 1655
		}
		break;
1656
	case ACB_ADAPTER_TYPE_C: {
1657
		struct MessageUnit_C __iomem *reg = acb->pmuC;
1658
		pqbuffer = (struct QBUFFER __iomem *)&reg->message_wbuffer;
1659 1660 1661 1662 1663 1664 1665
		}
		break;
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg = acb->pmuD;
		pqbuffer = (struct QBUFFER __iomem *)reg->message_wbuffer;
		}
		break;
1666 1667 1668 1669
	}
	return pqbuffer;
}

1670 1671 1672
static uint32_t
arcmsr_Read_iop_rqbuffer_in_DWORD(struct AdapterControlBlock *acb,
		struct QBUFFER __iomem *prbuffer)
1673
{
1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688
	uint8_t *pQbuffer;
	uint8_t *buf1 = NULL;
	uint32_t __iomem *iop_data;
	uint32_t iop_len, data_len, *buf2 = NULL;

	iop_data = (uint32_t __iomem *)prbuffer->data;
	iop_len = readl(&prbuffer->data_len);
	if (iop_len > 0) {
		buf1 = kmalloc(128, GFP_ATOMIC);
		buf2 = (uint32_t *)buf1;
		if (buf1 == NULL)
			return 0;
		data_len = iop_len;
		while (data_len >= 4) {
			*buf2++ = readl(iop_data);
1689
			iop_data++;
1690
			data_len -= 4;
1691
		}
1692 1693 1694 1695 1696
		if (data_len)
			*buf2 = readl(iop_data);
		buf2 = (uint32_t *)buf1;
	}
	while (iop_len > 0) {
1697
		pQbuffer = &acb->rqbuffer[acb->rqbuf_putIndex];
1698
		*pQbuffer = *buf1;
1699
		acb->rqbuf_putIndex++;
1700
		/* if last, index number set it to 0 */
1701
		acb->rqbuf_putIndex %= ARCMSR_MAX_QBUFFER;
1702 1703 1704
		buf1++;
		iop_len--;
	}
1705
	kfree(buf2);
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718
	/* let IOP know data has been read */
	arcmsr_iop_message_read(acb);
	return 1;
}

uint32_t
arcmsr_Read_iop_rqbuffer_data(struct AdapterControlBlock *acb,
	struct QBUFFER __iomem *prbuffer) {

	uint8_t *pQbuffer;
	uint8_t __iomem *iop_data;
	uint32_t iop_len;

1719
	if (acb->adapter_type & (ACB_ADAPTER_TYPE_C | ACB_ADAPTER_TYPE_D))
1720 1721 1722 1723
		return arcmsr_Read_iop_rqbuffer_in_DWORD(acb, prbuffer);
	iop_data = (uint8_t __iomem *)prbuffer->data;
	iop_len = readl(&prbuffer->data_len);
	while (iop_len > 0) {
1724
		pQbuffer = &acb->rqbuffer[acb->rqbuf_putIndex];
1725
		*pQbuffer = readb(iop_data);
1726 1727
		acb->rqbuf_putIndex++;
		acb->rqbuf_putIndex %= ARCMSR_MAX_QBUFFER;
1728 1729
		iop_data++;
		iop_len--;
1730
	}
1731 1732 1733
	arcmsr_iop_message_read(acb);
	return 1;
}
1734

1735 1736 1737 1738 1739 1740 1741 1742
static void arcmsr_iop2drv_data_wrote_handle(struct AdapterControlBlock *acb)
{
	unsigned long flags;
	struct QBUFFER __iomem  *prbuffer;
	int32_t buf_empty_len;

	spin_lock_irqsave(&acb->rqbuffer_lock, flags);
	prbuffer = arcmsr_get_iop_rqbuffer(acb);
1743
	buf_empty_len = (acb->rqbuf_putIndex - acb->rqbuf_getIndex - 1) &
1744 1745 1746 1747 1748
		(ARCMSR_MAX_QBUFFER - 1);
	if (buf_empty_len >= readl(&prbuffer->data_len)) {
		if (arcmsr_Read_iop_rqbuffer_data(acb, prbuffer) == 0)
			acb->acb_flags |= ACB_F_IOPDATA_OVERFLOW;
	} else
1749
		acb->acb_flags |= ACB_F_IOPDATA_OVERFLOW;
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769
	spin_unlock_irqrestore(&acb->rqbuffer_lock, flags);
}

static void arcmsr_write_ioctldata2iop_in_DWORD(struct AdapterControlBlock *acb)
{
	uint8_t *pQbuffer;
	struct QBUFFER __iomem *pwbuffer;
	uint8_t *buf1 = NULL;
	uint32_t __iomem *iop_data;
	uint32_t allxfer_len = 0, data_len, *buf2 = NULL, data;

	if (acb->acb_flags & ACB_F_MESSAGE_WQBUFFER_READED) {
		buf1 = kmalloc(128, GFP_ATOMIC);
		buf2 = (uint32_t *)buf1;
		if (buf1 == NULL)
			return;

		acb->acb_flags &= (~ACB_F_MESSAGE_WQBUFFER_READED);
		pwbuffer = arcmsr_get_iop_wqbuffer(acb);
		iop_data = (uint32_t __iomem *)pwbuffer->data;
1770
		while ((acb->wqbuf_getIndex != acb->wqbuf_putIndex)
1771
			&& (allxfer_len < 124)) {
1772
			pQbuffer = &acb->wqbuffer[acb->wqbuf_getIndex];
1773
			*buf1 = *pQbuffer;
1774 1775
			acb->wqbuf_getIndex++;
			acb->wqbuf_getIndex %= ARCMSR_MAX_QBUFFER;
1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
			buf1++;
			allxfer_len++;
		}
		data_len = allxfer_len;
		buf1 = (uint8_t *)buf2;
		while (data_len >= 4) {
			data = *buf2++;
			writel(data, iop_data);
			iop_data++;
			data_len -= 4;
		}
		if (data_len) {
			data = *buf2;
			writel(data, iop_data);
		}
		writel(allxfer_len, &pwbuffer->data_len);
		kfree(buf1);
		arcmsr_iop_message_wrote(acb);
1794 1795 1796
	}
}

1797 1798
void
arcmsr_write_ioctldata2iop(struct AdapterControlBlock *acb)
1799
{
1800 1801 1802 1803
	uint8_t *pQbuffer;
	struct QBUFFER __iomem *pwbuffer;
	uint8_t __iomem *iop_data;
	int32_t allxfer_len = 0;
1804

1805
	if (acb->adapter_type & (ACB_ADAPTER_TYPE_C | ACB_ADAPTER_TYPE_D)) {
1806 1807 1808 1809
		arcmsr_write_ioctldata2iop_in_DWORD(acb);
		return;
	}
	if (acb->acb_flags & ACB_F_MESSAGE_WQBUFFER_READED) {
1810 1811 1812
		acb->acb_flags &= (~ACB_F_MESSAGE_WQBUFFER_READED);
		pwbuffer = arcmsr_get_iop_wqbuffer(acb);
		iop_data = (uint8_t __iomem *)pwbuffer->data;
1813
		while ((acb->wqbuf_getIndex != acb->wqbuf_putIndex)
1814
			&& (allxfer_len < 124)) {
1815
			pQbuffer = &acb->wqbuffer[acb->wqbuf_getIndex];
1816
			writeb(*pQbuffer, iop_data);
1817 1818
			acb->wqbuf_getIndex++;
			acb->wqbuf_getIndex %= ARCMSR_MAX_QBUFFER;
1819 1820 1821
			iop_data++;
			allxfer_len++;
		}
1822
		writel(allxfer_len, &pwbuffer->data_len);
1823 1824
		arcmsr_iop_message_wrote(acb);
	}
1825
}
1826

1827 1828 1829 1830 1831 1832
static void arcmsr_iop2drv_data_read_handle(struct AdapterControlBlock *acb)
{
	unsigned long flags;

	spin_lock_irqsave(&acb->wqbuffer_lock, flags);
	acb->acb_flags |= ACB_F_MESSAGE_WQBUFFER_READED;
1833
	if (acb->wqbuf_getIndex != acb->wqbuf_putIndex)
1834
		arcmsr_write_ioctldata2iop(acb);
1835
	if (acb->wqbuf_getIndex == acb->wqbuf_putIndex)
1836
		acb->acb_flags |= ACB_F_MESSAGE_WQBUFFER_CLEARED;
1837
	spin_unlock_irqrestore(&acb->wqbuffer_lock, flags);
1838 1839
}

1840
static void arcmsr_hbaA_doorbell_isr(struct AdapterControlBlock *acb)
1841 1842
{
	uint32_t outbound_doorbell;
Al Viro's avatar
Al Viro committed
1843
	struct MessageUnit_A __iomem *reg = acb->pmuA;
1844
	outbound_doorbell = readl(&reg->outbound_doorbell);
1845 1846 1847 1848 1849 1850 1851 1852 1853
	do {
		writel(outbound_doorbell, &reg->outbound_doorbell);
		if (outbound_doorbell & ARCMSR_OUTBOUND_IOP331_DATA_WRITE_OK)
			arcmsr_iop2drv_data_wrote_handle(acb);
		if (outbound_doorbell & ARCMSR_OUTBOUND_IOP331_DATA_READ_OK)
			arcmsr_iop2drv_data_read_handle(acb);
		outbound_doorbell = readl(&reg->outbound_doorbell);
	} while (outbound_doorbell & (ARCMSR_OUTBOUND_IOP331_DATA_WRITE_OK
		| ARCMSR_OUTBOUND_IOP331_DATA_READ_OK));
1854
}
1855
static void arcmsr_hbaC_doorbell_isr(struct AdapterControlBlock *pACB)
1856 1857
{
	uint32_t outbound_doorbell;
1858
	struct MessageUnit_C __iomem *reg = pACB->pmuC;
1859 1860 1861 1862 1863 1864 1865 1866
	/*
	*******************************************************************
	**  Maybe here we need to check wrqbuffer_lock is lock or not
	**  DOORBELL: din! don!
	**  check if there are any mail need to pack from firmware
	*******************************************************************
	*/
	outbound_doorbell = readl(&reg->outbound_doorbell);
1867 1868 1869 1870 1871 1872 1873 1874
	do {
		writel(outbound_doorbell, &reg->outbound_doorbell_clear);
		readl(&reg->outbound_doorbell_clear);
		if (outbound_doorbell & ARCMSR_HBCMU_IOP2DRV_DATA_WRITE_OK)
			arcmsr_iop2drv_data_wrote_handle(pACB);
		if (outbound_doorbell & ARCMSR_HBCMU_IOP2DRV_DATA_READ_OK)
			arcmsr_iop2drv_data_read_handle(pACB);
		if (outbound_doorbell & ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE)
1875
			arcmsr_hbaC_message_isr(pACB);
1876 1877 1878 1879
		outbound_doorbell = readl(&reg->outbound_doorbell);
	} while (outbound_doorbell & (ARCMSR_HBCMU_IOP2DRV_DATA_WRITE_OK
		| ARCMSR_HBCMU_IOP2DRV_DATA_READ_OK
		| ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE));
1880
}
1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901

static void arcmsr_hbaD_doorbell_isr(struct AdapterControlBlock *pACB)
{
	uint32_t outbound_doorbell;
	struct MessageUnit_D  *pmu = pACB->pmuD;

	outbound_doorbell = readl(pmu->outbound_doorbell);
	do {
		writel(outbound_doorbell, pmu->outbound_doorbell);
		if (outbound_doorbell & ARCMSR_ARC1214_IOP2DRV_MESSAGE_CMD_DONE)
			arcmsr_hbaD_message_isr(pACB);
		if (outbound_doorbell & ARCMSR_ARC1214_IOP2DRV_DATA_WRITE_OK)
			arcmsr_iop2drv_data_wrote_handle(pACB);
		if (outbound_doorbell & ARCMSR_ARC1214_IOP2DRV_DATA_READ_OK)
			arcmsr_iop2drv_data_read_handle(pACB);
		outbound_doorbell = readl(pmu->outbound_doorbell);
	} while (outbound_doorbell & (ARCMSR_ARC1214_IOP2DRV_DATA_WRITE_OK
		| ARCMSR_ARC1214_IOP2DRV_DATA_READ_OK
		| ARCMSR_ARC1214_IOP2DRV_MESSAGE_CMD_DONE));
}

1902
static void arcmsr_hbaA_postqueue_isr(struct AdapterControlBlock *acb)
1903 1904
{
	uint32_t flag_ccb;
Al Viro's avatar
Al Viro committed
1905
	struct MessageUnit_A __iomem *reg = acb->pmuA;
1906 1907 1908
	struct ARCMSR_CDB *pARCMSR_CDB;
	struct CommandControlBlock *pCCB;
	bool error;
1909
	while ((flag_ccb = readl(&reg->outbound_queueport)) != 0xFFFFFFFF) {
1910 1911 1912 1913
		pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset + (flag_ccb << 5));/*frame must be 32 bytes aligned*/
		pCCB = container_of(pARCMSR_CDB, struct CommandControlBlock, arcmsr_cdb);
		error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE0) ? true : false;
		arcmsr_drain_donequeue(acb, pCCB, error);
1914 1915
	}
}
1916
static void arcmsr_hbaB_postqueue_isr(struct AdapterControlBlock *acb)
1917 1918 1919
{
	uint32_t index;
	uint32_t flag_ccb;
Al Viro's avatar
Al Viro committed
1920
	struct MessageUnit_B *reg = acb->pmuB;
1921 1922 1923
	struct ARCMSR_CDB *pARCMSR_CDB;
	struct CommandControlBlock *pCCB;
	bool error;
1924
	index = reg->doneq_index;
1925 1926
	while ((flag_ccb = reg->done_qbuffer[index]) != 0) {
		reg->done_qbuffer[index] = 0;
1927 1928 1929 1930
		pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset+(flag_ccb << 5));/*frame must be 32 bytes aligned*/
		pCCB = container_of(pARCMSR_CDB, struct CommandControlBlock, arcmsr_cdb);
		error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE0) ? true : false;
		arcmsr_drain_donequeue(acb, pCCB, error);
1931 1932 1933 1934 1935
		index++;
		index %= ARCMSR_MAX_HBB_POSTQUEUE;
		reg->doneq_index = index;
	}
}
1936

1937
static void arcmsr_hbaC_postqueue_isr(struct AdapterControlBlock *acb)
1938
{
1939
	struct MessageUnit_C __iomem *phbcmu;
1940 1941 1942 1943 1944
	struct ARCMSR_CDB *arcmsr_cdb;
	struct CommandControlBlock *ccb;
	uint32_t flag_ccb, ccb_cdb_phy, throttling = 0;
	int error;

1945
	phbcmu = acb->pmuC;
1946 1947 1948
	/* areca cdb command done */
	/* Use correct offset and size for syncing */

1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
	while ((flag_ccb = readl(&phbcmu->outbound_queueport_low)) !=
			0xFFFFFFFF) {
		ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
		arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset
			+ ccb_cdb_phy);
		ccb = container_of(arcmsr_cdb, struct CommandControlBlock,
			arcmsr_cdb);
		error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE1)
			? true : false;
		/* check if command done with no error */
		arcmsr_drain_donequeue(acb, ccb, error);
		throttling++;
		if (throttling == ARCMSR_HBC_ISR_THROTTLING_LEVEL) {
			writel(ARCMSR_HBCMU_DRV2IOP_POSTQUEUE_THROTTLING,
				&phbcmu->inbound_doorbell);
			throttling = 0;
		}
1966 1967
	}
}
1968 1969 1970

static void arcmsr_hbaD_postqueue_isr(struct AdapterControlBlock *acb)
{
1971
	u32 outbound_write_pointer, doneq_index, index_stripped, toggle;
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
	uint32_t addressLow, ccb_cdb_phy;
	int error;
	struct MessageUnit_D  *pmu;
	struct ARCMSR_CDB *arcmsr_cdb;
	struct CommandControlBlock *ccb;
	unsigned long flags;

	spin_lock_irqsave(&acb->doneq_lock, flags);
	pmu = acb->pmuD;
	outbound_write_pointer = pmu->done_qbuffer[0].addressLow + 1;
	doneq_index = pmu->doneq_index;
	if ((doneq_index & 0xFFF) != (outbound_write_pointer & 0xFFF)) {
		do {
1985 1986 1987 1988 1989
			toggle = doneq_index & 0x4000;
			index_stripped = (doneq_index & 0xFFF) + 1;
			index_stripped %= ARCMSR_MAX_ARC1214_DONEQUEUE;
			pmu->doneq_index = index_stripped ? (index_stripped | toggle) :
				((toggle ^ 0x4000) + 1);
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010
			doneq_index = pmu->doneq_index;
			addressLow = pmu->done_qbuffer[doneq_index &
				0xFFF].addressLow;
			ccb_cdb_phy = (addressLow & 0xFFFFFFF0);
			arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset
				+ ccb_cdb_phy);
			ccb = container_of(arcmsr_cdb,
				struct CommandControlBlock, arcmsr_cdb);
			error = (addressLow & ARCMSR_CCBREPLY_FLAG_ERROR_MODE1)
				? true : false;
			arcmsr_drain_donequeue(acb, ccb, error);
			writel(doneq_index, pmu->outboundlist_read_pointer);
		} while ((doneq_index & 0xFFF) !=
			(outbound_write_pointer & 0xFFF));
	}
	writel(ARCMSR_ARC1214_OUTBOUND_LIST_INTERRUPT_CLEAR,
		pmu->outboundlist_interrupt_cause);
	readl(pmu->outboundlist_interrupt_cause);
	spin_unlock_irqrestore(&acb->doneq_lock, flags);
}

2011 2012 2013 2014
/*
**********************************************************************************
** Handle a message interrupt
**
2015
** The only message interrupt we expect is in response to a query for the current adapter config.  
2016 2017 2018
** We want this in order to compare the drivemap so that we can detect newly-attached drives.
**********************************************************************************
*/
2019
static void arcmsr_hbaA_message_isr(struct AdapterControlBlock *acb)
2020
{
2021
	struct MessageUnit_A __iomem *reg  = acb->pmuA;
2022 2023 2024 2025
	/*clear interrupt and message state*/
	writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT, &reg->outbound_intstatus);
	schedule_work(&acb->arcmsr_do_message_isr_bh);
}
2026
static void arcmsr_hbaB_message_isr(struct AdapterControlBlock *acb)
2027 2028
{
	struct MessageUnit_B *reg  = acb->pmuB;
2029

2030
	/*clear interrupt and message state*/
2031
	writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN, reg->iop2drv_doorbell);
2032 2033
	schedule_work(&acb->arcmsr_do_message_isr_bh);
}
2034 2035 2036 2037 2038 2039 2040 2041 2042
/*
**********************************************************************************
** Handle a message interrupt
**
** The only message interrupt we expect is in response to a query for the
** current adapter config.
** We want this in order to compare the drivemap so that we can detect newly-attached drives.
**********************************************************************************
*/
2043
static void arcmsr_hbaC_message_isr(struct AdapterControlBlock *acb)
2044
{
2045
	struct MessageUnit_C __iomem *reg  = acb->pmuC;
2046 2047 2048 2049 2050
	/*clear interrupt and message state*/
	writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR, &reg->outbound_doorbell_clear);
	schedule_work(&acb->arcmsr_do_message_isr_bh);
}

2051 2052 2053 2054 2055 2056 2057 2058 2059
static void arcmsr_hbaD_message_isr(struct AdapterControlBlock *acb)
{
	struct MessageUnit_D *reg  = acb->pmuD;

	writel(ARCMSR_ARC1214_IOP2DRV_MESSAGE_CMD_DONE, reg->outbound_doorbell);
	readl(reg->outbound_doorbell);
	schedule_work(&acb->arcmsr_do_message_isr_bh);
}

2060
static int arcmsr_hbaA_handle_isr(struct AdapterControlBlock *acb)
2061 2062
{
	uint32_t outbound_intstatus;
Al Viro's avatar
Al Viro committed
2063
	struct MessageUnit_A __iomem *reg = acb->pmuA;
2064
	outbound_intstatus = readl(&reg->outbound_intstatus) &
2065
		acb->outbound_int_enable;
2066 2067 2068 2069 2070
	if (!(outbound_intstatus & ARCMSR_MU_OUTBOUND_HANDLE_INT))
		return IRQ_NONE;
	do {
		writel(outbound_intstatus, &reg->outbound_intstatus);
		if (outbound_intstatus & ARCMSR_MU_OUTBOUND_DOORBELL_INT)
2071
			arcmsr_hbaA_doorbell_isr(acb);
2072
		if (outbound_intstatus & ARCMSR_MU_OUTBOUND_POSTQUEUE_INT)
2073
			arcmsr_hbaA_postqueue_isr(acb);
2074
		if (outbound_intstatus & ARCMSR_MU_OUTBOUND_MESSAGE0_INT)
2075
			arcmsr_hbaA_message_isr(acb);
2076 2077 2078 2079 2080 2081
		outbound_intstatus = readl(&reg->outbound_intstatus) &
			acb->outbound_int_enable;
	} while (outbound_intstatus & (ARCMSR_MU_OUTBOUND_DOORBELL_INT
		| ARCMSR_MU_OUTBOUND_POSTQUEUE_INT
		| ARCMSR_MU_OUTBOUND_MESSAGE0_INT));
	return IRQ_HANDLED;
2082 2083
}

2084
static int arcmsr_hbaB_handle_isr(struct AdapterControlBlock *acb)
2085 2086
{
	uint32_t outbound_doorbell;
Al Viro's avatar
Al Viro committed
2087
	struct MessageUnit_B *reg = acb->pmuB;
2088
	outbound_doorbell = readl(reg->iop2drv_doorbell) &
2089
				acb->outbound_int_enable;
2090
	if (!outbound_doorbell)
2091 2092 2093 2094 2095 2096 2097 2098 2099
		return IRQ_NONE;
	do {
		writel(~outbound_doorbell, reg->iop2drv_doorbell);
		writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT, reg->drv2iop_doorbell);
		if (outbound_doorbell & ARCMSR_IOP2DRV_DATA_WRITE_OK)
			arcmsr_iop2drv_data_wrote_handle(acb);
		if (outbound_doorbell & ARCMSR_IOP2DRV_DATA_READ_OK)
			arcmsr_iop2drv_data_read_handle(acb);
		if (outbound_doorbell & ARCMSR_IOP2DRV_CDB_DONE)
2100
			arcmsr_hbaB_postqueue_isr(acb);
2101
		if (outbound_doorbell & ARCMSR_IOP2DRV_MESSAGE_CMD_DONE)
2102
			arcmsr_hbaB_message_isr(acb);
2103 2104 2105 2106 2107 2108 2109
		outbound_doorbell = readl(reg->iop2drv_doorbell) &
			acb->outbound_int_enable;
	} while (outbound_doorbell & (ARCMSR_IOP2DRV_DATA_WRITE_OK
		| ARCMSR_IOP2DRV_DATA_READ_OK
		| ARCMSR_IOP2DRV_CDB_DONE
		| ARCMSR_IOP2DRV_MESSAGE_CMD_DONE));
	return IRQ_HANDLED;
2110 2111
}

2112
static int arcmsr_hbaC_handle_isr(struct AdapterControlBlock *pACB)
2113 2114
{
	uint32_t host_interrupt_status;
2115
	struct MessageUnit_C __iomem *phbcmu = pACB->pmuC;
2116 2117 2118 2119 2120
	/*
	*********************************************
	**   check outbound intstatus
	*********************************************
	*/
2121 2122 2123 2124 2125 2126 2127
	host_interrupt_status = readl(&phbcmu->host_int_status) &
		(ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR |
		ARCMSR_HBCMU_OUTBOUND_DOORBELL_ISR);
	if (!host_interrupt_status)
		return IRQ_NONE;
	do {
		if (host_interrupt_status & ARCMSR_HBCMU_OUTBOUND_DOORBELL_ISR)
2128
			arcmsr_hbaC_doorbell_isr(pACB);
2129 2130
		/* MU post queue interrupts*/
		if (host_interrupt_status & ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR)
2131
			arcmsr_hbaC_postqueue_isr(pACB);
2132 2133 2134 2135
		host_interrupt_status = readl(&phbcmu->host_int_status);
	} while (host_interrupt_status & (ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR |
		ARCMSR_HBCMU_OUTBOUND_DOORBELL_ISR));
	return IRQ_HANDLED;
2136
}
2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162

static irqreturn_t arcmsr_hbaD_handle_isr(struct AdapterControlBlock *pACB)
{
	u32 host_interrupt_status;
	struct MessageUnit_D  *pmu = pACB->pmuD;

	host_interrupt_status = readl(pmu->host_int_status) &
		(ARCMSR_ARC1214_OUTBOUND_POSTQUEUE_ISR |
		ARCMSR_ARC1214_OUTBOUND_DOORBELL_ISR);
	if (!host_interrupt_status)
		return IRQ_NONE;
	do {
		/* MU post queue interrupts*/
		if (host_interrupt_status &
			ARCMSR_ARC1214_OUTBOUND_POSTQUEUE_ISR)
			arcmsr_hbaD_postqueue_isr(pACB);
		if (host_interrupt_status &
			ARCMSR_ARC1214_OUTBOUND_DOORBELL_ISR)
			arcmsr_hbaD_doorbell_isr(pACB);
		host_interrupt_status = readl(pmu->host_int_status);
	} while (host_interrupt_status &
		(ARCMSR_ARC1214_OUTBOUND_POSTQUEUE_ISR |
		ARCMSR_ARC1214_OUTBOUND_DOORBELL_ISR));
	return IRQ_HANDLED;
}

2163 2164 2165
static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb)
{
	switch (acb->adapter_type) {
2166
	case ACB_ADAPTER_TYPE_A:
2167
		return arcmsr_hbaA_handle_isr(acb);
2168
		break;
2169
	case ACB_ADAPTER_TYPE_B:
2170
		return arcmsr_hbaB_handle_isr(acb);
2171
		break;
2172
	case ACB_ADAPTER_TYPE_C:
2173
		return arcmsr_hbaC_handle_isr(acb);
2174 2175
	case ACB_ADAPTER_TYPE_D:
		return arcmsr_hbaD_handle_isr(acb);
2176 2177
	default:
		return IRQ_NONE;
2178 2179 2180 2181 2182 2183 2184 2185
	}
}

static void arcmsr_iop_parking(struct AdapterControlBlock *acb)
{
	if (acb) {
		/* stop adapter background rebuild */
		if (acb->acb_flags & ACB_F_MSG_START_BGRB) {
2186
			uint32_t intmask_org;
2187
			acb->acb_flags &= ~ACB_F_MSG_START_BGRB;
2188
			intmask_org = arcmsr_disable_outbound_ints(acb);
2189 2190
			arcmsr_stop_adapter_bgrb(acb);
			arcmsr_flush_adapter_cache(acb);
2191 2192 2193 2194 2195
			arcmsr_enable_outbound_ints(acb, intmask_org);
		}
	}
}

2196 2197

void arcmsr_clear_iop2drv_rqueue_buffer(struct AdapterControlBlock *acb)
2198
{
2199 2200 2201 2202 2203 2204
	uint32_t	i;

	if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
		for (i = 0; i < 15; i++) {
			if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
				acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
2205 2206
				acb->rqbuf_getIndex = 0;
				acb->rqbuf_putIndex = 0;
2207 2208
				arcmsr_iop_message_read(acb);
				mdelay(30);
2209 2210 2211 2212
			} else if (acb->rqbuf_getIndex !=
				   acb->rqbuf_putIndex) {
				acb->rqbuf_getIndex = 0;
				acb->rqbuf_putIndex = 0;
2213 2214 2215
				mdelay(30);
			} else
				break;
2216 2217 2218 2219
		}
	}
}

2220
static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb,
2221
		struct scsi_cmnd *cmd)
2222 2223
{
	char *buffer;
2224 2225 2226 2227 2228 2229 2230 2231
	unsigned short use_sg;
	int retvalue = 0, transfer_len = 0;
	unsigned long flags;
	struct CMD_MESSAGE_FIELD *pcmdmessagefld;
	uint32_t controlcode = (uint32_t)cmd->cmnd[5] << 24 |
		(uint32_t)cmd->cmnd[6] << 16 |
		(uint32_t)cmd->cmnd[7] << 8 |
		(uint32_t)cmd->cmnd[8];
2232
	struct scatterlist *sg;
2233 2234

	use_sg = scsi_sg_count(cmd);
2235
	sg = scsi_sglist(cmd);
2236
	buffer = kmap_atomic(sg_page(sg)) + sg->offset;
2237
	if (use_sg > 1) {
2238 2239
		retvalue = ARCMSR_MESSAGE_FAIL;
		goto message_out;
2240
	}
2241
	transfer_len += sg->length;
2242 2243
	if (transfer_len > sizeof(struct CMD_MESSAGE_FIELD)) {
		retvalue = ARCMSR_MESSAGE_FAIL;
2244
		pr_info("%s: ARCMSR_MESSAGE_FAIL!\n", __func__);
2245 2246
		goto message_out;
	}
2247 2248
	pcmdmessagefld = (struct CMD_MESSAGE_FIELD *)buffer;
	switch (controlcode) {
2249
	case ARCMSR_MESSAGE_READ_RQBUFFER: {
2250
		unsigned char *ver_addr;
2251
		uint8_t *ptmpQbuffer;
2252
		uint32_t allxfer_len = 0;
2253
		ver_addr = kmalloc(ARCMSR_API_DATA_BUFLEN, GFP_ATOMIC);
2254
		if (!ver_addr) {
2255
			retvalue = ARCMSR_MESSAGE_FAIL;
2256
			pr_info("%s: memory not enough!\n", __func__);
2257 2258
			goto message_out;
		}
2259
		ptmpQbuffer = ver_addr;
2260
		spin_lock_irqsave(&acb->rqbuffer_lock, flags);
2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
		if (acb->rqbuf_getIndex != acb->rqbuf_putIndex) {
			unsigned int tail = acb->rqbuf_getIndex;
			unsigned int head = acb->rqbuf_putIndex;
			unsigned int cnt_to_end = CIRC_CNT_TO_END(head, tail, ARCMSR_MAX_QBUFFER);

			allxfer_len = CIRC_CNT(head, tail, ARCMSR_MAX_QBUFFER);
			if (allxfer_len > ARCMSR_API_DATA_BUFLEN)
				allxfer_len = ARCMSR_API_DATA_BUFLEN;

			if (allxfer_len <= cnt_to_end)
				memcpy(ptmpQbuffer, acb->rqbuffer + tail, allxfer_len);
			else {
				memcpy(ptmpQbuffer, acb->rqbuffer + tail, cnt_to_end);
				memcpy(ptmpQbuffer + cnt_to_end, acb->rqbuffer, allxfer_len - cnt_to_end);
2275
			}
2276
			acb->rqbuf_getIndex = (acb->rqbuf_getIndex + allxfer_len) % ARCMSR_MAX_QBUFFER;
2277
		}
2278 2279
		memcpy(pcmdmessagefld->messagedatabuffer, ver_addr,
			allxfer_len);
2280
		if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
Al Viro's avatar
Al Viro committed
2281
			struct QBUFFER __iomem *prbuffer;
2282 2283
			acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
			prbuffer = arcmsr_get_iop_rqbuffer(acb);
2284 2285
			if (arcmsr_Read_iop_rqbuffer_data(acb, prbuffer) == 0)
				acb->acb_flags |= ACB_F_IOPDATA_OVERFLOW;
2286
		}
2287
		spin_unlock_irqrestore(&acb->rqbuffer_lock, flags);
2288
		kfree(ver_addr);
2289 2290 2291 2292 2293 2294 2295
		pcmdmessagefld->cmdmessage.Length = allxfer_len;
		if (acb->fw_flag == FW_DEADLOCK)
			pcmdmessagefld->cmdmessage.ReturnCode =
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
			pcmdmessagefld->cmdmessage.ReturnCode =
				ARCMSR_MESSAGE_RETURNCODE_OK;
2296
		break;
2297
	}
2298
	case ARCMSR_MESSAGE_WRITE_WQBUFFER: {
2299
		unsigned char *ver_addr;
2300
		int32_t user_len, cnt2end;
2301
		uint8_t *pQbuffer, *ptmpuserbuffer;
2302
		ver_addr = kmalloc(ARCMSR_API_DATA_BUFLEN, GFP_ATOMIC);
2303
		if (!ver_addr) {
2304 2305 2306
			retvalue = ARCMSR_MESSAGE_FAIL;
			goto message_out;
		}
2307
		ptmpuserbuffer = ver_addr;
2308
		user_len = pcmdmessagefld->cmdmessage.Length;
2309 2310 2311
		memcpy(ptmpuserbuffer,
			pcmdmessagefld->messagedatabuffer, user_len);
		spin_lock_irqsave(&acb->wqbuffer_lock, flags);
2312
		if (acb->wqbuf_putIndex != acb->wqbuf_getIndex) {
2313 2314
			struct SENSE_DATA *sensebuffer =
				(struct SENSE_DATA *)cmd->sense_buffer;
2315
			arcmsr_write_ioctldata2iop(acb);
2316
			/* has error report sensedata */
2317
			sensebuffer->ErrorCode = SCSI_SENSE_CURRENT_ERRORS;
2318 2319 2320 2321 2322 2323
			sensebuffer->SenseKey = ILLEGAL_REQUEST;
			sensebuffer->AdditionalSenseLength = 0x0A;
			sensebuffer->AdditionalSenseCode = 0x20;
			sensebuffer->Valid = 1;
			retvalue = ARCMSR_MESSAGE_FAIL;
		} else {
2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337
			pQbuffer = &acb->wqbuffer[acb->wqbuf_putIndex];
			cnt2end = ARCMSR_MAX_QBUFFER - acb->wqbuf_putIndex;
			if (user_len > cnt2end) {
				memcpy(pQbuffer, ptmpuserbuffer, cnt2end);
				ptmpuserbuffer += cnt2end;
				user_len -= cnt2end;
				acb->wqbuf_putIndex = 0;
				pQbuffer = acb->wqbuffer;
			}
			memcpy(pQbuffer, ptmpuserbuffer, user_len);
			acb->wqbuf_putIndex += user_len;
			acb->wqbuf_putIndex %= ARCMSR_MAX_QBUFFER;
			if (acb->acb_flags & ACB_F_MESSAGE_WQBUFFER_CLEARED) {
				acb->acb_flags &=
2338
						~ACB_F_MESSAGE_WQBUFFER_CLEARED;
2339
				arcmsr_write_ioctldata2iop(acb);
2340
			}
2341
		}
2342 2343 2344 2345 2346 2347 2348 2349
		spin_unlock_irqrestore(&acb->wqbuffer_lock, flags);
		kfree(ver_addr);
		if (acb->fw_flag == FW_DEADLOCK)
			pcmdmessagefld->cmdmessage.ReturnCode =
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
			pcmdmessagefld->cmdmessage.ReturnCode =
				ARCMSR_MESSAGE_RETURNCODE_OK;
2350
		break;
2351
	}
2352
	case ARCMSR_MESSAGE_CLEAR_RQBUFFER: {
2353
		uint8_t *pQbuffer = acb->rqbuffer;
2354 2355 2356

		arcmsr_clear_iop2drv_rqueue_buffer(acb);
		spin_lock_irqsave(&acb->rqbuffer_lock, flags);
2357
		acb->acb_flags |= ACB_F_MESSAGE_RQBUFFER_CLEARED;
2358 2359
		acb->rqbuf_getIndex = 0;
		acb->rqbuf_putIndex = 0;
2360
		memset(pQbuffer, 0, ARCMSR_MAX_QBUFFER);
2361 2362
		spin_unlock_irqrestore(&acb->rqbuffer_lock, flags);
		if (acb->fw_flag == FW_DEADLOCK)
2363
			pcmdmessagefld->cmdmessage.ReturnCode =
2364 2365
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
2366
			pcmdmessagefld->cmdmessage.ReturnCode =
2367
				ARCMSR_MESSAGE_RETURNCODE_OK;
2368
		break;
2369
	}
2370
	case ARCMSR_MESSAGE_CLEAR_WQBUFFER: {
2371
		uint8_t *pQbuffer = acb->wqbuffer;
2372 2373 2374
		spin_lock_irqsave(&acb->wqbuffer_lock, flags);
		acb->acb_flags |= (ACB_F_MESSAGE_WQBUFFER_CLEARED |
			ACB_F_MESSAGE_WQBUFFER_READED);
2375 2376
		acb->wqbuf_getIndex = 0;
		acb->wqbuf_putIndex = 0;
2377
		memset(pQbuffer, 0, ARCMSR_MAX_QBUFFER);
2378 2379 2380 2381 2382 2383 2384
		spin_unlock_irqrestore(&acb->wqbuffer_lock, flags);
		if (acb->fw_flag == FW_DEADLOCK)
			pcmdmessagefld->cmdmessage.ReturnCode =
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
			pcmdmessagefld->cmdmessage.ReturnCode =
				ARCMSR_MESSAGE_RETURNCODE_OK;
2385
		break;
2386
	}
2387
	case ARCMSR_MESSAGE_CLEAR_ALLQBUFFER: {
2388
		uint8_t *pQbuffer;
2389 2390 2391
		arcmsr_clear_iop2drv_rqueue_buffer(acb);
		spin_lock_irqsave(&acb->rqbuffer_lock, flags);
		acb->acb_flags |= ACB_F_MESSAGE_RQBUFFER_CLEARED;
2392 2393
		acb->rqbuf_getIndex = 0;
		acb->rqbuf_putIndex = 0;
2394 2395
		pQbuffer = acb->rqbuffer;
		memset(pQbuffer, 0, sizeof(struct QBUFFER));
2396 2397 2398 2399
		spin_unlock_irqrestore(&acb->rqbuffer_lock, flags);
		spin_lock_irqsave(&acb->wqbuffer_lock, flags);
		acb->acb_flags |= (ACB_F_MESSAGE_WQBUFFER_CLEARED |
			ACB_F_MESSAGE_WQBUFFER_READED);
2400 2401
		acb->wqbuf_getIndex = 0;
		acb->wqbuf_putIndex = 0;
2402 2403
		pQbuffer = acb->wqbuffer;
		memset(pQbuffer, 0, sizeof(struct QBUFFER));
2404 2405
		spin_unlock_irqrestore(&acb->wqbuffer_lock, flags);
		if (acb->fw_flag == FW_DEADLOCK)
2406
			pcmdmessagefld->cmdmessage.ReturnCode =
2407 2408
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
2409
			pcmdmessagefld->cmdmessage.ReturnCode =
2410
				ARCMSR_MESSAGE_RETURNCODE_OK;
2411
		break;
2412
	}
2413
	case ARCMSR_MESSAGE_RETURN_CODE_3F: {
2414
		if (acb->fw_flag == FW_DEADLOCK)
2415
			pcmdmessagefld->cmdmessage.ReturnCode =
2416 2417
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
2418
			pcmdmessagefld->cmdmessage.ReturnCode =
2419
				ARCMSR_MESSAGE_RETURNCODE_3F;
2420
		break;
2421
	}
2422
	case ARCMSR_MESSAGE_SAY_HELLO: {
2423
		int8_t *hello_string = "Hello! I am ARCMSR";
2424
		if (acb->fw_flag == FW_DEADLOCK)
2425
			pcmdmessagefld->cmdmessage.ReturnCode =
2426 2427
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
2428
			pcmdmessagefld->cmdmessage.ReturnCode =
2429 2430 2431
				ARCMSR_MESSAGE_RETURNCODE_OK;
		memcpy(pcmdmessagefld->messagedatabuffer,
			hello_string, (int16_t)strlen(hello_string));
2432
		break;
2433 2434 2435
	}
	case ARCMSR_MESSAGE_SAY_GOODBYE: {
		if (acb->fw_flag == FW_DEADLOCK)
2436
			pcmdmessagefld->cmdmessage.ReturnCode =
2437 2438 2439 2440
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
			pcmdmessagefld->cmdmessage.ReturnCode =
				ARCMSR_MESSAGE_RETURNCODE_OK;
2441 2442
		arcmsr_iop_parking(acb);
		break;
2443 2444 2445
	}
	case ARCMSR_MESSAGE_FLUSH_ADAPTER_CACHE: {
		if (acb->fw_flag == FW_DEADLOCK)
2446
			pcmdmessagefld->cmdmessage.ReturnCode =
2447 2448 2449 2450
				ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
		else
			pcmdmessagefld->cmdmessage.ReturnCode =
				ARCMSR_MESSAGE_RETURNCODE_OK;
2451 2452
		arcmsr_flush_adapter_cache(acb);
		break;
2453
	}
2454 2455
	default:
		retvalue = ARCMSR_MESSAGE_FAIL;
2456 2457 2458 2459 2460 2461
		pr_info("%s: unknown controlcode!\n", __func__);
	}
message_out:
	if (use_sg) {
		struct scatterlist *sg = scsi_sglist(cmd);
		kunmap_atomic(buffer - sg->offset);
2462 2463 2464 2465 2466 2467 2468 2469
	}
	return retvalue;
}

static struct CommandControlBlock *arcmsr_get_freeccb(struct AdapterControlBlock *acb)
{
	struct list_head *head = &acb->ccb_free_list;
	struct CommandControlBlock *ccb = NULL;
2470 2471
	unsigned long flags;
	spin_lock_irqsave(&acb->ccblist_lock, flags);
2472 2473
	if (!list_empty(head)) {
		ccb = list_entry(head->next, struct CommandControlBlock, list);
2474
		list_del_init(&ccb->list);
2475
	}else{
2476
		spin_unlock_irqrestore(&acb->ccblist_lock, flags);
2477
		return NULL;
2478
	}
2479
	spin_unlock_irqrestore(&acb->ccblist_lock, flags);
2480 2481 2482 2483 2484 2485 2486 2487 2488 2489
	return ccb;
}

static void arcmsr_handle_virtual_command(struct AdapterControlBlock *acb,
		struct scsi_cmnd *cmd)
{
	switch (cmd->cmnd[0]) {
	case INQUIRY: {
		unsigned char inqdata[36];
		char *buffer;
2490
		struct scatterlist *sg;
2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501

		if (cmd->device->lun) {
			cmd->result = (DID_TIME_OUT << 16);
			cmd->scsi_done(cmd);
			return;
		}
		inqdata[0] = TYPE_PROCESSOR;
		/* Periph Qualifier & Periph Dev Type */
		inqdata[1] = 0;
		/* rem media bit & Dev Type Modifier */
		inqdata[2] = 0;
2502
		/* ISO, ECMA, & ANSI versions */
2503 2504 2505 2506 2507 2508 2509 2510
		inqdata[4] = 31;
		/* length of additional data */
		strncpy(&inqdata[8], "Areca   ", 8);
		/* Vendor Identification */
		strncpy(&inqdata[16], "RAID controller ", 16);
		/* Product Identification */
		strncpy(&inqdata[32], "R001", 4); /* Product Revision */

2511
		sg = scsi_sglist(cmd);
2512
		buffer = kmap_atomic(sg_page(sg)) + sg->offset;
2513

2514
		memcpy(buffer, inqdata, sizeof(inqdata));
2515
		sg = scsi_sglist(cmd);
2516
		kunmap_atomic(buffer - sg->offset);
2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532

		cmd->scsi_done(cmd);
	}
	break;
	case WRITE_BUFFER:
	case READ_BUFFER: {
		if (arcmsr_iop_message_xfer(acb, cmd))
			cmd->result = (DID_ERROR << 16);
		cmd->scsi_done(cmd);
	}
	break;
	default:
		cmd->scsi_done(cmd);
	}
}

Jeff Garzik's avatar
Jeff Garzik committed
2533
static int arcmsr_queue_command_lck(struct scsi_cmnd *cmd,
2534 2535 2536
	void (* done)(struct scsi_cmnd *))
{
	struct Scsi_Host *host = cmd->device->host;
2537
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
2538 2539 2540
	struct CommandControlBlock *ccb;
	int target = cmd->device->id;
	int lun = cmd->device->lun;
2541
	uint8_t scsicmd = cmd->cmnd[0];
2542 2543 2544
	cmd->scsi_done = done;
	cmd->host_scribble = NULL;
	cmd->result = 0;
2545 2546 2547
	if ((scsicmd == SYNCHRONIZE_CACHE) ||(scsicmd == SEND_DIAGNOSTIC)){
		if(acb->devstate[target][lun] == ARECA_RAID_GONE) {
    			cmd->result = (DID_NO_CONNECT << 16);
2548 2549 2550 2551
		}
		cmd->scsi_done(cmd);
		return 0;
	}
2552
	if (target == 16) {
2553 2554 2555 2556 2557 2558 2559
		/* virtual device for iop message transfer */
		arcmsr_handle_virtual_command(acb, cmd);
		return 0;
	}
	ccb = arcmsr_get_freeccb(acb);
	if (!ccb)
		return SCSI_MLQUEUE_HOST_BUSY;
2560
	if (arcmsr_build_ccb( acb, ccb, cmd ) == FAILED) {
2561 2562 2563 2564
		cmd->result = (DID_ERROR << 16) | (RESERVATION_CONFLICT << 1);
		cmd->scsi_done(cmd);
		return 0;
	}
2565 2566 2567 2568
	arcmsr_post_ccb(acb, ccb);
	return 0;
}

Jeff Garzik's avatar
Jeff Garzik committed
2569 2570
static DEF_SCSI_QCMD(arcmsr_queue_command)

2571
static bool arcmsr_hbaA_get_config(struct AdapterControlBlock *acb)
2572
{
Al Viro's avatar
Al Viro committed
2573
	struct MessageUnit_A __iomem *reg = acb->pmuA;
2574 2575
	char *acb_firm_model = acb->firm_model;
	char *acb_firm_version = acb->firm_version;
2576
	char *acb_device_map = acb->device_map;
Al Viro's avatar
Al Viro committed
2577 2578
	char __iomem *iop_firm_model = (char __iomem *)(&reg->message_rwbuffer[15]);
	char __iomem *iop_firm_version = (char __iomem *)(&reg->message_rwbuffer[17]);
2579
	char __iomem *iop_device_map = (char __iomem *)(&reg->message_rwbuffer[21]);
2580 2581
	int count;
	writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, &reg->inbound_msgaddr0);
2582
	if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
2583 2584
		printk(KERN_NOTICE "arcmsr%d: wait 'get adapter firmware \
			miscellaneous data' timeout \n", acb->host->host_no);
2585
		return false;
2586
	}
2587
	count = 8;
2588
	while (count){
2589 2590 2591 2592 2593
		*acb_firm_model = readb(iop_firm_model);
		acb_firm_model++;
		iop_firm_model++;
		count--;
	}
2594

2595
	count = 16;
2596
	while (count){
2597 2598 2599 2600 2601
		*acb_firm_version = readb(iop_firm_version);
		acb_firm_version++;
		iop_firm_version++;
		count--;
	}
2602

2603 2604 2605 2606 2607 2608 2609
	count=16;
	while(count){
		*acb_device_map = readb(iop_device_map);
		acb_device_map++;
		iop_device_map++;
		count--;
	}
2610
	pr_notice("Areca RAID Controller%d: Model %s, F/W %s\n",
2611
		acb->host->host_no,
2612 2613
		acb->firm_model,
		acb->firm_version);
2614
	acb->signature = readl(&reg->message_rwbuffer[0]);
2615 2616 2617 2618
	acb->firm_request_len = readl(&reg->message_rwbuffer[1]);
	acb->firm_numbers_queue = readl(&reg->message_rwbuffer[2]);
	acb->firm_sdram_size = readl(&reg->message_rwbuffer[3]);
	acb->firm_hd_channels = readl(&reg->message_rwbuffer[4]);
2619 2620
	acb->firm_cfg_version = readl(&reg->message_rwbuffer[25]);  /*firm_cfg_version,25,100-103*/
	return true;
2621
}
2622
static bool arcmsr_hbaB_get_config(struct AdapterControlBlock *acb)
2623
{
Al Viro's avatar
Al Viro committed
2624
	struct MessageUnit_B *reg = acb->pmuB;
2625 2626 2627
	struct pci_dev *pdev = acb->pdev;
	void *dma_coherent;
	dma_addr_t dma_coherent_handle;
2628 2629
	char *acb_firm_model = acb->firm_model;
	char *acb_firm_version = acb->firm_version;
2630
	char *acb_device_map = acb->device_map;
2631
	char __iomem *iop_firm_model;
2632
	/*firm_model,15,60-67*/
2633
	char __iomem *iop_firm_version;
2634
	/*firm_version,17,68-83*/
2635
	char __iomem *iop_device_map;
2636
	/*firm_version,21,84-99*/
2637
	int count;
2638 2639 2640 2641

	acb->roundup_ccbsize = roundup(sizeof(struct MessageUnit_B), 32);
	dma_coherent = dma_alloc_coherent(&pdev->dev, acb->roundup_ccbsize,
			&dma_coherent_handle, GFP_KERNEL);
2642
	if (!dma_coherent){
2643 2644 2645
		printk(KERN_NOTICE
			"arcmsr%d: dma_alloc_coherent got error for hbb mu\n",
			acb->host->host_no);
2646 2647
		return false;
	}
2648
	acb->dma_coherent_handle2 = dma_coherent_handle;
2649
	acb->dma_coherent2 = dma_coherent;
2650 2651
	reg = (struct MessageUnit_B *)dma_coherent;
	acb->pmuB = reg;
2652
	reg->drv2iop_doorbell= (uint32_t __iomem *)((unsigned long)acb->mem_base0 + ARCMSR_DRV2IOP_DOORBELL);
2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663
	reg->drv2iop_doorbell_mask = (uint32_t __iomem *)((unsigned long)acb->mem_base0 + ARCMSR_DRV2IOP_DOORBELL_MASK);
	reg->iop2drv_doorbell = (uint32_t __iomem *)((unsigned long)acb->mem_base0 + ARCMSR_IOP2DRV_DOORBELL);
	reg->iop2drv_doorbell_mask = (uint32_t __iomem *)((unsigned long)acb->mem_base0 + ARCMSR_IOP2DRV_DOORBELL_MASK);
	reg->message_wbuffer = (uint32_t __iomem *)((unsigned long)acb->mem_base1 + ARCMSR_MESSAGE_WBUFFER);
	reg->message_rbuffer =  (uint32_t __iomem *)((unsigned long)acb->mem_base1 + ARCMSR_MESSAGE_RBUFFER);
	reg->message_rwbuffer = (uint32_t __iomem *)((unsigned long)acb->mem_base1 + ARCMSR_MESSAGE_RWBUFFER);
	iop_firm_model = (char __iomem *)(&reg->message_rwbuffer[15]);	/*firm_model,15,60-67*/
	iop_firm_version = (char __iomem *)(&reg->message_rwbuffer[17]);	/*firm_version,17,68-83*/
	iop_device_map = (char __iomem *)(&reg->message_rwbuffer[21]);	/*firm_version,21,84-99*/

	writel(ARCMSR_MESSAGE_GET_CONFIG, reg->drv2iop_doorbell);
2664
	if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
2665 2666
		printk(KERN_NOTICE "arcmsr%d: wait 'get adapter firmware \
			miscellaneous data' timeout \n", acb->host->host_no);
2667
		goto err_free_dma;
2668 2669
	}
	count = 8;
2670
	while (count){
2671 2672 2673 2674 2675 2676
		*acb_firm_model = readb(iop_firm_model);
		acb_firm_model++;
		iop_firm_model++;
		count--;
	}
	count = 16;
2677
	while (count){
2678 2679 2680 2681 2682 2683
		*acb_firm_version = readb(iop_firm_version);
		acb_firm_version++;
		iop_firm_version++;
		count--;
	}

2684 2685 2686 2687 2688 2689 2690 2691
	count = 16;
	while(count){
		*acb_device_map = readb(iop_device_map);
		acb_device_map++;
		iop_device_map++;
		count--;
	}
	
2692
	pr_notice("Areca RAID Controller%d: Model %s, F/W %s\n",
2693
		acb->host->host_no,
2694 2695
		acb->firm_model,
		acb->firm_version);
2696

2697
	acb->signature = readl(&reg->message_rwbuffer[0]);
2698
	/*firm_signature,1,00-03*/
2699
	acb->firm_request_len = readl(&reg->message_rwbuffer[1]);
2700
	/*firm_request_len,1,04-07*/
2701
	acb->firm_numbers_queue = readl(&reg->message_rwbuffer[2]);
2702
	/*firm_numbers_queue,2,08-11*/
2703
	acb->firm_sdram_size = readl(&reg->message_rwbuffer[3]);
2704
	/*firm_sdram_size,3,12-15*/
2705
	acb->firm_hd_channels = readl(&reg->message_rwbuffer[4]);
2706
	/*firm_ide_channels,4,16-19*/
2707 2708 2709
	acb->firm_cfg_version = readl(&reg->message_rwbuffer[25]);  /*firm_cfg_version,25,100-103*/
	/*firm_ide_channels,4,16-19*/
	return true;
2710 2711 2712 2713
err_free_dma:
	dma_free_coherent(&acb->pdev->dev, acb->roundup_ccbsize,
			acb->dma_coherent2, acb->dma_coherent_handle2);
	return false;
2714
}
2715

2716
static bool arcmsr_hbaC_get_config(struct AdapterControlBlock *pACB)
2717 2718
{
	uint32_t intmask_org, Index, firmware_state = 0;
2719
	struct MessageUnit_C __iomem *reg = pACB->pmuC;
2720 2721
	char *acb_firm_model = pACB->firm_model;
	char *acb_firm_version = pACB->firm_version;
2722 2723
	char __iomem *iop_firm_model = (char __iomem *)(&reg->msgcode_rwbuffer[15]);    /*firm_model,15,60-67*/
	char __iomem *iop_firm_version = (char __iomem *)(&reg->msgcode_rwbuffer[17]);  /*firm_version,17,68-83*/
2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761
	int count;
	/* disable all outbound interrupt */
	intmask_org = readl(&reg->host_int_mask); /* disable outbound message0 int */
	writel(intmask_org|ARCMSR_HBCMU_ALL_INTMASKENABLE, &reg->host_int_mask);
	/* wait firmware ready */
	do {
		firmware_state = readl(&reg->outbound_msgaddr1);
	} while ((firmware_state & ARCMSR_HBCMU_MESSAGE_FIRMWARE_OK) == 0);
	/* post "get config" instruction */
	writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, &reg->inbound_msgaddr0);
	writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &reg->inbound_doorbell);
	/* wait message ready */
	for (Index = 0; Index < 2000; Index++) {
		if (readl(&reg->outbound_doorbell) & ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE) {
			writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR, &reg->outbound_doorbell_clear);/*clear interrupt*/
			break;
		}
		udelay(10);
	} /*max 1 seconds*/
	if (Index >= 2000) {
		printk(KERN_NOTICE "arcmsr%d: wait 'get adapter firmware \
			miscellaneous data' timeout \n", pACB->host->host_no);
		return false;
	}
	count = 8;
	while (count) {
		*acb_firm_model = readb(iop_firm_model);
		acb_firm_model++;
		iop_firm_model++;
		count--;
	}
	count = 16;
	while (count) {
		*acb_firm_version = readb(iop_firm_version);
		acb_firm_version++;
		iop_firm_version++;
		count--;
	}
2762
	pr_notice("Areca RAID Controller%d: Model %s, F/W %s\n",
2763
		pACB->host->host_no,
2764 2765
		pACB->firm_model,
		pACB->firm_version);
2766 2767 2768 2769 2770 2771 2772 2773
	pACB->firm_request_len = readl(&reg->msgcode_rwbuffer[1]);   /*firm_request_len,1,04-07*/
	pACB->firm_numbers_queue = readl(&reg->msgcode_rwbuffer[2]); /*firm_numbers_queue,2,08-11*/
	pACB->firm_sdram_size = readl(&reg->msgcode_rwbuffer[3]);    /*firm_sdram_size,3,12-15*/
	pACB->firm_hd_channels = readl(&reg->msgcode_rwbuffer[4]);  /*firm_ide_channels,4,16-19*/
	pACB->firm_cfg_version = readl(&reg->msgcode_rwbuffer[25]);  /*firm_cfg_version,25,100-103*/
	/*all interrupt service will be enable at arcmsr_iop_init*/
	return true;
}
2774 2775 2776 2777 2778 2779 2780 2781 2782 2783

static bool arcmsr_hbaD_get_config(struct AdapterControlBlock *acb)
{
	char *acb_firm_model = acb->firm_model;
	char *acb_firm_version = acb->firm_version;
	char *acb_device_map = acb->device_map;
	char __iomem *iop_firm_model;
	char __iomem *iop_firm_version;
	char __iomem *iop_device_map;
	u32 count;
2784
	struct MessageUnit_D *reg;
2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886
	void *dma_coherent2;
	dma_addr_t dma_coherent_handle2;
	struct pci_dev *pdev = acb->pdev;

	acb->roundup_ccbsize = roundup(sizeof(struct MessageUnit_D), 32);
	dma_coherent2 = dma_alloc_coherent(&pdev->dev, acb->roundup_ccbsize,
		&dma_coherent_handle2, GFP_KERNEL);
	if (!dma_coherent2) {
		pr_notice("DMA allocation failed...\n");
		return false;
	}
	memset(dma_coherent2, 0, acb->roundup_ccbsize);
	acb->dma_coherent_handle2 = dma_coherent_handle2;
	acb->dma_coherent2 = dma_coherent2;
	reg = (struct MessageUnit_D *)dma_coherent2;
	acb->pmuD = reg;
	reg->chip_id = acb->mem_base0 + ARCMSR_ARC1214_CHIP_ID;
	reg->cpu_mem_config = acb->mem_base0 +
		ARCMSR_ARC1214_CPU_MEMORY_CONFIGURATION;
	reg->i2o_host_interrupt_mask = acb->mem_base0 +
		ARCMSR_ARC1214_I2_HOST_INTERRUPT_MASK;
	reg->sample_at_reset = acb->mem_base0 + ARCMSR_ARC1214_SAMPLE_RESET;
	reg->reset_request = acb->mem_base0 + ARCMSR_ARC1214_RESET_REQUEST;
	reg->host_int_status = acb->mem_base0 +
		ARCMSR_ARC1214_MAIN_INTERRUPT_STATUS;
	reg->pcief0_int_enable = acb->mem_base0 +
		ARCMSR_ARC1214_PCIE_F0_INTERRUPT_ENABLE;
	reg->inbound_msgaddr0 = acb->mem_base0 +
		ARCMSR_ARC1214_INBOUND_MESSAGE0;
	reg->inbound_msgaddr1 = acb->mem_base0 +
		ARCMSR_ARC1214_INBOUND_MESSAGE1;
	reg->outbound_msgaddr0 = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_MESSAGE0;
	reg->outbound_msgaddr1 = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_MESSAGE1;
	reg->inbound_doorbell = acb->mem_base0 +
		ARCMSR_ARC1214_INBOUND_DOORBELL;
	reg->outbound_doorbell = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_DOORBELL;
	reg->outbound_doorbell_enable = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_DOORBELL_ENABLE;
	reg->inboundlist_base_low = acb->mem_base0 +
		ARCMSR_ARC1214_INBOUND_LIST_BASE_LOW;
	reg->inboundlist_base_high = acb->mem_base0 +
		ARCMSR_ARC1214_INBOUND_LIST_BASE_HIGH;
	reg->inboundlist_write_pointer = acb->mem_base0 +
		ARCMSR_ARC1214_INBOUND_LIST_WRITE_POINTER;
	reg->outboundlist_base_low = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_LIST_BASE_LOW;
	reg->outboundlist_base_high = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_LIST_BASE_HIGH;
	reg->outboundlist_copy_pointer = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_LIST_COPY_POINTER;
	reg->outboundlist_read_pointer = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_LIST_READ_POINTER;
	reg->outboundlist_interrupt_cause = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_INTERRUPT_CAUSE;
	reg->outboundlist_interrupt_enable = acb->mem_base0 +
		ARCMSR_ARC1214_OUTBOUND_INTERRUPT_ENABLE;
	reg->message_wbuffer = acb->mem_base0 + ARCMSR_ARC1214_MESSAGE_WBUFFER;
	reg->message_rbuffer = acb->mem_base0 + ARCMSR_ARC1214_MESSAGE_RBUFFER;
	reg->msgcode_rwbuffer = acb->mem_base0 +
		ARCMSR_ARC1214_MESSAGE_RWBUFFER;
	iop_firm_model = (char __iomem *)(&reg->msgcode_rwbuffer[15]);
	iop_firm_version = (char __iomem *)(&reg->msgcode_rwbuffer[17]);
	iop_device_map = (char __iomem *)(&reg->msgcode_rwbuffer[21]);
	if (readl(acb->pmuD->outbound_doorbell) &
		ARCMSR_ARC1214_IOP2DRV_MESSAGE_CMD_DONE) {
		writel(ARCMSR_ARC1214_IOP2DRV_MESSAGE_CMD_DONE,
			acb->pmuD->outbound_doorbell);/*clear interrupt*/
	}
	/* post "get config" instruction */
	writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, reg->inbound_msgaddr0);
	/* wait message ready */
	if (!arcmsr_hbaD_wait_msgint_ready(acb)) {
		pr_notice("arcmsr%d: wait get adapter firmware "
			"miscellaneous data timeout\n", acb->host->host_no);
		dma_free_coherent(&acb->pdev->dev, acb->roundup_ccbsize,
			acb->dma_coherent2, acb->dma_coherent_handle2);
		return false;
	}
	count = 8;
	while (count) {
		*acb_firm_model = readb(iop_firm_model);
		acb_firm_model++;
		iop_firm_model++;
		count--;
	}
	count = 16;
	while (count) {
		*acb_firm_version = readb(iop_firm_version);
		acb_firm_version++;
		iop_firm_version++;
		count--;
	}
	count = 16;
	while (count) {
		*acb_device_map = readb(iop_device_map);
		acb_device_map++;
		iop_device_map++;
		count--;
	}
2887
	acb->signature = readl(&reg->msgcode_rwbuffer[0]);
2888
	/*firm_signature,1,00-03*/
2889
	acb->firm_request_len = readl(&reg->msgcode_rwbuffer[1]);
2890
	/*firm_request_len,1,04-07*/
2891
	acb->firm_numbers_queue = readl(&reg->msgcode_rwbuffer[2]);
2892
	/*firm_numbers_queue,2,08-11*/
2893
	acb->firm_sdram_size = readl(&reg->msgcode_rwbuffer[3]);
2894
	/*firm_sdram_size,3,12-15*/
2895
	acb->firm_hd_channels = readl(&reg->msgcode_rwbuffer[4]);
2896 2897 2898 2899 2900 2901 2902 2903 2904
	/*firm_hd_channels,4,16-19*/
	acb->firm_cfg_version = readl(&reg->msgcode_rwbuffer[25]);
	pr_notice("Areca RAID Controller%d: Model %s, F/W %s\n",
		acb->host->host_no,
		acb->firm_model,
		acb->firm_version);
	return true;
}

2905
static bool arcmsr_get_firmware_spec(struct AdapterControlBlock *acb)
2906
{
2907 2908 2909 2910
	bool rtn = false;

	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A:
2911
		rtn = arcmsr_hbaA_get_config(acb);
2912 2913
		break;
	case ACB_ADAPTER_TYPE_B:
2914
		rtn = arcmsr_hbaB_get_config(acb);
2915 2916
		break;
	case ACB_ADAPTER_TYPE_C:
2917
		rtn = arcmsr_hbaC_get_config(acb);
2918
		break;
2919 2920 2921
	case ACB_ADAPTER_TYPE_D:
		rtn = arcmsr_hbaD_get_config(acb);
		break;
2922 2923 2924 2925 2926
	default:
		break;
	}
	if (acb->firm_numbers_queue > ARCMSR_MAX_OUTSTANDING_CMD)
		acb->maxOutstanding = ARCMSR_MAX_OUTSTANDING_CMD;
2927
	else
2928 2929 2930
		acb->maxOutstanding = acb->firm_numbers_queue - 1;
	acb->host->can_queue = acb->maxOutstanding;
	return rtn;
2931 2932
}

2933
static int arcmsr_hbaA_polling_ccbdone(struct AdapterControlBlock *acb,
2934 2935
	struct CommandControlBlock *poll_ccb)
{
Al Viro's avatar
Al Viro committed
2936
	struct MessageUnit_A __iomem *reg = acb->pmuA;
2937
	struct CommandControlBlock *ccb;
2938
	struct ARCMSR_CDB *arcmsr_cdb;
2939
	uint32_t flag_ccb, outbound_intstatus, poll_ccb_done = 0, poll_count = 0;
2940
	int rtn;
2941
	bool error;
2942
	polling_hba_ccb_retry:
2943
	poll_count++;
2944
	outbound_intstatus = readl(&reg->outbound_intstatus) & acb->outbound_int_enable;
2945 2946 2947
	writel(outbound_intstatus, &reg->outbound_intstatus);/*clear interrupt*/
	while (1) {
		if ((flag_ccb = readl(&reg->outbound_queueport)) == 0xFFFFFFFF) {
2948
			if (poll_ccb_done){
2949
				rtn = SUCCESS;
2950
				break;
2951 2952 2953
			}else {
				msleep(25);
				if (poll_count > 100){
2954
					rtn = FAILED;
2955
					break;
2956
				}
2957
				goto polling_hba_ccb_retry;
2958 2959
			}
		}
2960 2961
		arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset + (flag_ccb << 5));
		ccb = container_of(arcmsr_cdb, struct CommandControlBlock, arcmsr_cdb);
2962
		poll_ccb_done |= (ccb == poll_ccb) ? 1 : 0;
2963 2964 2965
		if ((ccb->acb != acb) || (ccb->startdone != ARCMSR_CCB_START)) {
			if ((ccb->startdone == ARCMSR_CCB_ABORTED) || (ccb == poll_ccb)) {
				printk(KERN_NOTICE "arcmsr%d: scsi id = %d lun = %d ccb = '0x%p'"
2966 2967 2968
					" poll command abort successfully \n"
					, acb->host->host_no
					, ccb->pcmd->device->id
Hannes Reinecke's avatar
Hannes Reinecke committed
2969
					, (u32)ccb->pcmd->device->lun
2970 2971
					, ccb);
				ccb->pcmd->result = DID_ABORT << 16;
2972
				arcmsr_ccb_complete(ccb);
2973 2974
				continue;
			}
2975 2976
			printk(KERN_NOTICE "arcmsr%d: polling get an illegal ccb"
				" command done ccb = '0x%p'"
2977
				"ccboutstandingcount = %d \n"
2978 2979 2980 2981
				, acb->host->host_no
				, ccb
				, atomic_read(&acb->ccboutstandingcount));
			continue;
2982 2983 2984
		}
		error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE0) ? true : false;
		arcmsr_report_ccb_state(acb, ccb, error);
2985
	}
2986 2987
	return rtn;
}
2988

2989
static int arcmsr_hbaB_polling_ccbdone(struct AdapterControlBlock *acb,
2990 2991
					struct CommandControlBlock *poll_ccb)
{
2992
	struct MessageUnit_B *reg = acb->pmuB;
2993
	struct ARCMSR_CDB *arcmsr_cdb;
2994 2995
	struct CommandControlBlock *ccb;
	uint32_t flag_ccb, poll_ccb_done = 0, poll_count = 0;
2996
	int index, rtn;
2997
	bool error;
2998
	polling_hbb_ccb_retry:
2999

3000 3001
	poll_count++;
	/* clear doorbell interrupt */
3002
	writel(ARCMSR_DOORBELL_INT_CLEAR_PATTERN, reg->iop2drv_doorbell);
3003 3004
	while(1){
		index = reg->doneq_index;
3005 3006
		flag_ccb = reg->done_qbuffer[index];
		if (flag_ccb == 0) {
3007
			if (poll_ccb_done){
3008
				rtn = SUCCESS;
3009 3010 3011 3012
				break;
			}else {
				msleep(25);
				if (poll_count > 100){
3013
					rtn = FAILED;
3014
					break;
3015
				}
3016
				goto polling_hbb_ccb_retry;
3017
			}
3018
		}
3019
		reg->done_qbuffer[index] = 0;
3020 3021 3022 3023 3024
		index++;
		/*if last index number set it to 0 */
		index %= ARCMSR_MAX_HBB_POSTQUEUE;
		reg->doneq_index = index;
		/* check if command done with no error*/
3025 3026
		arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset + (flag_ccb << 5));
		ccb = container_of(arcmsr_cdb, struct CommandControlBlock, arcmsr_cdb);
3027
		poll_ccb_done |= (ccb == poll_ccb) ? 1 : 0;
3028 3029
		if ((ccb->acb != acb) || (ccb->startdone != ARCMSR_CCB_START)) {
			if ((ccb->startdone == ARCMSR_CCB_ABORTED) || (ccb == poll_ccb)) {
3030 3031
				printk(KERN_NOTICE "arcmsr%d: scsi id = %d lun = %d ccb = '0x%p'"
					" poll command abort successfully \n"
3032 3033
					,acb->host->host_no
					,ccb->pcmd->device->id
Hannes Reinecke's avatar
Hannes Reinecke committed
3034
					,(u32)ccb->pcmd->device->lun
3035 3036
					,ccb);
				ccb->pcmd->result = DID_ABORT << 16;
3037
				arcmsr_ccb_complete(ccb);
3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053
				continue;
			}
			printk(KERN_NOTICE "arcmsr%d: polling get an illegal ccb"
				" command done ccb = '0x%p'"
				"ccboutstandingcount = %d \n"
				, acb->host->host_no
				, ccb
				, atomic_read(&acb->ccboutstandingcount));
			continue;
		} 
		error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE0) ? true : false;
		arcmsr_report_ccb_state(acb, ccb, error);
	}
	return rtn;
}

3054 3055
static int arcmsr_hbaC_polling_ccbdone(struct AdapterControlBlock *acb,
		struct CommandControlBlock *poll_ccb)
3056
{
3057
	struct MessageUnit_C __iomem *reg = acb->pmuC;
3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075
	uint32_t flag_ccb, ccb_cdb_phy;
	struct ARCMSR_CDB *arcmsr_cdb;
	bool error;
	struct CommandControlBlock *pCCB;
	uint32_t poll_ccb_done = 0, poll_count = 0;
	int rtn;
polling_hbc_ccb_retry:
	poll_count++;
	while (1) {
		if ((readl(&reg->host_int_status) & ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR) == 0) {
			if (poll_ccb_done) {
				rtn = SUCCESS;
				break;
			} else {
				msleep(25);
				if (poll_count > 100) {
					rtn = FAILED;
					break;
3076
				}
3077 3078 3079 3080 3081 3082 3083
				goto polling_hbc_ccb_retry;
			}
		}
		flag_ccb = readl(&reg->outbound_queueport_low);
		ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
		arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset + ccb_cdb_phy);/*frame must be 32 bytes aligned*/
		pCCB = container_of(arcmsr_cdb, struct CommandControlBlock, arcmsr_cdb);
3084
		poll_ccb_done |= (pCCB == poll_ccb) ? 1 : 0;
3085 3086 3087 3088 3089
		/* check ifcommand done with no error*/
		if ((pCCB->acb != acb) || (pCCB->startdone != ARCMSR_CCB_START)) {
			if (pCCB->startdone == ARCMSR_CCB_ABORTED) {
				printk(KERN_NOTICE "arcmsr%d: scsi id = %d lun = %d ccb = '0x%p'"
					" poll command abort successfully \n"
3090
					, acb->host->host_no
3091
					, pCCB->pcmd->device->id
Hannes Reinecke's avatar
Hannes Reinecke committed
3092
					, (u32)pCCB->pcmd->device->lun
3093 3094 3095
					, pCCB);
					pCCB->pcmd->result = DID_ABORT << 16;
					arcmsr_ccb_complete(pCCB);
3096
				continue;
3097 3098 3099 3100 3101 3102 3103 3104
			}
			printk(KERN_NOTICE "arcmsr%d: polling get an illegal ccb"
				" command done ccb = '0x%p'"
				"ccboutstandingcount = %d \n"
				, acb->host->host_no
				, pCCB
				, atomic_read(&acb->ccboutstandingcount));
			continue;
3105
		}
3106 3107 3108
		error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE1) ? true : false;
		arcmsr_report_ccb_state(acb, pCCB, error);
	}
3109
	return rtn;
3110
}
3111 3112 3113 3114 3115 3116

static int arcmsr_hbaD_polling_ccbdone(struct AdapterControlBlock *acb,
				struct CommandControlBlock *poll_ccb)
{
	bool error;
	uint32_t poll_ccb_done = 0, poll_count = 0, flag_ccb, ccb_cdb_phy;
3117
	int rtn, doneq_index, index_stripped, outbound_write_pointer, toggle;
3118 3119 3120 3121 3122 3123 3124 3125
	unsigned long flags;
	struct ARCMSR_CDB *arcmsr_cdb;
	struct CommandControlBlock *pCCB;
	struct MessageUnit_D *pmu = acb->pmuD;

polling_hbaD_ccb_retry:
	poll_count++;
	while (1) {
3126
		spin_lock_irqsave(&acb->doneq_lock, flags);
3127 3128 3129
		outbound_write_pointer = pmu->done_qbuffer[0].addressLow + 1;
		doneq_index = pmu->doneq_index;
		if ((outbound_write_pointer & 0xFFF) == (doneq_index & 0xFFF)) {
3130
			spin_unlock_irqrestore(&acb->doneq_lock, flags);
3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142
			if (poll_ccb_done) {
				rtn = SUCCESS;
				break;
			} else {
				msleep(25);
				if (poll_count > 40) {
					rtn = FAILED;
					break;
				}
				goto polling_hbaD_ccb_retry;
			}
		}
3143 3144 3145 3146 3147
		toggle = doneq_index & 0x4000;
		index_stripped = (doneq_index & 0xFFF) + 1;
		index_stripped %= ARCMSR_MAX_ARC1214_DONEQUEUE;
		pmu->doneq_index = index_stripped ? (index_stripped | toggle) :
				((toggle ^ 0x4000) + 1);
3148
		doneq_index = pmu->doneq_index;
3149
		spin_unlock_irqrestore(&acb->doneq_lock, flags);
3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
		flag_ccb = pmu->done_qbuffer[doneq_index & 0xFFF].addressLow;
		ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
		arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset +
			ccb_cdb_phy);
		pCCB = container_of(arcmsr_cdb, struct CommandControlBlock,
			arcmsr_cdb);
		poll_ccb_done |= (pCCB == poll_ccb) ? 1 : 0;
		if ((pCCB->acb != acb) ||
			(pCCB->startdone != ARCMSR_CCB_START)) {
			if (pCCB->startdone == ARCMSR_CCB_ABORTED) {
				pr_notice("arcmsr%d: scsi id = %d "
					"lun = %d ccb = '0x%p' poll command "
					"abort successfully\n"
					, acb->host->host_no
					, pCCB->pcmd->device->id
					, (u32)pCCB->pcmd->device->lun
					, pCCB);
				pCCB->pcmd->result = DID_ABORT << 16;
				arcmsr_ccb_complete(pCCB);
				continue;
			}
			pr_notice("arcmsr%d: polling an illegal "
				"ccb command done ccb = '0x%p' "
				"ccboutstandingcount = %d\n"
				, acb->host->host_no
				, pCCB
				, atomic_read(&acb->ccboutstandingcount));
			continue;
		}
		error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE1)
			? true : false;
		arcmsr_report_ccb_state(acb, pCCB, error);
	}
	return rtn;
}

3186
static int arcmsr_polling_ccbdone(struct AdapterControlBlock *acb,
3187 3188
					struct CommandControlBlock *poll_ccb)
{
3189
	int rtn = 0;
3190 3191 3192
	switch (acb->adapter_type) {

	case ACB_ADAPTER_TYPE_A: {
3193
		rtn = arcmsr_hbaA_polling_ccbdone(acb, poll_ccb);
3194 3195 3196 3197
		}
		break;

	case ACB_ADAPTER_TYPE_B: {
3198
		rtn = arcmsr_hbaB_polling_ccbdone(acb, poll_ccb);
3199
		}
3200 3201
		break;
	case ACB_ADAPTER_TYPE_C: {
3202
		rtn = arcmsr_hbaC_polling_ccbdone(acb, poll_ccb);
3203
		}
3204 3205 3206 3207
		break;
	case ACB_ADAPTER_TYPE_D:
		rtn = arcmsr_hbaD_polling_ccbdone(acb, poll_ccb);
		break;
3208
	}
3209
	return rtn;
3210
}
3211 3212

static int arcmsr_iop_confirm(struct AdapterControlBlock *acb)
3213
{
3214
	uint32_t cdb_phyaddr, cdb_phyaddr_hi32;
3215
	dma_addr_t dma_coherent_handle;
3216

3217 3218 3219 3220 3221 3222
	/*
	********************************************************************
	** here we need to tell iop 331 our freeccb.HighPart
	** if freeccb.HighPart is not zero
	********************************************************************
	*/
3223 3224
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_B:
3225
	case ACB_ADAPTER_TYPE_D:
3226 3227 3228 3229 3230 3231 3232 3233
		dma_coherent_handle = acb->dma_coherent_handle2;
		break;
	default:
		dma_coherent_handle = acb->dma_coherent_handle;
		break;
	}
	cdb_phyaddr = lower_32_bits(dma_coherent_handle);
	cdb_phyaddr_hi32 = upper_32_bits(dma_coherent_handle);
3234
	acb->cdb_phyaddr_hi32 = cdb_phyaddr_hi32;
3235 3236 3237 3238 3239 3240 3241 3242
	/*
	***********************************************************************
	**    if adapter type B, set window of "post command Q"
	***********************************************************************
	*/
	switch (acb->adapter_type) {

	case ACB_ADAPTER_TYPE_A: {
3243
		if (cdb_phyaddr_hi32 != 0) {
Al Viro's avatar
Al Viro committed
3244
			struct MessageUnit_A __iomem *reg = acb->pmuA;
3245 3246
			writel(ARCMSR_SIGNATURE_SET_CONFIG, \
						&reg->message_rwbuffer[0]);
3247
			writel(cdb_phyaddr_hi32, &reg->message_rwbuffer[1]);
3248 3249
			writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, \
							&reg->inbound_msgaddr0);
3250
			if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
3251 3252 3253 3254
				printk(KERN_NOTICE "arcmsr%d: ""set ccb high \
				part physical address timeout\n",
				acb->host->host_no);
				return 1;
3255
			}
3256 3257 3258
		}
		}
		break;
3259

3260
	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
3261
		uint32_t __iomem *rwbuffer;
3262

Al Viro's avatar
Al Viro committed
3263
		struct MessageUnit_B *reg = acb->pmuB;
3264 3265
		reg->postq_index = 0;
		reg->doneq_index = 0;
3266
		writel(ARCMSR_MESSAGE_SET_POST_WINDOW, reg->drv2iop_doorbell);
3267
		if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
3268
			printk(KERN_NOTICE "arcmsr%d: cannot set driver mode\n", \
3269 3270 3271
				acb->host->host_no);
			return 1;
		}
3272
		rwbuffer = reg->message_rwbuffer;
3273 3274 3275
		/* driver "set config" signature */
		writel(ARCMSR_SIGNATURE_SET_CONFIG, rwbuffer++);
		/* normal should be zero */
3276
		writel(cdb_phyaddr_hi32, rwbuffer++);
3277
		/* postQ size (256 + 8)*4	 */
3278
		writel(cdb_phyaddr, rwbuffer++);
3279
		/* doneQ size (256 + 8)*4	 */
3280
		writel(cdb_phyaddr + 1056, rwbuffer++);
3281 3282 3283
		/* ccb maxQ size must be --> [(256 + 8)*4]*/
		writel(1056, rwbuffer);

3284
		writel(ARCMSR_MESSAGE_SET_CONFIG, reg->drv2iop_doorbell);
3285
		if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
3286 3287 3288 3289
			printk(KERN_NOTICE "arcmsr%d: 'set command Q window' \
			timeout \n",acb->host->host_no);
			return 1;
		}
3290
		writel(ARCMSR_MESSAGE_START_DRIVER_MODE, reg->drv2iop_doorbell);
3291
		if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
3292 3293 3294 3295
			pr_err("arcmsr%d: can't set driver mode.\n",
				acb->host->host_no);
			return 1;
		}
3296 3297
		}
		break;
3298 3299
	case ACB_ADAPTER_TYPE_C: {
		if (cdb_phyaddr_hi32 != 0) {
3300
			struct MessageUnit_C __iomem *reg = acb->pmuC;
3301

3302 3303
			printk(KERN_NOTICE "arcmsr%d: cdb_phyaddr_hi32=0x%x\n",
					acb->adapter_index, cdb_phyaddr_hi32);
3304 3305 3306 3307
			writel(ARCMSR_SIGNATURE_SET_CONFIG, &reg->msgcode_rwbuffer[0]);
			writel(cdb_phyaddr_hi32, &reg->msgcode_rwbuffer[1]);
			writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, &reg->inbound_msgaddr0);
			writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &reg->inbound_doorbell);
3308
			if (!arcmsr_hbaC_wait_msgint_ready(acb)) {
3309 3310 3311 3312 3313 3314
				printk(KERN_NOTICE "arcmsr%d: 'set command Q window' \
				timeout \n", acb->host->host_no);
				return 1;
			}
		}
		}
3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335
		break;
	case ACB_ADAPTER_TYPE_D: {
		uint32_t __iomem *rwbuffer;
		struct MessageUnit_D *reg = acb->pmuD;
		reg->postq_index = 0;
		reg->doneq_index = 0;
		rwbuffer = reg->msgcode_rwbuffer;
		writel(ARCMSR_SIGNATURE_SET_CONFIG, rwbuffer++);
		writel(cdb_phyaddr_hi32, rwbuffer++);
		writel(cdb_phyaddr, rwbuffer++);
		writel(cdb_phyaddr + (ARCMSR_MAX_ARC1214_POSTQUEUE *
			sizeof(struct InBound_SRB)), rwbuffer++);
		writel(0x100, rwbuffer);
		writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, reg->inbound_msgaddr0);
		if (!arcmsr_hbaD_wait_msgint_ready(acb)) {
			pr_notice("arcmsr%d: 'set command Q window' timeout\n",
				acb->host->host_no);
			return 1;
		}
		}
		break;
3336 3337 3338
	}
	return 0;
}
3339

3340 3341 3342 3343 3344 3345
static void arcmsr_wait_firmware_ready(struct AdapterControlBlock *acb)
{
	uint32_t firmware_state = 0;
	switch (acb->adapter_type) {

	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
3346
		struct MessageUnit_A __iomem *reg = acb->pmuA;
3347 3348 3349 3350 3351 3352 3353
		do {
			firmware_state = readl(&reg->outbound_msgaddr1);
		} while ((firmware_state & ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK) == 0);
		}
		break;

	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
3354
		struct MessageUnit_B *reg = acb->pmuB;
3355
		do {
3356
			firmware_state = readl(reg->iop2drv_doorbell);
3357
		} while ((firmware_state & ARCMSR_MESSAGE_FIRMWARE_OK) == 0);
3358
		writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT, reg->drv2iop_doorbell);
3359 3360
		}
		break;
3361
	case ACB_ADAPTER_TYPE_C: {
3362
		struct MessageUnit_C __iomem *reg = acb->pmuC;
3363 3364 3365 3366
		do {
			firmware_state = readl(&reg->outbound_msgaddr1);
		} while ((firmware_state & ARCMSR_HBCMU_MESSAGE_FIRMWARE_OK) == 0);
		}
3367 3368 3369 3370 3371 3372 3373 3374 3375
		break;
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg = acb->pmuD;
		do {
			firmware_state = readl(reg->outbound_msgaddr1);
		} while ((firmware_state &
			ARCMSR_ARC1214_MESSAGE_FIRMWARE_OK) == 0);
		}
		break;
3376
	}
3377 3378
}

3379
static void arcmsr_hbaA_request_device_map(struct AdapterControlBlock *acb)
3380 3381
{
	struct MessageUnit_A __iomem *reg = acb->pmuA;
3382
	if (unlikely(atomic_read(&acb->rq_map_token) == 0) || ((acb->acb_flags & ACB_F_BUS_RESET) != 0 ) || ((acb->acb_flags & ACB_F_ABORT) != 0 )){
3383
		mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3384
		return;
3385
	} else {
3386
		acb->fw_flag = FW_NORMAL;
3387
		if (atomic_read(&acb->ante_token_value) == atomic_read(&acb->rq_map_token)){
3388 3389
			atomic_set(&acb->rq_map_token, 16);
		}
3390
		atomic_set(&acb->ante_token_value, atomic_read(&acb->rq_map_token));
3391 3392
		if (atomic_dec_and_test(&acb->rq_map_token)) {
			mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3393
			return;
3394
		}
3395
		writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, &reg->inbound_msgaddr0);
3396
		mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3397 3398 3399 3400
	}
	return;
}

3401
static void arcmsr_hbaB_request_device_map(struct AdapterControlBlock *acb)
3402
{
3403
	struct MessageUnit_B *reg = acb->pmuB;
3404
	if (unlikely(atomic_read(&acb->rq_map_token) == 0) || ((acb->acb_flags & ACB_F_BUS_RESET) != 0 ) || ((acb->acb_flags & ACB_F_ABORT) != 0 )){
3405
		mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3406 3407 3408 3409
		return;
	} else {
		acb->fw_flag = FW_NORMAL;
		if (atomic_read(&acb->ante_token_value) == atomic_read(&acb->rq_map_token)) {
3410
			atomic_set(&acb->rq_map_token, 16);
3411 3412
		}
		atomic_set(&acb->ante_token_value, atomic_read(&acb->rq_map_token));
3413 3414
		if (atomic_dec_and_test(&acb->rq_map_token)) {
			mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3415
			return;
3416
		}
3417 3418 3419 3420 3421
		writel(ARCMSR_MESSAGE_GET_CONFIG, reg->drv2iop_doorbell);
		mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
	}
	return;
}
3422

3423
static void arcmsr_hbaC_request_device_map(struct AdapterControlBlock *acb)
3424 3425
{
	struct MessageUnit_C __iomem *reg = acb->pmuC;
3426
	if (unlikely(atomic_read(&acb->rq_map_token) == 0) || ((acb->acb_flags & ACB_F_BUS_RESET) != 0) || ((acb->acb_flags & ACB_F_ABORT) != 0)) {
3427
		mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3428
		return;
3429
	} else {
3430 3431
		acb->fw_flag = FW_NORMAL;
		if (atomic_read(&acb->ante_token_value) == atomic_read(&acb->rq_map_token)) {
3432 3433
			atomic_set(&acb->rq_map_token, 16);
		}
3434
		atomic_set(&acb->ante_token_value, atomic_read(&acb->rq_map_token));
3435 3436
		if (atomic_dec_and_test(&acb->rq_map_token)) {
			mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3437
			return;
3438
		}
3439 3440 3441
		writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, &reg->inbound_msgaddr0);
		writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &reg->inbound_doorbell);
		mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3442 3443 3444 3445
	}
	return;
}

3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474
static void arcmsr_hbaD_request_device_map(struct AdapterControlBlock *acb)
{
	struct MessageUnit_D *reg = acb->pmuD;

	if (unlikely(atomic_read(&acb->rq_map_token) == 0) ||
		((acb->acb_flags & ACB_F_BUS_RESET) != 0) ||
		((acb->acb_flags & ACB_F_ABORT) != 0)) {
		mod_timer(&acb->eternal_timer,
			jiffies + msecs_to_jiffies(6 * HZ));
	} else {
		acb->fw_flag = FW_NORMAL;
		if (atomic_read(&acb->ante_token_value) ==
			atomic_read(&acb->rq_map_token)) {
			atomic_set(&acb->rq_map_token, 16);
		}
		atomic_set(&acb->ante_token_value,
			atomic_read(&acb->rq_map_token));
		if (atomic_dec_and_test(&acb->rq_map_token)) {
			mod_timer(&acb->eternal_timer, jiffies +
				msecs_to_jiffies(6 * HZ));
			return;
		}
		writel(ARCMSR_INBOUND_MESG0_GET_CONFIG,
			reg->inbound_msgaddr0);
		mod_timer(&acb->eternal_timer, jiffies +
			msecs_to_jiffies(6 * HZ));
	}
}

3475 3476 3477 3478 3479
static void arcmsr_request_device_map(unsigned long pacb)
{
	struct AdapterControlBlock *acb = (struct AdapterControlBlock *)pacb;
	switch (acb->adapter_type) {
		case ACB_ADAPTER_TYPE_A: {
3480
			arcmsr_hbaA_request_device_map(acb);
3481 3482 3483
		}
		break;
		case ACB_ADAPTER_TYPE_B: {
3484
			arcmsr_hbaB_request_device_map(acb);
3485 3486
		}
		break;
3487
		case ACB_ADAPTER_TYPE_C: {
3488
			arcmsr_hbaC_request_device_map(acb);
3489
		}
3490 3491 3492 3493
		break;
		case ACB_ADAPTER_TYPE_D:
			arcmsr_hbaD_request_device_map(acb);
		break;
3494 3495 3496
	}
}

3497
static void arcmsr_hbaA_start_bgrb(struct AdapterControlBlock *acb)
3498
{
Al Viro's avatar
Al Viro committed
3499
	struct MessageUnit_A __iomem *reg = acb->pmuA;
3500 3501
	acb->acb_flags |= ACB_F_MSG_START_BGRB;
	writel(ARCMSR_INBOUND_MESG0_START_BGRB, &reg->inbound_msgaddr0);
3502
	if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
3503 3504
		printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
				rebulid' timeout \n", acb->host->host_no);
3505 3506 3507
	}
}

3508
static void arcmsr_hbaB_start_bgrb(struct AdapterControlBlock *acb)
3509
{
Al Viro's avatar
Al Viro committed
3510
	struct MessageUnit_B *reg = acb->pmuB;
3511
	acb->acb_flags |= ACB_F_MSG_START_BGRB;
3512
	writel(ARCMSR_MESSAGE_START_BGRB, reg->drv2iop_doorbell);
3513
	if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
3514 3515 3516 3517
		printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
				rebulid' timeout \n",acb->host->host_no);
	}
}
3518

3519
static void arcmsr_hbaC_start_bgrb(struct AdapterControlBlock *pACB)
3520
{
3521
	struct MessageUnit_C __iomem *phbcmu = pACB->pmuC;
3522 3523 3524
	pACB->acb_flags |= ACB_F_MSG_START_BGRB;
	writel(ARCMSR_INBOUND_MESG0_START_BGRB, &phbcmu->inbound_msgaddr0);
	writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, &phbcmu->inbound_doorbell);
3525
	if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
3526 3527 3528 3529 3530
		printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
				rebulid' timeout \n", pACB->host->host_no);
	}
	return;
}
3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543

static void arcmsr_hbaD_start_bgrb(struct AdapterControlBlock *pACB)
{
	struct MessageUnit_D *pmu = pACB->pmuD;

	pACB->acb_flags |= ACB_F_MSG_START_BGRB;
	writel(ARCMSR_INBOUND_MESG0_START_BGRB, pmu->inbound_msgaddr0);
	if (!arcmsr_hbaD_wait_msgint_ready(pACB)) {
		pr_notice("arcmsr%d: wait 'start adapter "
			"background rebulid' timeout\n", pACB->host->host_no);
	}
}

3544
static void arcmsr_start_adapter_bgrb(struct AdapterControlBlock *acb)
3545
{
3546 3547
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A:
3548
		arcmsr_hbaA_start_bgrb(acb);
3549 3550
		break;
	case ACB_ADAPTER_TYPE_B:
3551
		arcmsr_hbaB_start_bgrb(acb);
3552
		break;
3553
	case ACB_ADAPTER_TYPE_C:
3554
		arcmsr_hbaC_start_bgrb(acb);
3555 3556 3557 3558
		break;
	case ACB_ADAPTER_TYPE_D:
		arcmsr_hbaD_start_bgrb(acb);
		break;
3559 3560
	}
}
3561

3562 3563 3564 3565
static void arcmsr_clear_doorbell_queue_buffer(struct AdapterControlBlock *acb)
{
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A: {
Al Viro's avatar
Al Viro committed
3566
		struct MessageUnit_A __iomem *reg = acb->pmuA;
3567 3568 3569 3570 3571 3572 3573 3574
		uint32_t outbound_doorbell;
		/* empty doorbell Qbuffer if door bell ringed */
		outbound_doorbell = readl(&reg->outbound_doorbell);
		/*clear doorbell interrupt */
		writel(outbound_doorbell, &reg->outbound_doorbell);
		writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK, &reg->inbound_doorbell);
		}
		break;
3575

3576
	case ACB_ADAPTER_TYPE_B: {
Al Viro's avatar
Al Viro committed
3577
		struct MessageUnit_B *reg = acb->pmuB;
3578
		/*clear interrupt and message state*/
3579 3580
		writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN, reg->iop2drv_doorbell);
		writel(ARCMSR_DRV2IOP_DATA_READ_OK, reg->drv2iop_doorbell);
3581 3582 3583
		/* let IOP know data has been read */
		}
		break;
3584
	case ACB_ADAPTER_TYPE_C: {
3585
		struct MessageUnit_C __iomem *reg = acb->pmuC;
3586
		uint32_t outbound_doorbell, i;
3587 3588 3589 3590
		/* empty doorbell Qbuffer if door bell ringed */
		outbound_doorbell = readl(&reg->outbound_doorbell);
		writel(outbound_doorbell, &reg->outbound_doorbell_clear);
		writel(ARCMSR_HBCMU_DRV2IOP_DATA_READ_OK, &reg->inbound_doorbell);
3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602
		for (i = 0; i < 200; i++) {
			msleep(20);
			outbound_doorbell = readl(&reg->outbound_doorbell);
			if (outbound_doorbell &
				ARCMSR_HBCMU_IOP2DRV_DATA_WRITE_OK) {
				writel(outbound_doorbell,
					&reg->outbound_doorbell_clear);
				writel(ARCMSR_HBCMU_DRV2IOP_DATA_READ_OK,
					&reg->inbound_doorbell);
			} else
				break;
		}
3603
		}
3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626
		break;
	case ACB_ADAPTER_TYPE_D: {
		struct MessageUnit_D *reg = acb->pmuD;
		uint32_t outbound_doorbell, i;
		/* empty doorbell Qbuffer if door bell ringed */
		outbound_doorbell = readl(reg->outbound_doorbell);
		writel(outbound_doorbell, reg->outbound_doorbell);
		writel(ARCMSR_ARC1214_DRV2IOP_DATA_OUT_READ,
			reg->inbound_doorbell);
		for (i = 0; i < 200; i++) {
			msleep(20);
			outbound_doorbell = readl(reg->outbound_doorbell);
			if (outbound_doorbell &
				ARCMSR_ARC1214_IOP2DRV_DATA_WRITE_OK) {
				writel(outbound_doorbell,
					reg->outbound_doorbell);
				writel(ARCMSR_ARC1214_DRV2IOP_DATA_OUT_READ,
					reg->inbound_doorbell);
			} else
				break;
		}
		}
		break;
3627
	}
3628
}
3629

3630 3631 3632 3633 3634 3635 3636 3637
static void arcmsr_enable_eoi_mode(struct AdapterControlBlock *acb)
{
	switch (acb->adapter_type) {
	case ACB_ADAPTER_TYPE_A:
		return;
	case ACB_ADAPTER_TYPE_B:
		{
			struct MessageUnit_B *reg = acb->pmuB;
3638
			writel(ARCMSR_MESSAGE_ACTIVE_EOI_MODE, reg->drv2iop_doorbell);
3639
			if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
3640 3641 3642 3643 3644
				printk(KERN_NOTICE "ARCMSR IOP enables EOI_MODE TIMEOUT");
				return;
			}
		}
		break;
3645 3646
	case ACB_ADAPTER_TYPE_C:
		return;
3647 3648 3649 3650
	}
	return;
}

3651 3652 3653
static void arcmsr_hardware_reset(struct AdapterControlBlock *acb)
{
	uint8_t value[64];
3654 3655 3656
	int i, count = 0;
	struct MessageUnit_A __iomem *pmuA = acb->pmuA;
	struct MessageUnit_C __iomem *pmuC = acb->pmuC;
3657
	struct MessageUnit_D *pmuD = acb->pmuD;
3658

3659
	/* backup pci config data */
3660
	printk(KERN_NOTICE "arcmsr%d: executing hw bus reset .....\n", acb->host->host_no);
3661 3662 3663 3664
	for (i = 0; i < 64; i++) {
		pci_read_config_byte(acb->pdev, i, &value[i]);
	}
	/* hardware reset signal */
3665
	if ((acb->dev_id == 0x1680)) {
3666 3667 3668 3669 3670 3671 3672 3673 3674 3675
		writel(ARCMSR_ARC1680_BUS_RESET, &pmuA->reserved1[0]);
	} else if ((acb->dev_id == 0x1880)) {
		do {
			count++;
			writel(0xF, &pmuC->write_sequence);
			writel(0x4, &pmuC->write_sequence);
			writel(0xB, &pmuC->write_sequence);
			writel(0x2, &pmuC->write_sequence);
			writel(0x7, &pmuC->write_sequence);
			writel(0xD, &pmuC->write_sequence);
3676
		} while (((readl(&pmuC->host_diagnostic) & ARCMSR_ARC1880_DiagWrite_ENABLE) == 0) && (count < 5));
3677
		writel(ARCMSR_ARC1880_RESET_ADAPTER, &pmuC->host_diagnostic);
3678 3679
	} else if ((acb->dev_id == 0x1214)) {
		writel(0x20, pmuD->reset_request);
3680
	} else {
3681
		pci_write_config_byte(acb->pdev, 0x84, 0x20);
3682
	}
3683
	msleep(2000);
3684 3685 3686 3687 3688 3689 3690
	/* write back pci config data */
	for (i = 0; i < 64; i++) {
		pci_write_config_byte(acb->pdev, i, value[i]);
	}
	msleep(1000);
	return;
}
3691 3692 3693
static void arcmsr_iop_init(struct AdapterControlBlock *acb)
{
	uint32_t intmask_org;
3694 3695
	/* disable all outbound interrupt */
	intmask_org = arcmsr_disable_outbound_ints(acb);
3696 3697
	arcmsr_wait_firmware_ready(acb);
	arcmsr_iop_confirm(acb);
3698 3699 3700 3701
	/*start background rebuild*/
	arcmsr_start_adapter_bgrb(acb);
	/* empty doorbell Qbuffer if door bell ringed */
	arcmsr_clear_doorbell_queue_buffer(acb);
3702
	arcmsr_enable_eoi_mode(acb);
3703 3704
	/* enable outbound Post Queue,outbound doorbell Interrupt */
	arcmsr_enable_outbound_ints(acb, intmask_org);
3705 3706 3707
	acb->acb_flags |= ACB_F_IOP_INITED;
}

3708
static uint8_t arcmsr_iop_reset(struct AdapterControlBlock *acb)
3709 3710 3711
{
	struct CommandControlBlock *ccb;
	uint32_t intmask_org;
3712
	uint8_t rtnval = 0x00;
3713
	int i = 0;
3714 3715
	unsigned long flags;

3716
	if (atomic_read(&acb->ccboutstandingcount) != 0) {
3717 3718
		/* disable all outbound interrupt */
		intmask_org = arcmsr_disable_outbound_ints(acb);
3719
		/* talk to iop 331 outstanding command aborted */
3720
		rtnval = arcmsr_abort_allcmd(acb);
3721
		/* clear all outbound posted Q */
3722
		arcmsr_done4abort_postqueue(acb);
3723 3724
		for (i = 0; i < ARCMSR_MAX_FREECCB_NUM; i++) {
			ccb = acb->pccb_pool[i];
3725
			if (ccb->startdone == ARCMSR_CCB_START) {
3726 3727 3728 3729 3730 3731
				scsi_dma_unmap(ccb->pcmd);
				ccb->startdone = ARCMSR_CCB_DONE;
				ccb->ccb_flags = 0;
				spin_lock_irqsave(&acb->ccblist_lock, flags);
				list_add_tail(&ccb->list, &acb->ccb_free_list);
				spin_unlock_irqrestore(&acb->ccblist_lock, flags);
3732 3733
			}
		}
3734
		atomic_set(&acb->ccboutstandingcount, 0);
3735 3736
		/* enable all outbound interrupt */
		arcmsr_enable_outbound_ints(acb, intmask_org);
3737
		return rtnval;
3738
	}
3739
	return rtnval;
3740 3741 3742 3743
}

static int arcmsr_bus_reset(struct scsi_cmnd *cmd)
{
3744
	struct AdapterControlBlock *acb;
3745 3746 3747 3748
	uint32_t intmask_org, outbound_doorbell;
	int retry_count = 0;
	int rtn = FAILED;
	acb = (struct AdapterControlBlock *) cmd->device->host->hostdata;
3749
	printk(KERN_ERR "arcmsr: executing bus reset eh.....num_resets = %d, num_aborts = %d \n", acb->num_resets, acb->num_aborts);
3750 3751
	acb->num_resets++;

3752 3753 3754
	switch(acb->adapter_type){
		case ACB_ADAPTER_TYPE_A:{
			if (acb->acb_flags & ACB_F_BUS_RESET){
3755
				long timeout;
3756 3757
				printk(KERN_ERR "arcmsr: there is an  bus reset eh proceeding.......\n");
				timeout = wait_event_timeout(wait_q, (acb->acb_flags & ACB_F_BUS_RESET) == 0, 220*HZ);
3758 3759 3760 3761 3762
				if (timeout) {
					return SUCCESS;
				}
			}
			acb->acb_flags |= ACB_F_BUS_RESET;
3763
			if (!arcmsr_iop_reset(acb)) {
3764 3765
				struct MessageUnit_A __iomem *reg;
				reg = acb->pmuA;
3766 3767
				arcmsr_hardware_reset(acb);
				acb->acb_flags &= ~ACB_F_IOP_INITED;
3768
sleep_again:
3769
				ssleep(ARCMSR_SLEEPTIME);
3770
				if ((readl(&reg->outbound_msgaddr1) & ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK) == 0) {
3771 3772
					printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d\n", acb->host->host_no, retry_count);
					if (retry_count > ARCMSR_RETRYCOUNT) {
3773
						acb->fw_flag = FW_DEADLOCK;
3774
						printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!!\n", acb->host->host_no);
3775
						return FAILED;
3776 3777 3778 3779 3780 3781 3782
					}
					retry_count++;
					goto sleep_again;
				}
				acb->acb_flags |= ACB_F_IOP_INITED;
				/* disable all outbound interrupt */
				intmask_org = arcmsr_disable_outbound_ints(acb);
3783
				arcmsr_get_firmware_spec(acb);
3784 3785 3786 3787 3788 3789 3790 3791
				arcmsr_start_adapter_bgrb(acb);
				/* clear Qbuffer if door bell ringed */
				outbound_doorbell = readl(&reg->outbound_doorbell);
				writel(outbound_doorbell, &reg->outbound_doorbell); /*clear interrupt */
   				writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK, &reg->inbound_doorbell);
				/* enable outbound Post Queue,outbound doorbell Interrupt */
				arcmsr_enable_outbound_ints(acb, intmask_org);
				atomic_set(&acb->rq_map_token, 16);
3792 3793
				atomic_set(&acb->ante_token_value, 16);
				acb->fw_flag = FW_NORMAL;
3794
				mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3795 3796
				acb->acb_flags &= ~ACB_F_BUS_RESET;
				rtn = SUCCESS;
3797
				printk(KERN_ERR "arcmsr: scsi  bus reset eh returns with success\n");
3798 3799
			} else {
				acb->acb_flags &= ~ACB_F_BUS_RESET;
3800 3801 3802 3803
				atomic_set(&acb->rq_map_token, 16);
				atomic_set(&acb->ante_token_value, 16);
				acb->fw_flag = FW_NORMAL;
				mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6*HZ));
3804
				rtn = SUCCESS;
3805
			}
3806
			break;
3807
		}
3808 3809
		case ACB_ADAPTER_TYPE_B:{
			acb->acb_flags |= ACB_F_BUS_RESET;
3810
			if (!arcmsr_iop_reset(acb)) {
3811 3812
				acb->acb_flags &= ~ACB_F_BUS_RESET;
				rtn = FAILED;
3813 3814
			} else {
				acb->acb_flags &= ~ACB_F_BUS_RESET;
3815 3816 3817 3818
				atomic_set(&acb->rq_map_token, 16);
				atomic_set(&acb->ante_token_value, 16);
				acb->fw_flag = FW_NORMAL;
				mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3819
				rtn = SUCCESS;
3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838
			}
			break;
		}
		case ACB_ADAPTER_TYPE_C:{
			if (acb->acb_flags & ACB_F_BUS_RESET) {
				long timeout;
				printk(KERN_ERR "arcmsr: there is an bus reset eh proceeding.......\n");
				timeout = wait_event_timeout(wait_q, (acb->acb_flags & ACB_F_BUS_RESET) == 0, 220*HZ);
				if (timeout) {
					return SUCCESS;
				}
			}
			acb->acb_flags |= ACB_F_BUS_RESET;
			if (!arcmsr_iop_reset(acb)) {
				struct MessageUnit_C __iomem *reg;
				reg = acb->pmuC;
				arcmsr_hardware_reset(acb);
				acb->acb_flags &= ~ACB_F_IOP_INITED;
sleep:
3839
				ssleep(ARCMSR_SLEEPTIME);
3840
				if ((readl(&reg->host_diagnostic) & 0x04) != 0) {
3841 3842
					printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, retry=%d\n", acb->host->host_no, retry_count);
					if (retry_count > ARCMSR_RETRYCOUNT) {
3843
						acb->fw_flag = FW_DEADLOCK;
3844
						printk(KERN_ERR "arcmsr%d: waiting for hw bus reset return, RETRY TERMINATED!!\n", acb->host->host_no);
3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855
						return FAILED;
					}
					retry_count++;
					goto sleep;
				}
				acb->acb_flags |= ACB_F_IOP_INITED;
				/* disable all outbound interrupt */
				intmask_org = arcmsr_disable_outbound_ints(acb);
				arcmsr_get_firmware_spec(acb);
				arcmsr_start_adapter_bgrb(acb);
				/* clear Qbuffer if door bell ringed */
3856
				arcmsr_clear_doorbell_queue_buffer(acb);
3857 3858 3859 3860 3861
				/* enable outbound Post Queue,outbound doorbell Interrupt */
				arcmsr_enable_outbound_ints(acb, intmask_org);
				atomic_set(&acb->rq_map_token, 16);
				atomic_set(&acb->ante_token_value, 16);
				acb->fw_flag = FW_NORMAL;
3862
				mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
3863 3864 3865 3866 3867
				acb->acb_flags &= ~ACB_F_BUS_RESET;
				rtn = SUCCESS;
				printk(KERN_ERR "arcmsr: scsi bus reset eh returns with success\n");
			} else {
				acb->acb_flags &= ~ACB_F_BUS_RESET;
3868 3869 3870 3871
				atomic_set(&acb->rq_map_token, 16);
				atomic_set(&acb->ante_token_value, 16);
				acb->fw_flag = FW_NORMAL;
				mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6*HZ));
3872 3873 3874
				rtn = SUCCESS;
			}
			break;
3875
		}
3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935
		case ACB_ADAPTER_TYPE_D: {
			if (acb->acb_flags & ACB_F_BUS_RESET) {
				long timeout;
				pr_notice("arcmsr: there is an bus reset"
					" eh proceeding.......\n");
				timeout = wait_event_timeout(wait_q, (acb->acb_flags
					& ACB_F_BUS_RESET) == 0, 220 * HZ);
				if (timeout)
					return SUCCESS;
			}
			acb->acb_flags |= ACB_F_BUS_RESET;
			if (!arcmsr_iop_reset(acb)) {
				struct MessageUnit_D *reg;
				reg = acb->pmuD;
				arcmsr_hardware_reset(acb);
				acb->acb_flags &= ~ACB_F_IOP_INITED;
			nap:
				ssleep(ARCMSR_SLEEPTIME);
				if ((readl(reg->sample_at_reset) & 0x80) != 0) {
					pr_err("arcmsr%d: waiting for "
						"hw bus reset return, retry=%d\n",
						acb->host->host_no, retry_count);
					if (retry_count > ARCMSR_RETRYCOUNT) {
						acb->fw_flag = FW_DEADLOCK;
						pr_err("arcmsr%d: waiting for hw bus"
							" reset return, "
							"RETRY TERMINATED!!\n",
							acb->host->host_no);
						return FAILED;
					}
					retry_count++;
					goto nap;
				}
				acb->acb_flags |= ACB_F_IOP_INITED;
				/* disable all outbound interrupt */
				intmask_org = arcmsr_disable_outbound_ints(acb);
				arcmsr_get_firmware_spec(acb);
				arcmsr_start_adapter_bgrb(acb);
				arcmsr_clear_doorbell_queue_buffer(acb);
				arcmsr_enable_outbound_ints(acb, intmask_org);
				atomic_set(&acb->rq_map_token, 16);
				atomic_set(&acb->ante_token_value, 16);
				acb->fw_flag = FW_NORMAL;
				mod_timer(&acb->eternal_timer,
					jiffies + msecs_to_jiffies(6 * HZ));
				acb->acb_flags &= ~ACB_F_BUS_RESET;
				rtn = SUCCESS;
				pr_err("arcmsr: scsi bus reset "
					"eh returns with success\n");
			} else {
				acb->acb_flags &= ~ACB_F_BUS_RESET;
				atomic_set(&acb->rq_map_token, 16);
				atomic_set(&acb->ante_token_value, 16);
				acb->fw_flag = FW_NORMAL;
				mod_timer(&acb->eternal_timer,
					jiffies + msecs_to_jiffies(6 * HZ));
				rtn = SUCCESS;
			}
			break;
		}
3936 3937
	}
	return rtn;
3938 3939
}

3940
static int arcmsr_abort_one_cmd(struct AdapterControlBlock *acb,
3941 3942
		struct CommandControlBlock *ccb)
{
3943 3944 3945
	int rtn;
	rtn = arcmsr_polling_ccbdone(acb, ccb);
	return rtn;
3946 3947 3948 3949 3950 3951 3952
}

static int arcmsr_abort(struct scsi_cmnd *cmd)
{
	struct AdapterControlBlock *acb =
		(struct AdapterControlBlock *)cmd->device->host->hostdata;
	int i = 0;
3953
	int rtn = FAILED;
3954 3955
	uint32_t intmask_org;

3956
	printk(KERN_NOTICE
3957
		"arcmsr%d: abort device command of scsi id = %d lun = %d\n",
Hannes Reinecke's avatar
Hannes Reinecke committed
3958
		acb->host->host_no, cmd->device->id, (u32)cmd->device->lun);
3959
	acb->acb_flags |= ACB_F_ABORT;
3960 3961 3962 3963 3964 3965 3966
	acb->num_aborts++;
	/*
	************************************************
	** the all interrupt service routine is locked
	** we need to handle it as soon as possible and exit
	************************************************
	*/
3967 3968
	if (!atomic_read(&acb->ccboutstandingcount)) {
		acb->acb_flags &= ~ACB_F_ABORT;
3969
		return rtn;
3970
	}
3971

3972
	intmask_org = arcmsr_disable_outbound_ints(acb);
3973 3974 3975
	for (i = 0; i < ARCMSR_MAX_FREECCB_NUM; i++) {
		struct CommandControlBlock *ccb = acb->pccb_pool[i];
		if (ccb->startdone == ARCMSR_CCB_START && ccb->pcmd == cmd) {
3976 3977
			ccb->startdone = ARCMSR_CCB_ABORTED;
			rtn = arcmsr_abort_one_cmd(acb, ccb);
3978 3979 3980
			break;
		}
	}
3981
	acb->acb_flags &= ~ACB_F_ABORT;
3982
	arcmsr_enable_outbound_ints(acb, intmask_org);
3983
	return rtn;
3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994
}

static const char *arcmsr_info(struct Scsi_Host *host)
{
	struct AdapterControlBlock *acb =
		(struct AdapterControlBlock *) host->hostdata;
	static char buf[256];
	char *type;
	int raid6 = 1;
	switch (acb->pdev->device) {
	case PCI_DEVICE_ID_ARECA_1110:
3995 3996
	case PCI_DEVICE_ID_ARECA_1200:
	case PCI_DEVICE_ID_ARECA_1202:
3997 3998 3999 4000 4001 4002 4003
	case PCI_DEVICE_ID_ARECA_1210:
		raid6 = 0;
		/*FALLTHRU*/
	case PCI_DEVICE_ID_ARECA_1120:
	case PCI_DEVICE_ID_ARECA_1130:
	case PCI_DEVICE_ID_ARECA_1160:
	case PCI_DEVICE_ID_ARECA_1170:
4004
	case PCI_DEVICE_ID_ARECA_1201:
4005 4006 4007 4008 4009 4010 4011
	case PCI_DEVICE_ID_ARECA_1220:
	case PCI_DEVICE_ID_ARECA_1230:
	case PCI_DEVICE_ID_ARECA_1260:
	case PCI_DEVICE_ID_ARECA_1270:
	case PCI_DEVICE_ID_ARECA_1280:
		type = "SATA";
		break;
4012
	case PCI_DEVICE_ID_ARECA_1214:
4013 4014 4015 4016
	case PCI_DEVICE_ID_ARECA_1380:
	case PCI_DEVICE_ID_ARECA_1381:
	case PCI_DEVICE_ID_ARECA_1680:
	case PCI_DEVICE_ID_ARECA_1681:
4017
	case PCI_DEVICE_ID_ARECA_1880:
4018
		type = "SAS/SATA";
4019 4020
		break;
	default:
4021 4022
		type = "unknown";
		raid6 =	0;
4023 4024
		break;
	}
4025 4026
	sprintf(buf, "Areca %s RAID Controller %s\narcmsr version %s\n",
		type, raid6 ? "(RAID6 capable)" : "", ARCMSR_DRIVER_VERSION);
4027 4028
	return buf;
}