2006-07-12 15:59:32 +00:00
|
|
|
/*
|
|
|
|
*******************************************************************************
|
|
|
|
** O.S : Linux
|
|
|
|
** FILE NAME : arcmsr_hba.c
|
2014-08-19 07:22:45 +00:00
|
|
|
** BY : Nick Cheng, C.L. Huang
|
|
|
|
** Description: SCSI RAID Device Driver for Areca RAID Controller
|
2006-07-12 15:59:32 +00:00
|
|
|
*******************************************************************************
|
2014-08-19 07:22:45 +00:00
|
|
|
** Copyright (C) 2002 - 2014, Areca Technology Corporation All rights reserved
|
2006-07-12 15:59:32 +00:00
|
|
|
**
|
|
|
|
** Web site: www.areca.com.tw
|
2007-09-13 09:26:40 +00:00
|
|
|
** E-mail: support@areca.com.tw
|
2006-07-12 15:59:32 +00:00
|
|
|
**
|
|
|
|
** 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
|
2020-03-02 08:16:15 +00:00
|
|
|
** Firmware Specification, see Documentation/scsi/arcmsr_spec.rst
|
2006-07-12 15:59:32 +00:00
|
|
|
*******************************************************************************
|
|
|
|
*/
|
|
|
|
#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>
|
2010-08-17 04:20:07 +00:00
|
|
|
#include <linux/slab.h>
|
2006-07-12 15:59:32 +00:00
|
|
|
#include <linux/pci.h>
|
2007-06-15 03:43:32 +00:00
|
|
|
#include <linux/aer.h>
|
2014-09-24 09:33:34 +00:00
|
|
|
#include <linux/circ_buf.h>
|
2006-07-12 15:59:32 +00:00
|
|
|
#include <asm/dma.h>
|
|
|
|
#include <asm/io.h>
|
2016-12-24 19:46:01 +00:00
|
|
|
#include <linux/uaccess.h>
|
2006-07-12 15:59:32 +00:00
|
|
|
#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"
|
2014-08-19 07:22:45 +00:00
|
|
|
MODULE_AUTHOR("Nick Cheng, C.L. Huang <support@areca.com.tw>");
|
|
|
|
MODULE_DESCRIPTION("Areca ARC11xx/12xx/16xx/188x SAS/SATA RAID Controller Driver");
|
2006-07-12 15:59:32 +00:00
|
|
|
MODULE_LICENSE("Dual BSD/GPL");
|
|
|
|
MODULE_VERSION(ARCMSR_DRIVER_VERSION);
|
2011-04-29 14:28:24 +00:00
|
|
|
|
2017-12-05 02:26:38 +00:00
|
|
|
static int msix_enable = 1;
|
|
|
|
module_param(msix_enable, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(msix_enable, "Enable MSI-X interrupt(0 ~ 1), msix_enable=1(enable), =0(disable)");
|
|
|
|
|
2017-12-05 02:24:01 +00:00
|
|
|
static int msi_enable = 1;
|
|
|
|
module_param(msi_enable, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(msi_enable, "Enable MSI interrupt(0 ~ 1), msi_enable=1(enable), =0(disable)");
|
|
|
|
|
2017-12-05 01:47:44 +00:00
|
|
|
static int host_can_queue = ARCMSR_DEFAULT_OUTSTANDING_CMD;
|
|
|
|
module_param(host_can_queue, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(host_can_queue, " adapter queue depth(32 ~ 1024), default is 128");
|
|
|
|
|
2017-12-05 01:55:02 +00:00
|
|
|
static int cmd_per_lun = ARCMSR_DEFAULT_CMD_PERLUN;
|
|
|
|
module_param(cmd_per_lun, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(cmd_per_lun, " device queue depth(1 ~ 128), default is 32");
|
|
|
|
|
2018-12-19 08:53:44 +00:00
|
|
|
static int dma_mask_64 = 0;
|
|
|
|
module_param(dma_mask_64, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(dma_mask_64, " set DMA mask to 64 bits(0 ~ 1), dma_mask_64=1(64 bits), =0(32 bits)");
|
|
|
|
|
2017-12-05 01:59:52 +00:00
|
|
|
static int set_date_time = 0;
|
|
|
|
module_param(set_date_time, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(set_date_time, " send date, time to iop(0 ~ 1), set_date_time=1(enable), default(=0) is disable");
|
|
|
|
|
2020-10-27 03:31:31 +00:00
|
|
|
static int cmd_timeout = ARCMSR_DEFAULT_TIMEOUT;
|
|
|
|
module_param(cmd_timeout, int, S_IRUGO);
|
|
|
|
MODULE_PARM_DESC(cmd_timeout, " scsi cmd timeout(0 ~ 120 sec.), default is 90");
|
|
|
|
|
2011-04-29 14:28:24 +00:00
|
|
|
#define ARCMSR_SLEEPTIME 10
|
|
|
|
#define ARCMSR_RETRYCOUNT 12
|
|
|
|
|
2014-08-19 07:20:31 +00:00
|
|
|
static wait_queue_head_t wait_q;
|
2007-09-13 09:26:40 +00:00
|
|
|
static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb,
|
|
|
|
struct scsi_cmnd *cmd);
|
|
|
|
static int arcmsr_iop_confirm(struct AdapterControlBlock *acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
static int arcmsr_abort(struct scsi_cmnd *);
|
|
|
|
static int arcmsr_bus_reset(struct scsi_cmnd *);
|
|
|
|
static int arcmsr_bios_param(struct scsi_device *sdev,
|
2007-09-13 09:26:40 +00:00
|
|
|
struct block_device *bdev, sector_t capacity, int *info);
|
2010-11-16 07:10:29 +00:00
|
|
|
static int arcmsr_queue_command(struct Scsi_Host *h, struct scsi_cmnd *cmd);
|
2006-07-12 15:59:32 +00:00
|
|
|
static int arcmsr_probe(struct pci_dev *pdev,
|
|
|
|
const struct pci_device_id *id);
|
2020-11-02 16:47:10 +00:00
|
|
|
static int __maybe_unused arcmsr_suspend(struct device *dev);
|
|
|
|
static int __maybe_unused arcmsr_resume(struct device *dev);
|
2006-07-12 15:59:32 +00:00
|
|
|
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);
|
2007-09-13 09:26:40 +00:00
|
|
|
static u32 arcmsr_disable_outbound_ints(struct AdapterControlBlock *acb);
|
2014-08-19 06:26:09 +00:00
|
|
|
static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb,
|
|
|
|
u32 intmask_org);
|
2006-07-12 15:59:32 +00:00
|
|
|
static void arcmsr_stop_adapter_bgrb(struct AdapterControlBlock *acb);
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaA_flush_cache(struct AdapterControlBlock *acb);
|
|
|
|
static void arcmsr_hbaB_flush_cache(struct AdapterControlBlock *acb);
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-16 21:43:17 +00:00
|
|
|
static void arcmsr_request_device_map(struct timer_list *t);
|
2010-05-17 03:22:42 +00:00
|
|
|
static void arcmsr_message_isr_bh_fn(struct work_struct *work);
|
2010-06-18 07:39:12 +00:00
|
|
|
static bool arcmsr_get_firmware_spec(struct AdapterControlBlock *acb);
|
2010-05-17 03:22:42 +00:00
|
|
|
static void arcmsr_start_adapter_bgrb(struct AdapterControlBlock *acb);
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaC_message_isr(struct AdapterControlBlock *pACB);
|
2014-08-19 07:25:22 +00:00
|
|
|
static void arcmsr_hbaD_message_isr(struct AdapterControlBlock *acb);
|
2017-12-05 01:35:34 +00:00
|
|
|
static void arcmsr_hbaE_message_isr(struct AdapterControlBlock *acb);
|
|
|
|
static void arcmsr_hbaE_postqueue_isr(struct AdapterControlBlock *acb);
|
2020-09-28 10:35:05 +00:00
|
|
|
static void arcmsr_hbaF_postqueue_isr(struct AdapterControlBlock *acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
static void arcmsr_hardware_reset(struct AdapterControlBlock *acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
static const char *arcmsr_info(struct Scsi_Host *);
|
|
|
|
static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb);
|
2014-08-19 07:28:36 +00:00
|
|
|
static void arcmsr_free_irq(struct pci_dev *, struct AdapterControlBlock *);
|
2015-11-25 11:49:33 +00:00
|
|
|
static void arcmsr_wait_firmware_ready(struct AdapterControlBlock *acb);
|
2017-12-05 01:59:52 +00:00
|
|
|
static void arcmsr_set_iop_datetime(struct timer_list *);
|
2020-10-27 03:31:31 +00:00
|
|
|
static int arcmsr_slave_config(struct scsi_device *sdev);
|
2014-11-13 14:08:42 +00:00
|
|
|
static int arcmsr_adjust_disk_queue_depth(struct scsi_device *sdev, int queue_depth)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
|
|
|
if (queue_depth > ARCMSR_MAX_CMD_PERLUN)
|
|
|
|
queue_depth = ARCMSR_MAX_CMD_PERLUN;
|
2014-11-13 14:08:42 +00:00
|
|
|
return scsi_change_queue_depth(sdev, queue_depth);
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct scsi_host_template arcmsr_scsi_host_template = {
|
|
|
|
.module = THIS_MODULE,
|
2014-08-19 07:22:45 +00:00
|
|
|
.name = "Areca SAS/SATA RAID driver",
|
2006-07-12 15:59:32 +00:00
|
|
|
.info = arcmsr_info,
|
|
|
|
.queuecommand = arcmsr_queue_command,
|
2017-12-05 02:16:13 +00:00
|
|
|
.eh_abort_handler = arcmsr_abort,
|
2006-07-12 15:59:32 +00:00
|
|
|
.eh_bus_reset_handler = arcmsr_bus_reset,
|
|
|
|
.bios_param = arcmsr_bios_param,
|
2020-10-27 03:31:31 +00:00
|
|
|
.slave_configure = arcmsr_slave_config,
|
2006-07-12 15:59:32 +00:00
|
|
|
.change_queue_depth = arcmsr_adjust_disk_queue_depth,
|
2017-12-05 01:47:44 +00:00
|
|
|
.can_queue = ARCMSR_DEFAULT_OUTSTANDING_CMD,
|
2017-12-05 02:16:13 +00:00
|
|
|
.this_id = ARCMSR_SCSI_INITIATOR_ID,
|
|
|
|
.sg_tablesize = ARCMSR_DEFAULT_SG_ENTRIES,
|
|
|
|
.max_sectors = ARCMSR_MAX_XFER_SECTORS_C,
|
2017-12-05 01:55:02 +00:00
|
|
|
.cmd_per_lun = ARCMSR_DEFAULT_CMD_PERLUN,
|
2006-07-12 15:59:32 +00:00
|
|
|
.shost_attrs = arcmsr_host_attrs,
|
2013-10-23 10:25:40 +00:00
|
|
|
.no_write_same = 1,
|
2006-07-12 15:59:32 +00:00
|
|
|
};
|
2014-08-19 06:55:57 +00:00
|
|
|
|
2006-07-12 15:59:32 +00:00
|
|
|
static struct pci_device_id arcmsr_device_id_table[] = {
|
2014-08-19 06:55:57 +00:00
|
|
|
{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},
|
2015-11-25 11:49:33 +00:00
|
|
|
{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1203),
|
|
|
|
.driver_data = ACB_ADAPTER_TYPE_B},
|
2014-08-19 06:55:57 +00:00
|
|
|
{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1210),
|
|
|
|
.driver_data = ACB_ADAPTER_TYPE_A},
|
2014-08-19 07:25:22 +00:00
|
|
|
{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1214),
|
|
|
|
.driver_data = ACB_ADAPTER_TYPE_D},
|
2014-08-19 06:55:57 +00:00
|
|
|
{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},
|
2017-12-05 01:35:34 +00:00
|
|
|
{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1884),
|
|
|
|
.driver_data = ACB_ADAPTER_TYPE_E},
|
2020-09-28 10:35:05 +00:00
|
|
|
{PCI_DEVICE(PCI_VENDOR_ID_ARECA, PCI_DEVICE_ID_ARECA_1886),
|
|
|
|
.driver_data = ACB_ADAPTER_TYPE_F},
|
2006-07-12 15:59:32 +00:00
|
|
|
{0, 0}, /* Terminating entry */
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(pci, arcmsr_device_id_table);
|
2014-08-19 06:55:57 +00:00
|
|
|
|
2020-11-02 16:47:10 +00:00
|
|
|
static SIMPLE_DEV_PM_OPS(arcmsr_pm_ops, arcmsr_suspend, arcmsr_resume);
|
|
|
|
|
2006-07-12 15:59:32 +00:00
|
|
|
static struct pci_driver arcmsr_pci_driver = {
|
|
|
|
.name = "arcmsr",
|
2017-12-05 02:16:13 +00:00
|
|
|
.id_table = arcmsr_device_id_table,
|
2006-07-12 15:59:32 +00:00
|
|
|
.probe = arcmsr_probe,
|
|
|
|
.remove = arcmsr_remove,
|
2020-11-02 16:47:10 +00:00
|
|
|
.driver.pm = &arcmsr_pm_ops,
|
2007-06-15 03:43:32 +00:00
|
|
|
.shutdown = arcmsr_shutdown,
|
2006-07-12 15:59:32 +00:00
|
|
|
};
|
2010-07-13 12:03:04 +00:00
|
|
|
/*
|
|
|
|
****************************************************************************
|
|
|
|
****************************************************************************
|
|
|
|
*/
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2018-12-19 08:27:20 +00:00
|
|
|
static void arcmsr_free_io_queue(struct AdapterControlBlock *acb)
|
2010-06-18 07:39:12 +00:00
|
|
|
{
|
|
|
|
switch (acb->adapter_type) {
|
2014-08-19 07:25:22 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_D:
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
case ACB_ADAPTER_TYPE_F:
|
2018-12-19 08:24:03 +00:00
|
|
|
dma_free_coherent(&acb->pdev->dev, acb->ioqueue_size,
|
2014-08-19 07:14:14 +00:00
|
|
|
acb->dma_coherent2, acb->dma_coherent_handle2);
|
|
|
|
break;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool arcmsr_remap_pciregion(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
struct pci_dev *pdev = acb->pdev;
|
2010-07-13 12:03:04 +00:00
|
|
|
switch (acb->adapter_type){
|
2010-06-18 07:39:12 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A:{
|
2010-07-13 12:03:04 +00:00
|
|
|
acb->pmuA = ioremap(pci_resource_start(pdev,0), pci_resource_len(pdev,0));
|
2010-06-18 07:39:12 +00:00
|
|
|
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;
|
2010-07-13 12:03:04 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_C:{
|
2020-01-06 08:43:50 +00:00
|
|
|
acb->pmuC = ioremap(pci_resource_start(pdev, 1), pci_resource_len(pdev, 1));
|
2010-07-13 12:03:04 +00:00
|
|
|
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;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
void __iomem *mem_base0;
|
2020-07-13 07:46:30 +00:00
|
|
|
unsigned long addr, range;
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
addr = (unsigned long)pci_resource_start(pdev, 0);
|
|
|
|
range = pci_resource_len(pdev, 0);
|
2015-08-11 03:07:06 +00:00
|
|
|
mem_base0 = ioremap(addr, range);
|
2014-08-19 07:25:22 +00:00
|
|
|
if (!mem_base0) {
|
|
|
|
pr_notice("arcmsr%d: memory mapping region fail\n",
|
|
|
|
acb->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
acb->mem_base0 = mem_base0;
|
|
|
|
break;
|
|
|
|
}
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
acb->pmuE = ioremap(pci_resource_start(pdev, 1),
|
|
|
|
pci_resource_len(pdev, 1));
|
|
|
|
if (!acb->pmuE) {
|
|
|
|
pr_notice("arcmsr%d: memory mapping region fail \n",
|
|
|
|
acb->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
writel(0, &acb->pmuE->host_int_status); /*clear interrupt*/
|
|
|
|
writel(ARCMSR_HBEMU_DOORBELL_SYNC, &acb->pmuE->iobound_doorbell); /* synchronize doorbell to 0 */
|
|
|
|
acb->in_doorbell = 0;
|
|
|
|
acb->out_doorbell = 0;
|
|
|
|
break;
|
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
|
|
|
acb->pmuF = ioremap(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
|
|
|
|
if (!acb->pmuF) {
|
|
|
|
pr_notice("arcmsr%d: memory mapping region fail\n",
|
|
|
|
acb->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
writel(0, &acb->pmuF->host_int_status); /* clear interrupt */
|
|
|
|
writel(ARCMSR_HBFMU_DOORBELL_SYNC, &acb->pmuF->iobound_doorbell);
|
|
|
|
acb->in_doorbell = 0;
|
|
|
|
acb->out_doorbell = 0;
|
|
|
|
break;
|
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void arcmsr_unmap_pciregion(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
switch (acb->adapter_type) {
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A:
|
2010-07-13 12:03:04 +00:00
|
|
|
iounmap(acb->pmuA);
|
2020-09-28 10:45:32 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2010-07-13 12:03:04 +00:00
|
|
|
iounmap(acb->mem_base0);
|
|
|
|
iounmap(acb->mem_base1);
|
2020-09-28 10:45:32 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_C:
|
2010-07-13 12:03:04 +00:00
|
|
|
iounmap(acb->pmuC);
|
2020-09-28 10:45:32 +00:00
|
|
|
break;
|
2014-08-19 07:25:22 +00:00
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
iounmap(acb->mem_base0);
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
iounmap(acb->pmuE);
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
|
|
|
iounmap(acb->pmuF);
|
|
|
|
break;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
static irqreturn_t arcmsr_do_interrupt(int irq, void *dev_id)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
|
|
|
irqreturn_t handle_state;
|
2007-09-13 09:26:40 +00:00
|
|
|
struct AdapterControlBlock *acb = dev_id;
|
2006-07-12 15:59:32 +00:00
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2020-03-24 07:25:17 +00:00
|
|
|
int heads, sectors, cylinders, total_capacity;
|
|
|
|
|
|
|
|
if (scsi_partsize(bdev, capacity, geom))
|
|
|
|
return 0;
|
2006-07-12 15:59:32 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static uint8_t arcmsr_hbaA_wait_msgint_ready(struct AdapterControlBlock *acb)
|
2010-06-18 07:39:12 +00:00
|
|
|
{
|
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2011-04-29 14:28:24 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 2000; i++) {
|
|
|
|
if (readl(®->outbound_intstatus) &
|
|
|
|
ARCMSR_MU_OUTBOUND_MESSAGE0_INT) {
|
|
|
|
writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT,
|
|
|
|
®->outbound_intstatus);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
msleep(10);
|
|
|
|
} /* max 20 seconds */
|
2010-06-18 07:39:12 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
return false;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static uint8_t arcmsr_hbaB_wait_msgint_ready(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2010-06-18 07:39:12 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2011-04-29 14:28:24 +00:00
|
|
|
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 */
|
2010-06-18 07:39:12 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
return false;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static uint8_t arcmsr_hbaC_wait_msgint_ready(struct AdapterControlBlock *pACB)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *phbcmu = pACB->pmuC;
|
2011-04-29 14:28:24 +00:00
|
|
|
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 */
|
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
return false;
|
|
|
|
}
|
2011-04-29 14:28:24 +00:00
|
|
|
|
2014-08-19 07:25:22 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static bool arcmsr_hbaE_wait_msgint_ready(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
uint32_t read_doorbell;
|
|
|
|
struct MessageUnit_E __iomem *phbcmu = pACB->pmuE;
|
|
|
|
|
|
|
|
for (i = 0; i < 2000; i++) {
|
|
|
|
read_doorbell = readl(&phbcmu->iobound_doorbell);
|
|
|
|
if ((read_doorbell ^ pACB->in_doorbell) & ARCMSR_HBEMU_IOP2DRV_MESSAGE_CMD_DONE) {
|
|
|
|
writel(0, &phbcmu->host_int_status); /*clear interrupt*/
|
|
|
|
pACB->in_doorbell = read_doorbell;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
msleep(10);
|
|
|
|
} /* max 20 seconds */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaA_flush_cache(struct AdapterControlBlock *acb)
|
2010-06-18 07:39:12 +00:00
|
|
|
{
|
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
|
|
|
int retry_count = 30;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_FLUSH_CACHE, ®->inbound_msgaddr0);
|
|
|
|
do {
|
2014-08-19 07:10:12 +00:00
|
|
|
if (arcmsr_hbaA_wait_msgint_ready(acb))
|
2010-06-18 07:39:12 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaB_flush_cache(struct AdapterControlBlock *acb)
|
2010-06-18 07:39:12 +00:00
|
|
|
{
|
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
|
|
|
int retry_count = 30;
|
|
|
|
writel(ARCMSR_MESSAGE_FLUSH_CACHE, reg->drv2iop_doorbell);
|
|
|
|
do {
|
2014-08-19 07:10:12 +00:00
|
|
|
if (arcmsr_hbaB_wait_msgint_ready(acb))
|
2010-06-18 07:39:12 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaC_flush_cache(struct AdapterControlBlock *pACB)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = pACB->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
int retry_count = 30;/* enlarge wait flush adapter cache time: 10 minute */
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_FLUSH_CACHE, ®->inbound_msgaddr0);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, ®->inbound_doorbell);
|
|
|
|
do {
|
2014-08-19 07:10:12 +00:00
|
|
|
if (arcmsr_hbaC_wait_msgint_ready(pACB)) {
|
2010-07-13 12:03:04 +00:00
|
|
|
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;
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static void arcmsr_hbaE_flush_cache(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
int retry_count = 30;
|
|
|
|
struct MessageUnit_E __iomem *reg = pACB->pmuE;
|
|
|
|
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_FLUSH_CACHE, ®->inbound_msgaddr0);
|
|
|
|
pACB->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(pACB->out_doorbell, ®->iobound_doorbell);
|
|
|
|
do {
|
|
|
|
if (arcmsr_hbaE_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);
|
|
|
|
}
|
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
static void arcmsr_flush_adapter_cache(struct AdapterControlBlock *acb)
|
|
|
|
{
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaA_flush_cache(acb);
|
2010-06-18 07:39:12 +00:00
|
|
|
break;
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaB_flush_cache(acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
break;
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaC_flush_cache(acb);
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
arcmsr_hbaD_flush_cache(acb);
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
2017-12-05 01:35:34 +00:00
|
|
|
arcmsr_hbaE_flush_cache(acb);
|
|
|
|
break;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2018-12-19 08:31:00 +00:00
|
|
|
static void arcmsr_hbaB_assign_regAddr(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
|
|
|
|
|
|
|
if (acb->pdev->device == PCI_DEVICE_ID_ARECA_1203) {
|
|
|
|
reg->drv2iop_doorbell = MEM_BASE0(ARCMSR_DRV2IOP_DOORBELL_1203);
|
|
|
|
reg->drv2iop_doorbell_mask = MEM_BASE0(ARCMSR_DRV2IOP_DOORBELL_MASK_1203);
|
|
|
|
reg->iop2drv_doorbell = MEM_BASE0(ARCMSR_IOP2DRV_DOORBELL_1203);
|
|
|
|
reg->iop2drv_doorbell_mask = MEM_BASE0(ARCMSR_IOP2DRV_DOORBELL_MASK_1203);
|
|
|
|
} else {
|
|
|
|
reg->drv2iop_doorbell= MEM_BASE0(ARCMSR_DRV2IOP_DOORBELL);
|
|
|
|
reg->drv2iop_doorbell_mask = MEM_BASE0(ARCMSR_DRV2IOP_DOORBELL_MASK);
|
|
|
|
reg->iop2drv_doorbell = MEM_BASE0(ARCMSR_IOP2DRV_DOORBELL);
|
|
|
|
reg->iop2drv_doorbell_mask = MEM_BASE0(ARCMSR_IOP2DRV_DOORBELL_MASK);
|
|
|
|
}
|
|
|
|
reg->message_wbuffer = MEM_BASE1(ARCMSR_MESSAGE_WBUFFER);
|
|
|
|
reg->message_rbuffer = MEM_BASE1(ARCMSR_MESSAGE_RBUFFER);
|
|
|
|
reg->message_rwbuffer = MEM_BASE1(ARCMSR_MESSAGE_RWBUFFER);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void arcmsr_hbaD_assign_regAddr(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
|
|
|
|
reg->chip_id = MEM_BASE0(ARCMSR_ARC1214_CHIP_ID);
|
|
|
|
reg->cpu_mem_config = MEM_BASE0(ARCMSR_ARC1214_CPU_MEMORY_CONFIGURATION);
|
|
|
|
reg->i2o_host_interrupt_mask = MEM_BASE0(ARCMSR_ARC1214_I2_HOST_INTERRUPT_MASK);
|
|
|
|
reg->sample_at_reset = MEM_BASE0(ARCMSR_ARC1214_SAMPLE_RESET);
|
|
|
|
reg->reset_request = MEM_BASE0(ARCMSR_ARC1214_RESET_REQUEST);
|
|
|
|
reg->host_int_status = MEM_BASE0(ARCMSR_ARC1214_MAIN_INTERRUPT_STATUS);
|
|
|
|
reg->pcief0_int_enable = MEM_BASE0(ARCMSR_ARC1214_PCIE_F0_INTERRUPT_ENABLE);
|
|
|
|
reg->inbound_msgaddr0 = MEM_BASE0(ARCMSR_ARC1214_INBOUND_MESSAGE0);
|
|
|
|
reg->inbound_msgaddr1 = MEM_BASE0(ARCMSR_ARC1214_INBOUND_MESSAGE1);
|
|
|
|
reg->outbound_msgaddr0 = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_MESSAGE0);
|
|
|
|
reg->outbound_msgaddr1 = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_MESSAGE1);
|
|
|
|
reg->inbound_doorbell = MEM_BASE0(ARCMSR_ARC1214_INBOUND_DOORBELL);
|
|
|
|
reg->outbound_doorbell = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_DOORBELL);
|
|
|
|
reg->outbound_doorbell_enable = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_DOORBELL_ENABLE);
|
|
|
|
reg->inboundlist_base_low = MEM_BASE0(ARCMSR_ARC1214_INBOUND_LIST_BASE_LOW);
|
|
|
|
reg->inboundlist_base_high = MEM_BASE0(ARCMSR_ARC1214_INBOUND_LIST_BASE_HIGH);
|
|
|
|
reg->inboundlist_write_pointer = MEM_BASE0(ARCMSR_ARC1214_INBOUND_LIST_WRITE_POINTER);
|
|
|
|
reg->outboundlist_base_low = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_LIST_BASE_LOW);
|
|
|
|
reg->outboundlist_base_high = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_LIST_BASE_HIGH);
|
|
|
|
reg->outboundlist_copy_pointer = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_LIST_COPY_POINTER);
|
|
|
|
reg->outboundlist_read_pointer = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_LIST_READ_POINTER);
|
|
|
|
reg->outboundlist_interrupt_cause = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_INTERRUPT_CAUSE);
|
|
|
|
reg->outboundlist_interrupt_enable = MEM_BASE0(ARCMSR_ARC1214_OUTBOUND_INTERRUPT_ENABLE);
|
|
|
|
reg->message_wbuffer = MEM_BASE0(ARCMSR_ARC1214_MESSAGE_WBUFFER);
|
|
|
|
reg->message_rbuffer = MEM_BASE0(ARCMSR_ARC1214_MESSAGE_RBUFFER);
|
|
|
|
reg->msgcode_rwbuffer = MEM_BASE0(ARCMSR_ARC1214_MESSAGE_RWBUFFER);
|
|
|
|
}
|
|
|
|
|
2020-09-28 10:35:05 +00:00
|
|
|
static void arcmsr_hbaF_assign_regAddr(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
dma_addr_t host_buffer_dma;
|
|
|
|
struct MessageUnit_F __iomem *pmuF;
|
|
|
|
|
|
|
|
memset(acb->dma_coherent2, 0xff, acb->completeQ_size);
|
|
|
|
acb->message_wbuffer = (uint32_t *)round_up((unsigned long)acb->dma_coherent2 +
|
|
|
|
acb->completeQ_size, 4);
|
|
|
|
acb->message_rbuffer = ((void *)acb->message_wbuffer) + 0x100;
|
|
|
|
acb->msgcode_rwbuffer = ((void *)acb->message_wbuffer) + 0x200;
|
|
|
|
memset((void *)acb->message_wbuffer, 0, MESG_RW_BUFFER_SIZE);
|
|
|
|
host_buffer_dma = round_up(acb->dma_coherent_handle2 + acb->completeQ_size, 4);
|
|
|
|
pmuF = acb->pmuF;
|
|
|
|
/* host buffer low address, bit0:1 all buffer active */
|
|
|
|
writel(lower_32_bits(host_buffer_dma | 1), &pmuF->inbound_msgaddr0);
|
|
|
|
/* host buffer high address */
|
|
|
|
writel(upper_32_bits(host_buffer_dma), &pmuF->inbound_msgaddr1);
|
|
|
|
/* set host buffer physical address */
|
|
|
|
writel(ARCMSR_HBFMU_DOORBELL_SYNC1, &pmuF->iobound_doorbell);
|
|
|
|
}
|
|
|
|
|
2015-11-26 11:41:15 +00:00
|
|
|
static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
bool rtn = true;
|
|
|
|
void *dma_coherent;
|
|
|
|
dma_addr_t dma_coherent_handle;
|
|
|
|
struct pci_dev *pdev = acb->pdev;
|
|
|
|
|
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2018-12-19 08:24:03 +00:00
|
|
|
acb->ioqueue_size = roundup(sizeof(struct MessageUnit_B), 32);
|
2019-01-18 02:53:41 +00:00
|
|
|
dma_coherent = dma_alloc_coherent(&pdev->dev, acb->ioqueue_size,
|
2015-11-26 11:41:15 +00:00
|
|
|
&dma_coherent_handle, GFP_KERNEL);
|
|
|
|
if (!dma_coherent) {
|
|
|
|
pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
acb->dma_coherent_handle2 = dma_coherent_handle;
|
|
|
|
acb->dma_coherent2 = dma_coherent;
|
2018-12-19 08:31:00 +00:00
|
|
|
acb->pmuB = (struct MessageUnit_B *)dma_coherent;
|
|
|
|
arcmsr_hbaB_assign_regAddr(acb);
|
2015-11-26 11:41:15 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
2018-12-19 08:24:03 +00:00
|
|
|
acb->ioqueue_size = roundup(sizeof(struct MessageUnit_D), 32);
|
2019-01-18 02:53:41 +00:00
|
|
|
dma_coherent = dma_alloc_coherent(&pdev->dev, acb->ioqueue_size,
|
2015-11-26 11:41:15 +00:00
|
|
|
&dma_coherent_handle, GFP_KERNEL);
|
|
|
|
if (!dma_coherent) {
|
|
|
|
pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
acb->dma_coherent_handle2 = dma_coherent_handle;
|
|
|
|
acb->dma_coherent2 = dma_coherent;
|
2018-12-19 08:31:00 +00:00
|
|
|
acb->pmuD = (struct MessageUnit_D *)dma_coherent;
|
|
|
|
arcmsr_hbaD_assign_regAddr(acb);
|
2015-11-26 11:41:15 +00:00
|
|
|
}
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
uint32_t completeQ_size;
|
|
|
|
completeQ_size = sizeof(struct deliver_completeQ) * ARCMSR_MAX_HBE_DONEQUEUE + 128;
|
2018-12-19 08:24:03 +00:00
|
|
|
acb->ioqueue_size = roundup(completeQ_size, 32);
|
2019-01-18 02:53:41 +00:00
|
|
|
dma_coherent = dma_alloc_coherent(&pdev->dev, acb->ioqueue_size,
|
2017-12-05 01:35:34 +00:00
|
|
|
&dma_coherent_handle, GFP_KERNEL);
|
|
|
|
if (!dma_coherent){
|
|
|
|
pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
acb->dma_coherent_handle2 = dma_coherent_handle;
|
|
|
|
acb->dma_coherent2 = dma_coherent;
|
|
|
|
acb->pCompletionQ = dma_coherent;
|
2018-12-19 08:24:03 +00:00
|
|
|
acb->completionQ_entry = acb->ioqueue_size / sizeof(struct deliver_completeQ);
|
2017-12-05 01:35:34 +00:00
|
|
|
acb->doneq_index = 0;
|
|
|
|
}
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
|
|
|
uint32_t QueueDepth;
|
|
|
|
uint32_t depthTbl[] = {256, 512, 1024, 128, 64, 32};
|
|
|
|
|
|
|
|
arcmsr_wait_firmware_ready(acb);
|
|
|
|
QueueDepth = depthTbl[readl(&acb->pmuF->outbound_msgaddr1) & 7];
|
|
|
|
acb->completeQ_size = sizeof(struct deliver_completeQ) * QueueDepth + 128;
|
|
|
|
acb->ioqueue_size = roundup(acb->completeQ_size + MESG_RW_BUFFER_SIZE, 32);
|
|
|
|
dma_coherent = dma_alloc_coherent(&pdev->dev, acb->ioqueue_size,
|
|
|
|
&dma_coherent_handle, GFP_KERNEL);
|
|
|
|
if (!dma_coherent) {
|
|
|
|
pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
acb->dma_coherent_handle2 = dma_coherent_handle;
|
|
|
|
acb->dma_coherent2 = dma_coherent;
|
|
|
|
acb->pCompletionQ = dma_coherent;
|
|
|
|
acb->completionQ_entry = acb->completeQ_size / sizeof(struct deliver_completeQ);
|
|
|
|
acb->doneq_index = 0;
|
|
|
|
arcmsr_hbaF_assign_regAddr(acb);
|
|
|
|
}
|
|
|
|
break;
|
2015-11-26 11:41:15 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
static int arcmsr_alloc_ccb_pool(struct AdapterControlBlock *acb)
|
|
|
|
{
|
2010-07-13 12:03:04 +00:00
|
|
|
struct pci_dev *pdev = acb->pdev;
|
|
|
|
void *dma_coherent;
|
|
|
|
dma_addr_t dma_coherent_handle;
|
|
|
|
struct CommandControlBlock *ccb_tmp;
|
|
|
|
int i = 0, j = 0;
|
2018-12-19 08:34:58 +00:00
|
|
|
unsigned long cdb_phyaddr, next_ccb_phy;
|
2011-04-29 14:28:30 +00:00
|
|
|
unsigned long roundup_ccbsize;
|
2010-07-13 12:03:04 +00:00
|
|
|
unsigned long max_xfer_len;
|
|
|
|
unsigned long max_sg_entrys;
|
2018-12-19 08:34:58 +00:00
|
|
|
uint32_t firm_config_version, curr_phy_upper32;
|
2011-04-29 14:28:30 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
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 */
|
2011-04-29 14:28:30 +00:00
|
|
|
max_sg_entrys = (max_xfer_len/4096);
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
|
|
|
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);
|
2017-12-05 01:44:23 +00:00
|
|
|
acb->uncache_size = roundup_ccbsize * acb->maxFreeCCB;
|
2020-09-28 10:35:05 +00:00
|
|
|
if (acb->adapter_type != ACB_ADAPTER_TYPE_F)
|
|
|
|
acb->uncache_size += acb->ioqueue_size;
|
2010-07-13 12:03:04 +00:00
|
|
|
dma_coherent = dma_alloc_coherent(&pdev->dev, acb->uncache_size, &dma_coherent_handle, GFP_KERNEL);
|
|
|
|
if(!dma_coherent){
|
2011-04-29 14:28:30 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: dma_alloc_coherent got error\n", acb->host->host_no);
|
2010-07-13 12:03:04 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
acb->dma_coherent = dma_coherent;
|
|
|
|
acb->dma_coherent_handle = dma_coherent_handle;
|
|
|
|
memset(dma_coherent, 0, acb->uncache_size);
|
2017-12-05 01:35:34 +00:00
|
|
|
acb->ccbsize = roundup_ccbsize;
|
2010-07-13 12:03:04 +00:00
|
|
|
ccb_tmp = dma_coherent;
|
2018-12-19 08:34:58 +00:00
|
|
|
curr_phy_upper32 = upper_32_bits(dma_coherent_handle);
|
2010-07-13 12:03:04 +00:00
|
|
|
acb->vir2phy_offset = (unsigned long)dma_coherent - (unsigned long)dma_coherent_handle;
|
2017-12-05 01:44:23 +00:00
|
|
|
for(i = 0; i < acb->maxFreeCCB; i++){
|
2018-12-19 08:34:58 +00:00
|
|
|
cdb_phyaddr = (unsigned long)dma_coherent_handle + offsetof(struct CommandControlBlock, arcmsr_cdb);
|
2014-08-19 07:25:22 +00:00
|
|
|
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:
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
2014-08-19 07:25:22 +00:00
|
|
|
ccb_tmp->cdb_phyaddr = cdb_phyaddr;
|
|
|
|
break;
|
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
acb->pccb_pool[i] = ccb_tmp;
|
|
|
|
ccb_tmp->acb = acb;
|
2017-12-05 01:35:34 +00:00
|
|
|
ccb_tmp->smid = (u32)i << 16;
|
2010-07-13 12:03:04 +00:00
|
|
|
INIT_LIST_HEAD(&ccb_tmp->list);
|
2018-12-19 08:34:58 +00:00
|
|
|
next_ccb_phy = dma_coherent_handle + roundup_ccbsize;
|
|
|
|
if (upper_32_bits(next_ccb_phy) != curr_phy_upper32) {
|
|
|
|
acb->maxFreeCCB = i;
|
|
|
|
acb->host->can_queue = i;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
list_add_tail(&ccb_tmp->list, &acb->ccb_free_list);
|
2010-07-13 12:03:04 +00:00
|
|
|
ccb_tmp = (struct CommandControlBlock *)((unsigned long)ccb_tmp + roundup_ccbsize);
|
2018-12-19 08:34:58 +00:00
|
|
|
dma_coherent_handle = next_ccb_phy;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
if (acb->adapter_type != ACB_ADAPTER_TYPE_F) {
|
|
|
|
acb->dma_coherent_handle2 = dma_coherent_handle;
|
|
|
|
acb->dma_coherent2 = ccb_tmp;
|
|
|
|
}
|
2018-12-19 08:31:00 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_B:
|
|
|
|
acb->pmuB = (struct MessageUnit_B *)acb->dma_coherent2;
|
|
|
|
arcmsr_hbaB_assign_regAddr(acb);
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
acb->pmuD = (struct MessageUnit_D *)acb->dma_coherent2;
|
|
|
|
arcmsr_hbaD_assign_regAddr(acb);
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
acb->pCompletionQ = acb->dma_coherent2;
|
|
|
|
acb->completionQ_entry = acb->ioqueue_size / sizeof(struct deliver_completeQ);
|
|
|
|
acb->doneq_index = 0;
|
|
|
|
break;
|
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2010-05-17 03:22:42 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
static void arcmsr_message_isr_bh_fn(struct work_struct *work)
|
|
|
|
{
|
2014-08-19 06:59:00 +00:00
|
|
|
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;
|
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
switch (acb->adapter_type) {
|
2014-08-19 06:59:00 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2010-05-17 03:22:42 +00:00
|
|
|
|
2014-08-19 06:59:00 +00:00
|
|
|
signature = (uint32_t __iomem *)(®->message_rwbuffer[0]);
|
|
|
|
devicemap = (char __iomem *)(®->message_rwbuffer[21]);
|
2010-07-13 12:03:04 +00:00
|
|
|
break;
|
2014-08-19 06:59:00 +00:00
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
|
|
|
|
|
|
|
signature = (uint32_t __iomem *)(®->message_rwbuffer[0]);
|
|
|
|
devicemap = (char __iomem *)(®->message_rwbuffer[21]);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
|
|
|
|
|
|
|
signature = (uint32_t __iomem *)(®->msgcode_rwbuffer[0]);
|
|
|
|
devicemap = (char __iomem *)(®->msgcode_rwbuffer[21]);
|
|
|
|
break;
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
|
|
|
|
signature = (uint32_t __iomem *)(®->msgcode_rwbuffer[0]);
|
|
|
|
devicemap = (char __iomem *)(®->msgcode_rwbuffer[21]);
|
|
|
|
break;
|
|
|
|
}
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
|
|
|
|
signature = (uint32_t __iomem *)(®->msgcode_rwbuffer[0]);
|
|
|
|
devicemap = (char __iomem *)(®->msgcode_rwbuffer[21]);
|
|
|
|
break;
|
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
|
|
|
signature = (uint32_t __iomem *)(&acb->msgcode_rwbuffer[0]);
|
|
|
|
devicemap = (char __iomem *)(&acb->msgcode_rwbuffer[21]);
|
|
|
|
break;
|
|
|
|
}
|
2014-08-19 06:59:00 +00:00
|
|
|
}
|
|
|
|
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);
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-19 06:59:00 +00:00
|
|
|
temp >>= 1;
|
|
|
|
diff >>= 1;
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-19 06:59:00 +00:00
|
|
|
devicemap++;
|
|
|
|
acb_dev_map++;
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
2020-09-28 10:31:27 +00:00
|
|
|
acb->acb_flags &= ~ACB_F_MSG_GET_CONFIG;
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2014-08-19 06:23:31 +00:00
|
|
|
static int
|
|
|
|
arcmsr_request_irq(struct pci_dev *pdev, struct AdapterControlBlock *acb)
|
|
|
|
{
|
2016-09-11 13:31:23 +00:00
|
|
|
unsigned long flags;
|
|
|
|
int nvec, i;
|
|
|
|
|
2017-12-05 02:26:38 +00:00
|
|
|
if (msix_enable == 0)
|
|
|
|
goto msi_int0;
|
2016-09-11 13:31:23 +00:00
|
|
|
nvec = pci_alloc_irq_vectors(pdev, 1, ARCMST_NUM_MSIX_VECTORS,
|
|
|
|
PCI_IRQ_MSIX);
|
|
|
|
if (nvec > 0) {
|
|
|
|
pr_info("arcmsr%d: msi-x enabled\n", acb->host->host_no);
|
|
|
|
flags = 0;
|
|
|
|
} else {
|
2017-12-05 02:26:38 +00:00
|
|
|
msi_int0:
|
2017-12-05 02:24:01 +00:00
|
|
|
if (msi_enable == 1) {
|
|
|
|
nvec = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_MSI);
|
|
|
|
if (nvec == 1) {
|
|
|
|
dev_info(&pdev->dev, "msi enabled\n");
|
|
|
|
goto msi_int1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nvec = pci_alloc_irq_vectors(pdev, 1, 1, PCI_IRQ_LEGACY);
|
2016-09-11 13:31:23 +00:00
|
|
|
if (nvec < 1)
|
|
|
|
return FAILED;
|
2017-12-05 02:24:01 +00:00
|
|
|
msi_int1:
|
2016-09-11 13:31:23 +00:00
|
|
|
flags = IRQF_SHARED;
|
|
|
|
}
|
|
|
|
|
|
|
|
acb->vector_count = nvec;
|
|
|
|
for (i = 0; i < nvec; i++) {
|
|
|
|
if (request_irq(pci_irq_vector(pdev, i), arcmsr_do_interrupt,
|
|
|
|
flags, "arcmsr", acb)) {
|
2014-08-19 06:23:31 +00:00
|
|
|
pr_warn("arcmsr%d: request_irq =%d failed!\n",
|
2016-09-11 13:31:23 +00:00
|
|
|
acb->host->host_no, pci_irq_vector(pdev, i));
|
|
|
|
goto out_free_irq;
|
2014-08-19 06:23:31 +00:00
|
|
|
}
|
|
|
|
}
|
2016-09-11 13:31:23 +00:00
|
|
|
|
2014-08-19 06:23:31 +00:00
|
|
|
return SUCCESS;
|
2016-09-11 13:31:23 +00:00
|
|
|
out_free_irq:
|
|
|
|
while (--i >= 0)
|
|
|
|
free_irq(pci_irq_vector(pdev, i), acb);
|
|
|
|
pci_free_irq_vectors(pdev);
|
|
|
|
return FAILED;
|
2014-08-19 06:23:31 +00:00
|
|
|
}
|
|
|
|
|
2017-12-05 02:11:23 +00:00
|
|
|
static void arcmsr_init_get_devmap_timer(struct AdapterControlBlock *pacb)
|
|
|
|
{
|
|
|
|
INIT_WORK(&pacb->arcmsr_do_message_isr_bh, arcmsr_message_isr_bh_fn);
|
|
|
|
pacb->fw_flag = FW_NORMAL;
|
|
|
|
timer_setup(&pacb->eternal_timer, arcmsr_request_device_map, 0);
|
|
|
|
pacb->eternal_timer.expires = jiffies + msecs_to_jiffies(6 * HZ);
|
|
|
|
add_timer(&pacb->eternal_timer);
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:59:52 +00:00
|
|
|
static void arcmsr_init_set_datetime_timer(struct AdapterControlBlock *pacb)
|
|
|
|
{
|
|
|
|
timer_setup(&pacb->refresh_timer, arcmsr_set_iop_datetime, 0);
|
|
|
|
pacb->refresh_timer.expires = jiffies + msecs_to_jiffies(60 * 1000);
|
|
|
|
add_timer(&pacb->refresh_timer);
|
|
|
|
}
|
|
|
|
|
2018-12-19 08:56:34 +00:00
|
|
|
static int arcmsr_set_dma_mask(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
struct pci_dev *pcidev = acb->pdev;
|
|
|
|
|
|
|
|
if (IS_DMA64) {
|
|
|
|
if (((acb->adapter_type == ACB_ADAPTER_TYPE_A) && !dma_mask_64) ||
|
|
|
|
dma_set_mask(&pcidev->dev, DMA_BIT_MASK(64)))
|
|
|
|
goto dma32;
|
|
|
|
if (dma_set_coherent_mask(&pcidev->dev, DMA_BIT_MASK(64)) ||
|
|
|
|
dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(64))) {
|
|
|
|
printk("arcmsr: set DMA 64 mask failed\n");
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
dma32:
|
|
|
|
if (dma_set_mask(&pcidev->dev, DMA_BIT_MASK(32)) ||
|
|
|
|
dma_set_coherent_mask(&pcidev->dev, DMA_BIT_MASK(32)) ||
|
|
|
|
dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32))) {
|
|
|
|
printk("arcmsr: set DMA 32-bit mask failed\n");
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
static int arcmsr_probe(struct pci_dev *pdev, const struct pci_device_id *id)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
|
|
|
struct Scsi_Host *host;
|
|
|
|
struct AdapterControlBlock *acb;
|
2010-07-13 12:03:04 +00:00
|
|
|
uint8_t bus,dev_fun;
|
2006-07-12 15:59:32 +00:00
|
|
|
int error;
|
|
|
|
error = pci_enable_device(pdev);
|
2010-07-13 12:03:04 +00:00
|
|
|
if(error){
|
2010-06-18 07:39:12 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
host = scsi_host_alloc(&arcmsr_scsi_host_template, sizeof(struct AdapterControlBlock));
|
2010-07-13 12:03:04 +00:00
|
|
|
if(!host){
|
|
|
|
goto pci_disable_dev;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
init_waitqueue_head(&wait_q);
|
2006-07-12 15:59:32 +00:00
|
|
|
bus = pdev->bus->number;
|
|
|
|
dev_fun = pdev->devfn;
|
2010-06-18 07:39:12 +00:00
|
|
|
acb = (struct AdapterControlBlock *) host->hostdata;
|
2010-07-13 12:03:04 +00:00
|
|
|
memset(acb,0,sizeof(struct AdapterControlBlock));
|
2006-07-12 15:59:32 +00:00
|
|
|
acb->pdev = pdev;
|
2018-12-19 08:56:34 +00:00
|
|
|
acb->adapter_type = id->driver_data;
|
|
|
|
if (arcmsr_set_dma_mask(acb))
|
|
|
|
goto scsi_host_release;
|
2010-06-18 07:39:12 +00:00
|
|
|
acb->host = host;
|
2006-07-12 15:59:32 +00:00
|
|
|
host->max_lun = ARCMSR_MAX_TARGETLUN;
|
2010-07-13 12:03:04 +00:00
|
|
|
host->max_id = ARCMSR_MAX_TARGETID; /*16:8*/
|
|
|
|
host->max_cmd_len = 16; /*this is issue of 64bit LBA ,over 2T byte*/
|
2017-12-05 01:47:44 +00:00
|
|
|
if ((host_can_queue < ARCMSR_MIN_OUTSTANDING_CMD) || (host_can_queue > ARCMSR_MAX_OUTSTANDING_CMD))
|
|
|
|
host_can_queue = ARCMSR_DEFAULT_OUTSTANDING_CMD;
|
|
|
|
host->can_queue = host_can_queue; /* max simultaneous cmds */
|
2017-12-05 01:55:02 +00:00
|
|
|
if ((cmd_per_lun < ARCMSR_MIN_CMD_PERLUN) || (cmd_per_lun > ARCMSR_MAX_CMD_PERLUN))
|
|
|
|
cmd_per_lun = ARCMSR_DEFAULT_CMD_PERLUN;
|
|
|
|
host->cmd_per_lun = cmd_per_lun;
|
2006-07-12 15:59:32 +00:00
|
|
|
host->this_id = ARCMSR_SCSI_INITIATOR_ID;
|
|
|
|
host->unique_id = (bus << 8) | dev_fun;
|
2010-06-18 07:39:12 +00:00
|
|
|
pci_set_drvdata(pdev, host);
|
|
|
|
pci_set_master(pdev);
|
2006-07-12 15:59:32 +00:00
|
|
|
error = pci_request_regions(pdev, "arcmsr");
|
2010-07-13 12:03:04 +00:00
|
|
|
if(error){
|
2010-06-18 07:39:12 +00:00
|
|
|
goto scsi_host_release;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
spin_lock_init(&acb->eh_lock);
|
|
|
|
spin_lock_init(&acb->ccblist_lock);
|
2014-08-19 07:25:22 +00:00
|
|
|
spin_lock_init(&acb->postq_lock);
|
|
|
|
spin_lock_init(&acb->doneq_lock);
|
2014-08-19 07:17:45 +00:00
|
|
|
spin_lock_init(&acb->rqbuffer_lock);
|
|
|
|
spin_lock_init(&acb->wqbuffer_lock);
|
2006-07-12 15:59:32 +00:00
|
|
|
acb->acb_flags |= (ACB_F_MESSAGE_WQBUFFER_CLEARED |
|
2010-07-13 12:03:04 +00:00
|
|
|
ACB_F_MESSAGE_RQBUFFER_CLEARED |
|
|
|
|
ACB_F_MESSAGE_WQBUFFER_READED);
|
2006-07-12 15:59:32 +00:00
|
|
|
acb->acb_flags &= ~ACB_F_SCSISTOPADAPTER;
|
|
|
|
INIT_LIST_HEAD(&acb->ccb_free_list);
|
2010-06-18 07:39:12 +00:00
|
|
|
error = arcmsr_remap_pciregion(acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
if(!error){
|
2010-06-18 07:39:12 +00:00
|
|
|
goto pci_release_regs;
|
|
|
|
}
|
2015-11-26 11:41:15 +00:00
|
|
|
error = arcmsr_alloc_io_queue(acb);
|
|
|
|
if (!error)
|
|
|
|
goto unmap_pci_region;
|
2010-06-18 07:39:12 +00:00
|
|
|
error = arcmsr_get_firmware_spec(acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
if(!error){
|
2015-11-26 11:41:15 +00:00
|
|
|
goto free_hbb_mu;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
if (acb->adapter_type != ACB_ADAPTER_TYPE_F)
|
|
|
|
arcmsr_free_io_queue(acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
error = arcmsr_alloc_ccb_pool(acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
if(error){
|
2018-12-19 08:31:00 +00:00
|
|
|
goto unmap_pci_region;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
error = scsi_add_host(host, &pdev->dev);
|
2010-07-13 12:03:04 +00:00
|
|
|
if(error){
|
2014-08-19 07:28:36 +00:00
|
|
|
goto free_ccb_pool;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
2014-08-19 06:23:31 +00:00
|
|
|
if (arcmsr_request_irq(pdev, acb) == FAILED)
|
2010-06-18 07:39:12 +00:00
|
|
|
goto scsi_host_remove;
|
2014-08-19 06:23:31 +00:00
|
|
|
arcmsr_iop_init(acb);
|
2017-12-05 02:11:23 +00:00
|
|
|
arcmsr_init_get_devmap_timer(acb);
|
2017-12-05 01:59:52 +00:00
|
|
|
if (set_date_time)
|
|
|
|
arcmsr_init_set_datetime_timer(acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
if(arcmsr_alloc_sysfs_attr(acb))
|
2010-06-18 07:39:12 +00:00
|
|
|
goto out_free_sysfs;
|
2014-08-19 07:28:36 +00:00
|
|
|
scsi_scan_host(host);
|
2006-07-12 15:59:32 +00:00
|
|
|
return 0;
|
2010-07-13 12:03:04 +00:00
|
|
|
out_free_sysfs:
|
2017-12-05 01:59:52 +00:00
|
|
|
if (set_date_time)
|
|
|
|
del_timer_sync(&acb->refresh_timer);
|
2014-08-19 07:28:36 +00:00
|
|
|
del_timer_sync(&acb->eternal_timer);
|
|
|
|
flush_work(&acb->arcmsr_do_message_isr_bh);
|
2010-06-18 07:39:12 +00:00
|
|
|
arcmsr_stop_adapter_bgrb(acb);
|
|
|
|
arcmsr_flush_adapter_cache(acb);
|
2014-08-19 07:28:36 +00:00
|
|
|
arcmsr_free_irq(pdev, acb);
|
|
|
|
scsi_host_remove:
|
|
|
|
scsi_remove_host(host);
|
|
|
|
free_ccb_pool:
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_free_ccb_pool(acb);
|
2018-12-19 08:31:00 +00:00
|
|
|
goto unmap_pci_region;
|
2010-06-18 07:39:12 +00:00
|
|
|
free_hbb_mu:
|
2018-12-19 08:27:20 +00:00
|
|
|
arcmsr_free_io_queue(acb);
|
2010-06-18 07:39:12 +00:00
|
|
|
unmap_pci_region:
|
|
|
|
arcmsr_unmap_pciregion(acb);
|
|
|
|
pci_release_regs:
|
2006-07-12 15:59:32 +00:00
|
|
|
pci_release_regions(pdev);
|
2010-06-18 07:39:12 +00:00
|
|
|
scsi_host_release:
|
2006-07-12 15:59:32 +00:00
|
|
|
scsi_host_put(host);
|
2010-06-18 07:39:12 +00:00
|
|
|
pci_disable_dev:
|
2006-07-12 15:59:32 +00:00
|
|
|
pci_disable_device(pdev);
|
2010-06-18 07:39:12 +00:00
|
|
|
return -ENODEV;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 06:23:31 +00:00
|
|
|
static void arcmsr_free_irq(struct pci_dev *pdev,
|
|
|
|
struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2016-09-11 13:31:23 +00:00
|
|
|
for (i = 0; i < acb->vector_count; i++)
|
|
|
|
free_irq(pci_irq_vector(pdev, i), acb);
|
|
|
|
pci_free_irq_vectors(pdev);
|
2014-08-19 06:23:31 +00:00
|
|
|
}
|
|
|
|
|
2020-11-02 16:47:10 +00:00
|
|
|
static int __maybe_unused arcmsr_suspend(struct device *dev)
|
2014-08-19 06:26:09 +00:00
|
|
|
{
|
2020-11-02 16:47:10 +00:00
|
|
|
struct pci_dev *pdev = to_pci_dev(dev);
|
2014-08-19 06:26:09 +00:00
|
|
|
struct Scsi_Host *host = pci_get_drvdata(pdev);
|
|
|
|
struct AdapterControlBlock *acb =
|
|
|
|
(struct AdapterControlBlock *)host->hostdata;
|
|
|
|
|
2020-07-13 07:46:30 +00:00
|
|
|
arcmsr_disable_outbound_ints(acb);
|
2014-08-19 06:26:09 +00:00
|
|
|
arcmsr_free_irq(pdev, acb);
|
|
|
|
del_timer_sync(&acb->eternal_timer);
|
2017-12-05 01:59:52 +00:00
|
|
|
if (set_date_time)
|
|
|
|
del_timer_sync(&acb->refresh_timer);
|
2014-08-19 06:26:09 +00:00
|
|
|
flush_work(&acb->arcmsr_do_message_isr_bh);
|
|
|
|
arcmsr_stop_adapter_bgrb(acb);
|
|
|
|
arcmsr_flush_adapter_cache(acb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-11-02 16:47:10 +00:00
|
|
|
static int __maybe_unused arcmsr_resume(struct device *dev)
|
2014-08-19 06:26:09 +00:00
|
|
|
{
|
2020-11-02 16:47:10 +00:00
|
|
|
struct pci_dev *pdev = to_pci_dev(dev);
|
2014-08-19 06:26:09 +00:00
|
|
|
struct Scsi_Host *host = pci_get_drvdata(pdev);
|
|
|
|
struct AdapterControlBlock *acb =
|
|
|
|
(struct AdapterControlBlock *)host->hostdata;
|
|
|
|
|
2018-12-19 08:56:34 +00:00
|
|
|
if (arcmsr_set_dma_mask(acb))
|
|
|
|
goto controller_unregister;
|
2014-08-19 06:26:09 +00:00
|
|
|
if (arcmsr_request_irq(pdev, acb) == FAILED)
|
|
|
|
goto controller_stop;
|
2018-12-19 08:59:48 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2019-01-18 02:58:51 +00:00
|
|
|
uint32_t i;
|
|
|
|
for (i = 0; i < ARCMSR_MAX_HBB_POSTQUEUE; i++) {
|
|
|
|
reg->post_qbuffer[i] = 0;
|
|
|
|
reg->done_qbuffer[i] = 0;
|
|
|
|
}
|
2018-12-19 08:59:48 +00:00
|
|
|
reg->postq_index = 0;
|
|
|
|
reg->doneq_index = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_E:
|
2018-07-09 10:24:53 +00:00
|
|
|
writel(0, &acb->pmuE->host_int_status);
|
|
|
|
writel(ARCMSR_HBEMU_DOORBELL_SYNC, &acb->pmuE->iobound_doorbell);
|
|
|
|
acb->in_doorbell = 0;
|
|
|
|
acb->out_doorbell = 0;
|
|
|
|
acb->doneq_index = 0;
|
2018-12-19 08:59:48 +00:00
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
|
|
|
writel(0, &acb->pmuF->host_int_status);
|
|
|
|
writel(ARCMSR_HBFMU_DOORBELL_SYNC, &acb->pmuF->iobound_doorbell);
|
|
|
|
acb->in_doorbell = 0;
|
|
|
|
acb->out_doorbell = 0;
|
|
|
|
acb->doneq_index = 0;
|
|
|
|
arcmsr_hbaF_assign_regAddr(acb);
|
|
|
|
break;
|
2018-07-09 10:24:53 +00:00
|
|
|
}
|
2014-08-19 06:26:09 +00:00
|
|
|
arcmsr_iop_init(acb);
|
2017-12-05 02:11:23 +00:00
|
|
|
arcmsr_init_get_devmap_timer(acb);
|
2017-12-05 01:59:52 +00:00
|
|
|
if (set_date_time)
|
|
|
|
arcmsr_init_set_datetime_timer(acb);
|
2014-08-19 06:26:09 +00:00
|
|
|
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);
|
2020-09-28 10:35:05 +00:00
|
|
|
if (acb->adapter_type == ACB_ADAPTER_TYPE_F)
|
|
|
|
arcmsr_free_io_queue(acb);
|
2014-08-19 06:26:09 +00:00
|
|
|
arcmsr_unmap_pciregion(acb);
|
|
|
|
scsi_host_put(host);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static uint8_t arcmsr_hbaA_abort_allcmd(struct AdapterControlBlock *acb)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2006-07-12 15:59:32 +00:00
|
|
|
writel(ARCMSR_INBOUND_MESG0_ABORT_CMD, ®->inbound_msgaddr0);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
|
2007-09-13 09:26:40 +00:00
|
|
|
printk(KERN_NOTICE
|
2014-08-19 07:10:12 +00:00
|
|
|
"arcmsr%d: wait 'abort all outstanding command' timeout\n"
|
2007-09-13 09:26:40 +00:00
|
|
|
, acb->host->host_no);
|
2010-07-13 12:03:04 +00:00
|
|
|
return false;
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
return true;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static uint8_t arcmsr_hbaB_abort_allcmd(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_MESSAGE_ABORT_CMD, reg->drv2iop_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
2006-07-12 15:59:32 +00:00
|
|
|
printk(KERN_NOTICE
|
2014-08-19 07:10:12 +00:00
|
|
|
"arcmsr%d: wait 'abort all outstanding command' timeout\n"
|
2006-07-12 15:59:32 +00:00
|
|
|
, acb->host->host_no);
|
2010-07-13 12:03:04 +00:00
|
|
|
return false;
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
return true;
|
|
|
|
}
|
2014-08-19 07:10:12 +00:00
|
|
|
static uint8_t arcmsr_hbaC_abort_allcmd(struct AdapterControlBlock *pACB)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = pACB->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
writel(ARCMSR_INBOUND_MESG0_ABORT_CMD, ®->inbound_msgaddr0);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, ®->inbound_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
|
2010-07-13 12:03:04 +00:00
|
|
|
printk(KERN_NOTICE
|
2014-08-19 07:10:12 +00:00
|
|
|
"arcmsr%d: wait 'abort all outstanding command' timeout\n"
|
2010-07-13 12:03:04 +00:00
|
|
|
, pACB->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static uint8_t arcmsr_hbaE_abort_allcmd(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
struct MessageUnit_E __iomem *reg = pACB->pmuE;
|
|
|
|
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_ABORT_CMD, ®->inbound_msgaddr0);
|
|
|
|
pACB->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(pACB->out_doorbell, ®->iobound_doorbell);
|
|
|
|
if (!arcmsr_hbaE_wait_msgint_ready(pACB)) {
|
|
|
|
pr_notice("arcmsr%d: wait 'abort all outstanding "
|
|
|
|
"command' timeout\n", pACB->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
static uint8_t arcmsr_abort_allcmd(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2010-05-17 03:22:42 +00:00
|
|
|
uint8_t rtnval = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtnval = arcmsr_hbaA_abort_allcmd(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtnval = arcmsr_hbaB_abort_allcmd(acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
break;
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtnval = arcmsr_hbaC_abort_allcmd(acb);
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
rtnval = arcmsr_hbaD_abort_allcmd(acb);
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
2017-12-05 01:35:34 +00:00
|
|
|
rtnval = arcmsr_hbaE_abort_allcmd(acb);
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2010-05-17 03:22:42 +00:00
|
|
|
return rtnval;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
2006-07-12 15:59:32 +00:00
|
|
|
static void arcmsr_pci_unmap_dma(struct CommandControlBlock *ccb)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *pcmd = ccb->pcmd;
|
|
|
|
|
2007-05-14 10:25:56 +00:00
|
|
|
scsi_dma_unmap(pcmd);
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
static void arcmsr_ccb_complete(struct CommandControlBlock *ccb)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
|
|
|
struct AdapterControlBlock *acb = ccb->acb;
|
|
|
|
struct scsi_cmnd *pcmd = ccb->pcmd;
|
2010-06-18 07:39:12 +00:00
|
|
|
unsigned long flags;
|
|
|
|
atomic_dec(&acb->ccboutstandingcount);
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_pci_unmap_dma(ccb);
|
|
|
|
ccb->startdone = ARCMSR_CCB_DONE;
|
2010-06-18 07:39:12 +00:00
|
|
|
spin_lock_irqsave(&acb->ccblist_lock, flags);
|
2006-07-12 15:59:32 +00:00
|
|
|
list_add_tail(&ccb->list, &acb->ccb_free_list);
|
2010-06-18 07:39:12 +00:00
|
|
|
spin_unlock_irqrestore(&acb->ccblist_lock, flags);
|
2006-07-12 15:59:32 +00:00
|
|
|
pcmd->scsi_done(pcmd);
|
|
|
|
}
|
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
static void arcmsr_report_sense_info(struct CommandControlBlock *ccb)
|
|
|
|
{
|
|
|
|
struct scsi_cmnd *pcmd = ccb->pcmd;
|
2021-06-16 21:24:28 +00:00
|
|
|
|
2021-04-27 08:30:46 +00:00
|
|
|
pcmd->result = (DID_OK << 16) | SAM_STAT_CHECK_CONDITION;
|
2021-06-16 21:24:28 +00:00
|
|
|
if (pcmd->sense_buffer) {
|
|
|
|
struct SENSE_DATA *sensebuffer;
|
|
|
|
|
|
|
|
memcpy_and_pad(pcmd->sense_buffer,
|
|
|
|
SCSI_SENSE_BUFFERSIZE,
|
|
|
|
ccb->arcmsr_cdb.SenseData,
|
|
|
|
sizeof(ccb->arcmsr_cdb.SenseData),
|
|
|
|
0);
|
|
|
|
|
|
|
|
sensebuffer = (struct SENSE_DATA *)pcmd->sense_buffer;
|
2007-09-13 09:26:40 +00:00
|
|
|
sensebuffer->ErrorCode = SCSI_SENSE_CURRENT_ERRORS;
|
|
|
|
sensebuffer->Valid = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static u32 arcmsr_disable_outbound_ints(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
u32 orig_mask = 0;
|
2010-07-13 12:03:04 +00:00
|
|
|
switch (acb->adapter_type) {
|
2007-09-13 09:26:40 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A : {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2010-05-17 03:22:42 +00:00
|
|
|
orig_mask = readl(®->outbound_intmask);
|
2007-09-13 09:26:40 +00:00
|
|
|
writel(orig_mask|ARCMSR_MU_OUTBOUND_ALL_INTMASKENABLE, \
|
|
|
|
®->outbound_intmask);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_B : {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-06-18 07:39:12 +00:00
|
|
|
orig_mask = readl(reg->iop2drv_doorbell_mask);
|
|
|
|
writel(0, reg->iop2drv_doorbell_mask);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C:{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
/* disable all outbound interrupt */
|
|
|
|
orig_mask = readl(®->host_int_mask); /* disable outbound message0 int */
|
|
|
|
writel(orig_mask|ARCMSR_HBCMU_ALL_INTMASKENABLE, ®->host_int_mask);
|
|
|
|
}
|
|
|
|
break;
|
2014-08-19 07:25:22 +00:00
|
|
|
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;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
2017-12-05 01:35:34 +00:00
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
orig_mask = readl(®->host_int_mask);
|
|
|
|
writel(orig_mask | ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR | ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR, ®->host_int_mask);
|
|
|
|
readl(®->host_int_mask); /* Dummy readl to force pci flush */
|
|
|
|
}
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
return orig_mask;
|
|
|
|
}
|
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
static void arcmsr_report_ccb_state(struct AdapterControlBlock *acb,
|
|
|
|
struct CommandControlBlock *ccb, bool error)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
|
|
|
uint8_t id, lun;
|
|
|
|
id = ccb->pcmd->device->id;
|
|
|
|
lun = ccb->pcmd->device->lun;
|
2010-07-13 12:03:04 +00:00
|
|
|
if (!error) {
|
2007-09-13 09:26:40 +00:00
|
|
|
if (acb->devstate[id][lun] == ARECA_RAID_GONE)
|
|
|
|
acb->devstate[id][lun] = ARECA_RAID_GOOD;
|
2010-08-05 20:19:36 +00:00
|
|
|
ccb->pcmd->result = DID_OK << 16;
|
|
|
|
arcmsr_ccb_complete(ccb);
|
2010-07-13 12:03:04 +00:00
|
|
|
}else{
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (ccb->arcmsr_cdb.DeviceStatus) {
|
|
|
|
case ARCMSR_DEV_SELECT_TIMEOUT: {
|
|
|
|
acb->devstate[id][lun] = ARECA_RAID_GONE;
|
|
|
|
ccb->pcmd->result = DID_NO_CONNECT << 16;
|
2010-06-18 07:39:12 +00:00
|
|
|
arcmsr_ccb_complete(ccb);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ARCMSR_DEV_ABORTED:
|
|
|
|
|
|
|
|
case ARCMSR_DEV_INIT_FAIL: {
|
|
|
|
acb->devstate[id][lun] = ARECA_RAID_GONE;
|
|
|
|
ccb->pcmd->result = DID_BAD_TARGET << 16;
|
2010-06-18 07:39:12 +00:00
|
|
|
arcmsr_ccb_complete(ccb);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ARCMSR_DEV_CHECK_CONDITION: {
|
|
|
|
acb->devstate[id][lun] = ARECA_RAID_GOOD;
|
|
|
|
arcmsr_report_sense_info(ccb);
|
2010-06-18 07:39:12 +00:00
|
|
|
arcmsr_ccb_complete(ccb);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
static void arcmsr_drain_donequeue(struct AdapterControlBlock *acb, struct CommandControlBlock *pCCB, bool error)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2010-07-13 12:03:04 +00:00
|
|
|
if ((pCCB->acb != acb) || (pCCB->startdone != ARCMSR_CCB_START)) {
|
|
|
|
if (pCCB->startdone == ARCMSR_CCB_ABORTED) {
|
|
|
|
struct scsi_cmnd *abortcmd = pCCB->pcmd;
|
2007-09-13 09:26:40 +00:00
|
|
|
if (abortcmd) {
|
|
|
|
abortcmd->result |= DID_ABORT << 16;
|
2010-07-13 12:03:04 +00:00
|
|
|
arcmsr_ccb_complete(pCCB);
|
|
|
|
printk(KERN_NOTICE "arcmsr%d: pCCB ='0x%p' isr got aborted command \n",
|
|
|
|
acb->host->host_no, pCCB);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
return;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
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
|
2010-07-13 12:03:04 +00:00
|
|
|
, pCCB
|
|
|
|
, pCCB->acb
|
|
|
|
, pCCB->startdone
|
2007-09-13 09:26:40 +00:00
|
|
|
, atomic_read(&acb->ccboutstandingcount));
|
2019-11-14 18:00:07 +00:00
|
|
|
return;
|
2011-01-06 09:32:41 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
arcmsr_report_ccb_state(acb, pCCB, error);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arcmsr_done4abort_postqueue(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
int i = 0;
|
2018-12-19 08:43:15 +00:00
|
|
|
uint32_t flag_ccb;
|
2010-07-13 12:03:04 +00:00
|
|
|
struct ARCMSR_CDB *pARCMSR_CDB;
|
|
|
|
bool error;
|
|
|
|
struct CommandControlBlock *pCCB;
|
2020-07-13 07:46:30 +00:00
|
|
|
unsigned long ccb_cdb_phy;
|
2018-12-19 08:43:15 +00:00
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
uint32_t outbound_intstatus;
|
2007-10-29 05:08:28 +00:00
|
|
|
outbound_intstatus = readl(®->outbound_intstatus) &
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->outbound_int_enable;
|
|
|
|
/*clear and abort all outbound posted Q*/
|
|
|
|
writel(outbound_intstatus, ®->outbound_intstatus);/*clear interrupt*/
|
2010-07-13 12:03:04 +00:00
|
|
|
while(((flag_ccb = readl(®->outbound_queueport)) != 0xFFFFFFFF)
|
2017-12-05 01:51:27 +00:00
|
|
|
&& (i++ < acb->maxOutstanding)) {
|
2018-12-19 08:43:15 +00:00
|
|
|
ccb_cdb_phy = (flag_ccb << 5) & 0xffffffff;
|
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
|
|
|
pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset + ccb_cdb_phy);
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
/*clear all outbound posted Q*/
|
2011-01-06 09:32:41 +00:00
|
|
|
writel(ARCMSR_DOORBELL_INT_CLEAR_PATTERN, reg->iop2drv_doorbell); /* clear doorbell interrupt */
|
2007-09-13 09:26:40 +00:00
|
|
|
for (i = 0; i < ARCMSR_MAX_HBB_POSTQUEUE; i++) {
|
2014-08-19 07:20:31 +00:00
|
|
|
flag_ccb = reg->done_qbuffer[i];
|
|
|
|
if (flag_ccb != 0) {
|
|
|
|
reg->done_qbuffer[i] = 0;
|
2018-12-19 08:45:46 +00:00
|
|
|
ccb_cdb_phy = (flag_ccb << 5) & 0xffffffff;
|
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
|
|
|
pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset + ccb_cdb_phy);
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
reg->post_qbuffer[i] = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
reg->doneq_index = 0;
|
|
|
|
reg->postq_index = 0;
|
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2017-12-05 01:51:27 +00:00
|
|
|
while ((readl(®->host_int_status) & ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR) && (i++ < acb->maxOutstanding)) {
|
2010-07-13 12:03:04 +00:00
|
|
|
/*need to do*/
|
|
|
|
flag_ccb = readl(®->outbound_queueport_low);
|
|
|
|
ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
|
2018-12-19 08:48:16 +00:00
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
|
|
|
pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset + ccb_cdb_phy);
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *pmu = acb->pmuD;
|
2014-09-15 11:05:33 +00:00
|
|
|
uint32_t outbound_write_pointer;
|
|
|
|
uint32_t doneq_index, index_stripped, addressLow, residual, toggle;
|
|
|
|
unsigned long flags;
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
residual = atomic_read(&acb->ccboutstandingcount);
|
|
|
|
for (i = 0; i < residual; i++) {
|
2014-09-15 11:05:33 +00:00
|
|
|
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) !=
|
2014-08-19 07:25:22 +00:00
|
|
|
(outbound_write_pointer & 0xFFF)) {
|
2014-09-15 11:05:33 +00:00
|
|
|
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);
|
2014-08-19 07:25:22 +00:00
|
|
|
doneq_index = pmu->doneq_index;
|
2014-09-15 11:05:33 +00:00
|
|
|
spin_unlock_irqrestore(&acb->doneq_lock, flags);
|
2014-08-19 07:25:22 +00:00
|
|
|
addressLow = pmu->done_qbuffer[doneq_index &
|
|
|
|
0xFFF].addressLow;
|
|
|
|
ccb_cdb_phy = (addressLow & 0xFFFFFFF0);
|
2018-12-19 08:51:14 +00:00
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
2014-08-19 07:25:22 +00:00
|
|
|
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);
|
2014-09-15 11:05:33 +00:00
|
|
|
} else {
|
|
|
|
spin_unlock_irqrestore(&acb->doneq_lock, flags);
|
|
|
|
mdelay(10);
|
2014-08-19 07:25:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
pmu->postq_index = 0;
|
|
|
|
pmu->doneq_index = 0x40FF;
|
|
|
|
}
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
arcmsr_hbaE_postqueue_isr(acb);
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
|
|
|
arcmsr_hbaF_postqueue_isr(acb);
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-19 06:23:31 +00:00
|
|
|
|
2018-03-15 06:33:36 +00:00
|
|
|
static void arcmsr_remove_scsi_devices(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
char *acb_dev_map = (char *)acb->device_map;
|
|
|
|
int target, lun, i;
|
|
|
|
struct scsi_device *psdev;
|
|
|
|
struct CommandControlBlock *ccb;
|
|
|
|
char temp;
|
|
|
|
|
|
|
|
for (i = 0; i < acb->maxFreeCCB; i++) {
|
|
|
|
ccb = acb->pccb_pool[i];
|
|
|
|
if (ccb->startdone == ARCMSR_CCB_START) {
|
|
|
|
ccb->pcmd->result = DID_NO_CONNECT << 16;
|
|
|
|
arcmsr_pci_unmap_dma(ccb);
|
|
|
|
ccb->pcmd->scsi_done(ccb->pcmd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (target = 0; target < ARCMSR_MAX_TARGETID; target++) {
|
|
|
|
temp = *acb_dev_map;
|
|
|
|
if (temp) {
|
|
|
|
for (lun = 0; lun < ARCMSR_MAX_TARGETLUN; lun++) {
|
|
|
|
if (temp & 1) {
|
|
|
|
psdev = scsi_device_lookup(acb->host,
|
|
|
|
0, target, lun);
|
|
|
|
if (psdev != NULL) {
|
|
|
|
scsi_remove_device(psdev);
|
|
|
|
scsi_device_put(psdev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
temp >>= 1;
|
|
|
|
}
|
|
|
|
*acb_dev_map = 0;
|
|
|
|
}
|
|
|
|
acb_dev_map++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void arcmsr_free_pcidev(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
struct pci_dev *pdev;
|
|
|
|
struct Scsi_Host *host;
|
|
|
|
|
|
|
|
host = acb->host;
|
|
|
|
arcmsr_free_sysfs_attr(acb);
|
|
|
|
scsi_remove_host(host);
|
|
|
|
flush_work(&acb->arcmsr_do_message_isr_bh);
|
|
|
|
del_timer_sync(&acb->eternal_timer);
|
|
|
|
if (set_date_time)
|
|
|
|
del_timer_sync(&acb->refresh_timer);
|
|
|
|
pdev = acb->pdev;
|
|
|
|
arcmsr_free_irq(pdev, acb);
|
|
|
|
arcmsr_free_ccb_pool(acb);
|
2020-09-28 10:35:05 +00:00
|
|
|
if (acb->adapter_type == ACB_ADAPTER_TYPE_F)
|
|
|
|
arcmsr_free_io_queue(acb);
|
2018-03-15 06:33:36 +00:00
|
|
|
arcmsr_unmap_pciregion(acb);
|
|
|
|
pci_release_regions(pdev);
|
|
|
|
scsi_host_put(host);
|
|
|
|
pci_disable_device(pdev);
|
|
|
|
}
|
|
|
|
|
2006-07-12 15:59:32 +00:00
|
|
|
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;
|
2018-03-15 06:33:36 +00:00
|
|
|
uint16_t dev_id;
|
|
|
|
|
|
|
|
pci_read_config_word(pdev, PCI_DEVICE_ID, &dev_id);
|
|
|
|
if (dev_id == 0xffff) {
|
|
|
|
acb->acb_flags &= ~ACB_F_IOP_INITED;
|
|
|
|
acb->acb_flags |= ACB_F_ADAPTER_REMOVED;
|
|
|
|
arcmsr_remove_scsi_devices(acb);
|
|
|
|
arcmsr_free_pcidev(acb);
|
|
|
|
return;
|
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_free_sysfs_attr(acb);
|
|
|
|
scsi_remove_host(host);
|
2012-08-20 21:51:24 +00:00
|
|
|
flush_work(&acb->arcmsr_do_message_isr_bh);
|
2010-05-17 03:22:42 +00:00
|
|
|
del_timer_sync(&acb->eternal_timer);
|
2017-12-05 01:59:52 +00:00
|
|
|
if (set_date_time)
|
|
|
|
del_timer_sync(&acb->refresh_timer);
|
2010-05-17 03:22:42 +00:00
|
|
|
arcmsr_disable_outbound_ints(acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_stop_adapter_bgrb(acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
arcmsr_flush_adapter_cache(acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
acb->acb_flags |= ACB_F_SCSISTOPADAPTER;
|
|
|
|
acb->acb_flags &= ~ACB_F_IOP_INITED;
|
|
|
|
|
2017-12-05 01:51:27 +00:00
|
|
|
for (poll_count = 0; poll_count < acb->maxOutstanding; poll_count++){
|
2006-07-12 15:59:32 +00:00
|
|
|
if (!atomic_read(&acb->ccboutstandingcount))
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
arcmsr_interrupt(acb);/* FIXME: need spinlock */
|
2006-07-12 15:59:32 +00:00
|
|
|
msleep(25);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (atomic_read(&acb->ccboutstandingcount)) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
arcmsr_abort_allcmd(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
arcmsr_done4abort_postqueue(acb);
|
2017-12-05 01:44:23 +00:00
|
|
|
for (i = 0; i < acb->maxFreeCCB; i++) {
|
2006-07-12 15:59:32 +00:00
|
|
|
struct CommandControlBlock *ccb = acb->pccb_pool[i];
|
|
|
|
if (ccb->startdone == ARCMSR_CCB_START) {
|
|
|
|
ccb->startdone = ARCMSR_CCB_ABORTED;
|
|
|
|
ccb->pcmd->result = DID_ABORT << 16;
|
2010-06-18 07:39:12 +00:00
|
|
|
arcmsr_ccb_complete(ccb);
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-08-19 06:23:31 +00:00
|
|
|
arcmsr_free_irq(pdev, acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_free_ccb_pool(acb);
|
2020-09-28 10:35:05 +00:00
|
|
|
if (acb->adapter_type == ACB_ADAPTER_TYPE_F)
|
|
|
|
arcmsr_free_io_queue(acb);
|
2010-07-13 12:03:04 +00:00
|
|
|
arcmsr_unmap_pciregion(acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
pci_release_regions(pdev);
|
2010-07-13 12:03:04 +00:00
|
|
|
scsi_host_put(host);
|
2006-07-12 15:59:32 +00:00
|
|
|
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;
|
2018-03-15 06:33:36 +00:00
|
|
|
if (acb->acb_flags & ACB_F_ADAPTER_REMOVED)
|
|
|
|
return;
|
2010-05-17 03:22:42 +00:00
|
|
|
del_timer_sync(&acb->eternal_timer);
|
2017-12-05 01:59:52 +00:00
|
|
|
if (set_date_time)
|
|
|
|
del_timer_sync(&acb->refresh_timer);
|
2010-05-17 03:22:42 +00:00
|
|
|
arcmsr_disable_outbound_ints(acb);
|
2014-08-19 06:23:31 +00:00
|
|
|
arcmsr_free_irq(pdev, acb);
|
2012-08-20 21:51:24 +00:00
|
|
|
flush_work(&acb->arcmsr_do_message_isr_bh);
|
2006-07-12 15:59:32 +00:00
|
|
|
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);
|
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
static void arcmsr_enable_outbound_ints(struct AdapterControlBlock *acb,
|
2007-09-13 09:26:40 +00:00
|
|
|
u32 intmask_org)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
|
|
|
u32 mask;
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
mask = intmask_org & ~(ARCMSR_MU_OUTBOUND_POSTQUEUE_INTMASKENABLE |
|
2010-05-17 03:22:42 +00:00
|
|
|
ARCMSR_MU_OUTBOUND_DOORBELL_INTMASKENABLE|
|
|
|
|
ARCMSR_MU_OUTBOUND_MESSAGE0_INTMASKENABLE);
|
2007-09-13 09:26:40 +00:00
|
|
|
writel(mask, ®->outbound_intmask);
|
|
|
|
acb->outbound_int_enable = ~(intmask_org & mask) & 0x000000ff;
|
|
|
|
}
|
|
|
|
break;
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-05-17 03:22:42 +00:00
|
|
|
mask = intmask_org | (ARCMSR_IOP2DRV_DATA_WRITE_OK |
|
|
|
|
ARCMSR_IOP2DRV_DATA_READ_OK |
|
|
|
|
ARCMSR_IOP2DRV_CDB_DONE |
|
|
|
|
ARCMSR_IOP2DRV_MESSAGE_CMD_DONE);
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(mask, reg->iop2drv_doorbell_mask);
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->outbound_int_enable = (intmask_org | mask) & 0x0000000f;
|
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
mask = ~(ARCMSR_HBCMU_UTILITY_A_ISR_MASK | ARCMSR_HBCMU_OUTBOUND_DOORBELL_ISR_MASK|ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR_MASK);
|
|
|
|
writel(intmask_org & mask, ®->host_int_mask);
|
|
|
|
acb->outbound_int_enable = ~(intmask_org & mask) & 0x0000000f;
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
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;
|
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
2017-12-05 01:35:34 +00:00
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
|
|
|
|
mask = ~(ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR | ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR);
|
|
|
|
writel(intmask_org & mask, ®->host_int_mask);
|
|
|
|
break;
|
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-05 07:53:24 +00:00
|
|
|
static int arcmsr_build_ccb(struct AdapterControlBlock *acb,
|
2007-09-13 09:26:40 +00:00
|
|
|
struct CommandControlBlock *ccb, struct scsi_cmnd *pcmd)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
2007-09-13 09:26:40 +00:00
|
|
|
struct ARCMSR_CDB *arcmsr_cdb = (struct ARCMSR_CDB *)&ccb->arcmsr_cdb;
|
|
|
|
int8_t *psge = (int8_t *)&arcmsr_cdb->u;
|
2007-10-29 05:08:28 +00:00
|
|
|
__le32 address_lo, address_hi;
|
2007-09-13 09:26:40 +00:00
|
|
|
int arccdbsize = 0x30;
|
2010-06-18 07:39:12 +00:00
|
|
|
__le32 length = 0;
|
2010-07-13 12:03:04 +00:00
|
|
|
int i;
|
2010-06-18 07:39:12 +00:00
|
|
|
struct scatterlist *sg;
|
2007-09-13 09:26:40 +00:00
|
|
|
int nseg;
|
2006-07-12 15:59:32 +00:00
|
|
|
ccb->pcmd = pcmd;
|
2007-09-13 09:26:40 +00:00
|
|
|
memset(arcmsr_cdb, 0, sizeof(struct ARCMSR_CDB));
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_cdb->TargetID = pcmd->device->id;
|
|
|
|
arcmsr_cdb->LUN = pcmd->device->lun;
|
|
|
|
arcmsr_cdb->Function = 1;
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_cdb->msgContext = 0;
|
2006-07-12 15:59:32 +00:00
|
|
|
memcpy(arcmsr_cdb->Cdb, pcmd->cmnd, pcmd->cmd_len);
|
2007-05-14 10:25:56 +00:00
|
|
|
|
|
|
|
nseg = scsi_dma_map(pcmd);
|
2010-07-13 12:03:04 +00:00
|
|
|
if (unlikely(nseg > acb->host->sg_tablesize || nseg < 0))
|
2008-02-05 07:53:24 +00:00
|
|
|
return FAILED;
|
2010-07-13 12:03:04 +00:00
|
|
|
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;
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
|
|
|
arcmsr_cdb->sgcount = (uint8_t)nseg;
|
|
|
|
arcmsr_cdb->DataLength = scsi_bufflen(pcmd);
|
2010-06-18 07:39:12 +00:00
|
|
|
arcmsr_cdb->msgPages = arccdbsize/0x100 + (arccdbsize % 0x100 ? 1 : 0);
|
2010-07-13 12:03:04 +00:00
|
|
|
if ( arccdbsize > 256)
|
|
|
|
arcmsr_cdb->Flags |= ARCMSR_CDB_FLAG_SGL_BSIZE;
|
2011-01-01 18:40:23 +00:00
|
|
|
if (pcmd->sc_data_direction == DMA_TO_DEVICE)
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_cdb->Flags |= ARCMSR_CDB_FLAG_WRITE;
|
2010-07-13 12:03:04 +00:00
|
|
|
ccb->arc_cdb_size = arccdbsize;
|
2008-02-05 07:53:24 +00:00
|
|
|
return SUCCESS;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arcmsr_post_ccb(struct AdapterControlBlock *acb, struct CommandControlBlock *ccb)
|
|
|
|
{
|
2014-08-19 07:10:12 +00:00
|
|
|
uint32_t cdb_phyaddr = ccb->cdb_phyaddr;
|
2006-07-12 15:59:32 +00:00
|
|
|
struct ARCMSR_CDB *arcmsr_cdb = (struct ARCMSR_CDB *)&ccb->arcmsr_cdb;
|
|
|
|
atomic_inc(&acb->ccboutstandingcount);
|
|
|
|
ccb->startdone = ARCMSR_CCB_START;
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
|
|
|
|
if (arcmsr_cdb->Flags & ARCMSR_CDB_FLAG_SGL_BSIZE)
|
2014-08-19 07:10:12 +00:00
|
|
|
writel(cdb_phyaddr | ARCMSR_CCBPOST_FLAG_SGL_BSIZE,
|
2006-07-12 15:59:32 +00:00
|
|
|
®->inbound_queueport);
|
2014-08-19 07:10:12 +00:00
|
|
|
else
|
|
|
|
writel(cdb_phyaddr, ®->inbound_queueport);
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
2014-08-19 07:10:12 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
uint32_t ending_index, index = reg->postq_index;
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
ending_index = ((index + 1) % ARCMSR_MAX_HBB_POSTQUEUE);
|
2014-08-19 07:20:31 +00:00
|
|
|
reg->post_qbuffer[ending_index] = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
if (arcmsr_cdb->Flags & ARCMSR_CDB_FLAG_SGL_BSIZE) {
|
2014-08-19 07:20:31 +00:00
|
|
|
reg->post_qbuffer[index] =
|
|
|
|
cdb_phyaddr | ARCMSR_CCBPOST_FLAG_SGL_BSIZE;
|
2010-07-13 12:03:04 +00:00
|
|
|
} else {
|
2014-08-19 07:20:31 +00:00
|
|
|
reg->post_qbuffer[index] = cdb_phyaddr;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
index++;
|
|
|
|
index %= ARCMSR_MAX_HBB_POSTQUEUE;/*if last index number set it to 0 */
|
|
|
|
reg->postq_index = index;
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_DRV2IOP_CDB_POSTED, reg->drv2iop_doorbell);
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *phbcmu = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
uint32_t ccb_post_stamp, arc_cdb_size;
|
|
|
|
|
|
|
|
arc_cdb_size = (ccb->arc_cdb_size > 0x300) ? 0x300 : ccb->arc_cdb_size;
|
2014-08-19 07:10:12 +00:00
|
|
|
ccb_post_stamp = (cdb_phyaddr | ((arc_cdb_size - 1) >> 6) | 1);
|
2018-12-19 08:48:16 +00:00
|
|
|
writel(upper_32_bits(ccb->cdb_phyaddr), &phbcmu->inbound_queueport_high);
|
|
|
|
writel(ccb_post_stamp, &phbcmu->inbound_queueport_low);
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *pmu = acb->pmuD;
|
|
|
|
u16 index_stripped;
|
2014-09-15 11:05:33 +00:00
|
|
|
u16 postq_index, toggle;
|
2014-08-19 07:25:22 +00:00
|
|
|
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]);
|
2018-12-19 08:51:14 +00:00
|
|
|
pinbound_srb->addressHigh = upper_32_bits(ccb->cdb_phyaddr);
|
|
|
|
pinbound_srb->addressLow = cdb_phyaddr;
|
2014-08-19 07:25:22 +00:00
|
|
|
pinbound_srb->length = ccb->arc_cdb_size >> 2;
|
|
|
|
arcmsr_cdb->msgContext = dma_addr_lo32(cdb_phyaddr);
|
2014-09-15 11:05:33 +00:00
|
|
|
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);
|
2014-08-19 07:25:22 +00:00
|
|
|
writel(postq_index, pmu->inboundlist_write_pointer);
|
|
|
|
spin_unlock_irqrestore(&acb->postq_lock, flags);
|
|
|
|
break;
|
|
|
|
}
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
struct MessageUnit_E __iomem *pmu = acb->pmuE;
|
|
|
|
u32 ccb_post_stamp, arc_cdb_size;
|
|
|
|
|
|
|
|
arc_cdb_size = (ccb->arc_cdb_size > 0x300) ? 0x300 : ccb->arc_cdb_size;
|
|
|
|
ccb_post_stamp = (ccb->smid | ((arc_cdb_size - 1) >> 6));
|
|
|
|
writel(0, &pmu->inbound_queueport_high);
|
|
|
|
writel(ccb_post_stamp, &pmu->inbound_queueport_low);
|
|
|
|
break;
|
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
|
|
|
struct MessageUnit_F __iomem *pmu = acb->pmuF;
|
|
|
|
u32 ccb_post_stamp, arc_cdb_size;
|
|
|
|
|
|
|
|
if (ccb->arc_cdb_size <= 0x300)
|
|
|
|
arc_cdb_size = (ccb->arc_cdb_size - 1) >> 6 | 1;
|
2021-04-16 03:44:57 +00:00
|
|
|
else {
|
|
|
|
arc_cdb_size = ((ccb->arc_cdb_size + 0xff) >> 8) + 2;
|
|
|
|
if (arc_cdb_size > 0xF)
|
|
|
|
arc_cdb_size = 0xF;
|
|
|
|
arc_cdb_size = (arc_cdb_size << 1) | 1;
|
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
ccb_post_stamp = (ccb->smid | arc_cdb_size);
|
|
|
|
writel(0, &pmu->inbound_queueport_high);
|
|
|
|
writel(ccb_post_stamp, &pmu->inbound_queueport_low);
|
|
|
|
break;
|
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaA_stop_bgrb(struct AdapterControlBlock *acb)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2006-07-12 15:59:32 +00:00
|
|
|
acb->acb_flags &= ~ACB_F_MSG_START_BGRB;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_STOP_BGRB, ®->inbound_msgaddr0);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
|
2007-09-13 09:26:40 +00:00
|
|
|
printk(KERN_NOTICE
|
2018-09-03 17:35:29 +00:00
|
|
|
"arcmsr%d: wait 'stop adapter background rebuild' timeout\n"
|
2007-09-13 09:26:40 +00:00
|
|
|
, acb->host->host_no);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaB_stop_bgrb(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->acb_flags &= ~ACB_F_MSG_START_BGRB;
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_MESSAGE_STOP_BGRB, reg->drv2iop_doorbell);
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
2006-07-12 15:59:32 +00:00
|
|
|
printk(KERN_NOTICE
|
2018-09-03 17:35:29 +00:00
|
|
|
"arcmsr%d: wait 'stop adapter background rebuild' timeout\n"
|
2006-07-12 15:59:32 +00:00
|
|
|
, acb->host->host_no);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaC_stop_bgrb(struct AdapterControlBlock *pACB)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = pACB->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
pACB->acb_flags &= ~ACB_F_MSG_START_BGRB;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_STOP_BGRB, ®->inbound_msgaddr0);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, ®->inbound_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
|
2010-07-13 12:03:04 +00:00
|
|
|
printk(KERN_NOTICE
|
2018-09-03 17:35:29 +00:00
|
|
|
"arcmsr%d: wait 'stop adapter background rebuild' timeout\n"
|
2010-07-13 12:03:04 +00:00
|
|
|
, pACB->host->host_no);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
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))
|
2018-09-03 17:35:29 +00:00
|
|
|
pr_notice("arcmsr%d: wait 'stop adapter background rebuild' "
|
2014-08-19 07:25:22 +00:00
|
|
|
"timeout\n", pACB->host->host_no);
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static void arcmsr_hbaE_stop_bgrb(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
struct MessageUnit_E __iomem *reg = pACB->pmuE;
|
|
|
|
|
|
|
|
pACB->acb_flags &= ~ACB_F_MSG_START_BGRB;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_STOP_BGRB, ®->inbound_msgaddr0);
|
|
|
|
pACB->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(pACB->out_doorbell, ®->iobound_doorbell);
|
|
|
|
if (!arcmsr_hbaE_wait_msgint_ready(pACB)) {
|
2018-09-03 17:35:29 +00:00
|
|
|
pr_notice("arcmsr%d: wait 'stop adapter background rebuild' "
|
2017-12-05 01:35:34 +00:00
|
|
|
"timeout\n", pACB->host->host_no);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
static void arcmsr_stop_adapter_bgrb(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
switch (acb->adapter_type) {
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaA_stop_bgrb(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaB_stop_bgrb(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaC_stop_bgrb(acb);
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
arcmsr_hbaD_stop_bgrb(acb);
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
2017-12-05 01:35:34 +00:00
|
|
|
arcmsr_hbaE_stop_bgrb(acb);
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arcmsr_free_ccb_pool(struct AdapterControlBlock *acb)
|
|
|
|
{
|
2010-07-13 12:03:04 +00:00
|
|
|
dma_free_coherent(&acb->pdev->dev, acb->uncache_size, acb->dma_coherent, acb->dma_coherent_handle);
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:20:31 +00:00
|
|
|
static void arcmsr_iop_message_read(struct AdapterControlBlock *acb)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK, ®->inbound_doorbell);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_DRV2IOP_DATA_READ_OK, reg->drv2iop_doorbell);
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2014-08-19 07:25:22 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_DATA_READ_OK, ®->inbound_doorbell);
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
writel(ARCMSR_ARC1214_DRV2IOP_DATA_OUT_READ,
|
|
|
|
reg->inbound_doorbell);
|
|
|
|
}
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
2017-12-05 01:35:34 +00:00
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_DATA_READ_OK;
|
|
|
|
writel(acb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
}
|
|
|
|
break;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void arcmsr_iop_message_wrote(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2006-07-12 15:59:32 +00:00
|
|
|
/*
|
2007-09-13 09:26:40 +00:00
|
|
|
** push inbound doorbell tell iop, driver data write ok
|
|
|
|
** and wait reply on next hwinterrupt for next Qbuffer post
|
2006-07-12 15:59:32 +00:00
|
|
|
*/
|
2007-09-13 09:26:40 +00:00
|
|
|
writel(ARCMSR_INBOUND_DRIVER_DATA_WRITE_OK, ®->inbound_doorbell);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
/*
|
|
|
|
** push inbound doorbell tell iop, driver data write ok
|
|
|
|
** and wait reply on next hwinterrupt for next Qbuffer post
|
|
|
|
*/
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_DRV2IOP_DATA_WRITE_OK, reg->drv2iop_doorbell);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
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, ®->inbound_doorbell);
|
|
|
|
}
|
|
|
|
break;
|
2014-08-19 07:25:22 +00:00
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
writel(ARCMSR_ARC1214_DRV2IOP_DATA_IN_READY,
|
|
|
|
reg->inbound_doorbell);
|
|
|
|
}
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
2017-12-05 01:35:34 +00:00
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_DATA_WRITE_OK;
|
|
|
|
writel(acb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
}
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-10-29 05:08:28 +00:00
|
|
|
struct QBUFFER __iomem *arcmsr_get_iop_rqbuffer(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2007-10-29 05:08:58 +00:00
|
|
|
struct QBUFFER __iomem *qbuffer = NULL;
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
|
|
|
qbuffer = (struct QBUFFER __iomem *)®->message_rbuffer;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-06-18 07:39:12 +00:00
|
|
|
qbuffer = (struct QBUFFER __iomem *)reg->message_rbuffer;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *phbcmu = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
qbuffer = (struct QBUFFER __iomem *)&phbcmu->message_rbuffer;
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
qbuffer = (struct QBUFFER __iomem *)reg->message_rbuffer;
|
|
|
|
}
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
qbuffer = (struct QBUFFER __iomem *)®->message_rbuffer;
|
|
|
|
}
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
|
|
|
qbuffer = (struct QBUFFER __iomem *)acb->message_rbuffer;
|
|
|
|
}
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
return qbuffer;
|
|
|
|
}
|
|
|
|
|
2007-10-29 05:08:28 +00:00
|
|
|
static struct QBUFFER __iomem *arcmsr_get_iop_wqbuffer(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2007-10-29 05:08:58 +00:00
|
|
|
struct QBUFFER __iomem *pqbuffer = NULL;
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
|
|
|
pqbuffer = (struct QBUFFER __iomem *) ®->message_wbuffer;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-06-18 07:39:12 +00:00
|
|
|
pqbuffer = (struct QBUFFER __iomem *)reg->message_wbuffer;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
pqbuffer = (struct QBUFFER __iomem *)®->message_wbuffer;
|
2014-08-19 07:25:22 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
pqbuffer = (struct QBUFFER __iomem *)reg->message_wbuffer;
|
|
|
|
}
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
pqbuffer = (struct QBUFFER __iomem *)®->message_wbuffer;
|
|
|
|
}
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
|
|
|
pqbuffer = (struct QBUFFER __iomem *)acb->message_wbuffer;
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
return pqbuffer;
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:17:45 +00:00
|
|
|
static uint32_t
|
|
|
|
arcmsr_Read_iop_rqbuffer_in_DWORD(struct AdapterControlBlock *acb,
|
|
|
|
struct QBUFFER __iomem *prbuffer)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2014-08-19 07:17:45 +00:00
|
|
|
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);
|
2007-09-13 09:26:40 +00:00
|
|
|
iop_data++;
|
2014-08-19 07:17:45 +00:00
|
|
|
data_len -= 4;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2014-08-19 07:17:45 +00:00
|
|
|
if (data_len)
|
|
|
|
*buf2 = readl(iop_data);
|
|
|
|
buf2 = (uint32_t *)buf1;
|
|
|
|
}
|
|
|
|
while (iop_len > 0) {
|
2014-09-24 09:33:34 +00:00
|
|
|
pQbuffer = &acb->rqbuffer[acb->rqbuf_putIndex];
|
2014-08-19 07:17:45 +00:00
|
|
|
*pQbuffer = *buf1;
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->rqbuf_putIndex++;
|
2014-08-19 07:17:45 +00:00
|
|
|
/* if last, index number set it to 0 */
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->rqbuf_putIndex %= ARCMSR_MAX_QBUFFER;
|
2014-08-19 07:17:45 +00:00
|
|
|
buf1++;
|
|
|
|
iop_len--;
|
|
|
|
}
|
2014-09-24 09:33:34 +00:00
|
|
|
kfree(buf2);
|
2014-08-19 07:17:45 +00:00
|
|
|
/* 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;
|
|
|
|
|
2017-12-05 01:28:04 +00:00
|
|
|
if (acb->adapter_type > ACB_ADAPTER_TYPE_B)
|
2014-08-19 07:17:45 +00:00
|
|
|
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) {
|
2014-09-24 09:33:34 +00:00
|
|
|
pQbuffer = &acb->rqbuffer[acb->rqbuf_putIndex];
|
2014-08-19 07:17:45 +00:00
|
|
|
*pQbuffer = readb(iop_data);
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->rqbuf_putIndex++;
|
|
|
|
acb->rqbuf_putIndex %= ARCMSR_MAX_QBUFFER;
|
2014-08-19 07:17:45 +00:00
|
|
|
iop_data++;
|
|
|
|
iop_len--;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2014-08-19 07:17:45 +00:00
|
|
|
arcmsr_iop_message_read(acb);
|
|
|
|
return 1;
|
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2014-08-19 07:17:45 +00:00
|
|
|
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);
|
2014-09-24 09:33:34 +00:00
|
|
|
buf_empty_len = (acb->rqbuf_putIndex - acb->rqbuf_getIndex - 1) &
|
2014-08-19 07:17:45 +00:00
|
|
|
(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
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->acb_flags |= ACB_F_IOPDATA_OVERFLOW;
|
2014-08-19 07:17:45 +00:00
|
|
|
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;
|
2014-09-24 09:33:34 +00:00
|
|
|
while ((acb->wqbuf_getIndex != acb->wqbuf_putIndex)
|
2014-08-19 07:17:45 +00:00
|
|
|
&& (allxfer_len < 124)) {
|
2014-09-24 09:33:34 +00:00
|
|
|
pQbuffer = &acb->wqbuffer[acb->wqbuf_getIndex];
|
2014-08-19 07:17:45 +00:00
|
|
|
*buf1 = *pQbuffer;
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->wqbuf_getIndex++;
|
|
|
|
acb->wqbuf_getIndex %= ARCMSR_MAX_QBUFFER;
|
2014-08-19 07:17:45 +00:00
|
|
|
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);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:17:45 +00:00
|
|
|
void
|
|
|
|
arcmsr_write_ioctldata2iop(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2014-08-19 07:17:45 +00:00
|
|
|
uint8_t *pQbuffer;
|
|
|
|
struct QBUFFER __iomem *pwbuffer;
|
|
|
|
uint8_t __iomem *iop_data;
|
|
|
|
int32_t allxfer_len = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2017-12-05 01:28:04 +00:00
|
|
|
if (acb->adapter_type > ACB_ADAPTER_TYPE_B) {
|
2014-08-19 07:17:45 +00:00
|
|
|
arcmsr_write_ioctldata2iop_in_DWORD(acb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (acb->acb_flags & ACB_F_MESSAGE_WQBUFFER_READED) {
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->acb_flags &= (~ACB_F_MESSAGE_WQBUFFER_READED);
|
|
|
|
pwbuffer = arcmsr_get_iop_wqbuffer(acb);
|
|
|
|
iop_data = (uint8_t __iomem *)pwbuffer->data;
|
2014-09-24 09:33:34 +00:00
|
|
|
while ((acb->wqbuf_getIndex != acb->wqbuf_putIndex)
|
2014-08-19 07:17:45 +00:00
|
|
|
&& (allxfer_len < 124)) {
|
2014-09-24 09:33:34 +00:00
|
|
|
pQbuffer = &acb->wqbuffer[acb->wqbuf_getIndex];
|
2014-08-19 07:17:45 +00:00
|
|
|
writeb(*pQbuffer, iop_data);
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->wqbuf_getIndex++;
|
|
|
|
acb->wqbuf_getIndex %= ARCMSR_MAX_QBUFFER;
|
2007-09-13 09:26:40 +00:00
|
|
|
iop_data++;
|
|
|
|
allxfer_len++;
|
|
|
|
}
|
2014-08-19 07:17:45 +00:00
|
|
|
writel(allxfer_len, &pwbuffer->data_len);
|
2007-09-13 09:26:40 +00:00
|
|
|
arcmsr_iop_message_wrote(acb);
|
|
|
|
}
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2014-08-19 07:17:45 +00:00
|
|
|
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;
|
2014-09-24 09:33:34 +00:00
|
|
|
if (acb->wqbuf_getIndex != acb->wqbuf_putIndex)
|
2014-08-19 07:17:45 +00:00
|
|
|
arcmsr_write_ioctldata2iop(acb);
|
2014-09-24 09:33:34 +00:00
|
|
|
if (acb->wqbuf_getIndex == acb->wqbuf_putIndex)
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->acb_flags |= ACB_F_MESSAGE_WQBUFFER_CLEARED;
|
2014-08-19 07:17:45 +00:00
|
|
|
spin_unlock_irqrestore(&acb->wqbuffer_lock, flags);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaA_doorbell_isr(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
|
|
|
uint32_t outbound_doorbell;
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
outbound_doorbell = readl(®->outbound_doorbell);
|
2014-08-19 06:18:24 +00:00
|
|
|
do {
|
|
|
|
writel(outbound_doorbell, ®->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(®->outbound_doorbell);
|
|
|
|
} while (outbound_doorbell & (ARCMSR_OUTBOUND_IOP331_DATA_WRITE_OK
|
|
|
|
| ARCMSR_OUTBOUND_IOP331_DATA_READ_OK));
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaC_doorbell_isr(struct AdapterControlBlock *pACB)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
|
|
|
uint32_t outbound_doorbell;
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = pACB->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
/*
|
|
|
|
*******************************************************************
|
|
|
|
** 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(®->outbound_doorbell);
|
2014-08-19 06:18:24 +00:00
|
|
|
do {
|
|
|
|
writel(outbound_doorbell, ®->outbound_doorbell_clear);
|
|
|
|
readl(®->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)
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaC_message_isr(pACB);
|
2014-08-19 06:18:24 +00:00
|
|
|
outbound_doorbell = readl(®->outbound_doorbell);
|
|
|
|
} while (outbound_doorbell & (ARCMSR_HBCMU_IOP2DRV_DATA_WRITE_OK
|
|
|
|
| ARCMSR_HBCMU_IOP2DRV_DATA_READ_OK
|
|
|
|
| ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE));
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static void arcmsr_hbaE_doorbell_isr(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
2021-05-20 06:55:15 +00:00
|
|
|
uint32_t outbound_doorbell, in_doorbell, tmp, i;
|
2017-12-05 01:35:34 +00:00
|
|
|
struct MessageUnit_E __iomem *reg = pACB->pmuE;
|
|
|
|
|
2021-05-20 06:55:15 +00:00
|
|
|
if (pACB->adapter_type == ACB_ADAPTER_TYPE_F) {
|
|
|
|
for (i = 0; i < 5; i++) {
|
|
|
|
in_doorbell = readl(®->iobound_doorbell);
|
|
|
|
if (in_doorbell != 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
in_doorbell = readl(®->iobound_doorbell);
|
2017-12-05 01:35:34 +00:00
|
|
|
outbound_doorbell = in_doorbell ^ pACB->in_doorbell;
|
|
|
|
do {
|
|
|
|
writel(0, ®->host_int_status); /* clear interrupt */
|
|
|
|
if (outbound_doorbell & ARCMSR_HBEMU_IOP2DRV_DATA_WRITE_OK) {
|
|
|
|
arcmsr_iop2drv_data_wrote_handle(pACB);
|
|
|
|
}
|
|
|
|
if (outbound_doorbell & ARCMSR_HBEMU_IOP2DRV_DATA_READ_OK) {
|
|
|
|
arcmsr_iop2drv_data_read_handle(pACB);
|
|
|
|
}
|
|
|
|
if (outbound_doorbell & ARCMSR_HBEMU_IOP2DRV_MESSAGE_CMD_DONE) {
|
|
|
|
arcmsr_hbaE_message_isr(pACB);
|
|
|
|
}
|
|
|
|
tmp = in_doorbell;
|
|
|
|
in_doorbell = readl(®->iobound_doorbell);
|
|
|
|
outbound_doorbell = tmp ^ in_doorbell;
|
|
|
|
} while (outbound_doorbell & (ARCMSR_HBEMU_IOP2DRV_DATA_WRITE_OK
|
|
|
|
| ARCMSR_HBEMU_IOP2DRV_DATA_READ_OK
|
|
|
|
| ARCMSR_HBEMU_IOP2DRV_MESSAGE_CMD_DONE));
|
|
|
|
pACB->in_doorbell = in_doorbell;
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaA_postqueue_isr(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
|
|
|
uint32_t flag_ccb;
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2010-07-13 12:03:04 +00:00
|
|
|
struct ARCMSR_CDB *pARCMSR_CDB;
|
|
|
|
struct CommandControlBlock *pCCB;
|
|
|
|
bool error;
|
2018-12-19 08:43:15 +00:00
|
|
|
unsigned long cdb_phy_addr;
|
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
while ((flag_ccb = readl(®->outbound_queueport)) != 0xFFFFFFFF) {
|
2018-12-19 08:43:15 +00:00
|
|
|
cdb_phy_addr = (flag_ccb << 5) & 0xffffffff;
|
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
cdb_phy_addr = cdb_phy_addr | acb->cdb_phyadd_hipart;
|
|
|
|
pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset + cdb_phy_addr);
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaB_postqueue_isr(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
|
|
|
uint32_t index;
|
|
|
|
uint32_t flag_ccb;
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-07-13 12:03:04 +00:00
|
|
|
struct ARCMSR_CDB *pARCMSR_CDB;
|
|
|
|
struct CommandControlBlock *pCCB;
|
|
|
|
bool error;
|
2018-12-19 08:45:46 +00:00
|
|
|
unsigned long cdb_phy_addr;
|
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
index = reg->doneq_index;
|
2014-08-19 07:20:31 +00:00
|
|
|
while ((flag_ccb = reg->done_qbuffer[index]) != 0) {
|
2018-12-19 08:45:46 +00:00
|
|
|
cdb_phy_addr = (flag_ccb << 5) & 0xffffffff;
|
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
cdb_phy_addr = cdb_phy_addr | acb->cdb_phyadd_hipart;
|
|
|
|
pARCMSR_CDB = (struct ARCMSR_CDB *)(acb->vir2phy_offset + cdb_phy_addr);
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
2018-12-19 08:45:46 +00:00
|
|
|
reg->done_qbuffer[index] = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
index++;
|
|
|
|
index %= ARCMSR_MAX_HBB_POSTQUEUE;
|
|
|
|
reg->doneq_index = index;
|
|
|
|
}
|
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaC_postqueue_isr(struct AdapterControlBlock *acb)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *phbcmu;
|
2010-07-13 12:03:04 +00:00
|
|
|
struct ARCMSR_CDB *arcmsr_cdb;
|
|
|
|
struct CommandControlBlock *ccb;
|
2018-12-19 08:48:16 +00:00
|
|
|
uint32_t flag_ccb, throttling = 0;
|
|
|
|
unsigned long ccb_cdb_phy;
|
2010-07-13 12:03:04 +00:00
|
|
|
int error;
|
|
|
|
|
2014-08-19 07:20:31 +00:00
|
|
|
phbcmu = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
/* areca cdb command done */
|
|
|
|
/* Use correct offset and size for syncing */
|
|
|
|
|
2014-08-19 06:18:24 +00:00
|
|
|
while ((flag_ccb = readl(&phbcmu->outbound_queueport_low)) !=
|
|
|
|
0xFFFFFFFF) {
|
|
|
|
ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
|
2018-12-19 08:48:16 +00:00
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
2014-08-19 06:18:24 +00:00
|
|
|
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;
|
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
static void arcmsr_hbaD_postqueue_isr(struct AdapterControlBlock *acb)
|
|
|
|
{
|
2014-09-15 11:05:33 +00:00
|
|
|
u32 outbound_write_pointer, doneq_index, index_stripped, toggle;
|
2018-12-19 08:51:14 +00:00
|
|
|
uint32_t addressLow;
|
2014-08-19 07:25:22 +00:00
|
|
|
int error;
|
|
|
|
struct MessageUnit_D *pmu;
|
|
|
|
struct ARCMSR_CDB *arcmsr_cdb;
|
|
|
|
struct CommandControlBlock *ccb;
|
2020-07-13 07:46:30 +00:00
|
|
|
unsigned long flags, ccb_cdb_phy;
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
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 {
|
2014-09-15 11:05:33 +00:00
|
|
|
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);
|
2014-08-19 07:25:22 +00:00
|
|
|
doneq_index = pmu->doneq_index;
|
|
|
|
addressLow = pmu->done_qbuffer[doneq_index &
|
|
|
|
0xFFF].addressLow;
|
|
|
|
ccb_cdb_phy = (addressLow & 0xFFFFFFF0);
|
2018-12-19 08:51:14 +00:00
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
2014-08-19 07:25:22 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static void arcmsr_hbaE_postqueue_isr(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
uint32_t doneq_index;
|
|
|
|
uint16_t cmdSMID;
|
|
|
|
int error;
|
|
|
|
struct MessageUnit_E __iomem *pmu;
|
|
|
|
struct CommandControlBlock *ccb;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&acb->doneq_lock, flags);
|
|
|
|
doneq_index = acb->doneq_index;
|
|
|
|
pmu = acb->pmuE;
|
|
|
|
while ((readl(&pmu->reply_post_producer_index) & 0xFFFF) != doneq_index) {
|
|
|
|
cmdSMID = acb->pCompletionQ[doneq_index].cmdSMID;
|
|
|
|
ccb = acb->pccb_pool[cmdSMID];
|
|
|
|
error = (acb->pCompletionQ[doneq_index].cmdFlag
|
|
|
|
& ARCMSR_CCBREPLY_FLAG_ERROR_MODE1) ? true : false;
|
|
|
|
arcmsr_drain_donequeue(acb, ccb, error);
|
|
|
|
doneq_index++;
|
|
|
|
if (doneq_index >= acb->completionQ_entry)
|
|
|
|
doneq_index = 0;
|
|
|
|
}
|
|
|
|
acb->doneq_index = doneq_index;
|
|
|
|
writel(doneq_index, &pmu->reply_post_consumer_index);
|
|
|
|
spin_unlock_irqrestore(&acb->doneq_lock, flags);
|
|
|
|
}
|
|
|
|
|
2020-09-28 10:35:05 +00:00
|
|
|
static void arcmsr_hbaF_postqueue_isr(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
uint32_t doneq_index;
|
|
|
|
uint16_t cmdSMID;
|
|
|
|
int error;
|
|
|
|
struct MessageUnit_F __iomem *phbcmu;
|
|
|
|
struct CommandControlBlock *ccb;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&acb->doneq_lock, flags);
|
|
|
|
doneq_index = acb->doneq_index;
|
|
|
|
phbcmu = acb->pmuF;
|
|
|
|
while (1) {
|
|
|
|
cmdSMID = acb->pCompletionQ[doneq_index].cmdSMID;
|
|
|
|
if (cmdSMID == 0xffff)
|
|
|
|
break;
|
|
|
|
ccb = acb->pccb_pool[cmdSMID];
|
|
|
|
error = (acb->pCompletionQ[doneq_index].cmdFlag &
|
|
|
|
ARCMSR_CCBREPLY_FLAG_ERROR_MODE1) ? true : false;
|
|
|
|
arcmsr_drain_donequeue(acb, ccb, error);
|
|
|
|
acb->pCompletionQ[doneq_index].cmdSMID = 0xffff;
|
|
|
|
doneq_index++;
|
|
|
|
if (doneq_index >= acb->completionQ_entry)
|
|
|
|
doneq_index = 0;
|
|
|
|
}
|
|
|
|
acb->doneq_index = doneq_index;
|
|
|
|
writel(doneq_index, &phbcmu->reply_post_consumer_index);
|
|
|
|
spin_unlock_irqrestore(&acb->doneq_lock, flags);
|
|
|
|
}
|
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
/*
|
|
|
|
**********************************************************************************
|
|
|
|
** Handle a message interrupt
|
|
|
|
**
|
2010-07-13 12:03:04 +00:00
|
|
|
** The only message interrupt we expect is in response to a query for the current adapter config.
|
2010-05-17 03:22:42 +00:00
|
|
|
** We want this in order to compare the drivemap so that we can detect newly-attached drives.
|
|
|
|
**********************************************************************************
|
|
|
|
*/
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaA_message_isr(struct AdapterControlBlock *acb)
|
2010-05-17 03:22:42 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2010-05-17 03:22:42 +00:00
|
|
|
/*clear interrupt and message state*/
|
|
|
|
writel(ARCMSR_MU_OUTBOUND_MESSAGE0_INT, ®->outbound_intstatus);
|
2017-12-05 01:57:23 +00:00
|
|
|
if (acb->acb_flags & ACB_F_MSG_GET_CONFIG)
|
|
|
|
schedule_work(&acb->arcmsr_do_message_isr_bh);
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaB_message_isr(struct AdapterControlBlock *acb)
|
2010-05-17 03:22:42 +00:00
|
|
|
{
|
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
/*clear interrupt and message state*/
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_MESSAGE_INT_CLEAR_PATTERN, reg->iop2drv_doorbell);
|
2017-12-05 01:57:23 +00:00
|
|
|
if (acb->acb_flags & ACB_F_MSG_GET_CONFIG)
|
|
|
|
schedule_work(&acb->arcmsr_do_message_isr_bh);
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
/*
|
|
|
|
**********************************************************************************
|
|
|
|
** 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.
|
|
|
|
**********************************************************************************
|
|
|
|
*/
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaC_message_isr(struct AdapterControlBlock *acb)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
/*clear interrupt and message state*/
|
|
|
|
writel(ARCMSR_HBCMU_IOP2DRV_MESSAGE_CMD_DONE_DOORBELL_CLEAR, ®->outbound_doorbell_clear);
|
2017-12-05 01:57:23 +00:00
|
|
|
if (acb->acb_flags & ACB_F_MSG_GET_CONFIG)
|
|
|
|
schedule_work(&acb->arcmsr_do_message_isr_bh);
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:25:22 +00:00
|
|
|
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);
|
2017-12-05 01:57:23 +00:00
|
|
|
if (acb->acb_flags & ACB_F_MSG_GET_CONFIG)
|
|
|
|
schedule_work(&acb->arcmsr_do_message_isr_bh);
|
2014-08-19 07:25:22 +00:00
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static void arcmsr_hbaE_message_isr(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
|
|
|
|
writel(0, ®->host_int_status);
|
2017-12-05 01:57:23 +00:00
|
|
|
if (acb->acb_flags & ACB_F_MSG_GET_CONFIG)
|
|
|
|
schedule_work(&acb->arcmsr_do_message_isr_bh);
|
2017-12-05 01:35:34 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static int arcmsr_hbaA_handle_isr(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
|
|
|
uint32_t outbound_intstatus;
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2010-05-17 03:22:42 +00:00
|
|
|
outbound_intstatus = readl(®->outbound_intstatus) &
|
2010-07-13 12:03:04 +00:00
|
|
|
acb->outbound_int_enable;
|
2014-08-19 06:18:24 +00:00
|
|
|
if (!(outbound_intstatus & ARCMSR_MU_OUTBOUND_HANDLE_INT))
|
|
|
|
return IRQ_NONE;
|
|
|
|
do {
|
|
|
|
writel(outbound_intstatus, ®->outbound_intstatus);
|
|
|
|
if (outbound_intstatus & ARCMSR_MU_OUTBOUND_DOORBELL_INT)
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaA_doorbell_isr(acb);
|
2014-08-19 06:18:24 +00:00
|
|
|
if (outbound_intstatus & ARCMSR_MU_OUTBOUND_POSTQUEUE_INT)
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaA_postqueue_isr(acb);
|
2014-08-19 06:18:24 +00:00
|
|
|
if (outbound_intstatus & ARCMSR_MU_OUTBOUND_MESSAGE0_INT)
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaA_message_isr(acb);
|
2014-08-19 06:18:24 +00:00
|
|
|
outbound_intstatus = readl(®->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;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static int arcmsr_hbaB_handle_isr(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
|
|
|
uint32_t outbound_doorbell;
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-06-18 07:39:12 +00:00
|
|
|
outbound_doorbell = readl(reg->iop2drv_doorbell) &
|
2010-07-13 12:03:04 +00:00
|
|
|
acb->outbound_int_enable;
|
2007-09-13 09:26:40 +00:00
|
|
|
if (!outbound_doorbell)
|
2014-08-19 06:18:24 +00:00
|
|
|
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)
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaB_postqueue_isr(acb);
|
2014-08-19 06:18:24 +00:00
|
|
|
if (outbound_doorbell & ARCMSR_IOP2DRV_MESSAGE_CMD_DONE)
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaB_message_isr(acb);
|
2014-08-19 06:18:24 +00:00
|
|
|
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;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static int arcmsr_hbaC_handle_isr(struct AdapterControlBlock *pACB)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
|
|
|
uint32_t host_interrupt_status;
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *phbcmu = pACB->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
/*
|
|
|
|
*********************************************
|
|
|
|
** check outbound intstatus
|
|
|
|
*********************************************
|
|
|
|
*/
|
2014-08-19 06:18:24 +00:00
|
|
|
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)
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaC_doorbell_isr(pACB);
|
2014-08-19 06:18:24 +00:00
|
|
|
/* MU post queue interrupts*/
|
|
|
|
if (host_interrupt_status & ARCMSR_HBCMU_OUTBOUND_POSTQUEUE_ISR)
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaC_postqueue_isr(pACB);
|
2014-08-19 06:18:24 +00:00
|
|
|
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;
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static irqreturn_t arcmsr_hbaE_handle_isr(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
uint32_t host_interrupt_status;
|
|
|
|
struct MessageUnit_E __iomem *pmu = pACB->pmuE;
|
|
|
|
|
|
|
|
host_interrupt_status = readl(&pmu->host_int_status) &
|
|
|
|
(ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR |
|
|
|
|
ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR);
|
|
|
|
if (!host_interrupt_status)
|
|
|
|
return IRQ_NONE;
|
|
|
|
do {
|
|
|
|
/* MU ioctl transfer doorbell interrupts*/
|
|
|
|
if (host_interrupt_status & ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR) {
|
|
|
|
arcmsr_hbaE_doorbell_isr(pACB);
|
|
|
|
}
|
|
|
|
/* MU post queue interrupts*/
|
|
|
|
if (host_interrupt_status & ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR) {
|
|
|
|
arcmsr_hbaE_postqueue_isr(pACB);
|
|
|
|
}
|
|
|
|
host_interrupt_status = readl(&pmu->host_int_status);
|
|
|
|
} while (host_interrupt_status & (ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR |
|
|
|
|
ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR));
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2020-09-28 10:35:05 +00:00
|
|
|
static irqreturn_t arcmsr_hbaF_handle_isr(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
uint32_t host_interrupt_status;
|
|
|
|
struct MessageUnit_F __iomem *phbcmu = pACB->pmuF;
|
|
|
|
|
|
|
|
host_interrupt_status = readl(&phbcmu->host_int_status) &
|
|
|
|
(ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR |
|
|
|
|
ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR);
|
|
|
|
if (!host_interrupt_status)
|
|
|
|
return IRQ_NONE;
|
|
|
|
do {
|
|
|
|
/* MU post queue interrupts*/
|
|
|
|
if (host_interrupt_status & ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR)
|
|
|
|
arcmsr_hbaF_postqueue_isr(pACB);
|
|
|
|
|
|
|
|
/* MU ioctl transfer doorbell interrupts*/
|
|
|
|
if (host_interrupt_status & ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR)
|
|
|
|
arcmsr_hbaE_doorbell_isr(pACB);
|
|
|
|
|
|
|
|
host_interrupt_status = readl(&phbcmu->host_int_status);
|
|
|
|
} while (host_interrupt_status & (ARCMSR_HBEMU_OUTBOUND_POSTQUEUE_ISR |
|
|
|
|
ARCMSR_HBEMU_OUTBOUND_DOORBELL_ISR));
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
static irqreturn_t arcmsr_interrupt(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
switch (acb->adapter_type) {
|
2014-08-19 06:18:24 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A:
|
2014-08-19 07:10:12 +00:00
|
|
|
return arcmsr_hbaA_handle_isr(acb);
|
2014-08-19 06:18:24 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2014-08-19 07:10:12 +00:00
|
|
|
return arcmsr_hbaB_handle_isr(acb);
|
2014-08-19 06:18:24 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C:
|
2014-08-19 07:10:12 +00:00
|
|
|
return arcmsr_hbaC_handle_isr(acb);
|
2014-08-19 07:25:22 +00:00
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
return arcmsr_hbaD_handle_isr(acb);
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
return arcmsr_hbaE_handle_isr(acb);
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
|
|
|
return arcmsr_hbaF_handle_isr(acb);
|
2014-08-19 06:18:24 +00:00
|
|
|
default:
|
|
|
|
return IRQ_NONE;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void arcmsr_iop_parking(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
if (acb) {
|
|
|
|
/* stop adapter background rebuild */
|
|
|
|
if (acb->acb_flags & ACB_F_MSG_START_BGRB) {
|
2007-09-13 09:26:40 +00:00
|
|
|
uint32_t intmask_org;
|
2006-07-12 15:59:32 +00:00
|
|
|
acb->acb_flags &= ~ACB_F_MSG_START_BGRB;
|
2007-09-13 09:26:40 +00:00
|
|
|
intmask_org = arcmsr_disable_outbound_ints(acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_stop_adapter_bgrb(acb);
|
|
|
|
arcmsr_flush_adapter_cache(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
arcmsr_enable_outbound_ints(acb, intmask_org);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:17:45 +00:00
|
|
|
|
|
|
|
void arcmsr_clear_iop2drv_rqueue_buffer(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2014-08-19 07:17:45 +00:00
|
|
|
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;
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->rqbuf_getIndex = 0;
|
|
|
|
acb->rqbuf_putIndex = 0;
|
2014-08-19 07:17:45 +00:00
|
|
|
arcmsr_iop_message_read(acb);
|
|
|
|
mdelay(30);
|
2014-09-24 09:33:34 +00:00
|
|
|
} else if (acb->rqbuf_getIndex !=
|
|
|
|
acb->rqbuf_putIndex) {
|
|
|
|
acb->rqbuf_getIndex = 0;
|
|
|
|
acb->rqbuf_putIndex = 0;
|
2014-08-19 07:17:45 +00:00
|
|
|
mdelay(30);
|
|
|
|
} else
|
|
|
|
break;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
static int arcmsr_iop_message_xfer(struct AdapterControlBlock *acb,
|
2014-08-19 07:17:45 +00:00
|
|
|
struct scsi_cmnd *cmd)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
|
|
|
char *buffer;
|
2014-08-19 07:17:45 +00:00
|
|
|
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];
|
2007-05-14 10:25:56 +00:00
|
|
|
struct scatterlist *sg;
|
2014-08-19 07:17:45 +00:00
|
|
|
|
|
|
|
use_sg = scsi_sg_count(cmd);
|
2007-05-14 10:25:56 +00:00
|
|
|
sg = scsi_sglist(cmd);
|
2011-11-25 15:14:23 +00:00
|
|
|
buffer = kmap_atomic(sg_page(sg)) + sg->offset;
|
2014-08-19 07:17:45 +00:00
|
|
|
if (use_sg > 1) {
|
2007-05-14 10:25:56 +00:00
|
|
|
retvalue = ARCMSR_MESSAGE_FAIL;
|
|
|
|
goto message_out;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2007-05-14 10:25:56 +00:00
|
|
|
transfer_len += sg->length;
|
2006-07-12 15:59:32 +00:00
|
|
|
if (transfer_len > sizeof(struct CMD_MESSAGE_FIELD)) {
|
|
|
|
retvalue = ARCMSR_MESSAGE_FAIL;
|
2014-08-19 07:17:45 +00:00
|
|
|
pr_info("%s: ARCMSR_MESSAGE_FAIL!\n", __func__);
|
2006-07-12 15:59:32 +00:00
|
|
|
goto message_out;
|
|
|
|
}
|
2014-08-19 07:17:45 +00:00
|
|
|
pcmdmessagefld = (struct CMD_MESSAGE_FIELD *)buffer;
|
|
|
|
switch (controlcode) {
|
2006-07-12 15:59:32 +00:00
|
|
|
case ARCMSR_MESSAGE_READ_RQBUFFER: {
|
2008-02-20 13:29:05 +00:00
|
|
|
unsigned char *ver_addr;
|
2014-09-24 09:33:34 +00:00
|
|
|
uint8_t *ptmpQbuffer;
|
2014-08-19 07:17:45 +00:00
|
|
|
uint32_t allxfer_len = 0;
|
2014-09-24 09:33:34 +00:00
|
|
|
ver_addr = kmalloc(ARCMSR_API_DATA_BUFLEN, GFP_ATOMIC);
|
2008-02-20 13:29:05 +00:00
|
|
|
if (!ver_addr) {
|
2007-09-13 09:26:40 +00:00
|
|
|
retvalue = ARCMSR_MESSAGE_FAIL;
|
2014-08-19 07:17:45 +00:00
|
|
|
pr_info("%s: memory not enough!\n", __func__);
|
2007-09-13 09:26:40 +00:00
|
|
|
goto message_out;
|
|
|
|
}
|
2008-02-20 13:29:05 +00:00
|
|
|
ptmpQbuffer = ver_addr;
|
2014-08-19 07:17:45 +00:00
|
|
|
spin_lock_irqsave(&acb->rqbuffer_lock, flags);
|
2014-09-24 09:33:34 +00:00
|
|
|
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);
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->rqbuf_getIndex = (acb->rqbuf_getIndex + allxfer_len) % ARCMSR_MAX_QBUFFER;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2014-08-19 07:17:45 +00:00
|
|
|
memcpy(pcmdmessagefld->messagedatabuffer, ver_addr,
|
|
|
|
allxfer_len);
|
2007-09-13 09:26:40 +00:00
|
|
|
if (acb->acb_flags & ACB_F_IOPDATA_OVERFLOW) {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct QBUFFER __iomem *prbuffer;
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->acb_flags &= ~ACB_F_IOPDATA_OVERFLOW;
|
|
|
|
prbuffer = arcmsr_get_iop_rqbuffer(acb);
|
2014-08-19 07:17:45 +00:00
|
|
|
if (arcmsr_Read_iop_rqbuffer_data(acb, prbuffer) == 0)
|
|
|
|
acb->acb_flags |= ACB_F_IOPDATA_OVERFLOW;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
2014-08-19 07:17:45 +00:00
|
|
|
spin_unlock_irqrestore(&acb->rqbuffer_lock, flags);
|
2008-02-20 13:29:05 +00:00
|
|
|
kfree(ver_addr);
|
2014-08-19 07:17:45 +00:00
|
|
|
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;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
case ARCMSR_MESSAGE_WRITE_WQBUFFER: {
|
2008-02-20 13:29:05 +00:00
|
|
|
unsigned char *ver_addr;
|
2016-09-15 13:44:56 +00:00
|
|
|
uint32_t user_len;
|
|
|
|
int32_t cnt2end;
|
2007-09-13 09:26:40 +00:00
|
|
|
uint8_t *pQbuffer, *ptmpuserbuffer;
|
2016-09-23 11:22:26 +00:00
|
|
|
|
|
|
|
user_len = pcmdmessagefld->cmdmessage.Length;
|
|
|
|
if (user_len > ARCMSR_API_DATA_BUFLEN) {
|
2007-09-13 09:26:40 +00:00
|
|
|
retvalue = ARCMSR_MESSAGE_FAIL;
|
|
|
|
goto message_out;
|
|
|
|
}
|
2016-09-23 11:22:26 +00:00
|
|
|
|
|
|
|
ver_addr = kmalloc(ARCMSR_API_DATA_BUFLEN, GFP_ATOMIC);
|
|
|
|
if (!ver_addr) {
|
2016-09-15 13:44:56 +00:00
|
|
|
retvalue = ARCMSR_MESSAGE_FAIL;
|
|
|
|
goto message_out;
|
|
|
|
}
|
2016-09-23 11:22:26 +00:00
|
|
|
ptmpuserbuffer = ver_addr;
|
|
|
|
|
2014-08-19 07:17:45 +00:00
|
|
|
memcpy(ptmpuserbuffer,
|
|
|
|
pcmdmessagefld->messagedatabuffer, user_len);
|
|
|
|
spin_lock_irqsave(&acb->wqbuffer_lock, flags);
|
2014-09-24 09:33:34 +00:00
|
|
|
if (acb->wqbuf_putIndex != acb->wqbuf_getIndex) {
|
2007-09-13 09:26:40 +00:00
|
|
|
struct SENSE_DATA *sensebuffer =
|
|
|
|
(struct SENSE_DATA *)cmd->sense_buffer;
|
2014-08-19 07:17:45 +00:00
|
|
|
arcmsr_write_ioctldata2iop(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
/* has error report sensedata */
|
2014-08-19 07:17:45 +00:00
|
|
|
sensebuffer->ErrorCode = SCSI_SENSE_CURRENT_ERRORS;
|
2007-09-13 09:26:40 +00:00
|
|
|
sensebuffer->SenseKey = ILLEGAL_REQUEST;
|
|
|
|
sensebuffer->AdditionalSenseLength = 0x0A;
|
|
|
|
sensebuffer->AdditionalSenseCode = 0x20;
|
|
|
|
sensebuffer->Valid = 1;
|
|
|
|
retvalue = ARCMSR_MESSAGE_FAIL;
|
|
|
|
} else {
|
2014-09-24 09:33:34 +00:00
|
|
|
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 &=
|
2007-09-13 09:26:40 +00:00
|
|
|
~ACB_F_MESSAGE_WQBUFFER_CLEARED;
|
2014-09-24 09:33:34 +00:00
|
|
|
arcmsr_write_ioctldata2iop(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2014-08-19 07:17:45 +00:00
|
|
|
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;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
case ARCMSR_MESSAGE_CLEAR_RQBUFFER: {
|
2007-09-13 09:26:40 +00:00
|
|
|
uint8_t *pQbuffer = acb->rqbuffer;
|
2014-08-19 07:17:45 +00:00
|
|
|
|
|
|
|
arcmsr_clear_iop2drv_rqueue_buffer(acb);
|
|
|
|
spin_lock_irqsave(&acb->rqbuffer_lock, flags);
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->acb_flags |= ACB_F_MESSAGE_RQBUFFER_CLEARED;
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->rqbuf_getIndex = 0;
|
|
|
|
acb->rqbuf_putIndex = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
memset(pQbuffer, 0, ARCMSR_MAX_QBUFFER);
|
2014-08-19 07:17:45 +00:00
|
|
|
spin_unlock_irqrestore(&acb->rqbuffer_lock, flags);
|
|
|
|
if (acb->fw_flag == FW_DEADLOCK)
|
2010-06-18 07:39:12 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
|
|
|
|
else
|
2010-06-18 07:39:12 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_OK;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
case ARCMSR_MESSAGE_CLEAR_WQBUFFER: {
|
2007-09-13 09:26:40 +00:00
|
|
|
uint8_t *pQbuffer = acb->wqbuffer;
|
2014-08-19 07:17:45 +00:00
|
|
|
spin_lock_irqsave(&acb->wqbuffer_lock, flags);
|
|
|
|
acb->acb_flags |= (ACB_F_MESSAGE_WQBUFFER_CLEARED |
|
|
|
|
ACB_F_MESSAGE_WQBUFFER_READED);
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->wqbuf_getIndex = 0;
|
|
|
|
acb->wqbuf_putIndex = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
memset(pQbuffer, 0, ARCMSR_MAX_QBUFFER);
|
2014-08-19 07:17:45 +00:00
|
|
|
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;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
case ARCMSR_MESSAGE_CLEAR_ALLQBUFFER: {
|
2007-09-13 09:26:40 +00:00
|
|
|
uint8_t *pQbuffer;
|
2014-08-19 07:17:45 +00:00
|
|
|
arcmsr_clear_iop2drv_rqueue_buffer(acb);
|
|
|
|
spin_lock_irqsave(&acb->rqbuffer_lock, flags);
|
|
|
|
acb->acb_flags |= ACB_F_MESSAGE_RQBUFFER_CLEARED;
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->rqbuf_getIndex = 0;
|
|
|
|
acb->rqbuf_putIndex = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
pQbuffer = acb->rqbuffer;
|
|
|
|
memset(pQbuffer, 0, sizeof(struct QBUFFER));
|
2014-08-19 07:17:45 +00:00
|
|
|
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);
|
2014-09-24 09:33:34 +00:00
|
|
|
acb->wqbuf_getIndex = 0;
|
|
|
|
acb->wqbuf_putIndex = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
pQbuffer = acb->wqbuffer;
|
|
|
|
memset(pQbuffer, 0, sizeof(struct QBUFFER));
|
2014-08-19 07:17:45 +00:00
|
|
|
spin_unlock_irqrestore(&acb->wqbuffer_lock, flags);
|
|
|
|
if (acb->fw_flag == FW_DEADLOCK)
|
2010-06-18 07:39:12 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
|
|
|
|
else
|
2010-06-18 07:39:12 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_OK;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
case ARCMSR_MESSAGE_RETURN_CODE_3F: {
|
2014-08-19 07:17:45 +00:00
|
|
|
if (acb->fw_flag == FW_DEADLOCK)
|
2010-05-17 03:22:42 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
|
|
|
|
else
|
2010-06-18 07:39:12 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_3F;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
case ARCMSR_MESSAGE_SAY_HELLO: {
|
2007-09-13 09:26:40 +00:00
|
|
|
int8_t *hello_string = "Hello! I am ARCMSR";
|
2014-08-19 07:17:45 +00:00
|
|
|
if (acb->fw_flag == FW_DEADLOCK)
|
2010-05-17 03:22:42 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
|
|
|
|
else
|
2010-06-18 07:39:12 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_OK;
|
|
|
|
memcpy(pcmdmessagefld->messagedatabuffer,
|
|
|
|
hello_string, (int16_t)strlen(hello_string));
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
|
|
|
case ARCMSR_MESSAGE_SAY_GOODBYE: {
|
|
|
|
if (acb->fw_flag == FW_DEADLOCK)
|
2010-05-17 03:22:42 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
|
|
|
|
else
|
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
|
|
|
ARCMSR_MESSAGE_RETURNCODE_OK;
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_iop_parking(acb);
|
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
|
|
|
case ARCMSR_MESSAGE_FLUSH_ADAPTER_CACHE: {
|
|
|
|
if (acb->fw_flag == FW_DEADLOCK)
|
2010-05-17 03:22:42 +00:00
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
2014-08-19 07:17:45 +00:00
|
|
|
ARCMSR_MESSAGE_RETURNCODE_BUS_HANG_ON;
|
|
|
|
else
|
|
|
|
pcmdmessagefld->cmdmessage.ReturnCode =
|
|
|
|
ARCMSR_MESSAGE_RETURNCODE_OK;
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_flush_adapter_cache(acb);
|
|
|
|
break;
|
2014-08-19 07:17:45 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
default:
|
|
|
|
retvalue = ARCMSR_MESSAGE_FAIL;
|
2014-08-19 07:17:45 +00:00
|
|
|
pr_info("%s: unknown controlcode!\n", __func__);
|
|
|
|
}
|
|
|
|
message_out:
|
|
|
|
if (use_sg) {
|
|
|
|
struct scatterlist *sg = scsi_sglist(cmd);
|
|
|
|
kunmap_atomic(buffer - sg->offset);
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
return retvalue;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct CommandControlBlock *arcmsr_get_freeccb(struct AdapterControlBlock *acb)
|
|
|
|
{
|
2020-10-27 03:39:13 +00:00
|
|
|
struct list_head *head;
|
2006-07-12 15:59:32 +00:00
|
|
|
struct CommandControlBlock *ccb = NULL;
|
2010-06-18 07:39:12 +00:00
|
|
|
unsigned long flags;
|
2020-10-27 03:39:13 +00:00
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
spin_lock_irqsave(&acb->ccblist_lock, flags);
|
2020-10-27 03:39:13 +00:00
|
|
|
head = &acb->ccb_free_list;
|
2006-07-12 15:59:32 +00:00
|
|
|
if (!list_empty(head)) {
|
|
|
|
ccb = list_entry(head->next, struct CommandControlBlock, list);
|
2010-06-18 07:39:12 +00:00
|
|
|
list_del_init(&ccb->list);
|
2010-07-13 12:03:04 +00:00
|
|
|
}else{
|
2010-06-18 07:39:12 +00:00
|
|
|
spin_unlock_irqrestore(&acb->ccblist_lock, flags);
|
2014-08-19 07:20:31 +00:00
|
|
|
return NULL;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
spin_unlock_irqrestore(&acb->ccblist_lock, flags);
|
2006-07-12 15:59:32 +00:00
|
|
|
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;
|
2007-05-14 10:25:56 +00:00
|
|
|
struct scatterlist *sg;
|
2006-07-12 15:59:32 +00:00
|
|
|
|
|
|
|
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;
|
2007-06-15 03:43:32 +00:00
|
|
|
/* ISO, ECMA, & ANSI versions */
|
2006-07-12 15:59:32 +00:00
|
|
|
inqdata[4] = 31;
|
|
|
|
/* length of additional data */
|
scsi: arcmsr: Stop __builtin_strncpy complaining about a lack of space for NUL
SCSI strings like inqdata are not NUL terminated.
Fixes the following W=1 kernel build warning(s):
In file included from include/linux/bitmap.h:9,
from include/linux/nodemask.h:95,
from include/linux/mmzone.h:17,
from include/linux/gfp.h:6,
from include/linux/umh.h:4,
from include/linux/kmod.h:9,
from include/linux/module.h:16,
from drivers/scsi/arcmsr/arcmsr_hba.c:47:
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3055:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 4 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3053:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 16 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3051:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 8 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
Link: https://lore.kernel.org/r/20201102102544.1018706-1-lee.jones@linaro.org
Cc: support@areca.com.tw
Signed-off-by: Lee Jones <lee.jones@linaro.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-11-02 10:25:42 +00:00
|
|
|
memcpy(&inqdata[8], "Areca ", 8);
|
2006-07-12 15:59:32 +00:00
|
|
|
/* Vendor Identification */
|
scsi: arcmsr: Stop __builtin_strncpy complaining about a lack of space for NUL
SCSI strings like inqdata are not NUL terminated.
Fixes the following W=1 kernel build warning(s):
In file included from include/linux/bitmap.h:9,
from include/linux/nodemask.h:95,
from include/linux/mmzone.h:17,
from include/linux/gfp.h:6,
from include/linux/umh.h:4,
from include/linux/kmod.h:9,
from include/linux/module.h:16,
from drivers/scsi/arcmsr/arcmsr_hba.c:47:
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3055:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 4 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3053:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 16 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3051:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 8 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
Link: https://lore.kernel.org/r/20201102102544.1018706-1-lee.jones@linaro.org
Cc: support@areca.com.tw
Signed-off-by: Lee Jones <lee.jones@linaro.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-11-02 10:25:42 +00:00
|
|
|
memcpy(&inqdata[16], "RAID controller ", 16);
|
2006-07-12 15:59:32 +00:00
|
|
|
/* Product Identification */
|
scsi: arcmsr: Stop __builtin_strncpy complaining about a lack of space for NUL
SCSI strings like inqdata are not NUL terminated.
Fixes the following W=1 kernel build warning(s):
In file included from include/linux/bitmap.h:9,
from include/linux/nodemask.h:95,
from include/linux/mmzone.h:17,
from include/linux/gfp.h:6,
from include/linux/umh.h:4,
from include/linux/kmod.h:9,
from include/linux/module.h:16,
from drivers/scsi/arcmsr/arcmsr_hba.c:47:
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3055:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 4 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3053:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 16 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
In function ‘strncpy’,
inlined from ‘arcmsr_handle_virtual_command’ at drivers/scsi/arcmsr/arcmsr_hba.c:3051:3:
include/linux/string.h:297:30: warning: ‘__builtin_strncpy’ output truncated before terminating nul copying 8 bytes from a string of the same length [-Wstringop-truncation]
297 | #define __underlying_strncpy __builtin_strncpy
| ^
include/linux/string.h:307:9: note: in expansion of macro ‘__underlying_strncpy’
307 | return __underlying_strncpy(p, q, size);
| ^~~~~~~~~~~~~~~~~~~~
Link: https://lore.kernel.org/r/20201102102544.1018706-1-lee.jones@linaro.org
Cc: support@areca.com.tw
Signed-off-by: Lee Jones <lee.jones@linaro.org>
Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
2020-11-02 10:25:42 +00:00
|
|
|
memcpy(&inqdata[32], "R001", 4); /* Product Revision */
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2007-05-14 10:25:56 +00:00
|
|
|
sg = scsi_sglist(cmd);
|
2011-11-25 15:14:23 +00:00
|
|
|
buffer = kmap_atomic(sg_page(sg)) + sg->offset;
|
2007-05-14 10:25:56 +00:00
|
|
|
|
2006-07-12 15:59:32 +00:00
|
|
|
memcpy(buffer, inqdata, sizeof(inqdata));
|
2007-05-14 10:25:56 +00:00
|
|
|
sg = scsi_sglist(cmd);
|
2011-11-25 15:14:23 +00:00
|
|
|
kunmap_atomic(buffer - sg->offset);
|
2006-07-12 15:59:32 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-16 07:10:29 +00:00
|
|
|
static int arcmsr_queue_command_lck(struct scsi_cmnd *cmd,
|
2006-07-12 15:59:32 +00:00
|
|
|
void (* done)(struct scsi_cmnd *))
|
|
|
|
{
|
|
|
|
struct Scsi_Host *host = cmd->device->host;
|
2007-09-13 09:26:40 +00:00
|
|
|
struct AdapterControlBlock *acb = (struct AdapterControlBlock *) host->hostdata;
|
2006-07-12 15:59:32 +00:00
|
|
|
struct CommandControlBlock *ccb;
|
|
|
|
int target = cmd->device->id;
|
2018-03-15 06:33:36 +00:00
|
|
|
|
|
|
|
if (acb->acb_flags & ACB_F_ADAPTER_REMOVED) {
|
|
|
|
cmd->result = (DID_NO_CONNECT << 16);
|
|
|
|
cmd->scsi_done(cmd);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
cmd->scsi_done = done;
|
|
|
|
cmd->host_scribble = NULL;
|
|
|
|
cmd->result = 0;
|
2007-06-15 03:43:32 +00:00
|
|
|
if (target == 16) {
|
2006-07-12 15:59:32 +00:00
|
|
|
/* 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;
|
2010-07-13 12:03:04 +00:00
|
|
|
if (arcmsr_build_ccb( acb, ccb, cmd ) == FAILED) {
|
2021-04-27 08:30:46 +00:00
|
|
|
cmd->result = (DID_ERROR << 16) | SAM_STAT_RESERVATION_CONFLICT;
|
2008-02-05 07:53:24 +00:00
|
|
|
cmd->scsi_done(cmd);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
arcmsr_post_ccb(acb, ccb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-11-16 07:10:29 +00:00
|
|
|
static DEF_SCSI_QCMD(arcmsr_queue_command)
|
|
|
|
|
2020-10-27 03:31:31 +00:00
|
|
|
static int arcmsr_slave_config(struct scsi_device *sdev)
|
|
|
|
{
|
|
|
|
unsigned int dev_timeout;
|
|
|
|
|
|
|
|
dev_timeout = sdev->request_queue->rq_timeout;
|
|
|
|
if ((cmd_timeout > 0) && ((cmd_timeout * HZ) > dev_timeout))
|
|
|
|
blk_queue_rq_timeout(sdev->request_queue, cmd_timeout * HZ);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-12-12 10:53:33 +00:00
|
|
|
static void arcmsr_get_adapter_config(struct AdapterControlBlock *pACB, uint32_t *rwbuffer)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
|
|
|
int count;
|
2017-12-12 10:53:33 +00:00
|
|
|
uint32_t *acb_firm_model = (uint32_t *)pACB->firm_model;
|
|
|
|
uint32_t *acb_firm_version = (uint32_t *)pACB->firm_version;
|
|
|
|
uint32_t *acb_device_map = (uint32_t *)pACB->device_map;
|
|
|
|
uint32_t *firm_model = &rwbuffer[15];
|
|
|
|
uint32_t *firm_version = &rwbuffer[17];
|
|
|
|
uint32_t *device_map = &rwbuffer[21];
|
|
|
|
|
|
|
|
count = 2;
|
|
|
|
while (count) {
|
|
|
|
*acb_firm_model = readl(firm_model);
|
2006-07-12 15:59:32 +00:00
|
|
|
acb_firm_model++;
|
2017-12-12 10:53:33 +00:00
|
|
|
firm_model++;
|
2006-07-12 15:59:32 +00:00
|
|
|
count--;
|
|
|
|
}
|
2017-12-12 10:53:33 +00:00
|
|
|
count = 4;
|
|
|
|
while (count) {
|
|
|
|
*acb_firm_version = readl(firm_version);
|
2006-07-12 15:59:32 +00:00
|
|
|
acb_firm_version++;
|
2017-12-12 10:53:33 +00:00
|
|
|
firm_version++;
|
2006-07-12 15:59:32 +00:00
|
|
|
count--;
|
|
|
|
}
|
2017-12-12 10:53:33 +00:00
|
|
|
count = 4;
|
|
|
|
while (count) {
|
|
|
|
*acb_device_map = readl(device_map);
|
2010-07-13 12:03:04 +00:00
|
|
|
acb_device_map++;
|
2017-12-12 10:53:33 +00:00
|
|
|
device_map++;
|
2010-07-13 12:03:04 +00:00
|
|
|
count--;
|
|
|
|
}
|
2017-12-12 10:53:33 +00:00
|
|
|
pACB->signature = readl(&rwbuffer[0]);
|
|
|
|
pACB->firm_request_len = readl(&rwbuffer[1]);
|
|
|
|
pACB->firm_numbers_queue = readl(&rwbuffer[2]);
|
|
|
|
pACB->firm_sdram_size = readl(&rwbuffer[3]);
|
|
|
|
pACB->firm_hd_channels = readl(&rwbuffer[4]);
|
|
|
|
pACB->firm_cfg_version = readl(&rwbuffer[25]);
|
2014-08-19 07:03:55 +00:00
|
|
|
pr_notice("Areca RAID Controller%d: Model %s, F/W %s\n",
|
2017-12-12 10:53:33 +00:00
|
|
|
pACB->host->host_no,
|
|
|
|
pACB->firm_model,
|
|
|
|
pACB->firm_version);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool arcmsr_hbaA_get_config(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
|
|
|
|
|
|
|
arcmsr_wait_firmware_ready(acb);
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
|
|
|
|
printk(KERN_NOTICE "arcmsr%d: wait 'get adapter firmware \
|
|
|
|
miscellaneous data' timeout \n", acb->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
arcmsr_get_adapter_config(acb, reg->message_rwbuffer);
|
2010-06-18 07:39:12 +00:00
|
|
|
return true;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2014-08-19 07:10:12 +00:00
|
|
|
static bool arcmsr_hbaB_get_config(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2015-11-26 11:41:15 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-06-18 07:39:12 +00:00
|
|
|
|
2015-11-25 11:49:33 +00:00
|
|
|
arcmsr_wait_firmware_ready(acb);
|
|
|
|
writel(ARCMSR_MESSAGE_START_DRIVER_MODE, reg->drv2iop_doorbell);
|
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
|
|
|
printk(KERN_ERR "arcmsr%d: can't set driver mode.\n", acb->host->host_no);
|
2015-11-26 11:41:15 +00:00
|
|
|
return false;
|
2015-11-25 11:49:33 +00:00
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_MESSAGE_GET_CONFIG, reg->drv2iop_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
2007-09-13 09:26:40 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: wait 'get adapter firmware \
|
|
|
|
miscellaneous data' timeout \n", acb->host->host_no);
|
2015-11-26 11:41:15 +00:00
|
|
|
return false;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2017-12-12 10:53:33 +00:00
|
|
|
arcmsr_get_adapter_config(acb, reg->message_rwbuffer);
|
2010-06-18 07:39:12 +00:00
|
|
|
return true;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static bool arcmsr_hbaC_get_config(struct AdapterControlBlock *pACB)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2017-12-12 10:42:29 +00:00
|
|
|
uint32_t intmask_org;
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = pACB->pmuC;
|
2017-12-12 10:53:33 +00:00
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
/* disable all outbound interrupt */
|
|
|
|
intmask_org = readl(®->host_int_mask); /* disable outbound message0 int */
|
|
|
|
writel(intmask_org|ARCMSR_HBCMU_ALL_INTMASKENABLE, ®->host_int_mask);
|
|
|
|
/* wait firmware ready */
|
2017-12-12 10:42:29 +00:00
|
|
|
arcmsr_wait_firmware_ready(pACB);
|
2010-07-13 12:03:04 +00:00
|
|
|
/* post "get config" instruction */
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, ®->inbound_doorbell);
|
|
|
|
/* wait message ready */
|
2017-12-12 10:42:29 +00:00
|
|
|
if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
|
2010-07-13 12:03:04 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: wait 'get adapter firmware \
|
|
|
|
miscellaneous data' timeout \n", pACB->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
2017-12-12 10:53:33 +00:00
|
|
|
arcmsr_get_adapter_config(pACB, reg->msgcode_rwbuffer);
|
2010-07-13 12:03:04 +00:00
|
|
|
return true;
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
static bool arcmsr_hbaD_get_config(struct AdapterControlBlock *acb)
|
|
|
|
{
|
2015-11-26 11:41:15 +00:00
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
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*/
|
|
|
|
}
|
2017-12-12 10:48:24 +00:00
|
|
|
arcmsr_wait_firmware_ready(acb);
|
2014-08-19 07:25:22 +00:00
|
|
|
/* 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);
|
|
|
|
return false;
|
|
|
|
}
|
2017-12-12 10:53:33 +00:00
|
|
|
arcmsr_get_adapter_config(acb, reg->msgcode_rwbuffer);
|
2014-08-19 07:25:22 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static bool arcmsr_hbaE_get_config(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
struct MessageUnit_E __iomem *reg = pACB->pmuE;
|
2017-12-12 10:50:51 +00:00
|
|
|
uint32_t intmask_org;
|
2017-12-05 01:35:34 +00:00
|
|
|
|
|
|
|
/* disable all outbound interrupt */
|
|
|
|
intmask_org = readl(®->host_int_mask); /* disable outbound message0 int */
|
|
|
|
writel(intmask_org | ARCMSR_HBEMU_ALL_INTMASKENABLE, ®->host_int_mask);
|
|
|
|
/* wait firmware ready */
|
2017-12-12 10:50:51 +00:00
|
|
|
arcmsr_wait_firmware_ready(pACB);
|
2017-12-05 01:35:34 +00:00
|
|
|
mdelay(20);
|
|
|
|
/* post "get config" instruction */
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
|
|
|
|
pACB->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(pACB->out_doorbell, ®->iobound_doorbell);
|
|
|
|
/* wait message ready */
|
2017-12-12 10:50:51 +00:00
|
|
|
if (!arcmsr_hbaE_wait_msgint_ready(pACB)) {
|
2017-12-05 01:35:34 +00:00
|
|
|
pr_notice("arcmsr%d: wait get adapter firmware "
|
|
|
|
"miscellaneous data timeout\n", pACB->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
2017-12-12 10:53:33 +00:00
|
|
|
arcmsr_get_adapter_config(pACB, reg->msgcode_rwbuffer);
|
2017-12-05 01:35:34 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-09-28 10:35:05 +00:00
|
|
|
static bool arcmsr_hbaF_get_config(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
struct MessageUnit_F __iomem *reg = pACB->pmuF;
|
|
|
|
uint32_t intmask_org;
|
|
|
|
|
|
|
|
/* disable all outbound interrupt */
|
|
|
|
intmask_org = readl(®->host_int_mask); /* disable outbound message0 int */
|
|
|
|
writel(intmask_org | ARCMSR_HBEMU_ALL_INTMASKENABLE, ®->host_int_mask);
|
|
|
|
/* wait firmware ready */
|
|
|
|
arcmsr_wait_firmware_ready(pACB);
|
|
|
|
/* post "get config" instruction */
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
|
|
|
|
pACB->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(pACB->out_doorbell, ®->iobound_doorbell);
|
|
|
|
/* wait message ready */
|
|
|
|
if (!arcmsr_hbaE_wait_msgint_ready(pACB)) {
|
|
|
|
pr_notice("arcmsr%d: wait get adapter firmware miscellaneous data timeout\n",
|
|
|
|
pACB->host->host_no);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
arcmsr_get_adapter_config(pACB, pACB->msgcode_rwbuffer);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
static bool arcmsr_get_firmware_spec(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2014-08-19 06:29:41 +00:00
|
|
|
bool rtn = false;
|
|
|
|
|
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_A:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtn = arcmsr_hbaA_get_config(acb);
|
2014-08-19 06:29:41 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtn = arcmsr_hbaB_get_config(acb);
|
2014-08-19 06:29:41 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_C:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtn = arcmsr_hbaC_get_config(acb);
|
2014-08-19 06:29:41 +00:00
|
|
|
break;
|
2014-08-19 07:25:22 +00:00
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
rtn = arcmsr_hbaD_get_config(acb);
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
rtn = arcmsr_hbaE_get_config(acb);
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
|
|
|
rtn = arcmsr_hbaF_get_config(acb);
|
|
|
|
break;
|
2014-08-19 06:29:41 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2017-12-05 01:47:44 +00:00
|
|
|
acb->maxOutstanding = acb->firm_numbers_queue - 1;
|
|
|
|
if (acb->host->can_queue >= acb->firm_numbers_queue)
|
|
|
|
acb->host->can_queue = acb->maxOutstanding;
|
2010-07-13 12:03:04 +00:00
|
|
|
else
|
2017-12-05 01:47:44 +00:00
|
|
|
acb->maxOutstanding = acb->host->can_queue;
|
2017-12-05 01:44:23 +00:00
|
|
|
acb->maxFreeCCB = acb->host->can_queue;
|
|
|
|
if (acb->maxFreeCCB < ARCMSR_MAX_FREECCB_NUM)
|
|
|
|
acb->maxFreeCCB += 64;
|
2014-08-19 06:29:41 +00:00
|
|
|
return rtn;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static int arcmsr_hbaA_polling_ccbdone(struct AdapterControlBlock *acb,
|
2006-07-12 15:59:32 +00:00
|
|
|
struct CommandControlBlock *poll_ccb)
|
|
|
|
{
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2006-07-12 15:59:32 +00:00
|
|
|
struct CommandControlBlock *ccb;
|
2010-06-18 07:39:12 +00:00
|
|
|
struct ARCMSR_CDB *arcmsr_cdb;
|
2006-07-12 15:59:32 +00:00
|
|
|
uint32_t flag_ccb, outbound_intstatus, poll_ccb_done = 0, poll_count = 0;
|
2010-06-18 07:39:12 +00:00
|
|
|
int rtn;
|
2010-07-13 12:03:04 +00:00
|
|
|
bool error;
|
2018-12-19 08:43:15 +00:00
|
|
|
unsigned long ccb_cdb_phy;
|
|
|
|
|
|
|
|
polling_hba_ccb_retry:
|
2006-07-12 15:59:32 +00:00
|
|
|
poll_count++;
|
2007-09-13 09:26:40 +00:00
|
|
|
outbound_intstatus = readl(®->outbound_intstatus) & acb->outbound_int_enable;
|
2006-07-12 15:59:32 +00:00
|
|
|
writel(outbound_intstatus, ®->outbound_intstatus);/*clear interrupt*/
|
|
|
|
while (1) {
|
|
|
|
if ((flag_ccb = readl(®->outbound_queueport)) == 0xFFFFFFFF) {
|
2010-07-13 12:03:04 +00:00
|
|
|
if (poll_ccb_done){
|
2010-06-18 07:39:12 +00:00
|
|
|
rtn = SUCCESS;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
}else {
|
|
|
|
msleep(25);
|
|
|
|
if (poll_count > 100){
|
2010-06-18 07:39:12 +00:00
|
|
|
rtn = FAILED;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
goto polling_hba_ccb_retry;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
}
|
2018-12-19 08:43:15 +00:00
|
|
|
ccb_cdb_phy = (flag_ccb << 5) & 0xffffffff;
|
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
|
|
|
arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset + ccb_cdb_phy);
|
2010-06-18 07:39:12 +00:00
|
|
|
ccb = container_of(arcmsr_cdb, struct CommandControlBlock, arcmsr_cdb);
|
2014-08-19 06:47:16 +00:00
|
|
|
poll_ccb_done |= (ccb == poll_ccb) ? 1 : 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
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'"
|
2006-07-12 15:59:32 +00:00
|
|
|
" poll command abort successfully \n"
|
|
|
|
, acb->host->host_no
|
|
|
|
, ccb->pcmd->device->id
|
2014-06-25 13:27:36 +00:00
|
|
|
, (u32)ccb->pcmd->device->lun
|
2006-07-12 15:59:32 +00:00
|
|
|
, ccb);
|
|
|
|
ccb->pcmd->result = DID_ABORT << 16;
|
2010-06-18 07:39:12 +00:00
|
|
|
arcmsr_ccb_complete(ccb);
|
2006-07-12 15:59:32 +00:00
|
|
|
continue;
|
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: polling get an illegal ccb"
|
|
|
|
" command done ccb = '0x%p'"
|
2007-06-15 03:43:32 +00:00
|
|
|
"ccboutstandingcount = %d \n"
|
2006-07-12 15:59:32 +00:00
|
|
|
, acb->host->host_no
|
|
|
|
, ccb
|
|
|
|
, atomic_read(&acb->ccboutstandingcount));
|
|
|
|
continue;
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
|
|
|
error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE0) ? true : false;
|
|
|
|
arcmsr_report_ccb_state(acb, ccb, error);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
return rtn;
|
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static int arcmsr_hbaB_polling_ccbdone(struct AdapterControlBlock *acb,
|
2007-09-13 09:26:40 +00:00
|
|
|
struct CommandControlBlock *poll_ccb)
|
|
|
|
{
|
2010-07-13 12:03:04 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2010-06-18 07:39:12 +00:00
|
|
|
struct ARCMSR_CDB *arcmsr_cdb;
|
2010-07-13 12:03:04 +00:00
|
|
|
struct CommandControlBlock *ccb;
|
|
|
|
uint32_t flag_ccb, poll_ccb_done = 0, poll_count = 0;
|
2010-06-18 07:39:12 +00:00
|
|
|
int index, rtn;
|
2010-07-13 12:03:04 +00:00
|
|
|
bool error;
|
2018-12-19 08:45:46 +00:00
|
|
|
unsigned long ccb_cdb_phy;
|
2011-01-06 09:32:41 +00:00
|
|
|
|
2018-12-19 08:45:46 +00:00
|
|
|
polling_hbb_ccb_retry:
|
2010-07-13 12:03:04 +00:00
|
|
|
poll_count++;
|
|
|
|
/* clear doorbell interrupt */
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_DOORBELL_INT_CLEAR_PATTERN, reg->iop2drv_doorbell);
|
2010-07-13 12:03:04 +00:00
|
|
|
while(1){
|
|
|
|
index = reg->doneq_index;
|
2014-08-19 07:20:31 +00:00
|
|
|
flag_ccb = reg->done_qbuffer[index];
|
|
|
|
if (flag_ccb == 0) {
|
2010-07-13 12:03:04 +00:00
|
|
|
if (poll_ccb_done){
|
2010-06-18 07:39:12 +00:00
|
|
|
rtn = SUCCESS;
|
2010-07-13 12:03:04 +00:00
|
|
|
break;
|
|
|
|
}else {
|
|
|
|
msleep(25);
|
|
|
|
if (poll_count > 100){
|
2010-06-18 07:39:12 +00:00
|
|
|
rtn = FAILED;
|
2010-07-13 12:03:04 +00:00
|
|
|
break;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
goto polling_hbb_ccb_retry;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
2014-08-19 07:20:31 +00:00
|
|
|
reg->done_qbuffer[index] = 0;
|
2010-07-13 12:03:04 +00:00
|
|
|
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*/
|
2018-12-19 08:45:46 +00:00
|
|
|
ccb_cdb_phy = (flag_ccb << 5) & 0xffffffff;
|
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
|
|
|
arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset + ccb_cdb_phy);
|
2010-06-18 07:39:12 +00:00
|
|
|
ccb = container_of(arcmsr_cdb, struct CommandControlBlock, arcmsr_cdb);
|
2014-08-19 06:47:16 +00:00
|
|
|
poll_ccb_done |= (ccb == poll_ccb) ? 1 : 0;
|
2010-07-13 12:03:04 +00:00
|
|
|
if ((ccb->acb != acb) || (ccb->startdone != ARCMSR_CCB_START)) {
|
|
|
|
if ((ccb->startdone == ARCMSR_CCB_ABORTED) || (ccb == poll_ccb)) {
|
2010-06-18 07:39:12 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: scsi id = %d lun = %d ccb = '0x%p'"
|
|
|
|
" poll command abort successfully \n"
|
2010-07-13 12:03:04 +00:00
|
|
|
,acb->host->host_no
|
|
|
|
,ccb->pcmd->device->id
|
2014-06-25 13:27:36 +00:00
|
|
|
,(u32)ccb->pcmd->device->lun
|
2010-07-13 12:03:04 +00:00
|
|
|
,ccb);
|
|
|
|
ccb->pcmd->result = DID_ABORT << 16;
|
2010-06-18 07:39:12 +00:00
|
|
|
arcmsr_ccb_complete(ccb);
|
2010-07-13 12:03:04 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static int arcmsr_hbaC_polling_ccbdone(struct AdapterControlBlock *acb,
|
|
|
|
struct CommandControlBlock *poll_ccb)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2018-12-19 08:48:16 +00:00
|
|
|
uint32_t flag_ccb;
|
2010-07-13 12:03:04 +00:00
|
|
|
struct ARCMSR_CDB *arcmsr_cdb;
|
|
|
|
bool error;
|
|
|
|
struct CommandControlBlock *pCCB;
|
|
|
|
uint32_t poll_ccb_done = 0, poll_count = 0;
|
|
|
|
int rtn;
|
2018-12-19 08:48:16 +00:00
|
|
|
unsigned long ccb_cdb_phy;
|
|
|
|
|
2010-07-13 12:03:04 +00:00
|
|
|
polling_hbc_ccb_retry:
|
|
|
|
poll_count++;
|
|
|
|
while (1) {
|
|
|
|
if ((readl(®->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;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
goto polling_hbc_ccb_retry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
flag_ccb = readl(®->outbound_queueport_low);
|
|
|
|
ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
|
2018-12-19 08:48:16 +00:00
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
|
|
|
arcmsr_cdb = (struct ARCMSR_CDB *)(acb->vir2phy_offset + ccb_cdb_phy);
|
2010-07-13 12:03:04 +00:00
|
|
|
pCCB = container_of(arcmsr_cdb, struct CommandControlBlock, arcmsr_cdb);
|
2014-08-19 06:47:16 +00:00
|
|
|
poll_ccb_done |= (pCCB == poll_ccb) ? 1 : 0;
|
2010-07-13 12:03:04 +00:00
|
|
|
/* 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"
|
2006-07-12 15:59:32 +00:00
|
|
|
, acb->host->host_no
|
2010-07-13 12:03:04 +00:00
|
|
|
, pCCB->pcmd->device->id
|
2014-06-25 13:27:36 +00:00
|
|
|
, (u32)pCCB->pcmd->device->lun
|
2010-07-13 12:03:04 +00:00
|
|
|
, pCCB);
|
2019-11-14 18:00:07 +00:00
|
|
|
pCCB->pcmd->result = DID_ABORT << 16;
|
|
|
|
arcmsr_ccb_complete(pCCB);
|
2007-09-13 09:26:40 +00:00
|
|
|
continue;
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
|
|
|
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;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
error = (flag_ccb & ARCMSR_CCBREPLY_FLAG_ERROR_MODE1) ? true : false;
|
|
|
|
arcmsr_report_ccb_state(acb, pCCB, error);
|
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
return rtn;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
static int arcmsr_hbaD_polling_ccbdone(struct AdapterControlBlock *acb,
|
|
|
|
struct CommandControlBlock *poll_ccb)
|
|
|
|
{
|
|
|
|
bool error;
|
2018-12-19 08:51:14 +00:00
|
|
|
uint32_t poll_ccb_done = 0, poll_count = 0, flag_ccb;
|
2014-09-15 11:05:33 +00:00
|
|
|
int rtn, doneq_index, index_stripped, outbound_write_pointer, toggle;
|
2020-07-13 07:46:30 +00:00
|
|
|
unsigned long flags, ccb_cdb_phy;
|
2014-08-19 07:25:22 +00:00
|
|
|
struct ARCMSR_CDB *arcmsr_cdb;
|
|
|
|
struct CommandControlBlock *pCCB;
|
|
|
|
struct MessageUnit_D *pmu = acb->pmuD;
|
|
|
|
|
|
|
|
polling_hbaD_ccb_retry:
|
|
|
|
poll_count++;
|
|
|
|
while (1) {
|
2014-09-15 11:05:33 +00:00
|
|
|
spin_lock_irqsave(&acb->doneq_lock, flags);
|
2014-08-19 07:25:22 +00:00
|
|
|
outbound_write_pointer = pmu->done_qbuffer[0].addressLow + 1;
|
|
|
|
doneq_index = pmu->doneq_index;
|
|
|
|
if ((outbound_write_pointer & 0xFFF) == (doneq_index & 0xFFF)) {
|
2014-09-15 11:05:33 +00:00
|
|
|
spin_unlock_irqrestore(&acb->doneq_lock, flags);
|
2014-08-19 07:25:22 +00:00
|
|
|
if (poll_ccb_done) {
|
|
|
|
rtn = SUCCESS;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
msleep(25);
|
|
|
|
if (poll_count > 40) {
|
|
|
|
rtn = FAILED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
goto polling_hbaD_ccb_retry;
|
|
|
|
}
|
|
|
|
}
|
2014-09-15 11:05:33 +00:00
|
|
|
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);
|
2014-08-19 07:25:22 +00:00
|
|
|
doneq_index = pmu->doneq_index;
|
2014-09-15 11:05:33 +00:00
|
|
|
spin_unlock_irqrestore(&acb->doneq_lock, flags);
|
2014-08-19 07:25:22 +00:00
|
|
|
flag_ccb = pmu->done_qbuffer[doneq_index & 0xFFF].addressLow;
|
|
|
|
ccb_cdb_phy = (flag_ccb & 0xFFFFFFF0);
|
2018-12-19 08:51:14 +00:00
|
|
|
if (acb->cdb_phyadd_hipart)
|
|
|
|
ccb_cdb_phy = ccb_cdb_phy | acb->cdb_phyadd_hipart;
|
2014-08-19 07:25:22 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static int arcmsr_hbaE_polling_ccbdone(struct AdapterControlBlock *acb,
|
|
|
|
struct CommandControlBlock *poll_ccb)
|
|
|
|
{
|
|
|
|
bool error;
|
|
|
|
uint32_t poll_ccb_done = 0, poll_count = 0, doneq_index;
|
|
|
|
uint16_t cmdSMID;
|
|
|
|
unsigned long flags;
|
|
|
|
int rtn;
|
|
|
|
struct CommandControlBlock *pCCB;
|
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
|
|
|
|
polling_hbaC_ccb_retry:
|
|
|
|
poll_count++;
|
|
|
|
while (1) {
|
|
|
|
spin_lock_irqsave(&acb->doneq_lock, flags);
|
|
|
|
doneq_index = acb->doneq_index;
|
|
|
|
if ((readl(®->reply_post_producer_index) & 0xFFFF) ==
|
|
|
|
doneq_index) {
|
|
|
|
spin_unlock_irqrestore(&acb->doneq_lock, flags);
|
|
|
|
if (poll_ccb_done) {
|
|
|
|
rtn = SUCCESS;
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
msleep(25);
|
|
|
|
if (poll_count > 40) {
|
|
|
|
rtn = FAILED;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
goto polling_hbaC_ccb_retry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cmdSMID = acb->pCompletionQ[doneq_index].cmdSMID;
|
|
|
|
doneq_index++;
|
|
|
|
if (doneq_index >= acb->completionQ_entry)
|
|
|
|
doneq_index = 0;
|
|
|
|
acb->doneq_index = doneq_index;
|
|
|
|
spin_unlock_irqrestore(&acb->doneq_lock, flags);
|
|
|
|
pCCB = acb->pccb_pool[cmdSMID];
|
|
|
|
poll_ccb_done |= (pCCB == poll_ccb) ? 1 : 0;
|
|
|
|
/* check if command done with no error*/
|
|
|
|
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 = (acb->pCompletionQ[doneq_index].cmdFlag &
|
|
|
|
ARCMSR_CCBREPLY_FLAG_ERROR_MODE1) ? true : false;
|
|
|
|
arcmsr_report_ccb_state(acb, pCCB, error);
|
|
|
|
}
|
|
|
|
writel(doneq_index, ®->reply_post_consumer_index);
|
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
static int arcmsr_polling_ccbdone(struct AdapterControlBlock *acb,
|
2007-09-13 09:26:40 +00:00
|
|
|
struct CommandControlBlock *poll_ccb)
|
|
|
|
{
|
2010-06-18 07:39:12 +00:00
|
|
|
int rtn = 0;
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtn = arcmsr_hbaA_polling_ccbdone(acb, poll_ccb);
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtn = arcmsr_hbaB_polling_ccbdone(acb, poll_ccb);
|
2010-07-13 12:03:04 +00:00
|
|
|
break;
|
2020-09-28 10:45:32 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C:
|
2014-08-19 07:10:12 +00:00
|
|
|
rtn = arcmsr_hbaC_polling_ccbdone(acb, poll_ccb);
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
rtn = arcmsr_hbaD_polling_ccbdone(acb, poll_ccb);
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
2017-12-05 01:35:34 +00:00
|
|
|
rtn = arcmsr_hbaE_polling_ccbdone(acb, poll_ccb);
|
|
|
|
break;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
return rtn;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
|
2017-12-05 01:59:52 +00:00
|
|
|
static void arcmsr_set_iop_datetime(struct timer_list *t)
|
|
|
|
{
|
|
|
|
struct AdapterControlBlock *pacb = from_timer(pacb, t, refresh_timer);
|
2018-01-21 23:12:26 +00:00
|
|
|
unsigned int next_time;
|
|
|
|
struct tm tm;
|
|
|
|
|
2017-12-05 01:59:52 +00:00
|
|
|
union {
|
|
|
|
struct {
|
|
|
|
uint16_t signature;
|
|
|
|
uint8_t year;
|
|
|
|
uint8_t month;
|
|
|
|
uint8_t date;
|
|
|
|
uint8_t hour;
|
|
|
|
uint8_t minute;
|
|
|
|
uint8_t second;
|
|
|
|
} a;
|
|
|
|
struct {
|
|
|
|
uint32_t msg_time[2];
|
|
|
|
} b;
|
|
|
|
} datetime;
|
|
|
|
|
2018-01-21 23:12:26 +00:00
|
|
|
time64_to_tm(ktime_get_real_seconds(), -sys_tz.tz_minuteswest * 60, &tm);
|
2017-12-05 01:59:52 +00:00
|
|
|
|
|
|
|
datetime.a.signature = 0x55AA;
|
2018-01-21 23:12:26 +00:00
|
|
|
datetime.a.year = tm.tm_year - 100; /* base 2000 instead of 1900 */
|
|
|
|
datetime.a.month = tm.tm_mon;
|
|
|
|
datetime.a.date = tm.tm_mday;
|
|
|
|
datetime.a.hour = tm.tm_hour;
|
|
|
|
datetime.a.minute = tm.tm_min;
|
|
|
|
datetime.a.second = tm.tm_sec;
|
2017-12-05 01:59:52 +00:00
|
|
|
|
|
|
|
switch (pacb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
|
|
|
struct MessageUnit_A __iomem *reg = pacb->pmuA;
|
|
|
|
writel(datetime.b.msg_time[0], ®->message_rwbuffer[0]);
|
|
|
|
writel(datetime.b.msg_time[1], ®->message_rwbuffer[1]);
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_SYNC_TIMER, ®->inbound_msgaddr0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
|
|
|
uint32_t __iomem *rwbuffer;
|
|
|
|
struct MessageUnit_B *reg = pacb->pmuB;
|
|
|
|
rwbuffer = reg->message_rwbuffer;
|
|
|
|
writel(datetime.b.msg_time[0], rwbuffer++);
|
|
|
|
writel(datetime.b.msg_time[1], rwbuffer++);
|
|
|
|
writel(ARCMSR_MESSAGE_SYNC_TIMER, reg->drv2iop_doorbell);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
|
|
|
struct MessageUnit_C __iomem *reg = pacb->pmuC;
|
|
|
|
writel(datetime.b.msg_time[0], ®->msgcode_rwbuffer[0]);
|
|
|
|
writel(datetime.b.msg_time[1], ®->msgcode_rwbuffer[1]);
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_SYNC_TIMER, ®->inbound_msgaddr0);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, ®->inbound_doorbell);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
uint32_t __iomem *rwbuffer;
|
|
|
|
struct MessageUnit_D *reg = pacb->pmuD;
|
|
|
|
rwbuffer = reg->msgcode_rwbuffer;
|
|
|
|
writel(datetime.b.msg_time[0], rwbuffer++);
|
|
|
|
writel(datetime.b.msg_time[1], rwbuffer++);
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_SYNC_TIMER, reg->inbound_msgaddr0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
struct MessageUnit_E __iomem *reg = pacb->pmuE;
|
|
|
|
writel(datetime.b.msg_time[0], ®->msgcode_rwbuffer[0]);
|
|
|
|
writel(datetime.b.msg_time[1], ®->msgcode_rwbuffer[1]);
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_SYNC_TIMER, ®->inbound_msgaddr0);
|
|
|
|
pacb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(pacb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
break;
|
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
|
|
|
struct MessageUnit_F __iomem *reg = pacb->pmuF;
|
|
|
|
|
|
|
|
pacb->msgcode_rwbuffer[0] = datetime.b.msg_time[0];
|
|
|
|
pacb->msgcode_rwbuffer[1] = datetime.b.msg_time[1];
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_SYNC_TIMER, ®->inbound_msgaddr0);
|
|
|
|
pacb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(pacb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
break;
|
|
|
|
}
|
2017-12-05 01:59:52 +00:00
|
|
|
}
|
|
|
|
if (sys_tz.tz_minuteswest)
|
|
|
|
next_time = ARCMSR_HOURS;
|
|
|
|
else
|
|
|
|
next_time = ARCMSR_MINUTES;
|
|
|
|
mod_timer(&pacb->refresh_timer, jiffies + msecs_to_jiffies(next_time));
|
|
|
|
}
|
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
static int arcmsr_iop_confirm(struct AdapterControlBlock *acb)
|
2007-06-15 03:43:32 +00:00
|
|
|
{
|
2010-06-18 07:39:12 +00:00
|
|
|
uint32_t cdb_phyaddr, cdb_phyaddr_hi32;
|
2014-08-19 07:14:14 +00:00
|
|
|
dma_addr_t dma_coherent_handle;
|
2014-02-11 16:06:33 +00:00
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
/*
|
|
|
|
********************************************************************
|
|
|
|
** here we need to tell iop 331 our freeccb.HighPart
|
|
|
|
** if freeccb.HighPart is not zero
|
|
|
|
********************************************************************
|
|
|
|
*/
|
2014-08-19 07:14:14 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2014-08-19 07:25:22 +00:00
|
|
|
case ACB_ADAPTER_TYPE_D:
|
2014-08-19 07:14:14 +00:00
|
|
|
dma_coherent_handle = acb->dma_coherent_handle2;
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
2017-12-05 01:35:34 +00:00
|
|
|
dma_coherent_handle = acb->dma_coherent_handle +
|
|
|
|
offsetof(struct CommandControlBlock, arcmsr_cdb);
|
|
|
|
break;
|
2014-08-19 07:14:14 +00:00
|
|
|
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);
|
2010-07-13 12:03:04 +00:00
|
|
|
acb->cdb_phyaddr_hi32 = cdb_phyaddr_hi32;
|
2018-12-19 08:34:58 +00:00
|
|
|
acb->cdb_phyadd_hipart = ((uint64_t)cdb_phyaddr_hi32) << 32;
|
2007-09-13 09:26:40 +00:00
|
|
|
/*
|
|
|
|
***********************************************************************
|
|
|
|
** if adapter type B, set window of "post command Q"
|
|
|
|
***********************************************************************
|
|
|
|
*/
|
|
|
|
switch (acb->adapter_type) {
|
|
|
|
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2010-06-18 07:39:12 +00:00
|
|
|
if (cdb_phyaddr_hi32 != 0) {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
writel(ARCMSR_SIGNATURE_SET_CONFIG, \
|
|
|
|
®->message_rwbuffer[0]);
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(cdb_phyaddr_hi32, ®->message_rwbuffer[1]);
|
2007-09-13 09:26:40 +00:00
|
|
|
writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, \
|
|
|
|
®->inbound_msgaddr0);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
|
2007-09-13 09:26:40 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: ""set ccb high \
|
|
|
|
part physical address timeout\n",
|
|
|
|
acb->host->host_no);
|
|
|
|
return 1;
|
2007-06-15 03:43:32 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2007-06-15 03:43:32 +00:00
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
uint32_t __iomem *rwbuffer;
|
2007-06-15 03:43:32 +00:00
|
|
|
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
reg->postq_index = 0;
|
|
|
|
reg->doneq_index = 0;
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_MESSAGE_SET_POST_WINDOW, reg->drv2iop_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
2015-06-30 21:25:27 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: cannot set driver mode\n", \
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->host->host_no);
|
|
|
|
return 1;
|
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
rwbuffer = reg->message_rwbuffer;
|
2007-09-13 09:26:40 +00:00
|
|
|
/* driver "set config" signature */
|
|
|
|
writel(ARCMSR_SIGNATURE_SET_CONFIG, rwbuffer++);
|
|
|
|
/* normal should be zero */
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(cdb_phyaddr_hi32, rwbuffer++);
|
2007-09-13 09:26:40 +00:00
|
|
|
/* postQ size (256 + 8)*4 */
|
2014-08-19 07:14:14 +00:00
|
|
|
writel(cdb_phyaddr, rwbuffer++);
|
2007-09-13 09:26:40 +00:00
|
|
|
/* doneQ size (256 + 8)*4 */
|
2014-08-19 07:14:14 +00:00
|
|
|
writel(cdb_phyaddr + 1056, rwbuffer++);
|
2007-09-13 09:26:40 +00:00
|
|
|
/* ccb maxQ size must be --> [(256 + 8)*4]*/
|
|
|
|
writel(1056, rwbuffer);
|
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_MESSAGE_SET_CONFIG, reg->drv2iop_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
2007-09-13 09:26:40 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: 'set command Q window' \
|
|
|
|
timeout \n",acb->host->host_no);
|
|
|
|
return 1;
|
|
|
|
}
|
2014-08-19 07:01:28 +00:00
|
|
|
writel(ARCMSR_MESSAGE_START_DRIVER_MODE, reg->drv2iop_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
2014-08-19 07:01:28 +00:00
|
|
|
pr_err("arcmsr%d: can't set driver mode.\n",
|
|
|
|
acb->host->host_no);
|
|
|
|
return 1;
|
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
|
2011-04-29 14:28:24 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: cdb_phyaddr_hi32=0x%x\n",
|
|
|
|
acb->adapter_index, cdb_phyaddr_hi32);
|
2010-07-13 12:03:04 +00:00
|
|
|
writel(ARCMSR_SIGNATURE_SET_CONFIG, ®->msgcode_rwbuffer[0]);
|
|
|
|
writel(cdb_phyaddr_hi32, ®->msgcode_rwbuffer[1]);
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, ®->inbound_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaC_wait_msgint_ready(acb)) {
|
2010-07-13 12:03:04 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: 'set command Q window' \
|
|
|
|
timeout \n", acb->host->host_no);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
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;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
writel(ARCMSR_SIGNATURE_SET_CONFIG, ®->msgcode_rwbuffer[0]);
|
|
|
|
writel(ARCMSR_SIGNATURE_1884, ®->msgcode_rwbuffer[1]);
|
|
|
|
writel(cdb_phyaddr, ®->msgcode_rwbuffer[2]);
|
|
|
|
writel(cdb_phyaddr_hi32, ®->msgcode_rwbuffer[3]);
|
|
|
|
writel(acb->ccbsize, ®->msgcode_rwbuffer[4]);
|
2020-09-28 10:35:05 +00:00
|
|
|
writel(lower_32_bits(acb->dma_coherent_handle2), ®->msgcode_rwbuffer[5]);
|
|
|
|
writel(upper_32_bits(acb->dma_coherent_handle2), ®->msgcode_rwbuffer[6]);
|
2018-12-19 08:24:03 +00:00
|
|
|
writel(acb->ioqueue_size, ®->msgcode_rwbuffer[7]);
|
2017-12-05 01:35:34 +00:00
|
|
|
writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(acb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
if (!arcmsr_hbaE_wait_msgint_ready(acb)) {
|
|
|
|
pr_notice("arcmsr%d: 'set command Q window' timeout \n",
|
|
|
|
acb->host->host_no);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
|
|
|
struct MessageUnit_F __iomem *reg = acb->pmuF;
|
|
|
|
|
|
|
|
acb->msgcode_rwbuffer[0] = ARCMSR_SIGNATURE_SET_CONFIG;
|
|
|
|
acb->msgcode_rwbuffer[1] = ARCMSR_SIGNATURE_1886;
|
|
|
|
acb->msgcode_rwbuffer[2] = cdb_phyaddr;
|
|
|
|
acb->msgcode_rwbuffer[3] = cdb_phyaddr_hi32;
|
|
|
|
acb->msgcode_rwbuffer[4] = acb->ccbsize;
|
|
|
|
acb->msgcode_rwbuffer[5] = lower_32_bits(acb->dma_coherent_handle2);
|
|
|
|
acb->msgcode_rwbuffer[6] = upper_32_bits(acb->dma_coherent_handle2);
|
|
|
|
acb->msgcode_rwbuffer[7] = acb->completeQ_size;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_SET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(acb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
if (!arcmsr_hbaE_wait_msgint_ready(acb)) {
|
|
|
|
pr_notice("arcmsr%d: 'set command Q window' timeout\n",
|
|
|
|
acb->host->host_no);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2007-06-15 03:43:32 +00:00
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
static void arcmsr_wait_firmware_ready(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
uint32_t firmware_state = 0;
|
|
|
|
switch (acb->adapter_type) {
|
|
|
|
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
do {
|
2018-03-15 06:37:40 +00:00
|
|
|
if (!(acb->acb_flags & ACB_F_IOP_INITED))
|
|
|
|
msleep(20);
|
2007-09-13 09:26:40 +00:00
|
|
|
firmware_state = readl(®->outbound_msgaddr1);
|
|
|
|
} while ((firmware_state & ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK) == 0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
do {
|
2018-03-15 06:37:40 +00:00
|
|
|
if (!(acb->acb_flags & ACB_F_IOP_INITED))
|
|
|
|
msleep(20);
|
2010-06-18 07:39:12 +00:00
|
|
|
firmware_state = readl(reg->iop2drv_doorbell);
|
2007-09-13 09:26:40 +00:00
|
|
|
} while ((firmware_state & ARCMSR_MESSAGE_FIRMWARE_OK) == 0);
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_DRV2IOP_END_OF_INTERRUPT, reg->drv2iop_doorbell);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
do {
|
2018-03-15 06:37:40 +00:00
|
|
|
if (!(acb->acb_flags & ACB_F_IOP_INITED))
|
|
|
|
msleep(20);
|
2010-07-13 12:03:04 +00:00
|
|
|
firmware_state = readl(®->outbound_msgaddr1);
|
|
|
|
} while ((firmware_state & ARCMSR_HBCMU_MESSAGE_FIRMWARE_OK) == 0);
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
do {
|
2018-03-15 06:37:40 +00:00
|
|
|
if (!(acb->acb_flags & ACB_F_IOP_INITED))
|
|
|
|
msleep(20);
|
2014-08-19 07:25:22 +00:00
|
|
|
firmware_state = readl(reg->outbound_msgaddr1);
|
|
|
|
} while ((firmware_state &
|
|
|
|
ARCMSR_ARC1214_MESSAGE_FIRMWARE_OK) == 0);
|
|
|
|
}
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
2017-12-05 01:35:34 +00:00
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
do {
|
2018-03-15 06:37:40 +00:00
|
|
|
if (!(acb->acb_flags & ACB_F_IOP_INITED))
|
|
|
|
msleep(20);
|
2017-12-05 01:35:34 +00:00
|
|
|
firmware_state = readl(®->outbound_msgaddr1);
|
|
|
|
} while ((firmware_state & ARCMSR_HBEMU_MESSAGE_FIRMWARE_OK) == 0);
|
|
|
|
}
|
|
|
|
break;
|
2007-06-15 03:43:32 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
|
2017-12-13 08:33:36 +00:00
|
|
|
static void arcmsr_request_device_map(struct timer_list *t)
|
2017-12-05 01:35:34 +00:00
|
|
|
{
|
2017-12-13 08:33:36 +00:00
|
|
|
struct AdapterControlBlock *acb = from_timer(acb, t, eternal_timer);
|
2020-09-28 10:31:27 +00:00
|
|
|
if (acb->acb_flags & (ACB_F_MSG_GET_CONFIG | ACB_F_BUS_RESET | ACB_F_ABORT)) {
|
|
|
|
mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
|
2017-12-05 01:35:34 +00:00
|
|
|
} else {
|
|
|
|
acb->fw_flag = FW_NORMAL;
|
2017-12-13 08:33:36 +00:00
|
|
|
switch (acb->adapter_type) {
|
2010-05-17 03:22:42 +00:00
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2017-12-13 08:33:36 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
break;
|
|
|
|
}
|
2010-05-17 03:22:42 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2017-12-13 08:33:36 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
|
|
|
writel(ARCMSR_MESSAGE_GET_CONFIG, reg->drv2iop_doorbell);
|
|
|
|
break;
|
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2017-12-13 08:33:36 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_MESSAGE_CMD_DONE, ®->inbound_doorbell);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_D: {
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, reg->inbound_msgaddr0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case ACB_ADAPTER_TYPE_E: {
|
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(acb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
break;
|
|
|
|
}
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
|
|
|
struct MessageUnit_F __iomem *reg = acb->pmuF;
|
|
|
|
uint32_t outMsg1 = readl(®->outbound_msgaddr1);
|
|
|
|
|
|
|
|
if (!(outMsg1 & ARCMSR_HBFMU_MESSAGE_FIRMWARE_OK) ||
|
|
|
|
(outMsg1 & ARCMSR_HBFMU_MESSAGE_NO_VOLUME_CHANGE))
|
|
|
|
goto nxt6s;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_GET_CONFIG, ®->inbound_msgaddr0);
|
|
|
|
acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(acb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
break;
|
|
|
|
}
|
2017-12-13 08:33:36 +00:00
|
|
|
default:
|
|
|
|
return;
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
2017-12-13 08:33:36 +00:00
|
|
|
acb->acb_flags |= ACB_F_MSG_GET_CONFIG;
|
2020-09-28 10:35:05 +00:00
|
|
|
nxt6s:
|
2017-12-13 08:33:36 +00:00
|
|
|
mod_timer(&acb->eternal_timer, jiffies + msecs_to_jiffies(6 * HZ));
|
2010-05-17 03:22:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaA_start_bgrb(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->acb_flags |= ACB_F_MSG_START_BGRB;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_START_BGRB, ®->inbound_msgaddr0);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaA_wait_msgint_ready(acb)) {
|
2007-09-13 09:26:40 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
|
2018-09-03 17:35:29 +00:00
|
|
|
rebuild' timeout \n", acb->host->host_no);
|
2007-06-15 03:43:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaB_start_bgrb(struct AdapterControlBlock *acb)
|
2007-09-13 09:26:40 +00:00
|
|
|
{
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2007-09-13 09:26:40 +00:00
|
|
|
acb->acb_flags |= ACB_F_MSG_START_BGRB;
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_MESSAGE_START_BGRB, reg->drv2iop_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
2007-09-13 09:26:40 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
|
2018-09-03 17:35:29 +00:00
|
|
|
rebuild' timeout \n",acb->host->host_no);
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2014-08-19 07:10:12 +00:00
|
|
|
static void arcmsr_hbaC_start_bgrb(struct AdapterControlBlock *pACB)
|
2010-07-13 12:03:04 +00:00
|
|
|
{
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *phbcmu = pACB->pmuC;
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaC_wait_msgint_ready(pACB)) {
|
2010-07-13 12:03:04 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: wait 'start adapter background \
|
2018-09-03 17:35:29 +00:00
|
|
|
rebuild' timeout \n", pACB->host->host_no);
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
|
|
|
|
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 "
|
2018-09-03 17:35:29 +00:00
|
|
|
"background rebuild' timeout\n", pACB->host->host_no);
|
2014-08-19 07:25:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-12-05 01:35:34 +00:00
|
|
|
static void arcmsr_hbaE_start_bgrb(struct AdapterControlBlock *pACB)
|
|
|
|
{
|
|
|
|
struct MessageUnit_E __iomem *pmu = pACB->pmuE;
|
|
|
|
|
|
|
|
pACB->acb_flags |= ACB_F_MSG_START_BGRB;
|
|
|
|
writel(ARCMSR_INBOUND_MESG0_START_BGRB, &pmu->inbound_msgaddr0);
|
|
|
|
pACB->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_MESSAGE_CMD_DONE;
|
|
|
|
writel(pACB->out_doorbell, &pmu->iobound_doorbell);
|
|
|
|
if (!arcmsr_hbaE_wait_msgint_ready(pACB)) {
|
|
|
|
pr_notice("arcmsr%d: wait 'start adapter "
|
2018-09-03 17:35:29 +00:00
|
|
|
"background rebuild' timeout \n", pACB->host->host_no);
|
2017-12-05 01:35:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
static void arcmsr_start_adapter_bgrb(struct AdapterControlBlock *acb)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
2007-09-13 09:26:40 +00:00
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_A:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaA_start_bgrb(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_B:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaB_start_bgrb(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C:
|
2014-08-19 07:10:12 +00:00
|
|
|
arcmsr_hbaC_start_bgrb(acb);
|
2014-08-19 07:25:22 +00:00
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D:
|
|
|
|
arcmsr_hbaD_start_bgrb(acb);
|
|
|
|
break;
|
2017-12-05 01:35:34 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_F:
|
2017-12-05 01:35:34 +00:00
|
|
|
arcmsr_hbaE_start_bgrb(acb);
|
|
|
|
break;
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
static void arcmsr_clear_doorbell_queue_buffer(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
switch (acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_A: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
2007-09-13 09:26:40 +00:00
|
|
|
uint32_t outbound_doorbell;
|
|
|
|
/* empty doorbell Qbuffer if door bell ringed */
|
|
|
|
outbound_doorbell = readl(®->outbound_doorbell);
|
|
|
|
/*clear doorbell interrupt */
|
|
|
|
writel(outbound_doorbell, ®->outbound_doorbell);
|
|
|
|
writel(ARCMSR_INBOUND_DRIVER_DATA_READ_OK, ®->inbound_doorbell);
|
|
|
|
}
|
|
|
|
break;
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
case ACB_ADAPTER_TYPE_B: {
|
2007-10-29 05:08:28 +00:00
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
2017-12-05 02:02:16 +00:00
|
|
|
uint32_t outbound_doorbell, i;
|
|
|
|
writel(ARCMSR_DOORBELL_INT_CLEAR_PATTERN, reg->iop2drv_doorbell);
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_DRV2IOP_DATA_READ_OK, reg->drv2iop_doorbell);
|
2007-09-13 09:26:40 +00:00
|
|
|
/* let IOP know data has been read */
|
2017-12-05 02:02:16 +00:00
|
|
|
for(i=0; i < 200; i++) {
|
|
|
|
msleep(20);
|
|
|
|
outbound_doorbell = readl(reg->iop2drv_doorbell);
|
|
|
|
if( outbound_doorbell & ARCMSR_IOP2DRV_DATA_WRITE_OK) {
|
|
|
|
writel(ARCMSR_DOORBELL_INT_CLEAR_PATTERN, reg->iop2drv_doorbell);
|
|
|
|
writel(ARCMSR_DRV2IOP_DATA_READ_OK, reg->drv2iop_doorbell);
|
|
|
|
} else
|
|
|
|
break;
|
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C: {
|
2014-08-19 07:20:31 +00:00
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
2014-08-19 07:07:35 +00:00
|
|
|
uint32_t outbound_doorbell, i;
|
2010-07-13 12:03:04 +00:00
|
|
|
/* empty doorbell Qbuffer if door bell ringed */
|
|
|
|
outbound_doorbell = readl(®->outbound_doorbell);
|
|
|
|
writel(outbound_doorbell, ®->outbound_doorbell_clear);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_DATA_READ_OK, ®->inbound_doorbell);
|
2014-08-19 07:07:35 +00:00
|
|
|
for (i = 0; i < 200; i++) {
|
|
|
|
msleep(20);
|
|
|
|
outbound_doorbell = readl(®->outbound_doorbell);
|
|
|
|
if (outbound_doorbell &
|
|
|
|
ARCMSR_HBCMU_IOP2DRV_DATA_WRITE_OK) {
|
|
|
|
writel(outbound_doorbell,
|
|
|
|
®->outbound_doorbell_clear);
|
|
|
|
writel(ARCMSR_HBCMU_DRV2IOP_DATA_READ_OK,
|
|
|
|
®->inbound_doorbell);
|
|
|
|
} else
|
|
|
|
break;
|
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
2014-08-19 07:25:22 +00:00
|
|
|
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;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
case ACB_ADAPTER_TYPE_F: {
|
2017-12-05 01:35:34 +00:00
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
uint32_t i, tmp;
|
|
|
|
|
|
|
|
acb->in_doorbell = readl(®->iobound_doorbell);
|
|
|
|
writel(0, ®->host_int_status); /*clear interrupt*/
|
|
|
|
acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_DATA_READ_OK;
|
|
|
|
writel(acb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
for(i=0; i < 200; i++) {
|
|
|
|
msleep(20);
|
|
|
|
tmp = acb->in_doorbell;
|
|
|
|
acb->in_doorbell = readl(®->iobound_doorbell);
|
|
|
|
if((tmp ^ acb->in_doorbell) & ARCMSR_HBEMU_IOP2DRV_DATA_WRITE_OK) {
|
|
|
|
writel(0, ®->host_int_status); /*clear interrupt*/
|
|
|
|
acb->out_doorbell ^= ARCMSR_HBEMU_DRV2IOP_DATA_READ_OK;
|
|
|
|
writel(acb->out_doorbell, ®->iobound_doorbell);
|
|
|
|
} else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2007-09-13 09:26:40 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2008-02-05 07:53:24 +00:00
|
|
|
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;
|
2010-06-18 07:39:12 +00:00
|
|
|
writel(ARCMSR_MESSAGE_ACTIVE_EOI_MODE, reg->drv2iop_doorbell);
|
2014-08-19 07:10:12 +00:00
|
|
|
if (!arcmsr_hbaB_wait_msgint_ready(acb)) {
|
2008-02-05 07:53:24 +00:00
|
|
|
printk(KERN_NOTICE "ARCMSR IOP enables EOI_MODE TIMEOUT");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2010-07-13 12:03:04 +00:00
|
|
|
case ACB_ADAPTER_TYPE_C:
|
|
|
|
return;
|
2008-02-05 07:53:24 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
static void arcmsr_hardware_reset(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
uint8_t value[64];
|
2010-07-13 12:03:04 +00:00
|
|
|
int i, count = 0;
|
|
|
|
struct MessageUnit_A __iomem *pmuA = acb->pmuA;
|
|
|
|
struct MessageUnit_C __iomem *pmuC = acb->pmuC;
|
2014-08-19 07:25:22 +00:00
|
|
|
struct MessageUnit_D *pmuD = acb->pmuD;
|
2012-06-09 09:10:19 +00:00
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
/* backup pci config data */
|
2010-07-13 12:03:04 +00:00
|
|
|
printk(KERN_NOTICE "arcmsr%d: executing hw bus reset .....\n", acb->host->host_no);
|
2010-05-17 03:22:42 +00:00
|
|
|
for (i = 0; i < 64; i++) {
|
|
|
|
pci_read_config_byte(acb->pdev, i, &value[i]);
|
|
|
|
}
|
|
|
|
/* hardware reset signal */
|
2018-09-30 23:03:07 +00:00
|
|
|
if (acb->dev_id == 0x1680) {
|
2010-07-13 12:03:04 +00:00
|
|
|
writel(ARCMSR_ARC1680_BUS_RESET, &pmuA->reserved1[0]);
|
2018-09-30 23:03:07 +00:00
|
|
|
} else if (acb->dev_id == 0x1880) {
|
2010-07-13 12:03:04 +00:00
|
|
|
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);
|
2012-06-09 09:10:19 +00:00
|
|
|
} while (((readl(&pmuC->host_diagnostic) & ARCMSR_ARC1880_DiagWrite_ENABLE) == 0) && (count < 5));
|
2010-07-13 12:03:04 +00:00
|
|
|
writel(ARCMSR_ARC1880_RESET_ADAPTER, &pmuC->host_diagnostic);
|
2017-12-05 01:35:34 +00:00
|
|
|
} else if (acb->dev_id == 0x1884) {
|
|
|
|
struct MessageUnit_E __iomem *pmuE = acb->pmuE;
|
|
|
|
do {
|
|
|
|
count++;
|
|
|
|
writel(0x4, &pmuE->write_sequence_3xxx);
|
|
|
|
writel(0xB, &pmuE->write_sequence_3xxx);
|
|
|
|
writel(0x2, &pmuE->write_sequence_3xxx);
|
|
|
|
writel(0x7, &pmuE->write_sequence_3xxx);
|
|
|
|
writel(0xD, &pmuE->write_sequence_3xxx);
|
|
|
|
mdelay(10);
|
|
|
|
} while (((readl(&pmuE->host_diagnostic_3xxx) &
|
|
|
|
ARCMSR_ARC1884_DiagWrite_ENABLE) == 0) && (count < 5));
|
|
|
|
writel(ARCMSR_ARC188X_RESET_ADAPTER, &pmuE->host_diagnostic_3xxx);
|
2018-09-30 23:03:07 +00:00
|
|
|
} else if (acb->dev_id == 0x1214) {
|
2014-08-19 07:25:22 +00:00
|
|
|
writel(0x20, pmuD->reset_request);
|
2010-06-18 07:39:12 +00:00
|
|
|
} else {
|
2010-07-13 12:03:04 +00:00
|
|
|
pci_write_config_byte(acb->pdev, 0x84, 0x20);
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
2010-07-13 12:03:04 +00:00
|
|
|
msleep(2000);
|
2010-05-17 03:22:42 +00:00
|
|
|
/* write back pci config data */
|
|
|
|
for (i = 0; i < 64; i++) {
|
|
|
|
pci_write_config_byte(acb->pdev, i, value[i]);
|
|
|
|
}
|
|
|
|
msleep(1000);
|
|
|
|
return;
|
|
|
|
}
|
2017-12-05 01:31:59 +00:00
|
|
|
|
|
|
|
static bool arcmsr_reset_in_progress(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
bool rtn = true;
|
|
|
|
|
|
|
|
switch(acb->adapter_type) {
|
|
|
|
case ACB_ADAPTER_TYPE_A:{
|
|
|
|
struct MessageUnit_A __iomem *reg = acb->pmuA;
|
|
|
|
rtn = ((readl(®->outbound_msgaddr1) &
|
|
|
|
ARCMSR_OUTBOUND_MESG1_FIRMWARE_OK) == 0) ? true : false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_B:{
|
|
|
|
struct MessageUnit_B *reg = acb->pmuB;
|
|
|
|
rtn = ((readl(reg->iop2drv_doorbell) &
|
|
|
|
ARCMSR_MESSAGE_FIRMWARE_OK) == 0) ? true : false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_C:{
|
|
|
|
struct MessageUnit_C __iomem *reg = acb->pmuC;
|
|
|
|
rtn = (readl(®->host_diagnostic) & 0x04) ? true : false;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case ACB_ADAPTER_TYPE_D:{
|
|
|
|
struct MessageUnit_D *reg = acb->pmuD;
|
|
|
|
rtn = ((readl(reg->sample_at_reset) & 0x80) == 0) ?
|
|
|
|
true : false;
|
|
|
|
}
|
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case ACB_ADAPTER_TYPE_E:
|
|
|
|
case ACB_ADAPTER_TYPE_F:{
|
2017-12-05 01:35:34 +00:00
|
|
|
struct MessageUnit_E __iomem *reg = acb->pmuE;
|
|
|
|
rtn = (readl(®->host_diagnostic_3xxx) &
|
|
|
|
ARCMSR_ARC188X_RESET_ADAPTER) ? true : false;
|
|
|
|
}
|
|
|
|
break;
|
2017-12-05 01:31:59 +00:00
|
|
|
}
|
|
|
|
return rtn;
|
|
|
|
}
|
|
|
|
|
2007-09-13 09:26:40 +00:00
|
|
|
static void arcmsr_iop_init(struct AdapterControlBlock *acb)
|
|
|
|
{
|
|
|
|
uint32_t intmask_org;
|
2010-07-13 12:03:04 +00:00
|
|
|
/* disable all outbound interrupt */
|
|
|
|
intmask_org = arcmsr_disable_outbound_ints(acb);
|
2008-02-05 07:53:24 +00:00
|
|
|
arcmsr_wait_firmware_ready(acb);
|
|
|
|
arcmsr_iop_confirm(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
/*start background rebuild*/
|
|
|
|
arcmsr_start_adapter_bgrb(acb);
|
|
|
|
/* empty doorbell Qbuffer if door bell ringed */
|
|
|
|
arcmsr_clear_doorbell_queue_buffer(acb);
|
2008-02-05 07:53:24 +00:00
|
|
|
arcmsr_enable_eoi_mode(acb);
|
2007-09-13 09:26:40 +00:00
|
|
|
/* enable outbound Post Queue,outbound doorbell Interrupt */
|
|
|
|
arcmsr_enable_outbound_ints(acb, intmask_org);
|
2006-07-12 15:59:32 +00:00
|
|
|
acb->acb_flags |= ACB_F_IOP_INITED;
|
|
|
|
}
|
|
|
|
|
2010-05-17 03:22:42 +00:00
|
|
|
static uint8_t arcmsr_iop_reset(struct AdapterControlBlock *acb)
|
2006-07-12 15:59:32 +00:00
|
|
|
{
|
|
|
|
struct CommandControlBlock *ccb;
|
|
|
|
uint32_t intmask_org;
|
2010-05-17 03:22:42 +00:00
|
|
|
uint8_t rtnval = 0x00;
|
2006-07-12 15:59:32 +00:00
|
|
|
int i = 0;
|
2011-01-06 09:32:41 +00:00
|
|
|
unsigned long flags;
|
|
|
|
|
2006-07-12 15:59:32 +00:00
|
|
|
if (atomic_read(&acb->ccboutstandingcount) != 0) {
|
2010-05-17 03:22:42 +00:00
|
|
|
/* disable all outbound interrupt */
|
|
|
|
intmask_org = arcmsr_disable_outbound_ints(acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
/* talk to iop 331 outstanding command aborted */
|
2010-05-17 03:22:42 +00:00
|
|
|
rtnval = arcmsr_abort_allcmd(acb);
|
2006-07-12 15:59:32 +00:00
|
|
|
/* clear all outbound posted Q */
|
2007-09-13 09:26:40 +00:00
|
|
|
arcmsr_done4abort_postqueue(acb);
|
2017-12-05 01:44:23 +00:00
|
|
|
for (i = 0; i < acb->maxFreeCCB; i++) {
|
2006-07-12 15:59:32 +00:00
|
|
|
ccb = acb->pccb_pool[i];
|
2007-06-15 03:43:32 +00:00
|
|
|
if (ccb->startdone == ARCMSR_CCB_START) {
|
2011-01-06 09:32:41 +00:00
|
|
|
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);
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
}
|
2010-05-17 03:22:42 +00:00
|
|
|
atomic_set(&acb->ccboutstandingcount, 0);
|
2006-07-12 15:59:32 +00:00
|
|
|
/* enable all outbound interrupt */
|
|
|
|
arcmsr_enable_outbound_ints(acb, intmask_org);
|
2010-05-17 03:22:42 +00:00
|
|
|
return rtnval;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
2010-05-17 03:22:42 +00:00
|
|
|
return rtnval;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int arcmsr_bus_reset(struct scsi_cmnd *cmd)
|
|
|
|
{
|
2011-01-06 09:32:41 +00:00
|
|
|
struct AdapterControlBlock *acb;
|
2010-06-18 07:39:12 +00:00
|
|
|
int retry_count = 0;
|
|
|
|
int rtn = FAILED;
|
|
|
|
acb = (struct AdapterControlBlock *) cmd->device->host->hostdata;
|
2018-03-15 06:33:36 +00:00
|
|
|
if (acb->acb_flags & ACB_F_ADAPTER_REMOVED)
|
|
|
|
return SUCCESS;
|
2017-12-05 01:31:59 +00:00
|
|
|
pr_notice("arcmsr: executing bus reset eh.....num_resets = %d,"
|
|
|
|
" num_aborts = %d \n", acb->num_resets, acb->num_aborts);
|
2010-05-17 03:22:42 +00:00
|
|
|
acb->num_resets++;
|
|
|
|
|
2017-12-05 01:31:59 +00:00
|
|
|
if (acb->acb_flags & ACB_F_BUS_RESET) {
|
|
|
|
long timeout;
|
2017-12-05 02:18:47 +00:00
|
|
|
pr_notice("arcmsr: there is a bus reset eh proceeding...\n");
|
2017-12-05 01:31:59 +00:00
|
|
|
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)) {
|
|
|
|
arcmsr_hardware_reset(acb);
|
|
|
|
acb->acb_flags &= ~ACB_F_IOP_INITED;
|
|
|
|
wait_reset_done:
|
|
|
|
ssleep(ARCMSR_SLEEPTIME);
|
|
|
|
if (arcmsr_reset_in_progress(acb)) {
|
|
|
|
if (retry_count > ARCMSR_RETRYCOUNT) {
|
|
|
|
acb->fw_flag = FW_DEADLOCK;
|
|
|
|
pr_notice("arcmsr%d: waiting for hw bus reset"
|
|
|
|
" return, RETRY TERMINATED!!\n",
|
|
|
|
acb->host->host_no);
|
|
|
|
return FAILED;
|
2010-07-13 12:03:04 +00:00
|
|
|
}
|
2017-12-05 01:31:59 +00:00
|
|
|
retry_count++;
|
|
|
|
goto wait_reset_done;
|
2014-08-19 07:25:22 +00:00
|
|
|
}
|
2017-12-05 01:31:59 +00:00
|
|
|
arcmsr_iop_init(acb);
|
|
|
|
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_notice("arcmsr: scsi bus reset eh returns with success\n");
|
|
|
|
} else {
|
|
|
|
acb->acb_flags &= ~ACB_F_BUS_RESET;
|
|
|
|
acb->fw_flag = FW_NORMAL;
|
|
|
|
mod_timer(&acb->eternal_timer, jiffies +
|
|
|
|
msecs_to_jiffies(6 * HZ));
|
|
|
|
rtn = SUCCESS;
|
2010-06-18 07:39:12 +00:00
|
|
|
}
|
|
|
|
return rtn;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
|
2010-06-18 07:39:12 +00:00
|
|
|
static int arcmsr_abort_one_cmd(struct AdapterControlBlock *acb,
|
2006-07-12 15:59:32 +00:00
|
|
|
struct CommandControlBlock *ccb)
|
|
|
|
{
|
2010-06-18 07:39:12 +00:00
|
|
|
int rtn;
|
|
|
|
rtn = arcmsr_polling_ccbdone(acb, ccb);
|
|
|
|
return rtn;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int arcmsr_abort(struct scsi_cmnd *cmd)
|
|
|
|
{
|
|
|
|
struct AdapterControlBlock *acb =
|
|
|
|
(struct AdapterControlBlock *)cmd->device->host->hostdata;
|
|
|
|
int i = 0;
|
2010-06-18 07:39:12 +00:00
|
|
|
int rtn = FAILED;
|
2014-08-19 06:47:16 +00:00
|
|
|
uint32_t intmask_org;
|
|
|
|
|
2018-03-15 06:33:36 +00:00
|
|
|
if (acb->acb_flags & ACB_F_ADAPTER_REMOVED)
|
|
|
|
return SUCCESS;
|
2006-07-12 15:59:32 +00:00
|
|
|
printk(KERN_NOTICE
|
2014-08-19 06:47:16 +00:00
|
|
|
"arcmsr%d: abort device command of scsi id = %d lun = %d\n",
|
2014-06-25 13:27:36 +00:00
|
|
|
acb->host->host_no, cmd->device->id, (u32)cmd->device->lun);
|
2010-06-18 07:39:12 +00:00
|
|
|
acb->acb_flags |= ACB_F_ABORT;
|
2006-07-12 15:59:32 +00:00
|
|
|
acb->num_aborts++;
|
|
|
|
/*
|
|
|
|
************************************************
|
|
|
|
** the all interrupt service routine is locked
|
|
|
|
** we need to handle it as soon as possible and exit
|
|
|
|
************************************************
|
|
|
|
*/
|
2014-08-19 06:47:16 +00:00
|
|
|
if (!atomic_read(&acb->ccboutstandingcount)) {
|
|
|
|
acb->acb_flags &= ~ACB_F_ABORT;
|
2010-06-18 07:39:12 +00:00
|
|
|
return rtn;
|
2014-08-19 06:47:16 +00:00
|
|
|
}
|
2006-07-12 15:59:32 +00:00
|
|
|
|
2014-08-19 06:47:16 +00:00
|
|
|
intmask_org = arcmsr_disable_outbound_ints(acb);
|
2017-12-05 01:44:23 +00:00
|
|
|
for (i = 0; i < acb->maxFreeCCB; i++) {
|
2006-07-12 15:59:32 +00:00
|
|
|
struct CommandControlBlock *ccb = acb->pccb_pool[i];
|
|
|
|
if (ccb->startdone == ARCMSR_CCB_START && ccb->pcmd == cmd) {
|
2010-06-18 07:39:12 +00:00
|
|
|
ccb->startdone = ARCMSR_CCB_ABORTED;
|
|
|
|
rtn = arcmsr_abort_one_cmd(acb, ccb);
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-06-18 07:39:12 +00:00
|
|
|
acb->acb_flags &= ~ACB_F_ABORT;
|
2014-08-19 06:47:16 +00:00
|
|
|
arcmsr_enable_outbound_ints(acb, intmask_org);
|
2010-06-18 07:39:12 +00:00
|
|
|
return rtn;
|
2006-07-12 15:59:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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:
|
2007-09-13 09:26:40 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1200:
|
|
|
|
case PCI_DEVICE_ID_ARECA_1202:
|
2006-07-12 15:59:32 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1210:
|
|
|
|
raid6 = 0;
|
2020-08-23 22:36:59 +00:00
|
|
|
fallthrough;
|
2006-07-12 15:59:32 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1120:
|
|
|
|
case PCI_DEVICE_ID_ARECA_1130:
|
|
|
|
case PCI_DEVICE_ID_ARECA_1160:
|
|
|
|
case PCI_DEVICE_ID_ARECA_1170:
|
2007-09-13 09:26:40 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1201:
|
2015-11-25 11:49:33 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1203:
|
2006-07-12 15:59:32 +00:00
|
|
|
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;
|
2014-08-19 07:25:22 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1214:
|
2006-07-12 15:59:32 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1380:
|
|
|
|
case PCI_DEVICE_ID_ARECA_1381:
|
|
|
|
case PCI_DEVICE_ID_ARECA_1680:
|
|
|
|
case PCI_DEVICE_ID_ARECA_1681:
|
2010-07-13 12:03:04 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1880:
|
2017-12-05 01:35:34 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1884:
|
2014-08-19 07:22:45 +00:00
|
|
|
type = "SAS/SATA";
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
2020-09-28 10:35:05 +00:00
|
|
|
case PCI_DEVICE_ID_ARECA_1886:
|
|
|
|
type = "NVMe/SAS/SATA";
|
|
|
|
break;
|
2006-07-12 15:59:32 +00:00
|
|
|
default:
|
2014-08-19 07:22:45 +00:00
|
|
|
type = "unknown";
|
|
|
|
raid6 = 0;
|
2006-07-12 15:59:32 +00:00
|
|
|
break;
|
|
|
|
}
|
2014-08-19 07:22:45 +00:00
|
|
|
sprintf(buf, "Areca %s RAID Controller %s\narcmsr version %s\n",
|
|
|
|
type, raid6 ? "(RAID6 capable)" : "", ARCMSR_DRIVER_VERSION);
|
2006-07-12 15:59:32 +00:00
|
|
|
return buf;
|
|
|
|
}
|