| Current Path : /sys/dev/tws/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //sys/dev/tws/tws_services.c |
/*
* Copyright (c) 2010, LSI Corp.
* All rights reserved.
* Author : Manjunath Ranganathaiah
* Support: freebsdraid@lsi.com
*
* 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. Neither the name of the <ORGANIZATION> nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "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
* COPYRIGHT HOLDER OR CONTRIBUTORS 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.
*
* $FreeBSD: release/9.1.0/sys/dev/tws/tws_services.c 226969 2011-10-31 20:02:11Z delphij $
*/
#include <dev/tws/tws.h>
#include <dev/tws/tws_hdm.h>
#include <dev/tws/tws_services.h>
#include <sys/time.h>
void tws_q_insert_tail(struct tws_softc *sc, struct tws_request *req,
u_int8_t q_type );
struct tws_request * tws_q_remove_request(struct tws_softc *sc,
struct tws_request *req, u_int8_t q_type );
struct tws_request *tws_q_remove_head(struct tws_softc *sc, u_int8_t q_type );
void tws_q_insert_head(struct tws_softc *sc, struct tws_request *req,
u_int8_t q_type );
struct tws_request * tws_q_remove_tail(struct tws_softc *sc, u_int8_t q_type );
void tws_print_stats(void *arg);
struct tws_sense *tws_find_sense_from_mfa(struct tws_softc *sc, u_int64_t mfa);
static struct error_desc array[] = {
{ "Cannot add sysctl tree node", 0x2000, ERROR,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Register window not available", 0x2001, ERROR,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Can't allocate register window", 0x2002, ERROR,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Can't allocate interrupt", 0x2003, ERROR,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Can't set up interrupt", 0x2004, ERROR,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Couldn't intialize CAM", 0x2007, ERROR,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Couldn't create SIM device queue", 0x2100, ENOMEM,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Unable to create SIM entry", 0x2101, ENOMEM,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Unable to register the bus", 0x2102, ENXIO,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Unable to create the path", 0x2103, ENXIO,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Bus scan request to CAM failed", 0x2104, ENXIO,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Unable to intialize the driver", 0x2008, ENXIO,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
{ "Unable to intialize the controller", 0x2009, ENXIO,
"%s: (0x%02X: 0x%04X): %s:\n", "ERROR" },
};
void
tws_trace(const char *file, const char *fun, int linenum,
struct tws_softc *sc, char *desc, u_int64_t val1, u_int64_t val2)
{
struct tws_trace_rec *rec = (struct tws_trace_rec *)sc->trace_q.q;
volatile u_int16_t head, tail;
char fmt[256];
head = sc->trace_q.head;
tail = sc->trace_q.tail;
/*
getnanotime(&rec[tail].ts);
*/
strncpy(rec[tail].fname, file, TWS_TRACE_FNAME_LEN);
strncpy(rec[tail].func, fun, TWS_TRACE_FUNC_LEN);
rec[tail].linenum = linenum;
strncpy(rec[tail].desc, desc, TWS_TRACE_DESC_LEN);
rec[tail].val1 = val1;
rec[tail].val2 = val2;
tail = (tail+1) % sc->trace_q.depth;
if ( head == tail ) {
sc->trace_q.overflow = 1;
sc->trace_q.head = (head+1) % sc->trace_q.depth;
}
sc->trace_q.tail = tail;
/*
tws_circular_q_insert(sc, &sc->trace_q,
&rec, sizeof(struct tws_trace_rec));
*/
if ( sc->is64bit )
strcpy(fmt, "%05d:%s::%s :%s: 0x%016lx : 0x%016lx \n");
else
strcpy(fmt, "%05d:%s::%s :%s: 0x%016llx : 0x%016llx \n");
/*
printf("%05d:%s::%s :%s: 0x%016llx : 0x%016llx \n",
linenum, file, fun, desc, val1, val2);
*/
printf(fmt, linenum, file, fun, desc, val1, val2);
}
void
tws_log(struct tws_softc *sc, int index)
{
device_printf((sc)->tws_dev, array[index].fmt,
array[index].error_str,
array[index].error_code,
array[index].severity_level,
array[index].desc );
}
/* ----------- swap functions ----------- */
u_int16_t
tws_swap16(u_int16_t val)
{
return((val << 8) | (val >> 8));
}
u_int32_t
tws_swap32(u_int32_t val)
{
return(((val << 24) | ((val << 8) & (0xFF0000)) |
((val >> 8) & (0xFF00)) | (val >> 24)));
}
u_int64_t
tws_swap64(u_int64_t val)
{
return((((u_int64_t)(tws_swap32(((u_int32_t *)(&(val)))[1]))) << 32) |
((u_int32_t)(tws_swap32(((u_int32_t *)(&(val)))[0]))));
}
/* ----------- reg access ----------- */
void
tws_write_reg(struct tws_softc *sc, int offset,
u_int32_t value, int size)
{
bus_space_tag_t bus_tag = sc->bus_tag;
bus_space_handle_t bus_handle = sc->bus_handle;
if (size == 4)
bus_space_write_4(bus_tag, bus_handle, offset, value);
else
if (size == 2)
bus_space_write_2(bus_tag, bus_handle, offset,
(u_int16_t)value);
else
bus_space_write_1(bus_tag, bus_handle, offset, (u_int8_t)value);
}
u_int32_t
tws_read_reg(struct tws_softc *sc, int offset, int size)
{
bus_space_tag_t bus_tag = sc->bus_tag;
bus_space_handle_t bus_handle = sc->bus_handle;
if (size == 4)
return((u_int32_t)bus_space_read_4(bus_tag, bus_handle, offset));
else if (size == 2)
return((u_int32_t)bus_space_read_2(bus_tag, bus_handle, offset));
else
return((u_int32_t)bus_space_read_1(bus_tag, bus_handle, offset));
}
/* --------------------- Q service --------------------- */
/*
* intialize q pointers with null.
*/
void
tws_init_qs(struct tws_softc *sc)
{
mtx_lock(&sc->q_lock);
for(int i=0;i<TWS_MAX_QS;i++) {
sc->q_head[i] = NULL;
sc->q_tail[i] = NULL;
}
mtx_unlock(&sc->q_lock);
}
/* called with lock held */
static void
tws_insert2_empty_q(struct tws_softc *sc, struct tws_request *req,
u_int8_t q_type )
{
mtx_assert(&sc->q_lock, MA_OWNED);
req->next = req->prev = NULL;
sc->q_head[q_type] = sc->q_tail[q_type] = req;
}
/* called with lock held */
void
tws_q_insert_head(struct tws_softc *sc, struct tws_request *req,
u_int8_t q_type )
{
mtx_assert(&sc->q_lock, MA_OWNED);
if ( sc->q_head[q_type] == NULL ) {
tws_insert2_empty_q(sc, req, q_type);
} else {
req->next = sc->q_head[q_type];
req->prev = NULL;
sc->q_head[q_type]->prev = req;
sc->q_head[q_type] = req;
}
}
/* called with lock held */
void
tws_q_insert_tail(struct tws_softc *sc, struct tws_request *req,
u_int8_t q_type )
{
mtx_assert(&sc->q_lock, MA_OWNED);
if ( sc->q_tail[q_type] == NULL ) {
tws_insert2_empty_q(sc, req, q_type);
} else {
req->prev = sc->q_tail[q_type];
req->next = NULL;
sc->q_tail[q_type]->next = req;
sc->q_tail[q_type] = req;
}
}
/* called with lock held */
struct tws_request *
tws_q_remove_head(struct tws_softc *sc, u_int8_t q_type )
{
struct tws_request *r;
mtx_assert(&sc->q_lock, MA_OWNED);
r = sc->q_head[q_type];
if ( !r )
return(NULL);
if ( r->next == NULL && r->prev == NULL ) {
/* last element */
sc->q_head[q_type] = sc->q_tail[q_type] = NULL;
} else {
sc->q_head[q_type] = r->next;
r->next->prev = NULL;
r->next = NULL;
r->prev = NULL;
}
return(r);
}
/* called with lock held */
struct tws_request *
tws_q_remove_tail(struct tws_softc *sc, u_int8_t q_type )
{
struct tws_request *r;
mtx_assert(&sc->q_lock, MA_OWNED);
r = sc->q_tail[q_type];
if ( !r )
return(NULL);
if ( r->next == NULL && r->prev == NULL ) {
/* last element */
sc->q_head[q_type] = sc->q_tail[q_type] = NULL;
} else {
sc->q_tail[q_type] = r->prev;
r->prev->next = NULL;
r->next = NULL;
r->prev = NULL;
}
return(r);
}
/* returns removed request if successful. return NULL otherwise */
/* called with lock held */
struct tws_request *
tws_q_remove_request(struct tws_softc *sc, struct tws_request *req,
u_int8_t q_type )
{
struct tws_request *r;
mtx_assert(&sc->q_lock, MA_OWNED);
if ( req == NULL ) {
TWS_TRACE_DEBUG(sc, "null req", 0, q_type);
return(NULL);
}
if ( req == sc->q_head[q_type] )
return(tws_q_remove_head(sc, q_type));
if ( req == sc->q_tail[q_type] )
return(tws_q_remove_tail(sc, q_type));
/* The given node is not at head or tail.
* It's in the middle and there are more than
* 2 elements on the q.
*/
if ( req->next == NULL || req->prev == NULL ) {
TWS_TRACE_DEBUG(sc, "invalid req", 0, q_type);
return(NULL);
}
/* debug only */
r = sc->q_head[q_type];
while ( r ) {
if ( req == r )
break;
r = r->next;
}
if ( !r ) {
TWS_TRACE_DEBUG(sc, "req not in q", 0, req->request_id);
return(NULL);
}
/* debug end */
req->prev->next = r->next;
req->next->prev = r->prev;
req->next = NULL;
req->prev = NULL;
return(req);
}
struct tws_sense *
tws_find_sense_from_mfa(struct tws_softc *sc, u_int64_t mfa)
{
struct tws_sense *s;
int i;
TWS_TRACE_DEBUG(sc, "entry",sc,mfa);
i = (mfa - sc->dma_mem_phys) / sizeof(struct tws_command_packet);
if ( i>= 0 && i<tws_queue_depth) {
s = &sc->sense_bufs[i];
if ( mfa == s->hdr_pkt_phy )
return(s);
}
TWS_TRACE_DEBUG(sc, "return null",0,mfa);
return(NULL);
}
/* --------------------- Q service end --------------------- */
/* --------------------- misc service start --------------------- */
void
tws_print_stats(void *arg)
{
struct tws_softc *sc = (struct tws_softc *)arg;
TWS_TRACE(sc, "reqs(in, out)", sc->stats.reqs_in, sc->stats.reqs_out);
TWS_TRACE(sc, "reqs(err, intrs)", sc->stats.reqs_errored
, sc->stats.num_intrs);
TWS_TRACE(sc, "reqs(ioctls, scsi)", sc->stats.ioctls
, sc->stats.scsi_ios);
timeout(tws_print_stats, sc, 300*hz);
}
/* --------------------- misc service end --------------------- */