1998-09-15 07:32:57 +00:00
|
|
|
/*
|
|
|
|
* Generic driver for the BusLogic MultiMaster SCSI host adapters
|
|
|
|
* Product specific probe and attach routines can be found in:
|
1999-10-09 06:25:18 +00:00
|
|
|
* sys/dev/buslogic/bt_isa.c BT-54X, BT-445 cards
|
|
|
|
* sys/dev/buslogic/bt_mca.c BT-64X, SDC3211B, SDC3211F
|
|
|
|
* sys/dev/buslogic/bt_eisa.c BT-74X, BT-75x cards, SDC3222F
|
|
|
|
* sys/dev/buslogic/bt_pci.c BT-946, BT-948, BT-956, BT-958 cards
|
1998-09-15 07:32:57 +00:00
|
|
|
*
|
1999-03-08 21:36:34 +00:00
|
|
|
* Copyright (c) 1998, 1999 Justin T. Gibbs.
|
1998-09-15 07:32:57 +00:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* 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,
|
|
|
|
* without modification, immediately at the beginning of the file.
|
|
|
|
* 2. 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 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 AUTHOR 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.
|
|
|
|
*
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1998-09-15 07:32:57 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Special thanks to Leonard N. Zubkoff for writing such a complete and
|
|
|
|
* well documented Mylex/BusLogic MultiMaster driver for Linux. Support
|
|
|
|
* in this driver for the wide range of MultiMaster controllers and
|
|
|
|
* firmware revisions, with their otherwise undocumented quirks, would not
|
|
|
|
* have been possible without his efforts.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/sysctl.h>
|
1999-04-18 15:50:35 +00:00
|
|
|
#include <sys/bus.h>
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX It appears that BusLogic PCI adapters go out to lunch if you
|
|
|
|
* attempt to perform memory mapped I/O.
|
|
|
|
*/
|
|
|
|
#if 0
|
|
|
|
#include "pci.h"
|
|
|
|
#if NPCI > 0
|
|
|
|
#include <machine/bus_memio.h>
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#include <machine/bus_pio.h>
|
|
|
|
#include <machine/bus.h>
|
1999-04-18 15:50:35 +00:00
|
|
|
#include <sys/rman.h>
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
#include <cam/cam.h>
|
|
|
|
#include <cam/cam_ccb.h>
|
|
|
|
#include <cam/cam_sim.h>
|
|
|
|
#include <cam/cam_xpt_sim.h>
|
|
|
|
#include <cam/cam_debug.h>
|
|
|
|
|
|
|
|
#include <cam/scsi/scsi_message.h>
|
|
|
|
|
|
|
|
#include <vm/vm.h>
|
|
|
|
#include <vm/pmap.h>
|
|
|
|
|
|
|
|
#include <dev/buslogic/btreg.h>
|
|
|
|
|
1999-04-07 23:01:43 +00:00
|
|
|
#ifndef MAX
|
|
|
|
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
|
|
|
#endif
|
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
/* MailBox Management functions */
|
|
|
|
static __inline void btnextinbox(struct bt_softc *bt);
|
|
|
|
static __inline void btnextoutbox(struct bt_softc *bt);
|
|
|
|
|
|
|
|
static __inline void
|
|
|
|
btnextinbox(struct bt_softc *bt)
|
|
|
|
{
|
|
|
|
if (bt->cur_inbox == bt->last_inbox)
|
|
|
|
bt->cur_inbox = bt->in_boxes;
|
|
|
|
else
|
|
|
|
bt->cur_inbox++;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline void
|
|
|
|
btnextoutbox(struct bt_softc *bt)
|
|
|
|
{
|
|
|
|
if (bt->cur_outbox == bt->last_outbox)
|
|
|
|
bt->cur_outbox = bt->out_boxes;
|
|
|
|
else
|
|
|
|
bt->cur_outbox++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* CCB Mangement functions */
|
|
|
|
static __inline u_int32_t btccbvtop(struct bt_softc *bt,
|
|
|
|
struct bt_ccb *bccb);
|
|
|
|
static __inline struct bt_ccb* btccbptov(struct bt_softc *bt,
|
|
|
|
u_int32_t ccb_addr);
|
|
|
|
static __inline u_int32_t btsensepaddr(struct bt_softc *bt,
|
|
|
|
struct bt_ccb *bccb);
|
|
|
|
static __inline struct scsi_sense_data* btsensevaddr(struct bt_softc *bt,
|
|
|
|
struct bt_ccb *bccb);
|
|
|
|
|
|
|
|
static __inline u_int32_t
|
|
|
|
btccbvtop(struct bt_softc *bt, struct bt_ccb *bccb)
|
|
|
|
{
|
|
|
|
return (bt->bt_ccb_physbase
|
|
|
|
+ (u_int32_t)((caddr_t)bccb - (caddr_t)bt->bt_ccb_array));
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline struct bt_ccb *
|
|
|
|
btccbptov(struct bt_softc *bt, u_int32_t ccb_addr)
|
|
|
|
{
|
|
|
|
return (bt->bt_ccb_array +
|
|
|
|
((struct bt_ccb*)ccb_addr-(struct bt_ccb*)bt->bt_ccb_physbase));
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline u_int32_t
|
|
|
|
btsensepaddr(struct bt_softc *bt, struct bt_ccb *bccb)
|
|
|
|
{
|
|
|
|
u_int index;
|
|
|
|
|
|
|
|
index = (u_int)(bccb - bt->bt_ccb_array);
|
|
|
|
return (bt->sense_buffers_physbase
|
|
|
|
+ (index * sizeof(struct scsi_sense_data)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline struct scsi_sense_data *
|
|
|
|
btsensevaddr(struct bt_softc *bt, struct bt_ccb *bccb)
|
|
|
|
{
|
|
|
|
u_int index;
|
|
|
|
|
|
|
|
index = (u_int)(bccb - bt->bt_ccb_array);
|
|
|
|
return (bt->sense_buffers + index);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline struct bt_ccb* btgetccb(struct bt_softc *bt);
|
|
|
|
static __inline void btfreeccb(struct bt_softc *bt,
|
|
|
|
struct bt_ccb *bccb);
|
|
|
|
static void btallocccbs(struct bt_softc *bt);
|
|
|
|
static bus_dmamap_callback_t btexecuteccb;
|
|
|
|
static void btdone(struct bt_softc *bt, struct bt_ccb *bccb,
|
|
|
|
bt_mbi_comp_code_t comp_code);
|
|
|
|
|
|
|
|
/* Host adapter command functions */
|
|
|
|
static int btreset(struct bt_softc* bt, int hard_reset);
|
|
|
|
|
|
|
|
/* Initialization functions */
|
|
|
|
static int btinitmboxes(struct bt_softc *bt);
|
|
|
|
static bus_dmamap_callback_t btmapmboxes;
|
|
|
|
static bus_dmamap_callback_t btmapccbs;
|
|
|
|
static bus_dmamap_callback_t btmapsgs;
|
|
|
|
|
|
|
|
/* Transfer Negotiation Functions */
|
|
|
|
static void btfetchtransinfo(struct bt_softc *bt,
|
|
|
|
struct ccb_trans_settings *cts);
|
|
|
|
|
|
|
|
/* CAM SIM entry points */
|
|
|
|
#define ccb_bccb_ptr spriv_ptr0
|
|
|
|
#define ccb_bt_ptr spriv_ptr1
|
|
|
|
static void btaction(struct cam_sim *sim, union ccb *ccb);
|
|
|
|
static void btpoll(struct cam_sim *sim);
|
|
|
|
|
|
|
|
/* Our timeout handler */
|
|
|
|
timeout_t bttimeout;
|
|
|
|
|
|
|
|
u_long bt_unit = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XXX
|
|
|
|
* Do our own re-probe protection until a configuration
|
|
|
|
* manager can do it for us. This ensures that we don't
|
|
|
|
* reprobe a card already found by the EISA or PCI probes.
|
|
|
|
*/
|
|
|
|
struct bt_isa_port bt_isa_ports[] =
|
|
|
|
{
|
1998-11-10 06:44:54 +00:00
|
|
|
{ 0x130, 0, 4 },
|
|
|
|
{ 0x134, 0, 5 },
|
|
|
|
{ 0x230, 0, 2 },
|
|
|
|
{ 0x234, 0, 3 },
|
|
|
|
{ 0x330, 0, 0 },
|
|
|
|
{ 0x334, 0, 1 }
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* I/O ports listed in the order enumerated by the
|
|
|
|
* card for certain op codes.
|
|
|
|
*/
|
|
|
|
u_int16_t bt_board_ports[] =
|
|
|
|
{
|
|
|
|
0x330,
|
|
|
|
0x334,
|
|
|
|
0x230,
|
|
|
|
0x234,
|
|
|
|
0x130,
|
|
|
|
0x134
|
1998-09-15 07:32:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Exported functions */
|
1999-04-18 15:50:35 +00:00
|
|
|
void
|
|
|
|
bt_init_softc(device_t dev, struct resource *port,
|
|
|
|
struct resource *irq, struct resource *drq)
|
1998-09-15 07:32:57 +00:00
|
|
|
{
|
1999-04-18 15:50:35 +00:00
|
|
|
struct bt_softc *bt = device_get_softc(dev);
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
SLIST_INIT(&bt->free_bt_ccbs);
|
|
|
|
LIST_INIT(&bt->pending_ccbs);
|
|
|
|
SLIST_INIT(&bt->sg_maps);
|
1999-04-18 15:50:35 +00:00
|
|
|
bt->dev = dev;
|
|
|
|
bt->unit = device_get_unit(dev);
|
|
|
|
bt->port = port;
|
|
|
|
bt->irq = irq;
|
|
|
|
bt->drq = drq;
|
|
|
|
bt->tag = rman_get_bustag(port);
|
|
|
|
bt->bsh = rman_get_bushandle(port);
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
1999-04-18 15:50:35 +00:00
|
|
|
bt_free_softc(device_t dev)
|
1998-09-15 07:32:57 +00:00
|
|
|
{
|
1999-04-18 15:50:35 +00:00
|
|
|
struct bt_softc *bt = device_get_softc(dev);
|
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
switch (bt->init_level) {
|
|
|
|
default:
|
|
|
|
case 11:
|
|
|
|
bus_dmamap_unload(bt->sense_dmat, bt->sense_dmamap);
|
|
|
|
case 10:
|
|
|
|
bus_dmamem_free(bt->sense_dmat, bt->sense_buffers,
|
|
|
|
bt->sense_dmamap);
|
|
|
|
case 9:
|
|
|
|
bus_dma_tag_destroy(bt->sense_dmat);
|
|
|
|
case 8:
|
|
|
|
{
|
|
|
|
struct sg_map_node *sg_map;
|
|
|
|
|
|
|
|
while ((sg_map = SLIST_FIRST(&bt->sg_maps))!= NULL) {
|
|
|
|
SLIST_REMOVE_HEAD(&bt->sg_maps, links);
|
|
|
|
bus_dmamap_unload(bt->sg_dmat,
|
|
|
|
sg_map->sg_dmamap);
|
|
|
|
bus_dmamem_free(bt->sg_dmat, sg_map->sg_vaddr,
|
|
|
|
sg_map->sg_dmamap);
|
|
|
|
free(sg_map, M_DEVBUF);
|
|
|
|
}
|
|
|
|
bus_dma_tag_destroy(bt->sg_dmat);
|
|
|
|
}
|
|
|
|
case 7:
|
|
|
|
bus_dmamap_unload(bt->ccb_dmat, bt->ccb_dmamap);
|
|
|
|
case 6:
|
|
|
|
bus_dmamem_free(bt->ccb_dmat, bt->bt_ccb_array,
|
|
|
|
bt->ccb_dmamap);
|
|
|
|
bus_dmamap_destroy(bt->ccb_dmat, bt->ccb_dmamap);
|
|
|
|
case 5:
|
|
|
|
bus_dma_tag_destroy(bt->ccb_dmat);
|
|
|
|
case 4:
|
|
|
|
bus_dmamap_unload(bt->mailbox_dmat, bt->mailbox_dmamap);
|
|
|
|
case 3:
|
|
|
|
bus_dmamem_free(bt->mailbox_dmat, bt->in_boxes,
|
|
|
|
bt->mailbox_dmamap);
|
|
|
|
bus_dmamap_destroy(bt->mailbox_dmat, bt->mailbox_dmamap);
|
|
|
|
case 2:
|
|
|
|
bus_dma_tag_destroy(bt->buffer_dmat);
|
|
|
|
case 1:
|
|
|
|
bus_dma_tag_destroy(bt->mailbox_dmat);
|
|
|
|
case 0:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-03-08 21:36:34 +00:00
|
|
|
int
|
1999-04-18 15:50:35 +00:00
|
|
|
bt_port_probe(device_t dev, struct bt_probe_info *info)
|
1999-03-08 21:36:34 +00:00
|
|
|
{
|
1999-04-18 15:50:35 +00:00
|
|
|
struct bt_softc *bt = device_get_softc(dev);
|
1999-03-08 21:36:34 +00:00
|
|
|
config_data_t config_data;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/* See if there is really a card present */
|
1999-04-18 15:50:35 +00:00
|
|
|
if (bt_probe(dev) || bt_fetch_adapter_info(dev))
|
1999-03-08 21:36:34 +00:00
|
|
|
return(1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine our IRQ, and DMA settings and
|
|
|
|
* export them to the configuration system.
|
|
|
|
*/
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_CONFIG, NULL, /*parmlen*/0,
|
|
|
|
(u_int8_t*)&config_data, sizeof(config_data),
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
if (error != 0) {
|
|
|
|
printf("bt_port_probe: Could not determine IRQ or DMA "
|
|
|
|
"settings for adapter.\n");
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bt->model[0] == '5') {
|
|
|
|
/* DMA settings only make sense for ISA cards */
|
|
|
|
switch (config_data.dma_chan) {
|
|
|
|
case DMA_CHAN_5:
|
|
|
|
info->drq = 5;
|
|
|
|
break;
|
|
|
|
case DMA_CHAN_6:
|
|
|
|
info->drq = 6;
|
|
|
|
break;
|
|
|
|
case DMA_CHAN_7:
|
|
|
|
info->drq = 7;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("bt_port_probe: Invalid DMA setting "
|
|
|
|
"detected for adapter.\n");
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* VL/EISA/PCI DMA */
|
|
|
|
info->drq = -1;
|
|
|
|
}
|
|
|
|
switch (config_data.irq) {
|
|
|
|
case IRQ_9:
|
|
|
|
case IRQ_10:
|
|
|
|
case IRQ_11:
|
|
|
|
case IRQ_12:
|
|
|
|
case IRQ_14:
|
|
|
|
case IRQ_15:
|
|
|
|
info->irq = ffs(config_data.irq) + 8;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf("bt_port_probe: Invalid IRQ setting %x"
|
|
|
|
"detected for adapter.\n", config_data.irq);
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
/*
|
|
|
|
* Probe the adapter and verify that the card is a BusLogic.
|
|
|
|
*/
|
|
|
|
int
|
1999-04-18 15:50:35 +00:00
|
|
|
bt_probe(device_t dev)
|
1998-09-15 07:32:57 +00:00
|
|
|
{
|
1999-04-18 15:50:35 +00:00
|
|
|
struct bt_softc *bt = device_get_softc(dev);
|
1998-09-15 07:32:57 +00:00
|
|
|
esetup_info_data_t esetup_info;
|
|
|
|
u_int status;
|
|
|
|
u_int intstat;
|
|
|
|
u_int geometry;
|
|
|
|
int error;
|
|
|
|
u_int8_t param;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if the three I/O ports look reasonable.
|
|
|
|
* Touch the minimal number of registers in the
|
|
|
|
* failure case.
|
|
|
|
*/
|
|
|
|
status = bt_inb(bt, STATUS_REG);
|
|
|
|
if ((status == 0)
|
|
|
|
|| (status & (DIAG_ACTIVE|CMD_REG_BUSY|
|
|
|
|
STATUS_REG_RSVD|CMD_INVALID)) != 0) {
|
|
|
|
if (bootverbose)
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev, "Failed Status Reg Test - %x\n",
|
1998-09-15 07:32:57 +00:00
|
|
|
status);
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
intstat = bt_inb(bt, INTSTAT_REG);
|
|
|
|
if ((intstat & INTSTAT_REG_RSVD) != 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev, "Failed Intstat Reg Test\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
geometry = bt_inb(bt, GEOMETRY_REG);
|
|
|
|
if (geometry == 0xFF) {
|
|
|
|
if (bootverbose)
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev, "Failed Geometry Reg Test\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Looking good so far. Final test is to reset the
|
|
|
|
* adapter and attempt to fetch the extended setup
|
|
|
|
* information. This should filter out all 1542 cards.
|
|
|
|
*/
|
|
|
|
if ((error = btreset(bt, /*hard_reset*/TRUE)) != 0) {
|
|
|
|
if (bootverbose)
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev, "Failed Reset\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
param = sizeof(esetup_info);
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_ESETUP_INFO, ¶m, /*parmlen*/1,
|
|
|
|
(u_int8_t*)&esetup_info, sizeof(esetup_info),
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
if (error != 0) {
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Pull the boards setup information and record it in our softc.
|
|
|
|
*/
|
|
|
|
int
|
1999-04-18 15:50:35 +00:00
|
|
|
bt_fetch_adapter_info(device_t dev)
|
1998-09-15 07:32:57 +00:00
|
|
|
{
|
1999-04-18 15:50:35 +00:00
|
|
|
struct bt_softc *bt = device_get_softc(dev);
|
1998-09-15 07:32:57 +00:00
|
|
|
board_id_data_t board_id;
|
|
|
|
esetup_info_data_t esetup_info;
|
|
|
|
config_data_t config_data;
|
|
|
|
int error;
|
|
|
|
u_int8_t length_param;
|
|
|
|
|
|
|
|
/* First record the firmware version */
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_BOARD_ID, NULL, /*parmlen*/0,
|
|
|
|
(u_int8_t*)&board_id, sizeof(board_id),
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
if (error != 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev, "bt_fetch_adapter_info - Failed Get Board Info\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
bt->firmware_ver[0] = board_id.firmware_rev_major;
|
|
|
|
bt->firmware_ver[1] = '.';
|
|
|
|
bt->firmware_ver[2] = board_id.firmware_rev_minor;
|
|
|
|
bt->firmware_ver[3] = '\0';
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Depending on the firmware major and minor version,
|
|
|
|
* we may be able to fetch additional minor version info.
|
|
|
|
*/
|
|
|
|
if (bt->firmware_ver[0] > '0') {
|
|
|
|
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_FW_VER_3DIG, NULL, /*parmlen*/0,
|
|
|
|
(u_int8_t*)&bt->firmware_ver[3], 1,
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
if (error != 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev,
|
|
|
|
"bt_fetch_adapter_info - Failed Get "
|
|
|
|
"Firmware 3rd Digit\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
if (bt->firmware_ver[3] == ' ')
|
|
|
|
bt->firmware_ver[3] = '\0';
|
|
|
|
bt->firmware_ver[4] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(bt->firmware_ver, "3.3") >= 0) {
|
|
|
|
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_FW_VER_4DIG, NULL, /*parmlen*/0,
|
|
|
|
(u_int8_t*)&bt->firmware_ver[4], 1,
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
if (error != 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev,
|
|
|
|
"bt_fetch_adapter_info - Failed Get "
|
|
|
|
"Firmware 4th Digit\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
if (bt->firmware_ver[4] == ' ')
|
|
|
|
bt->firmware_ver[4] = '\0';
|
|
|
|
bt->firmware_ver[5] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Some boards do not handle the "recently documented"
|
|
|
|
* Inquire Board Model Number command correctly or do not give
|
|
|
|
* exact information. Use the Firmware and Extended Setup
|
|
|
|
* information in these cases to come up with the right answer.
|
|
|
|
* The major firmware revision number indicates:
|
|
|
|
*
|
|
|
|
* 5.xx BusLogic "W" Series Host Adapters:
|
|
|
|
* BT-948/958/958D
|
|
|
|
* 4.xx BusLogic "C" Series Host Adapters:
|
|
|
|
* BT-946C/956C/956CD/747C/757C/757CD/445C/545C/540CF
|
|
|
|
* 3.xx BusLogic "S" Series Host Adapters:
|
|
|
|
* BT-747S/747D/757S/757D/445S/545S/542D
|
|
|
|
* BT-542B/742A (revision H)
|
|
|
|
* 2.xx BusLogic "A" Series Host Adapters:
|
|
|
|
* BT-542B/742A (revision G and below)
|
|
|
|
* 0.xx AMI FastDisk VLB/EISA BusLogic Clone Host Adapter
|
|
|
|
*/
|
|
|
|
length_param = sizeof(esetup_info);
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_ESETUP_INFO, &length_param, /*parmlen*/1,
|
|
|
|
(u_int8_t*)&esetup_info, sizeof(esetup_info),
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
if (error != 0) {
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
bt->bios_addr = esetup_info.bios_addr << 12;
|
|
|
|
|
2000-11-13 03:44:20 +00:00
|
|
|
bt->mailbox_addrlimit = BUS_SPACE_MAXADDR;
|
1998-09-15 07:32:57 +00:00
|
|
|
if (esetup_info.bus_type == 'A'
|
|
|
|
&& bt->firmware_ver[0] == '2') {
|
1998-12-04 22:54:57 +00:00
|
|
|
snprintf(bt->model, sizeof(bt->model), "542B");
|
1998-09-15 07:32:57 +00:00
|
|
|
} else if (esetup_info.bus_type == 'E'
|
2000-11-13 03:44:20 +00:00
|
|
|
&& bt->firmware_ver[0] == '2') {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The 742A seems to object if its mailboxes are
|
|
|
|
* allocated above the 16MB mark.
|
|
|
|
*/
|
|
|
|
bt->mailbox_addrlimit = BUS_SPACE_MAXADDR_24BIT;
|
1998-12-04 22:54:57 +00:00
|
|
|
snprintf(bt->model, sizeof(bt->model), "742A");
|
1998-09-15 07:32:57 +00:00
|
|
|
} else if (esetup_info.bus_type == 'E'
|
|
|
|
&& bt->firmware_ver[0] == '0') {
|
|
|
|
/* AMI FastDisk EISA Series 441 0.x */
|
1998-12-04 22:54:57 +00:00
|
|
|
snprintf(bt->model, sizeof(bt->model), "747A");
|
1998-09-15 07:32:57 +00:00
|
|
|
} else {
|
|
|
|
ha_model_data_t model_data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
length_param = sizeof(model_data);
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_MODEL, &length_param, 1,
|
|
|
|
(u_int8_t*)&model_data, sizeof(model_data),
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
if (error != 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev,
|
|
|
|
"bt_fetch_adapter_info - Failed Inquire "
|
|
|
|
"Model Number\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
for (i = 0; i < sizeof(model_data.ascii_model); i++) {
|
|
|
|
bt->model[i] = model_data.ascii_model[i];
|
|
|
|
if (bt->model[i] == ' ')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
bt->model[i] = '\0';
|
|
|
|
}
|
|
|
|
|
1999-03-08 21:36:34 +00:00
|
|
|
bt->level_trigger_ints = esetup_info.level_trigger_ints ? 1 : 0;
|
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
/* SG element limits */
|
|
|
|
bt->max_sg = esetup_info.max_sg;
|
|
|
|
|
|
|
|
/* Set feature flags */
|
|
|
|
bt->wide_bus = esetup_info.wide_bus;
|
|
|
|
bt->diff_bus = esetup_info.diff_bus;
|
|
|
|
bt->ultra_scsi = esetup_info.ultra_scsi;
|
|
|
|
|
|
|
|
if ((bt->firmware_ver[0] == '5')
|
|
|
|
|| (bt->firmware_ver[0] == '4' && bt->wide_bus))
|
|
|
|
bt->extended_lun = TRUE;
|
|
|
|
|
|
|
|
bt->strict_rr = (strcmp(bt->firmware_ver, "3.31") >= 0);
|
|
|
|
|
|
|
|
bt->extended_trans =
|
|
|
|
((bt_inb(bt, GEOMETRY_REG) & EXTENDED_TRANSLATION) != 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine max CCB count and whether tagged queuing is
|
|
|
|
* available based on controller type. Tagged queuing
|
|
|
|
* only works on 'W' series adapters, 'C' series adapters
|
|
|
|
* with firmware of rev 4.42 and higher, and 'S' series
|
|
|
|
* adapters with firmware of rev 3.35 and higher. The
|
|
|
|
* maximum CCB counts are as follows:
|
|
|
|
*
|
|
|
|
* 192 BT-948/958/958D
|
|
|
|
* 100 BT-946C/956C/956CD/747C/757C/757CD/445C
|
|
|
|
* 50 BT-545C/540CF
|
|
|
|
* 30 BT-747S/747D/757S/757D/445S/545S/542D/542B/742A
|
|
|
|
*/
|
|
|
|
if (bt->firmware_ver[0] == '5') {
|
|
|
|
bt->max_ccbs = 192;
|
|
|
|
bt->tag_capable = TRUE;
|
|
|
|
} else if (bt->firmware_ver[0] == '4') {
|
|
|
|
if (bt->model[0] == '5')
|
|
|
|
bt->max_ccbs = 50;
|
|
|
|
else
|
|
|
|
bt->max_ccbs = 100;
|
|
|
|
bt->tag_capable = (strcmp(bt->firmware_ver, "4.22") >= 0);
|
|
|
|
} else {
|
|
|
|
bt->max_ccbs = 30;
|
|
|
|
if (bt->firmware_ver[0] == '3'
|
|
|
|
&& (strcmp(bt->firmware_ver, "3.35") >= 0))
|
|
|
|
bt->tag_capable = TRUE;
|
|
|
|
else
|
|
|
|
bt->tag_capable = FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bt->tag_capable != FALSE)
|
|
|
|
bt->tags_permitted = ALL_TARGETS;
|
|
|
|
|
|
|
|
/* Determine Sync/Wide/Disc settings */
|
|
|
|
if (bt->firmware_ver[0] >= '4') {
|
|
|
|
auto_scsi_data_t auto_scsi_data;
|
|
|
|
fetch_lram_params_t fetch_lram_params;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These settings are stored in the
|
|
|
|
* AutoSCSI data in LRAM of 'W' and 'C'
|
|
|
|
* adapters.
|
|
|
|
*/
|
|
|
|
fetch_lram_params.offset = AUTO_SCSI_BYTE_OFFSET;
|
|
|
|
fetch_lram_params.response_len = sizeof(auto_scsi_data);
|
|
|
|
error = bt_cmd(bt, BOP_FETCH_LRAM,
|
|
|
|
(u_int8_t*)&fetch_lram_params,
|
|
|
|
sizeof(fetch_lram_params),
|
|
|
|
(u_int8_t*)&auto_scsi_data,
|
|
|
|
sizeof(auto_scsi_data), DEFAULT_CMD_TIMEOUT);
|
|
|
|
|
|
|
|
if (error != 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev,
|
|
|
|
"bt_fetch_adapter_info - Failed "
|
|
|
|
"Get Auto SCSI Info\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
bt->disc_permitted = auto_scsi_data.low_disc_permitted
|
|
|
|
| (auto_scsi_data.high_disc_permitted << 8);
|
|
|
|
bt->sync_permitted = auto_scsi_data.low_sync_permitted
|
|
|
|
| (auto_scsi_data.high_sync_permitted << 8);
|
|
|
|
bt->fast_permitted = auto_scsi_data.low_fast_permitted
|
|
|
|
| (auto_scsi_data.high_fast_permitted << 8);
|
|
|
|
bt->ultra_permitted = auto_scsi_data.low_ultra_permitted
|
|
|
|
| (auto_scsi_data.high_ultra_permitted << 8);
|
|
|
|
bt->wide_permitted = auto_scsi_data.low_wide_permitted
|
|
|
|
| (auto_scsi_data.high_wide_permitted << 8);
|
|
|
|
|
|
|
|
if (bt->ultra_scsi == FALSE)
|
|
|
|
bt->ultra_permitted = 0;
|
|
|
|
|
|
|
|
if (bt->wide_bus == FALSE)
|
|
|
|
bt->wide_permitted = 0;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* 'S' and 'A' series have this information in the setup
|
|
|
|
* information structure.
|
|
|
|
*/
|
|
|
|
setup_data_t setup_info;
|
|
|
|
|
|
|
|
length_param = sizeof(setup_info);
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_SETUP_INFO, &length_param,
|
|
|
|
/*paramlen*/1, (u_int8_t*)&setup_info,
|
|
|
|
sizeof(setup_info), DEFAULT_CMD_TIMEOUT);
|
|
|
|
|
|
|
|
if (error != 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev,
|
|
|
|
"bt_fetch_adapter_info - Failed "
|
|
|
|
"Get Setup Info\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (setup_info.initiate_sync != 0) {
|
|
|
|
bt->sync_permitted = ALL_TARGETS;
|
|
|
|
|
|
|
|
if (bt->model[0] == '7') {
|
|
|
|
if (esetup_info.sync_neg10MB != 0)
|
|
|
|
bt->fast_permitted = ALL_TARGETS;
|
|
|
|
if (strcmp(bt->model, "757") == 0)
|
|
|
|
bt->wide_permitted = ALL_TARGETS;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
bt->disc_permitted = ALL_TARGETS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We need as many mailboxes as we can have ccbs */
|
|
|
|
bt->num_boxes = bt->max_ccbs;
|
|
|
|
|
|
|
|
/* Determine our SCSI ID */
|
|
|
|
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_CONFIG, NULL, /*parmlen*/0,
|
|
|
|
(u_int8_t*)&config_data, sizeof(config_data),
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
if (error != 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev,
|
|
|
|
"bt_fetch_adapter_info - Failed Get Config\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
bt->scsi_id = config_data.scsi_id;
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start the board, ready for normal operation
|
|
|
|
*/
|
|
|
|
int
|
1999-04-18 15:50:35 +00:00
|
|
|
bt_init(device_t dev)
|
1998-09-15 07:32:57 +00:00
|
|
|
{
|
1999-04-18 15:50:35 +00:00
|
|
|
struct bt_softc *bt = device_get_softc(dev);
|
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
/* Announce the Adapter */
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev, "BT-%s FW Rev. %s ", bt->model, bt->firmware_ver);
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
if (bt->ultra_scsi != 0)
|
|
|
|
printf("Ultra ");
|
|
|
|
|
|
|
|
if (bt->wide_bus != 0)
|
|
|
|
printf("Wide ");
|
|
|
|
else
|
|
|
|
printf("Narrow ");
|
|
|
|
|
|
|
|
if (bt->diff_bus != 0)
|
|
|
|
printf("Diff ");
|
|
|
|
|
|
|
|
printf("SCSI Host Adapter, SCSI ID %d, %d CCBs\n", bt->scsi_id,
|
|
|
|
bt->max_ccbs);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create our DMA tags. These tags define the kinds of device
|
2000-06-14 17:53:40 +00:00
|
|
|
* accessible memory allocations and memory mappings we will
|
1998-09-15 07:32:57 +00:00
|
|
|
* need to perform during normal operation.
|
|
|
|
*
|
|
|
|
* Unless we need to further restrict the allocation, we rely
|
|
|
|
* on the restrictions of the parent dmat, hence the common
|
|
|
|
* use of MAXADDR and MAXSIZE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* DMA tag for mapping buffers into device visible space. */
|
1999-08-16 01:52:21 +00:00
|
|
|
if (bus_dma_tag_create(bt->parent_dmat, /*alignment*/1, /*boundary*/0,
|
1998-09-15 07:32:57 +00:00
|
|
|
/*lowaddr*/BUS_SPACE_MAXADDR,
|
|
|
|
/*highaddr*/BUS_SPACE_MAXADDR,
|
|
|
|
/*filter*/NULL, /*filterarg*/NULL,
|
|
|
|
/*maxsize*/MAXBSIZE, /*nsegments*/BT_NSEG,
|
|
|
|
/*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
|
|
|
|
/*flags*/BUS_DMA_ALLOCNOW,
|
|
|
|
&bt->buffer_dmat) != 0) {
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
bt->init_level++;
|
|
|
|
/* DMA tag for our mailboxes */
|
1999-08-16 01:52:21 +00:00
|
|
|
if (bus_dma_tag_create(bt->parent_dmat, /*alignment*/1, /*boundary*/0,
|
2000-11-13 03:44:20 +00:00
|
|
|
/*lowaddr*/bt->mailbox_addrlimit,
|
1998-09-15 07:32:57 +00:00
|
|
|
/*highaddr*/BUS_SPACE_MAXADDR,
|
|
|
|
/*filter*/NULL, /*filterarg*/NULL,
|
|
|
|
bt->num_boxes * (sizeof(bt_mbox_in_t)
|
|
|
|
+ sizeof(bt_mbox_out_t)),
|
|
|
|
/*nsegments*/1,
|
|
|
|
/*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
|
|
|
|
/*flags*/0, &bt->mailbox_dmat) != 0) {
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
bt->init_level++;
|
|
|
|
|
|
|
|
/* Allocation for our mailboxes */
|
|
|
|
if (bus_dmamem_alloc(bt->mailbox_dmat, (void **)&bt->out_boxes,
|
|
|
|
BUS_DMA_NOWAIT, &bt->mailbox_dmamap) != 0) {
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
bt->init_level++;
|
|
|
|
|
|
|
|
/* And permanently map them */
|
|
|
|
bus_dmamap_load(bt->mailbox_dmat, bt->mailbox_dmamap,
|
|
|
|
bt->out_boxes,
|
|
|
|
bt->num_boxes * (sizeof(bt_mbox_in_t)
|
|
|
|
+ sizeof(bt_mbox_out_t)),
|
|
|
|
btmapmboxes, bt, /*flags*/0);
|
|
|
|
|
|
|
|
bt->init_level++;
|
|
|
|
|
|
|
|
bt->in_boxes = (bt_mbox_in_t *)&bt->out_boxes[bt->num_boxes];
|
|
|
|
|
|
|
|
btinitmboxes(bt);
|
|
|
|
|
|
|
|
/* DMA tag for our ccb structures */
|
1999-08-16 01:52:21 +00:00
|
|
|
if (bus_dma_tag_create(bt->parent_dmat, /*alignment*/1, /*boundary*/0,
|
1998-09-15 07:32:57 +00:00
|
|
|
/*lowaddr*/BUS_SPACE_MAXADDR,
|
|
|
|
/*highaddr*/BUS_SPACE_MAXADDR,
|
|
|
|
/*filter*/NULL, /*filterarg*/NULL,
|
|
|
|
bt->max_ccbs * sizeof(struct bt_ccb),
|
|
|
|
/*nsegments*/1,
|
|
|
|
/*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
|
|
|
|
/*flags*/0, &bt->ccb_dmat) != 0) {
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
bt->init_level++;
|
|
|
|
|
|
|
|
/* Allocation for our ccbs */
|
|
|
|
if (bus_dmamem_alloc(bt->ccb_dmat, (void **)&bt->bt_ccb_array,
|
|
|
|
BUS_DMA_NOWAIT, &bt->ccb_dmamap) != 0) {
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
bt->init_level++;
|
|
|
|
|
|
|
|
/* And permanently map them */
|
|
|
|
bus_dmamap_load(bt->ccb_dmat, bt->ccb_dmamap,
|
|
|
|
bt->bt_ccb_array,
|
|
|
|
bt->max_ccbs * sizeof(struct bt_ccb),
|
|
|
|
btmapccbs, bt, /*flags*/0);
|
|
|
|
|
|
|
|
bt->init_level++;
|
|
|
|
|
|
|
|
/* DMA tag for our S/G structures. We allocate in page sized chunks */
|
1999-08-16 01:52:21 +00:00
|
|
|
if (bus_dma_tag_create(bt->parent_dmat, /*alignment*/1, /*boundary*/0,
|
1998-09-15 07:32:57 +00:00
|
|
|
/*lowaddr*/BUS_SPACE_MAXADDR,
|
|
|
|
/*highaddr*/BUS_SPACE_MAXADDR,
|
|
|
|
/*filter*/NULL, /*filterarg*/NULL,
|
|
|
|
PAGE_SIZE, /*nsegments*/1,
|
|
|
|
/*maxsegsz*/BUS_SPACE_MAXSIZE_32BIT,
|
|
|
|
/*flags*/0, &bt->sg_dmat) != 0) {
|
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
bt->init_level++;
|
|
|
|
|
|
|
|
/* Perform initial CCB allocation */
|
|
|
|
bzero(bt->bt_ccb_array, bt->max_ccbs * sizeof(struct bt_ccb));
|
|
|
|
btallocccbs(bt);
|
|
|
|
|
|
|
|
if (bt->num_ccbs == 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(dev,
|
|
|
|
"bt_init - Unable to allocate initial ccbs\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
goto error_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that we are going and return (to probe)
|
|
|
|
*/
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_exit:
|
|
|
|
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
1999-04-18 15:50:35 +00:00
|
|
|
bt_attach(device_t dev)
|
1998-09-15 07:32:57 +00:00
|
|
|
{
|
1999-04-18 15:50:35 +00:00
|
|
|
struct bt_softc *bt = device_get_softc(dev);
|
1998-09-15 07:32:57 +00:00
|
|
|
int tagged_dev_openings;
|
|
|
|
struct cam_devq *devq;
|
1999-04-18 19:03:50 +00:00
|
|
|
int error;
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We reserve 1 ccb for error recovery, so don't
|
|
|
|
* tell the XPT about it.
|
|
|
|
*/
|
|
|
|
if (bt->tag_capable != 0)
|
|
|
|
tagged_dev_openings = bt->max_ccbs - 1;
|
|
|
|
else
|
|
|
|
tagged_dev_openings = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create the device queue for our SIM.
|
|
|
|
*/
|
|
|
|
devq = cam_simq_alloc(bt->max_ccbs - 1);
|
|
|
|
if (devq == NULL)
|
|
|
|
return (ENOMEM);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct our SIM entry
|
|
|
|
*/
|
|
|
|
bt->sim = cam_sim_alloc(btaction, btpoll, "bt", bt, bt->unit,
|
|
|
|
2, tagged_dev_openings, devq);
|
|
|
|
if (bt->sim == NULL) {
|
|
|
|
cam_simq_free(devq);
|
|
|
|
return (ENOMEM);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xpt_bus_register(bt->sim, 0) != CAM_SUCCESS) {
|
|
|
|
cam_sim_free(bt->sim, /*free_devq*/TRUE);
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (xpt_create_path(&bt->path, /*periph*/NULL,
|
|
|
|
cam_sim_path(bt->sim), CAM_TARGET_WILDCARD,
|
|
|
|
CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
|
|
|
|
xpt_bus_deregister(cam_sim_path(bt->sim));
|
|
|
|
cam_sim_free(bt->sim, /*free_devq*/TRUE);
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
1999-04-18 15:50:35 +00:00
|
|
|
/*
|
|
|
|
* Setup interrupt.
|
|
|
|
*/
|
1999-05-08 21:59:43 +00:00
|
|
|
error = bus_setup_intr(dev, bt->irq, INTR_TYPE_CAM,
|
|
|
|
bt_intr, bt, &bt->ih);
|
1999-04-18 19:03:50 +00:00
|
|
|
if (error) {
|
|
|
|
device_printf(dev, "bus_setup_intr() failed: %d\n", error);
|
|
|
|
return (error);
|
|
|
|
}
|
1998-09-15 07:32:57 +00:00
|
|
|
|
1999-04-18 15:50:35 +00:00
|
|
|
return (0);
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
bt_check_probed_iop(u_int ioport)
|
|
|
|
{
|
|
|
|
u_int i;
|
|
|
|
|
1998-11-10 06:44:54 +00:00
|
|
|
for (i = 0; i < BT_NUM_ISAPORTS; i++) {
|
1998-09-15 07:32:57 +00:00
|
|
|
if (bt_isa_ports[i].addr == ioport) {
|
|
|
|
if (bt_isa_ports[i].probed != 0)
|
|
|
|
return (1);
|
|
|
|
else {
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
bt_mark_probed_bio(isa_compat_io_t port)
|
|
|
|
{
|
|
|
|
if (port < BIO_DISABLED)
|
1998-11-10 06:44:54 +00:00
|
|
|
bt_mark_probed_iop(bt_board_ports[port]);
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
bt_mark_probed_iop(u_int ioport)
|
|
|
|
{
|
|
|
|
u_int i;
|
|
|
|
|
|
|
|
for (i = 0; i < BT_NUM_ISAPORTS; i++) {
|
|
|
|
if (ioport == bt_isa_ports[i].addr) {
|
|
|
|
bt_isa_ports[i].probed = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-11-10 06:44:54 +00:00
|
|
|
void
|
|
|
|
bt_find_probe_range(int ioport, int *port_index, int *max_port_index)
|
|
|
|
{
|
|
|
|
if (ioport > 0) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0;i < BT_NUM_ISAPORTS; i++)
|
|
|
|
if (ioport <= bt_isa_ports[i].addr)
|
|
|
|
break;
|
|
|
|
if ((i >= BT_NUM_ISAPORTS)
|
|
|
|
|| (ioport != bt_isa_ports[i].addr)) {
|
|
|
|
printf("
|
|
|
|
bt_isa_probe: Invalid baseport of 0x%x specified.
|
|
|
|
bt_isa_probe: Nearest valid baseport is 0x%x.
|
|
|
|
bt_isa_probe: Failing probe.\n",
|
|
|
|
ioport,
|
|
|
|
(i < BT_NUM_ISAPORTS)
|
|
|
|
? bt_isa_ports[i].addr
|
|
|
|
: bt_isa_ports[BT_NUM_ISAPORTS - 1].addr);
|
|
|
|
*port_index = *max_port_index = -1;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
*port_index = *max_port_index = bt_isa_ports[i].bio;
|
|
|
|
} else {
|
|
|
|
*port_index = 0;
|
|
|
|
*max_port_index = BT_NUM_ISAPORTS - 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
bt_iop_from_bio(isa_compat_io_t bio_index)
|
|
|
|
{
|
|
|
|
if (bio_index >= 0 && bio_index < BT_NUM_ISAPORTS)
|
|
|
|
return (bt_board_ports[bio_index]);
|
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
static void
|
|
|
|
btallocccbs(struct bt_softc *bt)
|
|
|
|
{
|
|
|
|
struct bt_ccb *next_ccb;
|
|
|
|
struct sg_map_node *sg_map;
|
|
|
|
bus_addr_t physaddr;
|
|
|
|
bt_sg_t *segs;
|
|
|
|
int newcount;
|
|
|
|
int i;
|
|
|
|
|
1999-04-23 23:28:20 +00:00
|
|
|
if (bt->num_ccbs >= bt->max_ccbs)
|
|
|
|
/* Can't allocate any more */
|
|
|
|
return;
|
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
next_ccb = &bt->bt_ccb_array[bt->num_ccbs];
|
|
|
|
|
|
|
|
sg_map = malloc(sizeof(*sg_map), M_DEVBUF, M_NOWAIT);
|
|
|
|
|
|
|
|
if (sg_map == NULL)
|
1999-04-23 23:28:20 +00:00
|
|
|
goto error_exit;
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
/* Allocate S/G space for the next batch of CCBS */
|
|
|
|
if (bus_dmamem_alloc(bt->sg_dmat, (void **)&sg_map->sg_vaddr,
|
|
|
|
BUS_DMA_NOWAIT, &sg_map->sg_dmamap) != 0) {
|
|
|
|
free(sg_map, M_DEVBUF);
|
1999-04-23 23:28:20 +00:00
|
|
|
goto error_exit;
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
SLIST_INSERT_HEAD(&bt->sg_maps, sg_map, links);
|
|
|
|
|
|
|
|
bus_dmamap_load(bt->sg_dmat, sg_map->sg_dmamap, sg_map->sg_vaddr,
|
|
|
|
PAGE_SIZE, btmapsgs, bt, /*flags*/0);
|
|
|
|
|
|
|
|
segs = sg_map->sg_vaddr;
|
|
|
|
physaddr = sg_map->sg_physaddr;
|
|
|
|
|
|
|
|
newcount = (PAGE_SIZE / (BT_NSEG * sizeof(bt_sg_t)));
|
|
|
|
for (i = 0; bt->num_ccbs < bt->max_ccbs && i < newcount; i++) {
|
|
|
|
int error;
|
|
|
|
|
|
|
|
next_ccb->sg_list = segs;
|
|
|
|
next_ccb->sg_list_phys = physaddr;
|
|
|
|
next_ccb->flags = BCCB_FREE;
|
|
|
|
error = bus_dmamap_create(bt->buffer_dmat, /*flags*/0,
|
|
|
|
&next_ccb->dmamap);
|
|
|
|
if (error != 0)
|
|
|
|
break;
|
|
|
|
SLIST_INSERT_HEAD(&bt->free_bt_ccbs, next_ccb, links);
|
|
|
|
segs += BT_NSEG;
|
|
|
|
physaddr += (BT_NSEG * sizeof(bt_sg_t));
|
|
|
|
next_ccb++;
|
|
|
|
bt->num_ccbs++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reserve a CCB for error recovery */
|
|
|
|
if (bt->recovery_bccb == NULL) {
|
|
|
|
bt->recovery_bccb = SLIST_FIRST(&bt->free_bt_ccbs);
|
|
|
|
SLIST_REMOVE_HEAD(&bt->free_bt_ccbs, links);
|
|
|
|
}
|
1999-04-23 23:28:20 +00:00
|
|
|
|
|
|
|
if (SLIST_FIRST(&bt->free_bt_ccbs) != NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
error_exit:
|
|
|
|
device_printf(bt->dev, "Can't malloc BCCBs\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static __inline void
|
|
|
|
btfreeccb(struct bt_softc *bt, struct bt_ccb *bccb)
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
if ((bccb->flags & BCCB_ACTIVE) != 0)
|
|
|
|
LIST_REMOVE(&bccb->ccb->ccb_h, sim_links.le);
|
|
|
|
if (bt->resource_shortage != 0
|
|
|
|
&& (bccb->ccb->ccb_h.status & CAM_RELEASE_SIMQ) == 0) {
|
|
|
|
bccb->ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
|
|
|
|
bt->resource_shortage = FALSE;
|
|
|
|
}
|
|
|
|
bccb->flags = BCCB_FREE;
|
|
|
|
SLIST_INSERT_HEAD(&bt->free_bt_ccbs, bccb, links);
|
1998-11-10 06:44:54 +00:00
|
|
|
bt->active_ccbs--;
|
1998-09-15 07:32:57 +00:00
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline struct bt_ccb*
|
|
|
|
btgetccb(struct bt_softc *bt)
|
|
|
|
{
|
|
|
|
struct bt_ccb* bccb;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
if ((bccb = SLIST_FIRST(&bt->free_bt_ccbs)) != NULL) {
|
|
|
|
SLIST_REMOVE_HEAD(&bt->free_bt_ccbs, links);
|
1998-11-10 06:44:54 +00:00
|
|
|
bt->active_ccbs++;
|
1999-04-23 23:28:20 +00:00
|
|
|
} else {
|
1998-09-15 07:32:57 +00:00
|
|
|
btallocccbs(bt);
|
|
|
|
bccb = SLIST_FIRST(&bt->free_bt_ccbs);
|
1999-04-23 23:28:20 +00:00
|
|
|
if (bccb != NULL) {
|
1998-09-15 07:32:57 +00:00
|
|
|
SLIST_REMOVE_HEAD(&bt->free_bt_ccbs, links);
|
1998-11-10 06:44:54 +00:00
|
|
|
bt->active_ccbs++;
|
|
|
|
}
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
|
|
|
|
return (bccb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
btaction(struct cam_sim *sim, union ccb *ccb)
|
|
|
|
{
|
|
|
|
struct bt_softc *bt;
|
|
|
|
|
|
|
|
CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("btaction\n"));
|
|
|
|
|
|
|
|
bt = (struct bt_softc *)cam_sim_softc(sim);
|
|
|
|
|
|
|
|
switch (ccb->ccb_h.func_code) {
|
|
|
|
/* Common cases first */
|
|
|
|
case XPT_SCSI_IO: /* Execute the requested I/O operation */
|
|
|
|
case XPT_RESET_DEV: /* Bus Device Reset the specified SCSI device */
|
|
|
|
{
|
|
|
|
struct bt_ccb *bccb;
|
|
|
|
struct bt_hccb *hccb;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get a bccb to use.
|
|
|
|
*/
|
|
|
|
if ((bccb = btgetccb(bt)) == NULL) {
|
|
|
|
int s;
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
bt->resource_shortage = TRUE;
|
|
|
|
splx(s);
|
|
|
|
xpt_freeze_simq(bt->sim, /*count*/1);
|
|
|
|
ccb->ccb_h.status = CAM_REQUEUE_REQ;
|
|
|
|
xpt_done(ccb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
hccb = &bccb->hccb;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* So we can find the BCCB when an abort is requested
|
|
|
|
*/
|
|
|
|
bccb->ccb = ccb;
|
|
|
|
ccb->ccb_h.ccb_bccb_ptr = bccb;
|
|
|
|
ccb->ccb_h.ccb_bt_ptr = bt;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Put all the arguments for the xfer in the bccb
|
|
|
|
*/
|
|
|
|
hccb->target_id = ccb->ccb_h.target_id;
|
|
|
|
hccb->target_lun = ccb->ccb_h.target_lun;
|
|
|
|
hccb->btstat = 0;
|
|
|
|
hccb->sdstat = 0;
|
|
|
|
|
|
|
|
if (ccb->ccb_h.func_code == XPT_SCSI_IO) {
|
|
|
|
struct ccb_scsiio *csio;
|
|
|
|
struct ccb_hdr *ccbh;
|
|
|
|
|
|
|
|
csio = &ccb->csio;
|
|
|
|
ccbh = &csio->ccb_h;
|
|
|
|
hccb->opcode = INITIATOR_CCB_WRESID;
|
1998-12-11 03:50:35 +00:00
|
|
|
hccb->datain = (ccb->ccb_h.flags & CAM_DIR_IN) ? 1 : 0;
|
|
|
|
hccb->dataout =(ccb->ccb_h.flags & CAM_DIR_OUT) ? 1 : 0;
|
1998-09-15 07:32:57 +00:00
|
|
|
hccb->cmd_len = csio->cdb_len;
|
|
|
|
if (hccb->cmd_len > sizeof(hccb->scsi_cdb)) {
|
|
|
|
ccb->ccb_h.status = CAM_REQ_INVALID;
|
|
|
|
btfreeccb(bt, bccb);
|
|
|
|
xpt_done(ccb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
hccb->sense_len = csio->sense_len;
|
1998-10-15 23:17:58 +00:00
|
|
|
if ((ccbh->flags & CAM_TAG_ACTION_VALID) != 0
|
|
|
|
&& ccb->csio.tag_action != CAM_TAG_ACTION_NONE) {
|
1998-09-15 07:32:57 +00:00
|
|
|
hccb->tag_enable = TRUE;
|
|
|
|
hccb->tag_type = (ccb->csio.tag_action & 0x3);
|
|
|
|
} else {
|
|
|
|
hccb->tag_enable = FALSE;
|
|
|
|
hccb->tag_type = 0;
|
|
|
|
}
|
|
|
|
if ((ccbh->flags & CAM_CDB_POINTER) != 0) {
|
|
|
|
if ((ccbh->flags & CAM_CDB_PHYS) == 0) {
|
|
|
|
bcopy(csio->cdb_io.cdb_ptr,
|
|
|
|
hccb->scsi_cdb, hccb->cmd_len);
|
|
|
|
} else {
|
|
|
|
/* I guess I could map it in... */
|
|
|
|
ccbh->status = CAM_REQ_INVALID;
|
|
|
|
btfreeccb(bt, bccb);
|
|
|
|
xpt_done(ccb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
bcopy(csio->cdb_io.cdb_bytes,
|
|
|
|
hccb->scsi_cdb, hccb->cmd_len);
|
|
|
|
}
|
|
|
|
/* If need be, bounce our sense buffer */
|
|
|
|
if (bt->sense_buffers != NULL) {
|
|
|
|
hccb->sense_addr = btsensepaddr(bt, bccb);
|
|
|
|
} else {
|
|
|
|
hccb->sense_addr = vtophys(&csio->sense_data);
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* If we have any data to send with this command,
|
|
|
|
* map it into bus space.
|
|
|
|
*/
|
|
|
|
/* Only use S/G if there is a transfer */
|
|
|
|
if ((ccbh->flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
|
|
|
|
if ((ccbh->flags & CAM_SCATTER_VALID) == 0) {
|
|
|
|
/*
|
|
|
|
* We've been given a pointer
|
|
|
|
* to a single buffer.
|
|
|
|
*/
|
|
|
|
if ((ccbh->flags & CAM_DATA_PHYS)==0) {
|
|
|
|
int s;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
s = splsoftvm();
|
|
|
|
error = bus_dmamap_load(
|
|
|
|
bt->buffer_dmat,
|
|
|
|
bccb->dmamap,
|
|
|
|
csio->data_ptr,
|
|
|
|
csio->dxfer_len,
|
|
|
|
btexecuteccb,
|
|
|
|
bccb,
|
|
|
|
/*flags*/0);
|
|
|
|
if (error == EINPROGRESS) {
|
|
|
|
/*
|
|
|
|
* So as to maintain
|
|
|
|
* ordering, freeze the
|
|
|
|
* controller queue
|
|
|
|
* until our mapping is
|
|
|
|
* returned.
|
|
|
|
*/
|
|
|
|
xpt_freeze_simq(bt->sim,
|
|
|
|
1);
|
|
|
|
csio->ccb_h.status |=
|
|
|
|
CAM_RELEASE_SIMQ;
|
|
|
|
}
|
|
|
|
splx(s);
|
|
|
|
} else {
|
|
|
|
struct bus_dma_segment seg;
|
|
|
|
|
|
|
|
/* Pointer to physical buffer */
|
|
|
|
seg.ds_addr =
|
|
|
|
(bus_addr_t)csio->data_ptr;
|
|
|
|
seg.ds_len = csio->dxfer_len;
|
|
|
|
btexecuteccb(bccb, &seg, 1, 0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct bus_dma_segment *segs;
|
|
|
|
|
|
|
|
if ((ccbh->flags & CAM_DATA_PHYS) != 0)
|
|
|
|
panic("btaction - Physical "
|
|
|
|
"segment pointers "
|
|
|
|
"unsupported");
|
|
|
|
|
|
|
|
if ((ccbh->flags&CAM_SG_LIST_PHYS)==0)
|
|
|
|
panic("btaction - Virtual "
|
|
|
|
"segment addresses "
|
|
|
|
"unsupported");
|
|
|
|
|
|
|
|
/* Just use the segments provided */
|
|
|
|
segs = (struct bus_dma_segment *)
|
|
|
|
csio->data_ptr;
|
|
|
|
btexecuteccb(bccb, segs,
|
|
|
|
csio->sglist_cnt, 0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
btexecuteccb(bccb, NULL, 0, 0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
hccb->opcode = INITIATOR_BUS_DEV_RESET;
|
|
|
|
/* No data transfer */
|
|
|
|
hccb->datain = TRUE;
|
|
|
|
hccb->dataout = TRUE;
|
|
|
|
hccb->cmd_len = 0;
|
|
|
|
hccb->sense_len = 0;
|
|
|
|
hccb->tag_enable = FALSE;
|
|
|
|
hccb->tag_type = 0;
|
|
|
|
btexecuteccb(bccb, NULL, 0, 0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_EN_LUN: /* Enable LUN as a target */
|
|
|
|
case XPT_TARGET_IO: /* Execute target I/O request */
|
|
|
|
case XPT_ACCEPT_TARGET_IO: /* Accept Host Target Mode CDB */
|
|
|
|
case XPT_CONT_TARGET_IO: /* Continue Host Target I/O Connection*/
|
|
|
|
case XPT_ABORT: /* Abort the specified CCB */
|
|
|
|
/* XXX Implement */
|
|
|
|
ccb->ccb_h.status = CAM_REQ_INVALID;
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
case XPT_SET_TRAN_SETTINGS:
|
|
|
|
{
|
|
|
|
/* XXX Implement */
|
Add a number of interrelated CAM feature enhancements and bug fixes.
NOTE: These changes will require recompilation of any userland
applications, like cdrecord, xmcd, etc., that use the CAM passthrough
interface. A make world is recommended.
camcontrol.[c8]:
- We now support two new commands, "tags" and "negotiate".
- The tags commands allows users to view the number of tagged
openings for a device as well as a number of other related
parameters, and it allows users to set tagged openings for
a device.
- The negotiate command allows users to enable and disable
disconnection and tagged queueing, set sync rates, offsets
and bus width. Note that not all of those features are
available for all controllers. Only the adv, ahc, and ncr
drivers fully support all of the features at this point.
Some cards do not allow the setting of sync rates, offsets and
the like, and some of the drivers don't have any facilities to
do so. Some drivers, like the adw driver, only support enabling
or disabling sync negotiation, but do not support setting sync
rates.
- new description in the camcontrol man page of how to format a disk
- cleanup of the camcontrol inquiry command
- add support in the 'devlist' command for skipping unconfigured devices if
-v was not specified on the command line.
- make use of the new base_transfer_speed in the path inquiry CCB.
- fix CCB bzero cases
cam_xpt.c, cam_sim.[ch], cam_ccb.h:
- new flags on many CCB function codes to designate whether they're
non-immediate, use a user-supplied CCB, and can only be passed from
userland programs via the xpt device. Use these flags in the transport
layer and pass driver to categorize CCBs.
- new flag in the transport layer device matching code for device nodes
that indicates whether a device is unconfigured
- bump the CAM version from 0x10 to 0x11
- Change the CAM ioctls to use the version as their group code, so we can
force users to recompile code even when the CCB size doesn't change.
- add + fill in a new value in the path inquiry CCB, base_transfer_speed.
Remove a corresponding field from the cam_sim structure, and add code to
every SIM to set this field to the proper value.
- Fix the set transfer settings code in the transport layer.
scsi_cd.c:
- make some variables volatile instead of just casting them in various
places
- fix a race condition in the changer code
- attach unless we get a "logical unit not supported" error. This should
fix all of the cases where people have devices that return weird errors
when they don't have media in the drive.
scsi_da.c:
- attach unless we get a "logical unit not supported" error
scsi_pass.c:
- for immediate CCBs, just malloc a CCB to send the user request in. This
gets rid of the 'held' count problem in camcontrol tags.
scsi_pass.h:
- change the CAM ioctls to use the CAM version as their group code.
adv driver:
- Allow changing the sync rate and offset separately.
adw driver
- Allow changing the sync rate and offset separately.
aha driver:
- Don't return CAM_REQ_CMP for SET_TRAN_SETTINGS CCBs.
ahc driver:
- Allow setting offset and sync rate separately
bt driver:
- Don't return CAM_REQ_CMP for SET_TRAN_SETTINGS CCBs.
NCR driver:
- Fix the ultra/ultra 2 negotiation bug
- allow setting both the sync rate and offset separately
Other HBA drivers:
- Put code in to set the base_transfer_speed field for
XPT_GET_TRAN_SETTINGS CCBs.
Reviewed by: gibbs, mjacob (isp), imp (aha)
1999-05-06 20:16:39 +00:00
|
|
|
ccb->ccb_h.status = CAM_PROVIDE_FAIL;
|
1998-09-15 07:32:57 +00:00
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_GET_TRAN_SETTINGS:
|
|
|
|
/* Get default/user set transfer settings for the target */
|
|
|
|
{
|
|
|
|
struct ccb_trans_settings *cts;
|
|
|
|
u_int target_mask;
|
|
|
|
|
|
|
|
cts = &ccb->cts;
|
|
|
|
target_mask = 0x01 << ccb->ccb_h.target_id;
|
|
|
|
if ((cts->flags & CCB_TRANS_USER_SETTINGS) != 0) {
|
|
|
|
cts->flags = 0;
|
|
|
|
if ((bt->disc_permitted & target_mask) != 0)
|
|
|
|
cts->flags |= CCB_TRANS_DISC_ENB;
|
|
|
|
if ((bt->tags_permitted & target_mask) != 0)
|
|
|
|
cts->flags |= CCB_TRANS_TAG_ENB;
|
|
|
|
if ((bt->wide_permitted & target_mask) != 0)
|
|
|
|
cts->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
|
|
|
|
else
|
|
|
|
cts->bus_width = MSG_EXT_WDTR_BUS_8_BIT;
|
|
|
|
if ((bt->ultra_permitted & target_mask) != 0)
|
|
|
|
cts->sync_period = 12;
|
|
|
|
else if ((bt->fast_permitted & target_mask) != 0)
|
|
|
|
cts->sync_period = 25;
|
|
|
|
else if ((bt->sync_permitted & target_mask) != 0)
|
|
|
|
cts->sync_period = 50;
|
|
|
|
else
|
|
|
|
cts->sync_period = 0;
|
|
|
|
|
|
|
|
if (cts->sync_period != 0)
|
|
|
|
cts->sync_offset = 15;
|
|
|
|
|
|
|
|
cts->valid = CCB_TRANS_SYNC_RATE_VALID
|
|
|
|
| CCB_TRANS_SYNC_OFFSET_VALID
|
|
|
|
| CCB_TRANS_BUS_WIDTH_VALID
|
|
|
|
| CCB_TRANS_DISC_VALID
|
|
|
|
| CCB_TRANS_TQ_VALID;
|
|
|
|
} else {
|
|
|
|
btfetchtransinfo(bt, cts);
|
|
|
|
}
|
|
|
|
|
|
|
|
ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_CALC_GEOMETRY:
|
|
|
|
{
|
|
|
|
struct ccb_calc_geometry *ccg;
|
|
|
|
u_int32_t size_mb;
|
|
|
|
u_int32_t secs_per_cylinder;
|
|
|
|
|
|
|
|
ccg = &ccb->ccg;
|
|
|
|
size_mb = ccg->volume_size
|
|
|
|
/ ((1024L * 1024L) / ccg->block_size);
|
|
|
|
|
|
|
|
if (size_mb >= 1024 && (bt->extended_trans != 0)) {
|
|
|
|
if (size_mb >= 2048) {
|
|
|
|
ccg->heads = 255;
|
|
|
|
ccg->secs_per_track = 63;
|
|
|
|
} else {
|
|
|
|
ccg->heads = 128;
|
|
|
|
ccg->secs_per_track = 32;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ccg->heads = 64;
|
|
|
|
ccg->secs_per_track = 32;
|
|
|
|
}
|
|
|
|
secs_per_cylinder = ccg->heads * ccg->secs_per_track;
|
|
|
|
ccg->cylinders = ccg->volume_size / secs_per_cylinder;
|
|
|
|
ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_RESET_BUS: /* Reset the specified SCSI bus */
|
|
|
|
{
|
|
|
|
btreset(bt, /*hardreset*/TRUE);
|
|
|
|
ccb->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case XPT_TERM_IO: /* Terminate the I/O process */
|
|
|
|
/* XXX Implement */
|
|
|
|
ccb->ccb_h.status = CAM_REQ_INVALID;
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
case XPT_PATH_INQ: /* Path routing inquiry */
|
|
|
|
{
|
|
|
|
struct ccb_pathinq *cpi = &ccb->cpi;
|
|
|
|
|
|
|
|
cpi->version_num = 1; /* XXX??? */
|
|
|
|
cpi->hba_inquiry = PI_SDTR_ABLE;
|
|
|
|
if (bt->tag_capable != 0)
|
|
|
|
cpi->hba_inquiry |= PI_TAG_ABLE;
|
|
|
|
if (bt->wide_bus != 0)
|
|
|
|
cpi->hba_inquiry |= PI_WIDE_16;
|
|
|
|
cpi->target_sprt = 0;
|
|
|
|
cpi->hba_misc = 0;
|
|
|
|
cpi->hba_eng_cnt = 0;
|
|
|
|
cpi->max_target = bt->wide_bus ? 15 : 7;
|
|
|
|
cpi->max_lun = 7;
|
|
|
|
cpi->initiator_id = bt->scsi_id;
|
|
|
|
cpi->bus_id = cam_sim_bus(sim);
|
Add a number of interrelated CAM feature enhancements and bug fixes.
NOTE: These changes will require recompilation of any userland
applications, like cdrecord, xmcd, etc., that use the CAM passthrough
interface. A make world is recommended.
camcontrol.[c8]:
- We now support two new commands, "tags" and "negotiate".
- The tags commands allows users to view the number of tagged
openings for a device as well as a number of other related
parameters, and it allows users to set tagged openings for
a device.
- The negotiate command allows users to enable and disable
disconnection and tagged queueing, set sync rates, offsets
and bus width. Note that not all of those features are
available for all controllers. Only the adv, ahc, and ncr
drivers fully support all of the features at this point.
Some cards do not allow the setting of sync rates, offsets and
the like, and some of the drivers don't have any facilities to
do so. Some drivers, like the adw driver, only support enabling
or disabling sync negotiation, but do not support setting sync
rates.
- new description in the camcontrol man page of how to format a disk
- cleanup of the camcontrol inquiry command
- add support in the 'devlist' command for skipping unconfigured devices if
-v was not specified on the command line.
- make use of the new base_transfer_speed in the path inquiry CCB.
- fix CCB bzero cases
cam_xpt.c, cam_sim.[ch], cam_ccb.h:
- new flags on many CCB function codes to designate whether they're
non-immediate, use a user-supplied CCB, and can only be passed from
userland programs via the xpt device. Use these flags in the transport
layer and pass driver to categorize CCBs.
- new flag in the transport layer device matching code for device nodes
that indicates whether a device is unconfigured
- bump the CAM version from 0x10 to 0x11
- Change the CAM ioctls to use the version as their group code, so we can
force users to recompile code even when the CCB size doesn't change.
- add + fill in a new value in the path inquiry CCB, base_transfer_speed.
Remove a corresponding field from the cam_sim structure, and add code to
every SIM to set this field to the proper value.
- Fix the set transfer settings code in the transport layer.
scsi_cd.c:
- make some variables volatile instead of just casting them in various
places
- fix a race condition in the changer code
- attach unless we get a "logical unit not supported" error. This should
fix all of the cases where people have devices that return weird errors
when they don't have media in the drive.
scsi_da.c:
- attach unless we get a "logical unit not supported" error
scsi_pass.c:
- for immediate CCBs, just malloc a CCB to send the user request in. This
gets rid of the 'held' count problem in camcontrol tags.
scsi_pass.h:
- change the CAM ioctls to use the CAM version as their group code.
adv driver:
- Allow changing the sync rate and offset separately.
adw driver
- Allow changing the sync rate and offset separately.
aha driver:
- Don't return CAM_REQ_CMP for SET_TRAN_SETTINGS CCBs.
ahc driver:
- Allow setting offset and sync rate separately
bt driver:
- Don't return CAM_REQ_CMP for SET_TRAN_SETTINGS CCBs.
NCR driver:
- Fix the ultra/ultra 2 negotiation bug
- allow setting both the sync rate and offset separately
Other HBA drivers:
- Put code in to set the base_transfer_speed field for
XPT_GET_TRAN_SETTINGS CCBs.
Reviewed by: gibbs, mjacob (isp), imp (aha)
1999-05-06 20:16:39 +00:00
|
|
|
cpi->base_transfer_speed = 3300;
|
1998-09-15 07:32:57 +00:00
|
|
|
strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
|
|
|
|
strncpy(cpi->hba_vid, "BusLogic", HBA_IDLEN);
|
|
|
|
strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
|
|
|
|
cpi->unit_number = cam_sim_unit(sim);
|
|
|
|
cpi->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
ccb->ccb_h.status = CAM_REQ_INVALID;
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
btexecuteccb(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
|
|
|
|
{
|
|
|
|
struct bt_ccb *bccb;
|
|
|
|
union ccb *ccb;
|
|
|
|
struct bt_softc *bt;
|
1998-10-15 23:46:33 +00:00
|
|
|
int s;
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
bccb = (struct bt_ccb *)arg;
|
|
|
|
ccb = bccb->ccb;
|
|
|
|
bt = (struct bt_softc *)ccb->ccb_h.ccb_bt_ptr;
|
|
|
|
|
|
|
|
if (error != 0) {
|
|
|
|
if (error != EFBIG)
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(bt->dev,
|
|
|
|
"Unexepected error 0x%x returned from "
|
|
|
|
"bus_dmamap_load\n", error);
|
1998-09-15 07:32:57 +00:00
|
|
|
if (ccb->ccb_h.status == CAM_REQ_INPROG) {
|
|
|
|
xpt_freeze_devq(ccb->ccb_h.path, /*count*/1);
|
|
|
|
ccb->ccb_h.status = CAM_REQ_TOO_BIG|CAM_DEV_QFRZN;
|
|
|
|
}
|
|
|
|
btfreeccb(bt, bccb);
|
|
|
|
xpt_done(ccb);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nseg != 0) {
|
|
|
|
bt_sg_t *sg;
|
|
|
|
bus_dma_segment_t *end_seg;
|
|
|
|
bus_dmasync_op_t op;
|
|
|
|
|
|
|
|
end_seg = dm_segs + nseg;
|
|
|
|
|
|
|
|
/* Copy the segments into our SG list */
|
|
|
|
sg = bccb->sg_list;
|
|
|
|
while (dm_segs < end_seg) {
|
|
|
|
sg->len = dm_segs->ds_len;
|
|
|
|
sg->addr = dm_segs->ds_addr;
|
|
|
|
sg++;
|
|
|
|
dm_segs++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nseg > 1) {
|
|
|
|
bccb->hccb.opcode = INITIATOR_SG_CCB_WRESID;
|
|
|
|
bccb->hccb.data_len = sizeof(bt_sg_t) * nseg;
|
|
|
|
bccb->hccb.data_addr = bccb->sg_list_phys;
|
|
|
|
} else {
|
|
|
|
bccb->hccb.data_len = bccb->sg_list->len;
|
|
|
|
bccb->hccb.data_addr = bccb->sg_list->addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN)
|
|
|
|
op = BUS_DMASYNC_PREREAD;
|
|
|
|
else
|
|
|
|
op = BUS_DMASYNC_PREWRITE;
|
|
|
|
|
|
|
|
bus_dmamap_sync(bt->buffer_dmat, bccb->dmamap, op);
|
|
|
|
|
|
|
|
} else {
|
1998-12-11 03:50:35 +00:00
|
|
|
bccb->hccb.opcode = INITIATOR_CCB;
|
1998-09-15 07:32:57 +00:00
|
|
|
bccb->hccb.data_len = 0;
|
|
|
|
bccb->hccb.data_addr = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Last time we need to check if this CCB needs to
|
|
|
|
* be aborted.
|
|
|
|
*/
|
|
|
|
if (ccb->ccb_h.status != CAM_REQ_INPROG) {
|
|
|
|
if (nseg != 0)
|
|
|
|
bus_dmamap_unload(bt->buffer_dmat, bccb->dmamap);
|
|
|
|
btfreeccb(bt, bccb);
|
|
|
|
xpt_done(ccb);
|
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
bccb->flags = BCCB_ACTIVE;
|
|
|
|
ccb->ccb_h.status |= CAM_SIM_QUEUED;
|
|
|
|
LIST_INSERT_HEAD(&bt->pending_ccbs, &ccb->ccb_h, sim_links.le);
|
|
|
|
|
|
|
|
ccb->ccb_h.timeout_ch =
|
|
|
|
timeout(bttimeout, (caddr_t)bccb,
|
|
|
|
(ccb->ccb_h.timeout * hz) / 1000);
|
|
|
|
|
|
|
|
/* Tell the adapter about this command */
|
|
|
|
bt->cur_outbox->ccb_addr = btccbvtop(bt, bccb);
|
1998-11-10 06:44:54 +00:00
|
|
|
if (bt->cur_outbox->action_code != BMBO_FREE) {
|
|
|
|
/*
|
|
|
|
* We should never encounter a busy mailbox.
|
|
|
|
* If we do, warn the user, and treat it as
|
|
|
|
* a resource shortage. If the controller is
|
|
|
|
* hung, one of the pending transactions will
|
|
|
|
* timeout causing us to start recovery operations.
|
|
|
|
*/
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(bt->dev,
|
|
|
|
"Encountered busy mailbox with %d out of %d "
|
|
|
|
"commands active!!!\n", bt->active_ccbs,
|
|
|
|
bt->max_ccbs);
|
1998-11-10 06:44:54 +00:00
|
|
|
untimeout(bttimeout, bccb, ccb->ccb_h.timeout_ch);
|
|
|
|
if (nseg != 0)
|
|
|
|
bus_dmamap_unload(bt->buffer_dmat, bccb->dmamap);
|
|
|
|
btfreeccb(bt, bccb);
|
|
|
|
bt->resource_shortage = TRUE;
|
|
|
|
xpt_freeze_simq(bt->sim, /*count*/1);
|
|
|
|
ccb->ccb_h.status = CAM_REQUEUE_REQ;
|
|
|
|
xpt_done(ccb);
|
|
|
|
return;
|
|
|
|
}
|
1998-09-15 07:32:57 +00:00
|
|
|
bt->cur_outbox->action_code = BMBO_START;
|
|
|
|
bt_outb(bt, COMMAND_REG, BOP_START_MBOX);
|
|
|
|
btnextoutbox(bt);
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
bt_intr(void *arg)
|
|
|
|
{
|
|
|
|
struct bt_softc *bt;
|
|
|
|
u_int intstat;
|
|
|
|
|
|
|
|
bt = (struct bt_softc *)arg;
|
|
|
|
while (((intstat = bt_inb(bt, INTSTAT_REG)) & INTR_PENDING) != 0) {
|
|
|
|
|
|
|
|
if ((intstat & CMD_COMPLETE) != 0) {
|
|
|
|
bt->latched_status = bt_inb(bt, STATUS_REG);
|
|
|
|
bt->command_cmp = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
bt_outb(bt, CONTROL_REG, RESET_INTR);
|
|
|
|
|
|
|
|
if ((intstat & IMB_LOADED) != 0) {
|
|
|
|
while (bt->cur_inbox->comp_code != BMBI_FREE) {
|
|
|
|
btdone(bt,
|
|
|
|
btccbptov(bt, bt->cur_inbox->ccb_addr),
|
|
|
|
bt->cur_inbox->comp_code);
|
|
|
|
bt->cur_inbox->comp_code = BMBI_FREE;
|
|
|
|
btnextinbox(bt);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((intstat & SCSI_BUS_RESET) != 0) {
|
|
|
|
btreset(bt, /*hardreset*/FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
btdone(struct bt_softc *bt, struct bt_ccb *bccb, bt_mbi_comp_code_t comp_code)
|
|
|
|
{
|
|
|
|
union ccb *ccb;
|
|
|
|
struct ccb_scsiio *csio;
|
|
|
|
|
|
|
|
ccb = bccb->ccb;
|
|
|
|
csio = &bccb->ccb->csio;
|
|
|
|
|
|
|
|
if ((bccb->flags & BCCB_ACTIVE) == 0) {
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(bt->dev,
|
|
|
|
"btdone - Attempt to free non-active BCCB %p\n",
|
|
|
|
(void *)bccb);
|
1998-09-15 07:32:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ccb->ccb_h.flags & CAM_DIR_MASK) != CAM_DIR_NONE) {
|
|
|
|
bus_dmasync_op_t op;
|
|
|
|
|
|
|
|
if ((ccb->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN)
|
|
|
|
op = BUS_DMASYNC_POSTREAD;
|
|
|
|
else
|
|
|
|
op = BUS_DMASYNC_POSTWRITE;
|
|
|
|
bus_dmamap_sync(bt->buffer_dmat, bccb->dmamap, op);
|
|
|
|
bus_dmamap_unload(bt->buffer_dmat, bccb->dmamap);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bccb == bt->recovery_bccb) {
|
|
|
|
/*
|
|
|
|
* The recovery BCCB does not have a CCB associated
|
|
|
|
* with it, so short circuit the normal error handling.
|
|
|
|
* We now traverse our list of pending CCBs and process
|
|
|
|
* any that were terminated by the recovery CCBs action.
|
|
|
|
* We also reinstate timeouts for all remaining, pending,
|
|
|
|
* CCBs.
|
|
|
|
*/
|
|
|
|
struct cam_path *path;
|
|
|
|
struct ccb_hdr *ccb_h;
|
|
|
|
cam_status error;
|
|
|
|
|
|
|
|
/* Notify all clients that a BDR occured */
|
|
|
|
error = xpt_create_path(&path, /*periph*/NULL,
|
|
|
|
cam_sim_path(bt->sim),
|
|
|
|
bccb->hccb.target_id,
|
|
|
|
CAM_LUN_WILDCARD);
|
|
|
|
|
|
|
|
if (error == CAM_REQ_CMP)
|
|
|
|
xpt_async(AC_SENT_BDR, path, NULL);
|
|
|
|
|
|
|
|
ccb_h = LIST_FIRST(&bt->pending_ccbs);
|
|
|
|
while (ccb_h != NULL) {
|
|
|
|
struct bt_ccb *pending_bccb;
|
|
|
|
|
|
|
|
pending_bccb = (struct bt_ccb *)ccb_h->ccb_bccb_ptr;
|
|
|
|
if (pending_bccb->hccb.target_id
|
|
|
|
== bccb->hccb.target_id) {
|
|
|
|
pending_bccb->hccb.btstat = BTSTAT_HA_BDR;
|
|
|
|
ccb_h = LIST_NEXT(ccb_h, sim_links.le);
|
|
|
|
btdone(bt, pending_bccb, BMBI_ERROR);
|
|
|
|
} else {
|
|
|
|
ccb_h->timeout_ch =
|
|
|
|
timeout(bttimeout, (caddr_t)pending_bccb,
|
|
|
|
(ccb_h->timeout * hz) / 1000);
|
|
|
|
ccb_h = LIST_NEXT(ccb_h, sim_links.le);
|
|
|
|
}
|
|
|
|
}
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(bt->dev, "No longer in timeout\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
untimeout(bttimeout, bccb, ccb->ccb_h.timeout_ch);
|
|
|
|
|
|
|
|
switch (comp_code) {
|
|
|
|
case BMBI_FREE:
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(bt->dev,
|
|
|
|
"btdone - CCB completed with free status!\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
break;
|
|
|
|
case BMBI_NOT_FOUND:
|
1999-04-18 15:50:35 +00:00
|
|
|
device_printf(bt->dev,
|
|
|
|
"btdone - CCB Abort failed to find CCB\n");
|
1998-09-15 07:32:57 +00:00
|
|
|
break;
|
|
|
|
case BMBI_ABORT:
|
|
|
|
case BMBI_ERROR:
|
1998-11-13 13:23:36 +00:00
|
|
|
if (bootverbose) {
|
|
|
|
printf("bt: ccb %p - error %x occured. "
|
|
|
|
"btstat = %x, sdstat = %x\n",
|
|
|
|
(void *)bccb, comp_code, bccb->hccb.btstat,
|
|
|
|
bccb->hccb.sdstat);
|
|
|
|
}
|
1998-09-15 07:32:57 +00:00
|
|
|
/* An error occured */
|
|
|
|
switch(bccb->hccb.btstat) {
|
|
|
|
case BTSTAT_DATARUN_ERROR:
|
1998-11-10 06:44:54 +00:00
|
|
|
if (bccb->hccb.data_len == 0) {
|
|
|
|
/*
|
|
|
|
* At least firmware 4.22, does this
|
|
|
|
* for a QUEUE FULL condition.
|
|
|
|
*/
|
|
|
|
bccb->hccb.sdstat = SCSI_STATUS_QUEUE_FULL;
|
|
|
|
} else if (bccb->hccb.data_len < 0) {
|
1998-09-15 07:32:57 +00:00
|
|
|
csio->ccb_h.status = CAM_DATA_RUN_ERR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
case BTSTAT_NOERROR:
|
|
|
|
case BTSTAT_LINKED_CMD_COMPLETE:
|
|
|
|
case BTSTAT_LINKED_CMD_FLAG_COMPLETE:
|
|
|
|
case BTSTAT_DATAUNDERUN_ERROR:
|
|
|
|
|
|
|
|
csio->scsi_status = bccb->hccb.sdstat;
|
|
|
|
csio->ccb_h.status |= CAM_SCSI_STATUS_ERROR;
|
|
|
|
switch(csio->scsi_status) {
|
|
|
|
case SCSI_STATUS_CHECK_COND:
|
|
|
|
case SCSI_STATUS_CMD_TERMINATED:
|
|
|
|
csio->ccb_h.status |= CAM_AUTOSNS_VALID;
|
|
|
|
/* Bounce sense back if necessary */
|
|
|
|
if (bt->sense_buffers != NULL) {
|
|
|
|
csio->sense_data =
|
|
|
|
*btsensevaddr(bt, bccb);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
case SCSI_STATUS_OK:
|
|
|
|
csio->ccb_h.status = CAM_REQ_CMP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
csio->resid = bccb->hccb.data_len;
|
|
|
|
break;
|
|
|
|
case BTSTAT_SELTIMEOUT:
|
|
|
|
csio->ccb_h.status = CAM_SEL_TIMEOUT;
|
|
|
|
break;
|
|
|
|
case BTSTAT_UNEXPECTED_BUSFREE:
|
|
|
|
csio->ccb_h.status = CAM_UNEXP_BUSFREE;
|
|
|
|
break;
|
|
|
|
case BTSTAT_INVALID_PHASE:
|
|
|
|
csio->ccb_h.status = CAM_SEQUENCE_FAIL;
|
|
|
|
break;
|
|
|
|
case BTSTAT_INVALID_ACTION_CODE:
|
|
|
|
panic("%s: Inavlid Action code", bt_name(bt));
|
|
|
|
break;
|
|
|
|
case BTSTAT_INVALID_OPCODE:
|
|
|
|
panic("%s: Inavlid CCB Opcode code", bt_name(bt));
|
|
|
|
break;
|
|
|
|
case BTSTAT_LINKED_CCB_LUN_MISMATCH:
|
|
|
|
/* We don't even support linked commands... */
|
|
|
|
panic("%s: Linked CCB Lun Mismatch", bt_name(bt));
|
|
|
|
break;
|
|
|
|
case BTSTAT_INVALID_CCB_OR_SG_PARAM:
|
|
|
|
panic("%s: Invalid CCB or SG list", bt_name(bt));
|
|
|
|
break;
|
|
|
|
case BTSTAT_AUTOSENSE_FAILED:
|
|
|
|
csio->ccb_h.status = CAM_AUTOSENSE_FAIL;
|
|
|
|
break;
|
|
|
|
case BTSTAT_TAGGED_MSG_REJECTED:
|
|
|
|
{
|
|
|
|
struct ccb_trans_settings neg;
|
|
|
|
|
|
|
|
xpt_print_path(csio->ccb_h.path);
|
|
|
|
printf("refuses tagged commands. Performing "
|
|
|
|
"non-tagged I/O\n");
|
|
|
|
neg.flags = 0;
|
|
|
|
neg.valid = CCB_TRANS_TQ_VALID;
|
|
|
|
xpt_setup_ccb(&neg.ccb_h, csio->ccb_h.path,
|
|
|
|
/*priority*/1);
|
|
|
|
xpt_async(AC_TRANSFER_NEG, csio->ccb_h.path, &neg);
|
|
|
|
bt->tags_permitted &= ~(0x01 << csio->ccb_h.target_id);
|
|
|
|
csio->ccb_h.status = CAM_MSG_REJECT_REC;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case BTSTAT_UNSUPPORTED_MSG_RECEIVED:
|
|
|
|
/*
|
|
|
|
* XXX You would think that this is
|
|
|
|
* a recoverable error... Hmmm.
|
|
|
|
*/
|
|
|
|
csio->ccb_h.status = CAM_REQ_CMP_ERR;
|
|
|
|
break;
|
|
|
|
case BTSTAT_HA_SOFTWARE_ERROR:
|
|
|
|
case BTSTAT_HA_WATCHDOG_ERROR:
|
|
|
|
case BTSTAT_HARDWARE_FAILURE:
|
|
|
|
/* Hardware reset ??? Can we recover ??? */
|
|
|
|
csio->ccb_h.status = CAM_NO_HBA;
|
|
|
|
break;
|
|
|
|
case BTSTAT_TARGET_IGNORED_ATN:
|
|
|
|
case BTSTAT_OTHER_SCSI_BUS_RESET:
|
|
|
|
case BTSTAT_HA_SCSI_BUS_RESET:
|
|
|
|
if ((csio->ccb_h.status & CAM_STATUS_MASK)
|
|
|
|
!= CAM_CMD_TIMEOUT)
|
|
|
|
csio->ccb_h.status = CAM_SCSI_BUS_RESET;
|
|
|
|
break;
|
|
|
|
case BTSTAT_HA_BDR:
|
|
|
|
if ((bccb->flags & BCCB_DEVICE_RESET) == 0)
|
|
|
|
csio->ccb_h.status = CAM_BDR_SENT;
|
|
|
|
else
|
|
|
|
csio->ccb_h.status = CAM_CMD_TIMEOUT;
|
|
|
|
break;
|
|
|
|
case BTSTAT_INVALID_RECONNECT:
|
|
|
|
case BTSTAT_ABORT_QUEUE_GENERATED:
|
|
|
|
csio->ccb_h.status = CAM_REQ_TERMIO;
|
|
|
|
break;
|
|
|
|
case BTSTAT_SCSI_PERROR_DETECTED:
|
|
|
|
csio->ccb_h.status = CAM_UNCOR_PARITY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (csio->ccb_h.status != CAM_REQ_CMP) {
|
|
|
|
xpt_freeze_devq(csio->ccb_h.path, /*count*/1);
|
|
|
|
csio->ccb_h.status |= CAM_DEV_QFRZN;
|
|
|
|
}
|
|
|
|
if ((bccb->flags & BCCB_RELEASE_SIMQ) != 0)
|
|
|
|
ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
|
|
|
|
btfreeccb(bt, bccb);
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
case BMBI_OK:
|
|
|
|
/* All completed without incident */
|
|
|
|
ccb->ccb_h.status |= CAM_REQ_CMP;
|
|
|
|
if ((bccb->flags & BCCB_RELEASE_SIMQ) != 0)
|
|
|
|
ccb->ccb_h.status |= CAM_RELEASE_SIMQ;
|
|
|
|
btfreeccb(bt, bccb);
|
|
|
|
xpt_done(ccb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
btreset(struct bt_softc* bt, int hard_reset)
|
|
|
|
{
|
|
|
|
struct ccb_hdr *ccb_h;
|
|
|
|
u_int status;
|
|
|
|
u_int timeout;
|
|
|
|
u_int8_t reset_type;
|
|
|
|
|
|
|
|
if (hard_reset != 0)
|
|
|
|
reset_type = HARD_RESET;
|
|
|
|
else
|
|
|
|
reset_type = SOFT_RESET;
|
|
|
|
bt_outb(bt, CONTROL_REG, reset_type);
|
|
|
|
|
|
|
|
/* Wait 5sec. for Diagnostic start */
|
|
|
|
timeout = 5 * 10000;
|
|
|
|
while (--timeout) {
|
|
|
|
status = bt_inb(bt, STATUS_REG);
|
|
|
|
if ((status & DIAG_ACTIVE) != 0)
|
|
|
|
break;
|
|
|
|
DELAY(100);
|
|
|
|
}
|
|
|
|
if (timeout == 0) {
|
|
|
|
if (bootverbose)
|
|
|
|
printf("%s: btreset - Diagnostic Active failed to "
|
|
|
|
"assert. status = 0x%x\n", bt_name(bt), status);
|
|
|
|
return (ETIMEDOUT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait 10sec. for Diagnostic end */
|
|
|
|
timeout = 10 * 10000;
|
|
|
|
while (--timeout) {
|
|
|
|
status = bt_inb(bt, STATUS_REG);
|
|
|
|
if ((status & DIAG_ACTIVE) == 0)
|
|
|
|
break;
|
|
|
|
DELAY(100);
|
|
|
|
}
|
|
|
|
if (timeout == 0) {
|
|
|
|
panic("%s: btreset - Diagnostic Active failed to drop. "
|
|
|
|
"status = 0x%x\n", bt_name(bt), status);
|
|
|
|
return (ETIMEDOUT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait for the host adapter to become ready or report a failure */
|
|
|
|
timeout = 10000;
|
|
|
|
while (--timeout) {
|
|
|
|
status = bt_inb(bt, STATUS_REG);
|
|
|
|
if ((status & (DIAG_FAIL|HA_READY|DATAIN_REG_READY)) != 0)
|
|
|
|
break;
|
|
|
|
DELAY(100);
|
|
|
|
}
|
|
|
|
if (timeout == 0) {
|
|
|
|
printf("%s: btreset - Host adapter failed to come ready. "
|
|
|
|
"status = 0x%x\n", bt_name(bt), status);
|
|
|
|
return (ETIMEDOUT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If the diagnostics failed, tell the user */
|
|
|
|
if ((status & DIAG_FAIL) != 0
|
|
|
|
|| (status & HA_READY) == 0) {
|
|
|
|
printf("%s: btreset - Adapter failed diagnostics\n",
|
|
|
|
bt_name(bt));
|
|
|
|
|
|
|
|
if ((status & DATAIN_REG_READY) != 0)
|
|
|
|
printf("%s: btreset - Host Adapter Error code = 0x%x\n",
|
1998-09-16 03:27:12 +00:00
|
|
|
bt_name(bt), bt_inb(bt, DATAIN_REG));
|
1998-09-15 07:32:57 +00:00
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we've allocated mailboxes, initialize them */
|
|
|
|
if (bt->init_level > 4)
|
|
|
|
btinitmboxes(bt);
|
|
|
|
|
|
|
|
/* If we've attached to the XPT, tell it about the event */
|
|
|
|
if (bt->path != NULL)
|
|
|
|
xpt_async(AC_BUS_RESET, bt->path, NULL);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform completion processing for all outstanding CCBs.
|
|
|
|
*/
|
|
|
|
while ((ccb_h = LIST_FIRST(&bt->pending_ccbs)) != NULL) {
|
|
|
|
struct bt_ccb *pending_bccb;
|
|
|
|
|
|
|
|
pending_bccb = (struct bt_ccb *)ccb_h->ccb_bccb_ptr;
|
|
|
|
pending_bccb->hccb.btstat = BTSTAT_HA_SCSI_BUS_RESET;
|
|
|
|
btdone(bt, pending_bccb, BMBI_ERROR);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send a command to the adapter.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
bt_cmd(struct bt_softc *bt, bt_op_t opcode, u_int8_t *params, u_int param_len,
|
|
|
|
u_int8_t *reply_data, u_int reply_len, u_int cmd_timeout)
|
|
|
|
{
|
|
|
|
u_int timeout;
|
|
|
|
u_int status;
|
1999-04-07 23:01:43 +00:00
|
|
|
u_int saved_status;
|
1998-09-15 07:32:57 +00:00
|
|
|
u_int intstat;
|
|
|
|
u_int reply_buf_size;
|
|
|
|
int s;
|
1998-12-11 03:50:35 +00:00
|
|
|
int cmd_complete;
|
1999-04-07 23:01:43 +00:00
|
|
|
int error;
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
/* No data returned to start */
|
|
|
|
reply_buf_size = reply_len;
|
|
|
|
reply_len = 0;
|
|
|
|
intstat = 0;
|
1998-12-11 03:50:35 +00:00
|
|
|
cmd_complete = 0;
|
1999-04-07 23:01:43 +00:00
|
|
|
saved_status = 0;
|
|
|
|
error = 0;
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
bt->command_cmp = 0;
|
|
|
|
/*
|
1999-04-07 23:01:43 +00:00
|
|
|
* Wait up to 10 sec. for the adapter to become
|
1998-09-15 07:32:57 +00:00
|
|
|
* ready to accept commands.
|
|
|
|
*/
|
1999-04-07 23:01:43 +00:00
|
|
|
timeout = 100000;
|
1998-09-15 07:32:57 +00:00
|
|
|
while (--timeout) {
|
|
|
|
status = bt_inb(bt, STATUS_REG);
|
|
|
|
if ((status & HA_READY) != 0
|
|
|
|
&& (status & CMD_REG_BUSY) == 0)
|
|
|
|
break;
|
1999-04-07 23:01:43 +00:00
|
|
|
/*
|
|
|
|
* Throw away any pending data which may be
|
|
|
|
* left over from earlier commands that we
|
|
|
|
* timedout on.
|
|
|
|
*/
|
|
|
|
if ((status & DATAIN_REG_READY) != 0)
|
|
|
|
(void)bt_inb(bt, DATAIN_REG);
|
1998-09-15 07:32:57 +00:00
|
|
|
DELAY(100);
|
|
|
|
}
|
|
|
|
if (timeout == 0) {
|
|
|
|
printf("%s: bt_cmd: Timeout waiting for adapter ready, "
|
|
|
|
"status = 0x%x\n", bt_name(bt), status);
|
|
|
|
return (ETIMEDOUT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Send the opcode followed by any necessary parameter bytes.
|
|
|
|
*/
|
|
|
|
bt_outb(bt, COMMAND_REG, opcode);
|
|
|
|
|
|
|
|
/*
|
1999-04-07 23:01:43 +00:00
|
|
|
* Wait for up to 1sec for each byte of the the
|
|
|
|
* parameter list sent to be sent.
|
1998-09-15 07:32:57 +00:00
|
|
|
*/
|
|
|
|
timeout = 10000;
|
|
|
|
while (param_len && --timeout) {
|
|
|
|
DELAY(100);
|
1999-04-07 23:01:43 +00:00
|
|
|
s = splcam();
|
1998-09-15 07:32:57 +00:00
|
|
|
status = bt_inb(bt, STATUS_REG);
|
|
|
|
intstat = bt_inb(bt, INTSTAT_REG);
|
1999-04-07 23:01:43 +00:00
|
|
|
splx(s);
|
1999-05-23 18:54:34 +00:00
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
if ((intstat & (INTR_PENDING|CMD_COMPLETE))
|
1998-12-11 03:50:35 +00:00
|
|
|
== (INTR_PENDING|CMD_COMPLETE)) {
|
1999-04-07 23:01:43 +00:00
|
|
|
saved_status = status;
|
1998-12-11 03:50:35 +00:00
|
|
|
cmd_complete = 1;
|
1998-09-15 07:32:57 +00:00
|
|
|
break;
|
1998-12-11 03:50:35 +00:00
|
|
|
}
|
1998-09-15 07:32:57 +00:00
|
|
|
if (bt->command_cmp != 0) {
|
1999-04-07 23:01:43 +00:00
|
|
|
saved_status = bt->latched_status;
|
1998-12-11 03:50:35 +00:00
|
|
|
cmd_complete = 1;
|
1998-09-15 07:32:57 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if ((status & DATAIN_REG_READY) != 0)
|
|
|
|
break;
|
|
|
|
if ((status & CMD_REG_BUSY) == 0) {
|
|
|
|
bt_outb(bt, COMMAND_REG, *params++);
|
|
|
|
param_len--;
|
1999-04-07 23:01:43 +00:00
|
|
|
timeout = 10000;
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (timeout == 0) {
|
|
|
|
printf("%s: bt_cmd: Timeout sending parameters, "
|
|
|
|
"status = 0x%x\n", bt_name(bt), status);
|
1999-04-07 23:01:43 +00:00
|
|
|
cmd_complete = 1;
|
|
|
|
saved_status = status;
|
|
|
|
error = ETIMEDOUT;
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
1999-04-07 23:01:43 +00:00
|
|
|
* Wait for the command to complete.
|
1998-09-15 07:32:57 +00:00
|
|
|
*/
|
1998-12-11 03:50:35 +00:00
|
|
|
while (cmd_complete == 0 && --cmd_timeout) {
|
1998-09-15 07:32:57 +00:00
|
|
|
|
1999-04-07 23:01:43 +00:00
|
|
|
s = splcam();
|
1998-09-15 07:32:57 +00:00
|
|
|
status = bt_inb(bt, STATUS_REG);
|
|
|
|
intstat = bt_inb(bt, INTSTAT_REG);
|
1999-05-23 18:54:34 +00:00
|
|
|
/*
|
|
|
|
* It may be that this command was issued with
|
|
|
|
* controller interrupts disabled. We'll never
|
|
|
|
* get to our command if an incoming mailbox
|
|
|
|
* interrupt is pending, so take care of completed
|
|
|
|
* mailbox commands by calling our interrupt handler.
|
|
|
|
*/
|
|
|
|
if ((intstat & (INTR_PENDING|IMB_LOADED))
|
|
|
|
== (INTR_PENDING|IMB_LOADED))
|
|
|
|
bt_intr(bt);
|
1999-04-07 23:01:43 +00:00
|
|
|
splx(s);
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
if (bt->command_cmp != 0) {
|
1999-04-07 23:01:43 +00:00
|
|
|
/*
|
|
|
|
* Our interrupt handler saw CMD_COMPLETE
|
|
|
|
* status before we did.
|
|
|
|
*/
|
|
|
|
cmd_complete = 1;
|
|
|
|
saved_status = bt->latched_status;
|
|
|
|
} else if ((intstat & (INTR_PENDING|CMD_COMPLETE))
|
|
|
|
== (INTR_PENDING|CMD_COMPLETE)) {
|
|
|
|
/*
|
|
|
|
* Our poll (in case interrupts are blocked)
|
|
|
|
* saw the CMD_COMPLETE interrupt.
|
|
|
|
*/
|
|
|
|
cmd_complete = 1;
|
|
|
|
saved_status = status;
|
|
|
|
} else if (opcode == BOP_MODIFY_IO_ADDR
|
|
|
|
&& (status & CMD_REG_BUSY) == 0) {
|
|
|
|
/*
|
|
|
|
* The BOP_MODIFY_IO_ADDR does not issue a CMD_COMPLETE,
|
|
|
|
* but it should update the status register. So, we
|
|
|
|
* consider this command complete when the CMD_REG_BUSY
|
|
|
|
* status clears.
|
|
|
|
*/
|
|
|
|
saved_status = status;
|
|
|
|
cmd_complete = 1;
|
|
|
|
} else if ((status & DATAIN_REG_READY) != 0) {
|
1998-09-15 07:32:57 +00:00
|
|
|
u_int8_t data;
|
|
|
|
|
|
|
|
data = bt_inb(bt, DATAIN_REG);
|
|
|
|
if (reply_len < reply_buf_size) {
|
|
|
|
*reply_data++ = data;
|
|
|
|
} else {
|
|
|
|
printf("%s: bt_cmd - Discarded reply data byte "
|
|
|
|
"for opcode 0x%x\n", bt_name(bt),
|
|
|
|
opcode);
|
|
|
|
}
|
1999-04-07 23:01:43 +00:00
|
|
|
/*
|
|
|
|
* Reset timeout to ensure at least a second
|
|
|
|
* between response bytes.
|
|
|
|
*/
|
|
|
|
cmd_timeout = MAX(cmd_timeout, 10000);
|
1998-09-15 07:32:57 +00:00
|
|
|
reply_len++;
|
|
|
|
|
1999-04-07 23:01:43 +00:00
|
|
|
} else if ((opcode == BOP_FETCH_LRAM)
|
|
|
|
&& (status & HA_READY) != 0) {
|
|
|
|
saved_status = status;
|
|
|
|
cmd_complete = 1;
|
|
|
|
}
|
1998-09-15 07:32:57 +00:00
|
|
|
DELAY(100);
|
|
|
|
}
|
1999-04-07 23:01:43 +00:00
|
|
|
if (cmd_timeout == 0) {
|
|
|
|
printf("%s: bt_cmd: Timeout waiting for command (%x) "
|
|
|
|
"to complete.\n%s: status = 0x%x, intstat = 0x%x, "
|
1999-05-23 18:54:34 +00:00
|
|
|
"rlen %d\n", bt_name(bt), opcode,
|
|
|
|
bt_name(bt), status, intstat, reply_len);
|
1999-04-07 23:01:43 +00:00
|
|
|
error = (ETIMEDOUT);
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear any pending interrupts. Block interrupts so our
|
|
|
|
* interrupt handler is not re-entered.
|
|
|
|
*/
|
|
|
|
s = splcam();
|
|
|
|
bt_intr(bt);
|
|
|
|
splx(s);
|
|
|
|
|
1999-04-07 23:01:43 +00:00
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
1998-09-15 07:32:57 +00:00
|
|
|
/*
|
|
|
|
* If the command was rejected by the controller, tell the caller.
|
|
|
|
*/
|
1999-04-07 23:01:43 +00:00
|
|
|
if ((saved_status & CMD_INVALID) != 0) {
|
1998-09-15 07:32:57 +00:00
|
|
|
/*
|
|
|
|
* Some early adapters may not recover properly from
|
|
|
|
* an invalid command. If it appears that the controller
|
|
|
|
* has wedged (i.e. status was not cleared by our interrupt
|
|
|
|
* reset above), perform a soft reset.
|
|
|
|
*/
|
|
|
|
if (bootverbose)
|
|
|
|
printf("%s: Invalid Command 0x%x\n", bt_name(bt),
|
|
|
|
opcode);
|
|
|
|
DELAY(1000);
|
|
|
|
status = bt_inb(bt, STATUS_REG);
|
|
|
|
if ((status & (CMD_INVALID|STATUS_REG_RSVD|DATAIN_REG_READY|
|
|
|
|
CMD_REG_BUSY|DIAG_FAIL|DIAG_ACTIVE)) != 0
|
|
|
|
|| (status & (HA_READY|INIT_REQUIRED))
|
|
|
|
!= (HA_READY|INIT_REQUIRED)) {
|
|
|
|
btreset(bt, /*hard_reset*/FALSE);
|
|
|
|
}
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (param_len > 0) {
|
|
|
|
/* The controller did not accept the full argument list */
|
|
|
|
return (E2BIG);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (reply_len != reply_buf_size) {
|
|
|
|
/* Too much or too little data received */
|
|
|
|
return (EMSGSIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We were successful */
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
btinitmboxes(struct bt_softc *bt) {
|
|
|
|
init_32b_mbox_params_t init_mbox;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
bzero(bt->in_boxes, sizeof(bt_mbox_in_t) * bt->num_boxes);
|
|
|
|
bzero(bt->out_boxes, sizeof(bt_mbox_out_t) * bt->num_boxes);
|
|
|
|
bt->cur_inbox = bt->in_boxes;
|
|
|
|
bt->last_inbox = bt->in_boxes + bt->num_boxes - 1;
|
|
|
|
bt->cur_outbox = bt->out_boxes;
|
|
|
|
bt->last_outbox = bt->out_boxes + bt->num_boxes - 1;
|
|
|
|
|
|
|
|
/* Tell the adapter about them */
|
|
|
|
init_mbox.num_boxes = bt->num_boxes;
|
|
|
|
init_mbox.base_addr[0] = bt->mailbox_physbase & 0xFF;
|
|
|
|
init_mbox.base_addr[1] = (bt->mailbox_physbase >> 8) & 0xFF;
|
|
|
|
init_mbox.base_addr[2] = (bt->mailbox_physbase >> 16) & 0xFF;
|
|
|
|
init_mbox.base_addr[3] = (bt->mailbox_physbase >> 24) & 0xFF;
|
|
|
|
error = bt_cmd(bt, BOP_INITIALIZE_32BMBOX, (u_int8_t *)&init_mbox,
|
|
|
|
/*parmlen*/sizeof(init_mbox), /*reply_buf*/NULL,
|
|
|
|
/*reply_len*/0, DEFAULT_CMD_TIMEOUT);
|
|
|
|
|
|
|
|
if (error != 0)
|
|
|
|
printf("btinitmboxes: Initialization command failed\n");
|
|
|
|
else if (bt->strict_rr != 0) {
|
|
|
|
/*
|
|
|
|
* If the controller supports
|
|
|
|
* strict round robin mode,
|
|
|
|
* enable it
|
|
|
|
*/
|
|
|
|
u_int8_t param;
|
|
|
|
|
|
|
|
param = 0;
|
|
|
|
error = bt_cmd(bt, BOP_ENABLE_STRICT_RR, ¶m, 1,
|
|
|
|
/*reply_buf*/NULL, /*reply_len*/0,
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
|
|
|
|
if (error != 0) {
|
|
|
|
printf("btinitmboxes: Unable to enable strict RR\n");
|
|
|
|
error = 0;
|
|
|
|
} else if (bootverbose) {
|
|
|
|
printf("%s: Using Strict Round Robin Mailbox Mode\n",
|
|
|
|
bt_name(bt));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update the XPT's idea of the negotiated transfer
|
|
|
|
* parameters for a particular target.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
btfetchtransinfo(struct bt_softc *bt, struct ccb_trans_settings* cts)
|
|
|
|
{
|
|
|
|
setup_data_t setup_info;
|
|
|
|
u_int target;
|
|
|
|
u_int targ_offset;
|
|
|
|
u_int targ_mask;
|
|
|
|
u_int sync_period;
|
|
|
|
int error;
|
|
|
|
u_int8_t param;
|
|
|
|
targ_syncinfo_t sync_info;
|
|
|
|
|
|
|
|
target = cts->ccb_h.target_id;
|
|
|
|
targ_offset = (target & 0x7);
|
|
|
|
targ_mask = (0x01 << targ_offset);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Inquire Setup Information. This command retreives the
|
|
|
|
* Wide negotiation status for recent adapters as well as
|
|
|
|
* the sync info for older models.
|
|
|
|
*/
|
|
|
|
param = sizeof(setup_info);
|
|
|
|
error = bt_cmd(bt, BOP_INQUIRE_SETUP_INFO, ¶m, /*paramlen*/1,
|
|
|
|
(u_int8_t*)&setup_info, sizeof(setup_info),
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
|
|
|
|
if (error != 0) {
|
1999-04-07 23:01:43 +00:00
|
|
|
printf("%s: btfetchtransinfo - Inquire Setup Info Failed %x\n",
|
|
|
|
bt_name(bt), error);
|
|
|
|
cts->valid = 0;
|
1998-09-15 07:32:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
sync_info = (target < 8) ? setup_info.low_syncinfo[targ_offset]
|
|
|
|
: setup_info.high_syncinfo[targ_offset];
|
|
|
|
|
|
|
|
if (sync_info.sync == 0)
|
|
|
|
cts->sync_offset = 0;
|
|
|
|
else
|
|
|
|
cts->sync_offset = sync_info.offset;
|
|
|
|
|
|
|
|
cts->bus_width = MSG_EXT_WDTR_BUS_8_BIT;
|
|
|
|
if (strcmp(bt->firmware_ver, "5.06L") >= 0) {
|
|
|
|
u_int wide_active;
|
|
|
|
|
|
|
|
wide_active =
|
|
|
|
(target < 8) ? (setup_info.low_wide_active & targ_mask)
|
|
|
|
: (setup_info.high_wide_active & targ_mask);
|
|
|
|
|
|
|
|
if (wide_active)
|
|
|
|
cts->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
|
1998-09-20 05:08:15 +00:00
|
|
|
} else if ((bt->wide_permitted & targ_mask) != 0) {
|
|
|
|
struct ccb_getdev cgd;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Prior to rev 5.06L, wide status isn't provided,
|
|
|
|
* so we "guess" that wide transfers are in effect
|
|
|
|
* if the user settings allow for wide and the inquiry
|
|
|
|
* data for the device indicates that it can handle
|
|
|
|
* wide transfers.
|
|
|
|
*/
|
|
|
|
xpt_setup_ccb(&cgd.ccb_h, cts->ccb_h.path, /*priority*/1);
|
|
|
|
cgd.ccb_h.func_code = XPT_GDEV_TYPE;
|
|
|
|
xpt_action((union ccb *)&cgd);
|
|
|
|
if ((cgd.ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP
|
|
|
|
&& (cgd.inq_data.flags & SID_WBus16) != 0)
|
|
|
|
cts->bus_width = MSG_EXT_WDTR_BUS_16_BIT;
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
1999-03-08 21:36:34 +00:00
|
|
|
if (bt->firmware_ver[0] >= '3') {
|
1998-09-15 07:32:57 +00:00
|
|
|
/*
|
|
|
|
* For adapters that can do fast or ultra speeds,
|
|
|
|
* use the more exact Target Sync Information command.
|
|
|
|
*/
|
|
|
|
target_sync_info_data_t sync_info;
|
|
|
|
|
|
|
|
param = sizeof(sync_info);
|
|
|
|
error = bt_cmd(bt, BOP_TARG_SYNC_INFO, ¶m, /*paramlen*/1,
|
|
|
|
(u_int8_t*)&sync_info, sizeof(sync_info),
|
|
|
|
DEFAULT_CMD_TIMEOUT);
|
|
|
|
|
|
|
|
if (error != 0) {
|
|
|
|
printf("%s: btfetchtransinfo - Inquire Sync "
|
|
|
|
"Info Failed 0x%x\n", bt_name(bt), error);
|
1999-04-07 23:01:43 +00:00
|
|
|
cts->valid = 0;
|
1998-09-15 07:32:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
sync_period = sync_info.sync_rate[target] * 100;
|
|
|
|
} else {
|
|
|
|
sync_period = 2000 + (500 * sync_info.period);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert ns value to standard SCSI sync rate */
|
|
|
|
if (cts->sync_offset != 0)
|
|
|
|
cts->sync_period = scsi_calc_syncparam(sync_period);
|
|
|
|
else
|
|
|
|
cts->sync_period = 0;
|
|
|
|
|
|
|
|
cts->valid = CCB_TRANS_SYNC_RATE_VALID
|
|
|
|
| CCB_TRANS_SYNC_OFFSET_VALID
|
|
|
|
| CCB_TRANS_BUS_WIDTH_VALID;
|
|
|
|
xpt_async(AC_TRANSFER_NEG, cts->ccb_h.path, cts);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
btmapmboxes(void *arg, bus_dma_segment_t *segs, int nseg, int error)
|
|
|
|
{
|
|
|
|
struct bt_softc* bt;
|
|
|
|
|
|
|
|
bt = (struct bt_softc*)arg;
|
|
|
|
bt->mailbox_physbase = segs->ds_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
btmapccbs(void *arg, bus_dma_segment_t *segs, int nseg, int error)
|
|
|
|
{
|
|
|
|
struct bt_softc* bt;
|
|
|
|
|
|
|
|
bt = (struct bt_softc*)arg;
|
|
|
|
bt->bt_ccb_physbase = segs->ds_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
btmapsgs(void *arg, bus_dma_segment_t *segs, int nseg, int error)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct bt_softc* bt;
|
|
|
|
|
|
|
|
bt = (struct bt_softc*)arg;
|
|
|
|
SLIST_FIRST(&bt->sg_maps)->sg_physaddr = segs->ds_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
btpoll(struct cam_sim *sim)
|
|
|
|
{
|
1998-10-09 21:38:36 +00:00
|
|
|
bt_intr(cam_sim_softc(sim));
|
1998-09-15 07:32:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
bttimeout(void *arg)
|
|
|
|
{
|
|
|
|
struct bt_ccb *bccb;
|
|
|
|
union ccb *ccb;
|
|
|
|
struct bt_softc *bt;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
bccb = (struct bt_ccb *)arg;
|
|
|
|
ccb = bccb->ccb;
|
|
|
|
bt = (struct bt_softc *)ccb->ccb_h.ccb_bt_ptr;
|
|
|
|
xpt_print_path(ccb->ccb_h.path);
|
1998-09-17 00:08:29 +00:00
|
|
|
printf("CCB %p - timed out\n", (void *)bccb);
|
1998-09-15 07:32:57 +00:00
|
|
|
|
|
|
|
s = splcam();
|
|
|
|
|
|
|
|
if ((bccb->flags & BCCB_ACTIVE) == 0) {
|
|
|
|
xpt_print_path(ccb->ccb_h.path);
|
1998-09-17 00:08:29 +00:00
|
|
|
printf("CCB %p - timed out CCB already completed\n",
|
|
|
|
(void *)bccb);
|
1998-09-15 07:32:57 +00:00
|
|
|
splx(s);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In order to simplify the recovery process, we ask the XPT
|
|
|
|
* layer to halt the queue of new transactions and we traverse
|
|
|
|
* the list of pending CCBs and remove their timeouts. This
|
|
|
|
* means that the driver attempts to clear only one error
|
|
|
|
* condition at a time. In general, timeouts that occur
|
|
|
|
* close together are related anyway, so there is no benefit
|
|
|
|
* in attempting to handle errors in parrallel. Timeouts will
|
|
|
|
* be reinstated when the recovery process ends.
|
|
|
|
*/
|
|
|
|
if ((bccb->flags & BCCB_DEVICE_RESET) == 0) {
|
|
|
|
struct ccb_hdr *ccb_h;
|
|
|
|
|
|
|
|
if ((bccb->flags & BCCB_RELEASE_SIMQ) == 0) {
|
|
|
|
xpt_freeze_simq(bt->sim, /*count*/1);
|
|
|
|
bccb->flags |= BCCB_RELEASE_SIMQ;
|
|
|
|
}
|
|
|
|
|
|
|
|
ccb_h = LIST_FIRST(&bt->pending_ccbs);
|
|
|
|
while (ccb_h != NULL) {
|
|
|
|
struct bt_ccb *pending_bccb;
|
|
|
|
|
|
|
|
pending_bccb = (struct bt_ccb *)ccb_h->ccb_bccb_ptr;
|
|
|
|
untimeout(bttimeout, pending_bccb, ccb_h->timeout_ch);
|
|
|
|
ccb_h = LIST_NEXT(ccb_h, sim_links.le);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((bccb->flags & BCCB_DEVICE_RESET) != 0
|
|
|
|
|| bt->cur_outbox->action_code != BMBO_FREE
|
1998-10-15 23:17:58 +00:00
|
|
|
|| ((bccb->hccb.tag_enable == TRUE)
|
1998-09-15 07:32:57 +00:00
|
|
|
&& (bt->firmware_ver[0] < '5'))) {
|
|
|
|
/*
|
|
|
|
* Try a full host adapter/SCSI bus reset.
|
|
|
|
* We do this only if we have already attempted
|
|
|
|
* to clear the condition with a BDR, or we cannot
|
|
|
|
* attempt a BDR for lack of mailbox resources
|
|
|
|
* or because of faulty firmware. It turns out
|
|
|
|
* that firmware versions prior to 5.xx treat BDRs
|
|
|
|
* as untagged commands that cannot be sent until
|
|
|
|
* all outstanding tagged commands have been processed.
|
|
|
|
* This makes it somewhat difficult to use a BDR to
|
|
|
|
* clear up a problem with an uncompleted tagged command.
|
|
|
|
*/
|
|
|
|
ccb->ccb_h.status = CAM_CMD_TIMEOUT;
|
|
|
|
btreset(bt, /*hardreset*/TRUE);
|
|
|
|
printf("%s: No longer in timeout\n", bt_name(bt));
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Send a Bus Device Reset message:
|
|
|
|
* The target that is holding up the bus may not
|
|
|
|
* be the same as the one that triggered this timeout
|
|
|
|
* (different commands have different timeout lengths),
|
|
|
|
* but we have no way of determining this from our
|
|
|
|
* timeout handler. Our strategy here is to queue a
|
|
|
|
* BDR message to the target of the timed out command.
|
|
|
|
* If this fails, we'll get another timeout 2 seconds
|
|
|
|
* later which will attempt a bus reset.
|
|
|
|
*/
|
|
|
|
bccb->flags |= BCCB_DEVICE_RESET;
|
|
|
|
ccb->ccb_h.timeout_ch =
|
|
|
|
timeout(bttimeout, (caddr_t)bccb, 2 * hz);
|
|
|
|
|
|
|
|
bt->recovery_bccb->hccb.opcode = INITIATOR_BUS_DEV_RESET;
|
|
|
|
|
|
|
|
/* No Data Transfer */
|
|
|
|
bt->recovery_bccb->hccb.datain = TRUE;
|
|
|
|
bt->recovery_bccb->hccb.dataout = TRUE;
|
|
|
|
bt->recovery_bccb->hccb.btstat = 0;
|
|
|
|
bt->recovery_bccb->hccb.sdstat = 0;
|
|
|
|
bt->recovery_bccb->hccb.target_id = ccb->ccb_h.target_id;
|
|
|
|
|
|
|
|
/* Tell the adapter about this command */
|
|
|
|
bt->cur_outbox->ccb_addr = btccbvtop(bt, bt->recovery_bccb);
|
|
|
|
bt->cur_outbox->action_code = BMBO_START;
|
|
|
|
bt_outb(bt, COMMAND_REG, BOP_START_MBOX);
|
|
|
|
btnextoutbox(bt);
|
|
|
|
}
|
|
|
|
|
|
|
|
splx(s);
|
|
|
|
}
|
|
|
|
|