1/*-
2 * Copyright (c) 2000 Michael Smith
3 * Copyright (c) 2000 BSDi
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
--- 8 unchanged lines hidden (view full) ---
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: head/sys/dev/mly/mly.c 68877 2000-11-18 15:21:22Z dwmalone $
28 */
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/malloc.h>
33#include <sys/kernel.h>
34#include <sys/bus.h>
35#include <sys/conf.h>
36#include <sys/ctype.h>
37
38#include <machine/bus_memio.h>
39#include <machine/bus.h>
40#include <machine/resource.h>
41#include <sys/rman.h>
42
43#include <cam/scsi/scsi_all.h>
44
45#include <dev/mly/mlyreg.h>
46#include <dev/mly/mlyvar.h>
47#define MLY_DEFINE_TABLES
48#include <dev/mly/mly_tables.h>
49
50static int mly_get_controllerinfo(struct mly_softc *sc);
51static void mly_scan_devices(struct mly_softc *sc);
52static void mly_rescan_btl(struct mly_softc *sc, int bus, int target);
53static void mly_complete_rescan(struct mly_command *mc);
--- 6 unchanged lines hidden (view full) ---
60static void mly_complete_event(struct mly_command *mc);
61static void mly_process_event(struct mly_softc *sc, struct mly_event *me);
62static void mly_periodic(void *data);
63
64static int mly_immediate_command(struct mly_command *mc);
65static int mly_start(struct mly_command *mc);
66static void mly_complete(void *context, int pending);
67
68static int mly_get_slot(struct mly_command *mc);
69static void mly_alloc_command_cluster_map(void *arg, bus_dma_segment_t *segs, int nseg, int error);
70static void mly_alloc_command_cluster(struct mly_softc *sc);
71static void mly_map_command(struct mly_command *mc);
72static void mly_unmap_command(struct mly_command *mc);
73
74static int mly_fwhandshake(struct mly_softc *sc);
75
76static void mly_describe_controller(struct mly_softc *sc);
77#ifdef MLY_DEBUG
78static void mly_printstate(struct mly_softc *sc);
79static void mly_print_command(struct mly_command *mc);
80static void mly_print_packet(struct mly_command *mc);
81static void mly_panic(struct mly_softc *sc, char *reason);
82#endif
83
84/********************************************************************************
85 ********************************************************************************
86 Device Interface
87 ********************************************************************************
88 ********************************************************************************/
89
90/********************************************************************************
91 * Initialise the controller and softc
92 */
93int
94mly_attach(struct mly_softc *sc)
95{
96 int error;
97
98 debug_called(1);
99
100 /*
101 * Initialise per-controller queues.
102 */
103 TAILQ_INIT(&sc->mly_freecmds);
104 TAILQ_INIT(&sc->mly_ready);
105 TAILQ_INIT(&sc->mly_completed);
106 TAILQ_INIT(&sc->mly_clusters);
107
108#if __FreeBSD_version >= 500005
109 /*
110 * Initialise command-completion task.
111 */
112 TASK_INIT(&sc->mly_task_complete, 0, mly_complete, sc);
113#endif
114
--- 4 unchanged lines hidden (view full) ---
119 * Wait for the controller to come ready, handshake with the firmware if required.
120 * This is typically only necessary on platforms where the controller BIOS does not
121 * run.
122 */
123 if ((error = mly_fwhandshake(sc)))
124 return(error);
125
126 /*
127 * Initialise the slot allocator so that we can issue commands.
128 */
129 sc->mly_max_commands = MLY_SLOT_MAX;
130 sc->mly_last_slot = MLY_SLOT_START;
131
132 /*
133 * Obtain controller feature information
134 */
135 if ((error = mly_get_controllerinfo(sc)))
136 return(error);
137
138 /*
139 * Update the slot allocator limit based on the controller inquiry.
140 */
141 sc->mly_max_commands = imin(sc->mly_controllerinfo->maximum_parallel_commands, MLY_SLOT_MAX);
142
143 /*
144 * Get the current event counter for health purposes, populate the initial
145 * health status buffer.
146 */
147 if ((error = mly_get_eventstatus(sc)))
148 return(error);
149
150 /*
151 * Enable memory-mailbox mode
--- 20 unchanged lines hidden (view full) ---
172 /*
173 * Instigate the first status poll immediately. Rescan completions won't
174 * happen until interrupts are enabled, which should still be before
175 * the SCSI subsystem gets to us. (XXX assuming CAM and interrupt-driven
176 * discovery here...)
177 */
178 mly_periodic((void *)sc);
179
180 /* enable interrupts now */
181 MLY_UNMASK_INTERRUPTS(sc);
182
183 return(0);
184}
185
186/********************************************************************************
187 * Bring the controller to a state where it can be safely left alone.
--- 177 unchanged lines hidden (view full) ---
365 mly_describe_code(mly_table_device_state, ldi->state));
366 } else if (mc->mc_length == sizeof(*pdi)) {
367 pdi = (struct mly_ioctl_getphysdevinfovalid *)mc->mc_data;
368 bus = pdi->channel;
369 target = pdi->target;
370 sc->mly_btl[bus][target].mb_flags = MLY_BTL_PHYSICAL; /* clears all other flags */
371 sc->mly_btl[bus][target].mb_type = MLY_DEVICE_TYPE_PHYSICAL;
372 sc->mly_btl[bus][target].mb_state = pdi->state;
373 if (pdi->state != MLY_DEVICE_STATE_UNCONFIGURED)
374 sc->mly_btl[bus][target].mb_flags |= MLY_BTL_PROTECTED;
375 debug(2, "BTL rescan for %d:%d returns %s", bus, target,
376 mly_describe_code(mly_table_device_state, pdi->state));
377 } else {
378 mly_printf(sc, "BTL rescan result corrupted\n");
379 }
380 } else {
--- 52 unchanged lines hidden (view full) ---
433 int error;
434
435 debug_called(1);
436
437 /* build the ioctl and send it */
438 bzero(&mci, sizeof(mci));
439 mci.sub_ioctl = MDACIOCTL_SETMEMORYMAILBOX;
440 /* set buffer addresses */
441 mci.param.setmemorymailbox.command_mailbox_physaddr = sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_command);
442 mci.param.setmemorymailbox.status_mailbox_physaddr = sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_status);
443 mci.param.setmemorymailbox.health_buffer_physaddr = sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_health);
444
445 /* set buffer sizes - abuse of data_size field is revolting */
446 sp = (u_int8_t *)&mci.data_size;
447 sp[0] = ((sizeof(union mly_command_packet) * MLY_MMBOX_COMMANDS) / 1024);
448 sp[1] = (sizeof(union mly_status_packet) * MLY_MMBOX_STATUS) / 1024;
449 mci.param.setmemorymailbox.health_buffer_size = sizeof(union mly_health_region) / 1024;
450
451 debug(1, "memory mailbox at %p (0x%llx/%d 0x%llx/%d 0x%llx/%d", sc->mly_mmbox,
452 mci.param.setmemorymailbox.command_mailbox_physaddr, sp[0],
453 mci.param.setmemorymailbox.status_mailbox_physaddr, sp[1],
454 mci.param.setmemorymailbox.health_buffer_physaddr, mci.param.setmemorymailbox.health_buffer_size);
455
456 if ((error = mly_ioctl(sc, &mci, NULL, 0, &status, NULL, NULL)))
457 return(error);
458 if (status != 0)
459 return(EIO);
460 sc->mly_state |= MLY_STATE_MMBOX_ACTIVE;
461 debug(1, "memory mailbox active");
462 return(0);
--- 338 unchanged lines hidden (view full) ---
801
802 /* spinning at splcam is ugly, but we're only used during controller init */
803 s = splcam();
804 if ((error = mly_start(mc)))
805 return(error);
806
807 if (sc->mly_state & MLY_STATE_INTERRUPTS_ON) {
808 /* sleep on the command */
809 while(MLY_CMD_STATE(mc) != MLY_CMD_COMPLETE) {
810 tsleep(mc, PRIBIO, "mlywait", 0);
811 }
812 } else {
813 /* spin and collect status while we do */
814 while(MLY_CMD_STATE(mc) != MLY_CMD_COMPLETE)
815 mly_done(mc->mc_sc);
816 }
817 splx(s);
818 return(0);
819}
820
821/********************************************************************************
822 * Start as much queued I/O as possible on the controller
823 */
--- 35 unchanged lines hidden (view full) ---
859{
860 struct mly_softc *sc = mc->mc_sc;
861 union mly_command_packet *pkt;
862 int s;
863
864 debug_called(2);
865
866 /*
867 * Set the command up for delivery to the controller. This may fail
868 * due to resource shortages.
869 */
870 if (mly_get_slot(mc))
871 return(EBUSY);
872 mly_map_command(mc);
873
874 s = splcam();
875 /*
876 * Do we have to use the hardware mailbox?
877 */
878 if (!(sc->mly_state & MLY_STATE_MMBOX_ACTIVE)) {
879 /*
880 * Check to see if the controller is ready for us.
881 */
882 if (MLY_IDBR_TRUE(sc, MLY_HM_CMDSENT)) {
883 splx(s);
884 return(EBUSY);
885 }
886
887 /*
888 * It's ready, send the command.
889 */
890 MLY_SET_MBOX(sc, sc->mly_command_mailbox, &mc->mc_packetphys);
891 MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_CMDSENT);
892
893 } else { /* use memory-mailbox mode */
894
895 pkt = &sc->mly_mmbox->mmm_command[sc->mly_mmbox_command_index];
896
897 /* check to see if the next slot is free yet */
898 if (pkt->mmbox.flag != 0) {
899 splx(s);
900 return(EBUSY);
901 }
902
903 /* copy in new command */
904 bcopy(mc->mc_packet->mmbox.data, pkt->mmbox.data, sizeof(pkt->mmbox.data));
905 /* barrier to ensure completion of previous write before we write the flag */
906 bus_space_barrier(NULL, NULL, 0, 0, BUS_SPACE_BARRIER_WRITE); /* tag/handle? */
907 /* copy flag last */
908 pkt->mmbox.flag = mc->mc_packet->mmbox.flag;
909 /* barrier to ensure completion of previous write before we notify the controller */
910 bus_space_barrier(NULL, NULL, 0, 0, BUS_SPACE_BARRIER_WRITE); /* tag/handle */
911
912 /* signal controller, update index */
913 MLY_SET_REG(sc, sc->mly_idbr, MLY_AM_CMDSENT);
914 sc->mly_mmbox_command_index = (sc->mly_mmbox_command_index + 1) % MLY_MMBOX_COMMANDS;
915 }
916
917 splx(s);
918 return(0);
919}
920
921/********************************************************************************
922 * Pick up command status from the controller, schedule a completion event
923 */
924void
--- 6 unchanged lines hidden (view full) ---
931
932 s = splcam();
933 worked = 0;
934
935 /* pick up hardware-mailbox commands */
936 if (MLY_ODBR_TRUE(sc, MLY_HM_STSREADY)) {
937 slot = MLY_GET_REG2(sc, sc->mly_status_mailbox);
938 if (slot < MLY_SLOT_MAX) {
939 mc = sc->mly_busycmds[slot];
940 if (mc != NULL) {
941 mc->mc_status = MLY_GET_REG(sc, sc->mly_status_mailbox + 2);
942 mc->mc_sense = MLY_GET_REG(sc, sc->mly_status_mailbox + 3);
943 mc->mc_resid = MLY_GET_REG4(sc, sc->mly_status_mailbox + 4);
944 mly_enqueue_completed(mc);
945 sc->mly_busycmds[slot] = NULL;
946 worked = 1;
947 } else {
948 mly_printf(sc, "got HM completion for nonbusy slot %u\n", slot);
949 }
950 } else {
951 /* slot 0xffff may mean "extremely bogus command" */
952 mly_printf(sc, "got HM completion for illegal slot %u\n", slot);
953 }
954 /* unconditionally acknowledge status */
955 MLY_SET_REG(sc, sc->mly_odbr, MLY_HM_STSREADY);
956 MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_STSACK);
957 }
--- 5 unchanged lines hidden (view full) ---
963
964 /* check for more status */
965 if (sp->mmbox.flag == 0)
966 break;
967
968 /* get slot number */
969 slot = sp->status.command_id;
970 if (slot < MLY_SLOT_MAX) {
971 mc = sc->mly_busycmds[slot];
972 if (mc != NULL) {
973 mc->mc_status = sp->status.status;
974 mc->mc_sense = sp->status.sense_length;
975 mc->mc_resid = sp->status.residue;
976 mly_enqueue_completed(mc);
977 sc->mly_busycmds[slot] = NULL;
978 worked = 1;
979 } else {
980 mly_printf(sc, "got AM completion for nonbusy slot %u\n", slot);
981 }
982 } else {
983 /* slot 0xffff may mean "extremely bogus command" */
984 mly_printf(sc, "got AM completion for illegal slot %u at %d\n", slot, sc->mly_mmbox_status_index);
985 }
986
987 /* clear and move to next slot */
988 sp->mmbox.flag = 0;
989 sc->mly_mmbox_status_index = (sc->mly_mmbox_status_index + 1) % MLY_MMBOX_STATUS;
990 }
991 /* acknowledge that we have collected status value(s) */
992 MLY_SET_REG(sc, sc->mly_odbr, MLY_AM_STSREADY);
993 }
994
995 splx(s);
--- 18 unchanged lines hidden (view full) ---
1014 void (* mc_complete)(struct mly_command *mc);
1015
1016
1017 debug_called(2);
1018
1019 /*
1020 * Spin pulling commands off the completed queue and processing them.
1021 */
1022 while ((mc = mly_dequeue_completed(sc)) != NULL) {
1023
1024 /*
1025 * Free controller resources, mark command complete.
1026 *
1027 * Note that as soon as we mark the command complete, it may be freed
1028 * out from under us, so we need to save the mc_complete field in
1029 * order to later avoid dereferencing mc. (We would not expect to
1030 * have a polling/sleeping consumer with mc_complete != NULL).
1031 */
1032 mly_unmap_command(mc);
1033 mc_complete = mc->mc_complete;
1034 MLY_CMD_SETSTATE(mc, MLY_CMD_COMPLETE);
1035
1036 /*
1037 * Call completion handler or wake up sleeping consumer.
1038 */
1039 if (mc_complete != NULL) {
1040 mc_complete(mc);
1041 } else {
1042 wakeup(mc);
--- 15 unchanged lines hidden (view full) ---
1058 * a while just to check up on it. While a filesystem is mounted, or I/O is
1059 * active this isn't really an issue.
1060 */
1061 if (sc->mly_mmbox->mmm_health.status.change_counter != sc->mly_event_change) {
1062 sc->mly_event_change = sc->mly_mmbox->mmm_health.status.change_counter;
1063 debug(1, "event change %d, event status update, %d -> %d", sc->mly_event_change,
1064 sc->mly_event_waiting, sc->mly_mmbox->mmm_health.status.next_event);
1065 sc->mly_event_waiting = sc->mly_mmbox->mmm_health.status.next_event;
1066 }
1067 if (sc->mly_event_counter != sc->mly_event_waiting)
1068 mly_fetch_event(sc);
1069}
1070
1071/********************************************************************************
1072 ********************************************************************************
1073 Command Buffer Management
1074 ********************************************************************************
1075 ********************************************************************************/
1076
1077/********************************************************************************
1078 * Give a command a slot in our lookup table, so that we can recover it when
1079 * the controller returns the slot number.
1080 *
1081 * Slots are freed in mly_done().
1082 */
1083static int
1084mly_get_slot(struct mly_command *mc)
1085{
1086 struct mly_softc *sc = mc->mc_sc;
1087 u_int16_t slot;
1088 int tries;
1089
1090 debug_called(3);
1091
1092 if (mc->mc_flags & MLY_CMD_SLOTTED)
1093 return(0);
1094
1095 /*
1096 * Optimisation for the controller-busy case - check to see whether
1097 * we are already over the limit and stop immediately.
1098 */
1099 if (sc->mly_busy_count >= sc->mly_max_commands)
1100 return(EBUSY);
1101
1102 /*
1103 * Scan forward from the last slot that we assigned looking for a free
1104 * slot. Don't scan more than the maximum number of commands that we
1105 * support (we should never reach the limit here due to the optimisation
1106 * above)
1107 */
1108 slot = sc->mly_last_slot;
1109 for (tries = sc->mly_max_commands; tries > 0; tries--) {
1110 if (sc->mly_busycmds[slot] == NULL) {
1111 sc->mly_busycmds[slot] = mc;
1112 mc->mc_slot = slot;
1113 mc->mc_packet->generic.command_id = slot;
1114 mc->mc_flags |= MLY_CMD_SLOTTED;
1115 sc->mly_last_slot = slot;
1116 return(0);
1117 }
1118 slot++;
1119 if (slot >= MLY_SLOT_MAX)
1120 slot = MLY_SLOT_START;
1121 }
1122 return(EBUSY);
1123}
1124
1125/********************************************************************************
1126 * Allocate a command.
1127 */
1128int
1129mly_alloc_command(struct mly_softc *sc, struct mly_command **mcp)
1130{
1131 struct mly_command *mc;
1132
1133 debug_called(3);
1134
1135 if ((mc = mly_dequeue_free(sc)) == NULL) {
1136 mly_alloc_command_cluster(sc);
1137 mc = mly_dequeue_free(sc);
1138 }
1139 if (mc != NULL)
1140 TAILQ_REMOVE(&sc->mly_freecmds, mc, mc_link);
1141
1142 if (mc == NULL)
1143 return(ENOMEM);
1144
1145 MLY_CMD_SETSTATE(mc, MLY_CMD_SETUP);
1146 *mcp = mc;
1147 return(0);
1148}
1149
1150/********************************************************************************
1151 * Release a command back to the freelist.
1152 */
1153void
1154mly_release_command(struct mly_command *mc)
1155{
1156 debug_called(3);
1157
1158 /*
1159 * Fill in parts of the command that may cause confusion if
1160 * a consumer doesn't when we are later allocated.
1161 */
1162 MLY_CMD_SETSTATE(mc, MLY_CMD_FREE);
1163 mc->mc_data = NULL;
1164 mc->mc_flags = 0;
1165 mc->mc_complete = NULL;
1166 mc->mc_private = NULL;
1167
1168 /*
1169 * By default, we set up to overwrite the command packet with
1170 * sense information.
1171 */
1172 mc->mc_packet->generic.sense_buffer_address = mc->mc_packetphys;
1173 mc->mc_packet->generic.maximum_sense_size = sizeof(union mly_command_packet);
1174
1175 mly_enqueue_free(mc);
1176}
1177
1178/********************************************************************************
1179 * Map helper for command cluster allocation.
1180 *
1181 * Note that there are never more command packets in a cluster than will fit in
1182 * a page, so there is no need to look at anything other than the base of the
1183 * allocation (which will be page-aligned).
1184 */
1185static void
1186mly_alloc_command_cluster_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1187{
1188 struct mly_command_cluster *mcc = (struct mly_command_cluster *)arg;
1189
1190 debug_called(2);
1191
1192 mcc->mcc_packetphys = segs[0].ds_addr;
1193}
1194
1195/********************************************************************************
1196 * Allocate and initialise a cluster of commands.
1197 */
1198static void
1199mly_alloc_command_cluster(struct mly_softc *sc)
1200{
1201 struct mly_command_cluster *mcc;
1202 struct mly_command *mc;
1203 int i;
1204
1205 debug_called(1);
1206
1207 mcc = malloc(sizeof(struct mly_command_cluster), M_DEVBUF, M_NOWAIT);
1208 if (mcc != NULL) {
1209
1210 /*
1211 * Allocate enough space for all the command packets for this cluster and
1212 * map them permanently into controller-visible space.
1213 */
1214 if (bus_dmamem_alloc(sc->mly_packet_dmat, (void **)&mcc->mcc_packet,
1215 BUS_DMA_NOWAIT, &mcc->mcc_packetmap)) {
1216 free(mcc, M_DEVBUF);
1217 return;
1218 }
1219 bus_dmamap_load(sc->mly_packet_dmat, mcc->mcc_packetmap, mcc->mcc_packet,
1220 MLY_CMD_CLUSTERCOUNT * sizeof(union mly_command_packet),
1221 mly_alloc_command_cluster_map, mcc, 0);
1222
1223 mly_enqueue_cluster(sc, mcc);
1224 for (i = 0; i < MLY_CMD_CLUSTERCOUNT; i++) {
1225 mc = &mcc->mcc_command[i];
1226 bzero(mc, sizeof(*mc));
1227 mc->mc_sc = sc;
1228 mc->mc_packet = mcc->mcc_packet + i;
1229 mc->mc_packetphys = mcc->mcc_packetphys + (i * sizeof(union mly_command_packet));
1230 if (!bus_dmamap_create(sc->mly_buffer_dmat, 0, &mc->mc_datamap))
1231 mly_release_command(mc);
1232 }
1233 }
1234}
1235
1236/********************************************************************************
1237 * Command-mapping helper function - populate this command slot's s/g table
1238 * with the s/g entries for this command.
1239 */
1240static void
1241mly_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1242{
1243 struct mly_command *mc = (struct mly_command *)arg;
1244 struct mly_softc *sc = mc->mc_sc;
1245 struct mly_command_generic *gen = &(mc->mc_packet->generic);
1246 struct mly_sg_entry *sg;
1247 int i, tabofs;
1248
1249 debug_called(3);
1250
1251 /* can we use the transfer structure directly? */
1252 if (nseg <= 2) {
1253 sg = &gen->transfer.direct.sg[0];
1254 gen->command_control.extended_sg_table = 0;
1255 } else {
1256 tabofs = (mc->mc_slot * MLY_MAXSGENTRIES);
1257 sg = sc->mly_sg_table + tabofs;
1258 gen->transfer.indirect.entries[0] = nseg;
1259 gen->transfer.indirect.table_physaddr[0] = sc->mly_sg_busaddr + (tabofs * sizeof(struct mly_sg_entry));
1260 gen->command_control.extended_sg_table = 1;
1261 }
1262
1263 /* copy the s/g table */
1264 for (i = 0; i < nseg; i++) {
--- 250 unchanged lines hidden (view full) ---
1515 */
1516static void
1517mly_print_command(struct mly_command *mc)
1518{
1519 struct mly_softc *sc = mc->mc_sc;
1520
1521 mly_printf(sc, "COMMAND @ %p\n", mc);
1522 mly_printf(sc, " slot %d\n", mc->mc_slot);
1523 mly_printf(sc, " state %d\n", MLY_CMD_STATE(mc));
1524 mly_printf(sc, " status 0x%x\n", mc->mc_status);
1525 mly_printf(sc, " sense len %d\n", mc->mc_sense);
1526 mly_printf(sc, " resid %d\n", mc->mc_resid);
1527 mly_printf(sc, " packet %p/0x%llx\n", mc->mc_packet, mc->mc_packetphys);
1528 if (mc->mc_packet != NULL)
1529 mly_print_packet(mc);
1530 mly_printf(sc, " data %p/%d\n", mc->mc_data, mc->mc_length);
1531 mly_printf(sc, " flags %b\n", mc->mc_flags, "\20\11slotted\12mapped\13priority\14datain\15dataout\n");
1532 mly_printf(sc, " complete %p\n", mc->mc_complete);
1533 mly_printf(sc, " private %p\n", mc->mc_private);
1534}
1535
1536/********************************************************************************
1537 * Print a command packet
1538 */
1539static void
--- 161 unchanged lines hidden (view full) ---
1701 */
1702static void
1703mly_panic(struct mly_softc *sc, char *reason)
1704{
1705 mly_printstate(sc);
1706 panic(reason);
1707}
1708#endif
2 * Copyright (c) 2000 Michael Smith
3 * Copyright (c) 2000 BSDi
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
--- 8 unchanged lines hidden (view full) ---
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 *
27 * $FreeBSD: head/sys/dev/mly/mly.c 68877 2000-11-18 15:21:22Z dwmalone $
28 */
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/malloc.h>
33#include <sys/kernel.h>
34#include <sys/bus.h>
35#include <sys/conf.h>
36#include <sys/ctype.h>
37
38#include <machine/bus_memio.h>
39#include <machine/bus.h>
40#include <machine/resource.h>
41#include <sys/rman.h>
42
43#include <cam/scsi/scsi_all.h>
44
45#include <dev/mly/mlyreg.h>
46#include <dev/mly/mlyvar.h>
47#define MLY_DEFINE_TABLES
48#include <dev/mly/mly_tables.h>
49
50static int mly_get_controllerinfo(struct mly_softc *sc);
51static void mly_scan_devices(struct mly_softc *sc);
52static void mly_rescan_btl(struct mly_softc *sc, int bus, int target);
53static void mly_complete_rescan(struct mly_command *mc);
--- 6 unchanged lines hidden (view full) ---
60static void mly_complete_event(struct mly_command *mc);
61static void mly_process_event(struct mly_softc *sc, struct mly_event *me);
62static void mly_periodic(void *data);
63
64static int mly_immediate_command(struct mly_command *mc);
65static int mly_start(struct mly_command *mc);
66static void mly_complete(void *context, int pending);
67
68static int mly_get_slot(struct mly_command *mc);
69static void mly_alloc_command_cluster_map(void *arg, bus_dma_segment_t *segs, int nseg, int error);
70static void mly_alloc_command_cluster(struct mly_softc *sc);
71static void mly_map_command(struct mly_command *mc);
72static void mly_unmap_command(struct mly_command *mc);
73
74static int mly_fwhandshake(struct mly_softc *sc);
75
76static void mly_describe_controller(struct mly_softc *sc);
77#ifdef MLY_DEBUG
78static void mly_printstate(struct mly_softc *sc);
79static void mly_print_command(struct mly_command *mc);
80static void mly_print_packet(struct mly_command *mc);
81static void mly_panic(struct mly_softc *sc, char *reason);
82#endif
83
84/********************************************************************************
85 ********************************************************************************
86 Device Interface
87 ********************************************************************************
88 ********************************************************************************/
89
90/********************************************************************************
91 * Initialise the controller and softc
92 */
93int
94mly_attach(struct mly_softc *sc)
95{
96 int error;
97
98 debug_called(1);
99
100 /*
101 * Initialise per-controller queues.
102 */
103 TAILQ_INIT(&sc->mly_freecmds);
104 TAILQ_INIT(&sc->mly_ready);
105 TAILQ_INIT(&sc->mly_completed);
106 TAILQ_INIT(&sc->mly_clusters);
107
108#if __FreeBSD_version >= 500005
109 /*
110 * Initialise command-completion task.
111 */
112 TASK_INIT(&sc->mly_task_complete, 0, mly_complete, sc);
113#endif
114
--- 4 unchanged lines hidden (view full) ---
119 * Wait for the controller to come ready, handshake with the firmware if required.
120 * This is typically only necessary on platforms where the controller BIOS does not
121 * run.
122 */
123 if ((error = mly_fwhandshake(sc)))
124 return(error);
125
126 /*
127 * Initialise the slot allocator so that we can issue commands.
128 */
129 sc->mly_max_commands = MLY_SLOT_MAX;
130 sc->mly_last_slot = MLY_SLOT_START;
131
132 /*
133 * Obtain controller feature information
134 */
135 if ((error = mly_get_controllerinfo(sc)))
136 return(error);
137
138 /*
139 * Update the slot allocator limit based on the controller inquiry.
140 */
141 sc->mly_max_commands = imin(sc->mly_controllerinfo->maximum_parallel_commands, MLY_SLOT_MAX);
142
143 /*
144 * Get the current event counter for health purposes, populate the initial
145 * health status buffer.
146 */
147 if ((error = mly_get_eventstatus(sc)))
148 return(error);
149
150 /*
151 * Enable memory-mailbox mode
--- 20 unchanged lines hidden (view full) ---
172 /*
173 * Instigate the first status poll immediately. Rescan completions won't
174 * happen until interrupts are enabled, which should still be before
175 * the SCSI subsystem gets to us. (XXX assuming CAM and interrupt-driven
176 * discovery here...)
177 */
178 mly_periodic((void *)sc);
179
180 /* enable interrupts now */
181 MLY_UNMASK_INTERRUPTS(sc);
182
183 return(0);
184}
185
186/********************************************************************************
187 * Bring the controller to a state where it can be safely left alone.
--- 177 unchanged lines hidden (view full) ---
365 mly_describe_code(mly_table_device_state, ldi->state));
366 } else if (mc->mc_length == sizeof(*pdi)) {
367 pdi = (struct mly_ioctl_getphysdevinfovalid *)mc->mc_data;
368 bus = pdi->channel;
369 target = pdi->target;
370 sc->mly_btl[bus][target].mb_flags = MLY_BTL_PHYSICAL; /* clears all other flags */
371 sc->mly_btl[bus][target].mb_type = MLY_DEVICE_TYPE_PHYSICAL;
372 sc->mly_btl[bus][target].mb_state = pdi->state;
373 if (pdi->state != MLY_DEVICE_STATE_UNCONFIGURED)
374 sc->mly_btl[bus][target].mb_flags |= MLY_BTL_PROTECTED;
375 debug(2, "BTL rescan for %d:%d returns %s", bus, target,
376 mly_describe_code(mly_table_device_state, pdi->state));
377 } else {
378 mly_printf(sc, "BTL rescan result corrupted\n");
379 }
380 } else {
--- 52 unchanged lines hidden (view full) ---
433 int error;
434
435 debug_called(1);
436
437 /* build the ioctl and send it */
438 bzero(&mci, sizeof(mci));
439 mci.sub_ioctl = MDACIOCTL_SETMEMORYMAILBOX;
440 /* set buffer addresses */
441 mci.param.setmemorymailbox.command_mailbox_physaddr = sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_command);
442 mci.param.setmemorymailbox.status_mailbox_physaddr = sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_status);
443 mci.param.setmemorymailbox.health_buffer_physaddr = sc->mly_mmbox_busaddr + offsetof(struct mly_mmbox, mmm_health);
444
445 /* set buffer sizes - abuse of data_size field is revolting */
446 sp = (u_int8_t *)&mci.data_size;
447 sp[0] = ((sizeof(union mly_command_packet) * MLY_MMBOX_COMMANDS) / 1024);
448 sp[1] = (sizeof(union mly_status_packet) * MLY_MMBOX_STATUS) / 1024;
449 mci.param.setmemorymailbox.health_buffer_size = sizeof(union mly_health_region) / 1024;
450
451 debug(1, "memory mailbox at %p (0x%llx/%d 0x%llx/%d 0x%llx/%d", sc->mly_mmbox,
452 mci.param.setmemorymailbox.command_mailbox_physaddr, sp[0],
453 mci.param.setmemorymailbox.status_mailbox_physaddr, sp[1],
454 mci.param.setmemorymailbox.health_buffer_physaddr, mci.param.setmemorymailbox.health_buffer_size);
455
456 if ((error = mly_ioctl(sc, &mci, NULL, 0, &status, NULL, NULL)))
457 return(error);
458 if (status != 0)
459 return(EIO);
460 sc->mly_state |= MLY_STATE_MMBOX_ACTIVE;
461 debug(1, "memory mailbox active");
462 return(0);
--- 338 unchanged lines hidden (view full) ---
801
802 /* spinning at splcam is ugly, but we're only used during controller init */
803 s = splcam();
804 if ((error = mly_start(mc)))
805 return(error);
806
807 if (sc->mly_state & MLY_STATE_INTERRUPTS_ON) {
808 /* sleep on the command */
809 while(MLY_CMD_STATE(mc) != MLY_CMD_COMPLETE) {
810 tsleep(mc, PRIBIO, "mlywait", 0);
811 }
812 } else {
813 /* spin and collect status while we do */
814 while(MLY_CMD_STATE(mc) != MLY_CMD_COMPLETE)
815 mly_done(mc->mc_sc);
816 }
817 splx(s);
818 return(0);
819}
820
821/********************************************************************************
822 * Start as much queued I/O as possible on the controller
823 */
--- 35 unchanged lines hidden (view full) ---
859{
860 struct mly_softc *sc = mc->mc_sc;
861 union mly_command_packet *pkt;
862 int s;
863
864 debug_called(2);
865
866 /*
867 * Set the command up for delivery to the controller. This may fail
868 * due to resource shortages.
869 */
870 if (mly_get_slot(mc))
871 return(EBUSY);
872 mly_map_command(mc);
873
874 s = splcam();
875 /*
876 * Do we have to use the hardware mailbox?
877 */
878 if (!(sc->mly_state & MLY_STATE_MMBOX_ACTIVE)) {
879 /*
880 * Check to see if the controller is ready for us.
881 */
882 if (MLY_IDBR_TRUE(sc, MLY_HM_CMDSENT)) {
883 splx(s);
884 return(EBUSY);
885 }
886
887 /*
888 * It's ready, send the command.
889 */
890 MLY_SET_MBOX(sc, sc->mly_command_mailbox, &mc->mc_packetphys);
891 MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_CMDSENT);
892
893 } else { /* use memory-mailbox mode */
894
895 pkt = &sc->mly_mmbox->mmm_command[sc->mly_mmbox_command_index];
896
897 /* check to see if the next slot is free yet */
898 if (pkt->mmbox.flag != 0) {
899 splx(s);
900 return(EBUSY);
901 }
902
903 /* copy in new command */
904 bcopy(mc->mc_packet->mmbox.data, pkt->mmbox.data, sizeof(pkt->mmbox.data));
905 /* barrier to ensure completion of previous write before we write the flag */
906 bus_space_barrier(NULL, NULL, 0, 0, BUS_SPACE_BARRIER_WRITE); /* tag/handle? */
907 /* copy flag last */
908 pkt->mmbox.flag = mc->mc_packet->mmbox.flag;
909 /* barrier to ensure completion of previous write before we notify the controller */
910 bus_space_barrier(NULL, NULL, 0, 0, BUS_SPACE_BARRIER_WRITE); /* tag/handle */
911
912 /* signal controller, update index */
913 MLY_SET_REG(sc, sc->mly_idbr, MLY_AM_CMDSENT);
914 sc->mly_mmbox_command_index = (sc->mly_mmbox_command_index + 1) % MLY_MMBOX_COMMANDS;
915 }
916
917 splx(s);
918 return(0);
919}
920
921/********************************************************************************
922 * Pick up command status from the controller, schedule a completion event
923 */
924void
--- 6 unchanged lines hidden (view full) ---
931
932 s = splcam();
933 worked = 0;
934
935 /* pick up hardware-mailbox commands */
936 if (MLY_ODBR_TRUE(sc, MLY_HM_STSREADY)) {
937 slot = MLY_GET_REG2(sc, sc->mly_status_mailbox);
938 if (slot < MLY_SLOT_MAX) {
939 mc = sc->mly_busycmds[slot];
940 if (mc != NULL) {
941 mc->mc_status = MLY_GET_REG(sc, sc->mly_status_mailbox + 2);
942 mc->mc_sense = MLY_GET_REG(sc, sc->mly_status_mailbox + 3);
943 mc->mc_resid = MLY_GET_REG4(sc, sc->mly_status_mailbox + 4);
944 mly_enqueue_completed(mc);
945 sc->mly_busycmds[slot] = NULL;
946 worked = 1;
947 } else {
948 mly_printf(sc, "got HM completion for nonbusy slot %u\n", slot);
949 }
950 } else {
951 /* slot 0xffff may mean "extremely bogus command" */
952 mly_printf(sc, "got HM completion for illegal slot %u\n", slot);
953 }
954 /* unconditionally acknowledge status */
955 MLY_SET_REG(sc, sc->mly_odbr, MLY_HM_STSREADY);
956 MLY_SET_REG(sc, sc->mly_idbr, MLY_HM_STSACK);
957 }
--- 5 unchanged lines hidden (view full) ---
963
964 /* check for more status */
965 if (sp->mmbox.flag == 0)
966 break;
967
968 /* get slot number */
969 slot = sp->status.command_id;
970 if (slot < MLY_SLOT_MAX) {
971 mc = sc->mly_busycmds[slot];
972 if (mc != NULL) {
973 mc->mc_status = sp->status.status;
974 mc->mc_sense = sp->status.sense_length;
975 mc->mc_resid = sp->status.residue;
976 mly_enqueue_completed(mc);
977 sc->mly_busycmds[slot] = NULL;
978 worked = 1;
979 } else {
980 mly_printf(sc, "got AM completion for nonbusy slot %u\n", slot);
981 }
982 } else {
983 /* slot 0xffff may mean "extremely bogus command" */
984 mly_printf(sc, "got AM completion for illegal slot %u at %d\n", slot, sc->mly_mmbox_status_index);
985 }
986
987 /* clear and move to next slot */
988 sp->mmbox.flag = 0;
989 sc->mly_mmbox_status_index = (sc->mly_mmbox_status_index + 1) % MLY_MMBOX_STATUS;
990 }
991 /* acknowledge that we have collected status value(s) */
992 MLY_SET_REG(sc, sc->mly_odbr, MLY_AM_STSREADY);
993 }
994
995 splx(s);
--- 18 unchanged lines hidden (view full) ---
1014 void (* mc_complete)(struct mly_command *mc);
1015
1016
1017 debug_called(2);
1018
1019 /*
1020 * Spin pulling commands off the completed queue and processing them.
1021 */
1022 while ((mc = mly_dequeue_completed(sc)) != NULL) {
1023
1024 /*
1025 * Free controller resources, mark command complete.
1026 *
1027 * Note that as soon as we mark the command complete, it may be freed
1028 * out from under us, so we need to save the mc_complete field in
1029 * order to later avoid dereferencing mc. (We would not expect to
1030 * have a polling/sleeping consumer with mc_complete != NULL).
1031 */
1032 mly_unmap_command(mc);
1033 mc_complete = mc->mc_complete;
1034 MLY_CMD_SETSTATE(mc, MLY_CMD_COMPLETE);
1035
1036 /*
1037 * Call completion handler or wake up sleeping consumer.
1038 */
1039 if (mc_complete != NULL) {
1040 mc_complete(mc);
1041 } else {
1042 wakeup(mc);
--- 15 unchanged lines hidden (view full) ---
1058 * a while just to check up on it. While a filesystem is mounted, or I/O is
1059 * active this isn't really an issue.
1060 */
1061 if (sc->mly_mmbox->mmm_health.status.change_counter != sc->mly_event_change) {
1062 sc->mly_event_change = sc->mly_mmbox->mmm_health.status.change_counter;
1063 debug(1, "event change %d, event status update, %d -> %d", sc->mly_event_change,
1064 sc->mly_event_waiting, sc->mly_mmbox->mmm_health.status.next_event);
1065 sc->mly_event_waiting = sc->mly_mmbox->mmm_health.status.next_event;
1066 }
1067 if (sc->mly_event_counter != sc->mly_event_waiting)
1068 mly_fetch_event(sc);
1069}
1070
1071/********************************************************************************
1072 ********************************************************************************
1073 Command Buffer Management
1074 ********************************************************************************
1075 ********************************************************************************/
1076
1077/********************************************************************************
1078 * Give a command a slot in our lookup table, so that we can recover it when
1079 * the controller returns the slot number.
1080 *
1081 * Slots are freed in mly_done().
1082 */
1083static int
1084mly_get_slot(struct mly_command *mc)
1085{
1086 struct mly_softc *sc = mc->mc_sc;
1087 u_int16_t slot;
1088 int tries;
1089
1090 debug_called(3);
1091
1092 if (mc->mc_flags & MLY_CMD_SLOTTED)
1093 return(0);
1094
1095 /*
1096 * Optimisation for the controller-busy case - check to see whether
1097 * we are already over the limit and stop immediately.
1098 */
1099 if (sc->mly_busy_count >= sc->mly_max_commands)
1100 return(EBUSY);
1101
1102 /*
1103 * Scan forward from the last slot that we assigned looking for a free
1104 * slot. Don't scan more than the maximum number of commands that we
1105 * support (we should never reach the limit here due to the optimisation
1106 * above)
1107 */
1108 slot = sc->mly_last_slot;
1109 for (tries = sc->mly_max_commands; tries > 0; tries--) {
1110 if (sc->mly_busycmds[slot] == NULL) {
1111 sc->mly_busycmds[slot] = mc;
1112 mc->mc_slot = slot;
1113 mc->mc_packet->generic.command_id = slot;
1114 mc->mc_flags |= MLY_CMD_SLOTTED;
1115 sc->mly_last_slot = slot;
1116 return(0);
1117 }
1118 slot++;
1119 if (slot >= MLY_SLOT_MAX)
1120 slot = MLY_SLOT_START;
1121 }
1122 return(EBUSY);
1123}
1124
1125/********************************************************************************
1126 * Allocate a command.
1127 */
1128int
1129mly_alloc_command(struct mly_softc *sc, struct mly_command **mcp)
1130{
1131 struct mly_command *mc;
1132
1133 debug_called(3);
1134
1135 if ((mc = mly_dequeue_free(sc)) == NULL) {
1136 mly_alloc_command_cluster(sc);
1137 mc = mly_dequeue_free(sc);
1138 }
1139 if (mc != NULL)
1140 TAILQ_REMOVE(&sc->mly_freecmds, mc, mc_link);
1141
1142 if (mc == NULL)
1143 return(ENOMEM);
1144
1145 MLY_CMD_SETSTATE(mc, MLY_CMD_SETUP);
1146 *mcp = mc;
1147 return(0);
1148}
1149
1150/********************************************************************************
1151 * Release a command back to the freelist.
1152 */
1153void
1154mly_release_command(struct mly_command *mc)
1155{
1156 debug_called(3);
1157
1158 /*
1159 * Fill in parts of the command that may cause confusion if
1160 * a consumer doesn't when we are later allocated.
1161 */
1162 MLY_CMD_SETSTATE(mc, MLY_CMD_FREE);
1163 mc->mc_data = NULL;
1164 mc->mc_flags = 0;
1165 mc->mc_complete = NULL;
1166 mc->mc_private = NULL;
1167
1168 /*
1169 * By default, we set up to overwrite the command packet with
1170 * sense information.
1171 */
1172 mc->mc_packet->generic.sense_buffer_address = mc->mc_packetphys;
1173 mc->mc_packet->generic.maximum_sense_size = sizeof(union mly_command_packet);
1174
1175 mly_enqueue_free(mc);
1176}
1177
1178/********************************************************************************
1179 * Map helper for command cluster allocation.
1180 *
1181 * Note that there are never more command packets in a cluster than will fit in
1182 * a page, so there is no need to look at anything other than the base of the
1183 * allocation (which will be page-aligned).
1184 */
1185static void
1186mly_alloc_command_cluster_map(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1187{
1188 struct mly_command_cluster *mcc = (struct mly_command_cluster *)arg;
1189
1190 debug_called(2);
1191
1192 mcc->mcc_packetphys = segs[0].ds_addr;
1193}
1194
1195/********************************************************************************
1196 * Allocate and initialise a cluster of commands.
1197 */
1198static void
1199mly_alloc_command_cluster(struct mly_softc *sc)
1200{
1201 struct mly_command_cluster *mcc;
1202 struct mly_command *mc;
1203 int i;
1204
1205 debug_called(1);
1206
1207 mcc = malloc(sizeof(struct mly_command_cluster), M_DEVBUF, M_NOWAIT);
1208 if (mcc != NULL) {
1209
1210 /*
1211 * Allocate enough space for all the command packets for this cluster and
1212 * map them permanently into controller-visible space.
1213 */
1214 if (bus_dmamem_alloc(sc->mly_packet_dmat, (void **)&mcc->mcc_packet,
1215 BUS_DMA_NOWAIT, &mcc->mcc_packetmap)) {
1216 free(mcc, M_DEVBUF);
1217 return;
1218 }
1219 bus_dmamap_load(sc->mly_packet_dmat, mcc->mcc_packetmap, mcc->mcc_packet,
1220 MLY_CMD_CLUSTERCOUNT * sizeof(union mly_command_packet),
1221 mly_alloc_command_cluster_map, mcc, 0);
1222
1223 mly_enqueue_cluster(sc, mcc);
1224 for (i = 0; i < MLY_CMD_CLUSTERCOUNT; i++) {
1225 mc = &mcc->mcc_command[i];
1226 bzero(mc, sizeof(*mc));
1227 mc->mc_sc = sc;
1228 mc->mc_packet = mcc->mcc_packet + i;
1229 mc->mc_packetphys = mcc->mcc_packetphys + (i * sizeof(union mly_command_packet));
1230 if (!bus_dmamap_create(sc->mly_buffer_dmat, 0, &mc->mc_datamap))
1231 mly_release_command(mc);
1232 }
1233 }
1234}
1235
1236/********************************************************************************
1237 * Command-mapping helper function - populate this command slot's s/g table
1238 * with the s/g entries for this command.
1239 */
1240static void
1241mly_map_command_sg(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1242{
1243 struct mly_command *mc = (struct mly_command *)arg;
1244 struct mly_softc *sc = mc->mc_sc;
1245 struct mly_command_generic *gen = &(mc->mc_packet->generic);
1246 struct mly_sg_entry *sg;
1247 int i, tabofs;
1248
1249 debug_called(3);
1250
1251 /* can we use the transfer structure directly? */
1252 if (nseg <= 2) {
1253 sg = &gen->transfer.direct.sg[0];
1254 gen->command_control.extended_sg_table = 0;
1255 } else {
1256 tabofs = (mc->mc_slot * MLY_MAXSGENTRIES);
1257 sg = sc->mly_sg_table + tabofs;
1258 gen->transfer.indirect.entries[0] = nseg;
1259 gen->transfer.indirect.table_physaddr[0] = sc->mly_sg_busaddr + (tabofs * sizeof(struct mly_sg_entry));
1260 gen->command_control.extended_sg_table = 1;
1261 }
1262
1263 /* copy the s/g table */
1264 for (i = 0; i < nseg; i++) {
--- 250 unchanged lines hidden (view full) ---
1515 */
1516static void
1517mly_print_command(struct mly_command *mc)
1518{
1519 struct mly_softc *sc = mc->mc_sc;
1520
1521 mly_printf(sc, "COMMAND @ %p\n", mc);
1522 mly_printf(sc, " slot %d\n", mc->mc_slot);
1523 mly_printf(sc, " state %d\n", MLY_CMD_STATE(mc));
1524 mly_printf(sc, " status 0x%x\n", mc->mc_status);
1525 mly_printf(sc, " sense len %d\n", mc->mc_sense);
1526 mly_printf(sc, " resid %d\n", mc->mc_resid);
1527 mly_printf(sc, " packet %p/0x%llx\n", mc->mc_packet, mc->mc_packetphys);
1528 if (mc->mc_packet != NULL)
1529 mly_print_packet(mc);
1530 mly_printf(sc, " data %p/%d\n", mc->mc_data, mc->mc_length);
1531 mly_printf(sc, " flags %b\n", mc->mc_flags, "\20\11slotted\12mapped\13priority\14datain\15dataout\n");
1532 mly_printf(sc, " complete %p\n", mc->mc_complete);
1533 mly_printf(sc, " private %p\n", mc->mc_private);
1534}
1535
1536/********************************************************************************
1537 * Print a command packet
1538 */
1539static void
--- 161 unchanged lines hidden (view full) ---
1701 */
1702static void
1703mly_panic(struct mly_softc *sc, char *reason)
1704{
1705 mly_printstate(sc);
1706 panic(reason);
1707}
1708#endif