1098ca2bdSWarner Losh /*- 20b80d21bSMatt Jacob * Generic routines for LSI Fusion adapters. 39b631363SMatt Jacob * FreeBSD Version. 49b631363SMatt Jacob * 59b631363SMatt Jacob * Copyright (c) 2000, 2001 by Greg Ansley 69b631363SMatt Jacob * 79b631363SMatt Jacob * Redistribution and use in source and binary forms, with or without 89b631363SMatt Jacob * modification, are permitted provided that the following conditions 99b631363SMatt Jacob * are met: 109b631363SMatt Jacob * 1. Redistributions of source code must retain the above copyright 119b631363SMatt Jacob * notice immediately at the beginning of the file, without modification, 129b631363SMatt Jacob * this list of conditions, and the following disclaimer. 139b631363SMatt Jacob * 2. The name of the author may not be used to endorse or promote products 149b631363SMatt Jacob * derived from this software without specific prior written permission. 159b631363SMatt Jacob * 169b631363SMatt Jacob * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 179b631363SMatt Jacob * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 189b631363SMatt Jacob * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 199b631363SMatt Jacob * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR 209b631363SMatt Jacob * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 219b631363SMatt Jacob * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 229b631363SMatt Jacob * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 239b631363SMatt Jacob * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 249b631363SMatt Jacob * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 259b631363SMatt Jacob * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 269b631363SMatt Jacob * SUCH DAMAGE. 279b631363SMatt Jacob */ 280b80d21bSMatt Jacob /*- 290b80d21bSMatt Jacob * Copyright (c) 2002, 2006 by Matthew Jacob 300b80d21bSMatt Jacob * All rights reserved. 310b80d21bSMatt Jacob * 320b80d21bSMatt Jacob * Redistribution and use in source and binary forms, with or without 330b80d21bSMatt Jacob * modification, are permitted provided that the following conditions are 340b80d21bSMatt Jacob * met: 350b80d21bSMatt Jacob * 1. Redistributions of source code must retain the above copyright 360b80d21bSMatt Jacob * notice, this list of conditions and the following disclaimer. 370b80d21bSMatt Jacob * 2. Redistributions in binary form must reproduce at minimum a disclaimer 380b80d21bSMatt Jacob * substantially similar to the "NO WARRANTY" disclaimer below 390b80d21bSMatt Jacob * ("Disclaimer") and any redistribution must be conditioned upon including 400b80d21bSMatt Jacob * a substantially similar Disclaimer requirement for further binary 410b80d21bSMatt Jacob * redistribution. 420b80d21bSMatt Jacob * 3. Neither the names of the above listed copyright holders nor the names 430b80d21bSMatt Jacob * of any contributors may be used to endorse or promote products derived 440b80d21bSMatt Jacob * from this software without specific prior written permission. 450b80d21bSMatt Jacob * 460b80d21bSMatt Jacob * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 470b80d21bSMatt Jacob * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 480b80d21bSMatt Jacob * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 490b80d21bSMatt Jacob * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 500b80d21bSMatt Jacob * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 510b80d21bSMatt Jacob * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 520b80d21bSMatt Jacob * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 530b80d21bSMatt Jacob * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 540b80d21bSMatt Jacob * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 550b80d21bSMatt Jacob * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF THE COPYRIGHT 560b80d21bSMatt Jacob * OWNER OR CONTRIBUTOR IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 570b80d21bSMatt Jacob * 580b80d21bSMatt Jacob * Support from Chris Ellsworth in order to make SAS adapters work 590b80d21bSMatt Jacob * is gratefully acknowledged. 60ec5fe39dSMatt Jacob * 61ec5fe39dSMatt Jacob * 62ec5fe39dSMatt Jacob * Support from LSI-Logic has also gone a great deal toward making this a 63ec5fe39dSMatt Jacob * workable subsystem and is gratefully acknowledged. 640b80d21bSMatt Jacob */ 650b80d21bSMatt Jacob /*- 66b0a2fdeeSScott Long * Copyright (c) 2004, Avid Technology, Inc. and its contributors. 67b0a2fdeeSScott Long * Copyright (c) 2005, WHEEL Sp. z o.o. 68b0a2fdeeSScott Long * Copyright (c) 2004, 2005 Justin T. Gibbs 69b0a2fdeeSScott Long * All rights reserved. 70b0a2fdeeSScott Long * 71b0a2fdeeSScott Long * Redistribution and use in source and binary forms, with or without 72b0a2fdeeSScott Long * modification, are permitted provided that the following conditions are 73b0a2fdeeSScott Long * met: 74b0a2fdeeSScott Long * 1. Redistributions of source code must retain the above copyright 75b0a2fdeeSScott Long * notice, this list of conditions and the following disclaimer. 76b0a2fdeeSScott Long * 2. Redistributions in binary form must reproduce at minimum a disclaimer 77b0a2fdeeSScott Long * substantially similar to the "NO WARRANTY" disclaimer below 78b0a2fdeeSScott Long * ("Disclaimer") and any redistribution must be conditioned upon including 79b0a2fdeeSScott Long * a substantially similar Disclaimer requirement for further binary 80b0a2fdeeSScott Long * redistribution. 81286e947fSJustin T. Gibbs * 3. Neither the names of the above listed copyright holders nor the names 82286e947fSJustin T. Gibbs * of any contributors may be used to endorse or promote products derived 83286e947fSJustin T. Gibbs * from this software without specific prior written permission. 84b0a2fdeeSScott Long * 85b0a2fdeeSScott Long * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 86b0a2fdeeSScott Long * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 87b0a2fdeeSScott Long * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 88b0a2fdeeSScott Long * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 89b0a2fdeeSScott Long * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 90b0a2fdeeSScott Long * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 91b0a2fdeeSScott Long * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 92b0a2fdeeSScott Long * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 93b0a2fdeeSScott Long * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 94b0a2fdeeSScott Long * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF THE COPYRIGHT 95b0a2fdeeSScott Long * OWNER OR CONTRIBUTOR IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 969b631363SMatt Jacob */ 979b631363SMatt Jacob 989295c6c5SDavid E. O'Brien #include <sys/cdefs.h> 999295c6c5SDavid E. O'Brien __FBSDID("$FreeBSD$"); 1009295c6c5SDavid E. O'Brien 101b0a2fdeeSScott Long #include <dev/mpt/mpt.h> 102b0a2fdeeSScott Long #include <dev/mpt/mpt_cam.h> /* XXX For static handler registration */ 103b0a2fdeeSScott Long #include <dev/mpt/mpt_raid.h> /* XXX For static handler registration */ 104b0a2fdeeSScott Long 105b0a2fdeeSScott Long #include <dev/mpt/mpilib/mpi.h> 106b0a2fdeeSScott Long #include <dev/mpt/mpilib/mpi_ioc.h> 107c87e3f83SMatt Jacob #include <dev/mpt/mpilib/mpi_fc.h> 108c87e3f83SMatt Jacob #include <dev/mpt/mpilib/mpi_targ.h> 109b0a2fdeeSScott Long 110b0a2fdeeSScott Long #include <sys/sysctl.h> 1117104aeefSMatt Jacob 1129b631363SMatt Jacob #define MPT_MAX_TRYS 3 1139b631363SMatt Jacob #define MPT_MAX_WAIT 300000 1149b631363SMatt Jacob 1159b631363SMatt Jacob static int maxwait_ack = 0; 1169b631363SMatt Jacob static int maxwait_int = 0; 1179b631363SMatt Jacob static int maxwait_state = 0; 1189b631363SMatt Jacob 119b0a2fdeeSScott Long TAILQ_HEAD(, mpt_softc) mpt_tailq = TAILQ_HEAD_INITIALIZER(mpt_tailq); 120b0a2fdeeSScott Long mpt_reply_handler_t *mpt_reply_handlers[MPT_NUM_REPLY_HANDLERS]; 1219b631363SMatt Jacob 122b0a2fdeeSScott Long static mpt_reply_handler_t mpt_default_reply_handler; 123b0a2fdeeSScott Long static mpt_reply_handler_t mpt_config_reply_handler; 124b0a2fdeeSScott Long static mpt_reply_handler_t mpt_handshake_reply_handler; 125b0a2fdeeSScott Long static mpt_reply_handler_t mpt_event_reply_handler; 126b0a2fdeeSScott Long static void mpt_send_event_ack(struct mpt_softc *mpt, request_t *ack_req, 127b0a2fdeeSScott Long MSG_EVENT_NOTIFY_REPLY *msg, uint32_t context); 128444dd2b6SMatt Jacob static int mpt_send_event_request(struct mpt_softc *mpt, int onoff); 129b0a2fdeeSScott Long static int mpt_soft_reset(struct mpt_softc *mpt); 130b0a2fdeeSScott Long static void mpt_hard_reset(struct mpt_softc *mpt); 131b0a2fdeeSScott Long static int mpt_configure_ioc(struct mpt_softc *mpt); 132c87e3f83SMatt Jacob static int mpt_enable_ioc(struct mpt_softc *mpt, int); 133b0a2fdeeSScott Long 134b0a2fdeeSScott Long /************************* Personality Module Support *************************/ 135b0a2fdeeSScott Long /* 136b0a2fdeeSScott Long * We include one extra entry that is guaranteed to be NULL 137b0a2fdeeSScott Long * to simplify our itterator. 138b0a2fdeeSScott Long */ 139b0a2fdeeSScott Long static struct mpt_personality *mpt_personalities[MPT_MAX_PERSONALITIES + 1]; 140b0a2fdeeSScott Long static __inline struct mpt_personality* 141b0a2fdeeSScott Long mpt_pers_find(struct mpt_softc *, u_int); 142b0a2fdeeSScott Long static __inline struct mpt_personality* 143b0a2fdeeSScott Long mpt_pers_find_reverse(struct mpt_softc *, u_int); 144b0a2fdeeSScott Long 145b0a2fdeeSScott Long static __inline struct mpt_personality * 146b0a2fdeeSScott Long mpt_pers_find(struct mpt_softc *mpt, u_int start_at) 147b0a2fdeeSScott Long { 148b0a2fdeeSScott Long KASSERT(start_at <= MPT_MAX_PERSONALITIES, 149b0a2fdeeSScott Long ("mpt_pers_find: starting position out of range\n")); 150b0a2fdeeSScott Long 151b0a2fdeeSScott Long while (start_at < MPT_MAX_PERSONALITIES 152b0a2fdeeSScott Long && (mpt->mpt_pers_mask & (0x1 << start_at)) == 0) { 153b0a2fdeeSScott Long start_at++; 154b0a2fdeeSScott Long } 155b0a2fdeeSScott Long return (mpt_personalities[start_at]); 156b0a2fdeeSScott Long } 157b0a2fdeeSScott Long 158b0a2fdeeSScott Long /* 159c87e3f83SMatt Jacob * Used infrequently, so no need to optimize like a forward 160b0a2fdeeSScott Long * traversal where we use the MAX+1 is guaranteed to be NULL 161b0a2fdeeSScott Long * trick. 162b0a2fdeeSScott Long */ 163b0a2fdeeSScott Long static __inline struct mpt_personality * 164b0a2fdeeSScott Long mpt_pers_find_reverse(struct mpt_softc *mpt, u_int start_at) 165b0a2fdeeSScott Long { 166b0a2fdeeSScott Long while (start_at < MPT_MAX_PERSONALITIES 167b0a2fdeeSScott Long && (mpt->mpt_pers_mask & (0x1 << start_at)) == 0) { 168b0a2fdeeSScott Long start_at--; 169b0a2fdeeSScott Long } 170b0a2fdeeSScott Long if (start_at < MPT_MAX_PERSONALITIES) 171b0a2fdeeSScott Long return (mpt_personalities[start_at]); 172b0a2fdeeSScott Long return (NULL); 173b0a2fdeeSScott Long } 174b0a2fdeeSScott Long 175b0a2fdeeSScott Long #define MPT_PERS_FOREACH(mpt, pers) \ 176b0a2fdeeSScott Long for (pers = mpt_pers_find(mpt, /*start_at*/0); \ 177b0a2fdeeSScott Long pers != NULL; \ 178b0a2fdeeSScott Long pers = mpt_pers_find(mpt, /*start_at*/pers->id+1)) 179b0a2fdeeSScott Long 180b0a2fdeeSScott Long #define MPT_PERS_FOREACH_REVERSE(mpt, pers) \ 181b0a2fdeeSScott Long for (pers = mpt_pers_find_reverse(mpt, MPT_MAX_PERSONALITIES-1);\ 182b0a2fdeeSScott Long pers != NULL; \ 183b0a2fdeeSScott Long pers = mpt_pers_find_reverse(mpt, /*start_at*/pers->id-1)) 184b0a2fdeeSScott Long 185b0a2fdeeSScott Long static mpt_load_handler_t mpt_stdload; 186b0a2fdeeSScott Long static mpt_probe_handler_t mpt_stdprobe; 187b0a2fdeeSScott Long static mpt_attach_handler_t mpt_stdattach; 188c87e3f83SMatt Jacob static mpt_enable_handler_t mpt_stdenable; 189b0a2fdeeSScott Long static mpt_event_handler_t mpt_stdevent; 190b0a2fdeeSScott Long static mpt_reset_handler_t mpt_stdreset; 191b0a2fdeeSScott Long static mpt_shutdown_handler_t mpt_stdshutdown; 192b0a2fdeeSScott Long static mpt_detach_handler_t mpt_stddetach; 193b0a2fdeeSScott Long static mpt_unload_handler_t mpt_stdunload; 194b0a2fdeeSScott Long static struct mpt_personality mpt_default_personality = 195b0a2fdeeSScott Long { 196b0a2fdeeSScott Long .load = mpt_stdload, 197b0a2fdeeSScott Long .probe = mpt_stdprobe, 198b0a2fdeeSScott Long .attach = mpt_stdattach, 199c87e3f83SMatt Jacob .enable = mpt_stdenable, 200b0a2fdeeSScott Long .event = mpt_stdevent, 201b0a2fdeeSScott Long .reset = mpt_stdreset, 202b0a2fdeeSScott Long .shutdown = mpt_stdshutdown, 203b0a2fdeeSScott Long .detach = mpt_stddetach, 204b0a2fdeeSScott Long .unload = mpt_stdunload 205b0a2fdeeSScott Long }; 206b0a2fdeeSScott Long 207b0a2fdeeSScott Long static mpt_load_handler_t mpt_core_load; 208b0a2fdeeSScott Long static mpt_attach_handler_t mpt_core_attach; 209c87e3f83SMatt Jacob static mpt_enable_handler_t mpt_core_enable; 210b0a2fdeeSScott Long static mpt_reset_handler_t mpt_core_ioc_reset; 211b0a2fdeeSScott Long static mpt_event_handler_t mpt_core_event; 212b0a2fdeeSScott Long static mpt_shutdown_handler_t mpt_core_shutdown; 213b0a2fdeeSScott Long static mpt_shutdown_handler_t mpt_core_detach; 214b0a2fdeeSScott Long static mpt_unload_handler_t mpt_core_unload; 215b0a2fdeeSScott Long static struct mpt_personality mpt_core_personality = 216b0a2fdeeSScott Long { 217b0a2fdeeSScott Long .name = "mpt_core", 218b0a2fdeeSScott Long .load = mpt_core_load, 219b0a2fdeeSScott Long .attach = mpt_core_attach, 220c87e3f83SMatt Jacob .enable = mpt_core_enable, 221b0a2fdeeSScott Long .event = mpt_core_event, 222b0a2fdeeSScott Long .reset = mpt_core_ioc_reset, 223b0a2fdeeSScott Long .shutdown = mpt_core_shutdown, 224b0a2fdeeSScott Long .detach = mpt_core_detach, 225b0a2fdeeSScott Long .unload = mpt_core_unload, 226b0a2fdeeSScott Long }; 227b0a2fdeeSScott Long 228b0a2fdeeSScott Long /* 229b0a2fdeeSScott Long * Manual declaration so that DECLARE_MPT_PERSONALITY doesn't need 230b0a2fdeeSScott Long * ordering information. We want the core to always register FIRST. 231b0a2fdeeSScott Long * other modules are set to SI_ORDER_SECOND. 232b0a2fdeeSScott Long */ 233b0a2fdeeSScott Long static moduledata_t mpt_core_mod = { 234b0a2fdeeSScott Long "mpt_core", mpt_modevent, &mpt_core_personality 235b0a2fdeeSScott Long }; 236b0a2fdeeSScott Long DECLARE_MODULE(mpt_core, mpt_core_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 237b0a2fdeeSScott Long MODULE_VERSION(mpt_core, 1); 238b0a2fdeeSScott Long 239c87e3f83SMatt Jacob #define MPT_PERS_ATTACHED(pers, mpt) ((mpt)->mpt_pers_mask & (0x1 << pers->id)) 240b0a2fdeeSScott Long 241b0a2fdeeSScott Long 242b0a2fdeeSScott Long int 243b0a2fdeeSScott Long mpt_modevent(module_t mod, int type, void *data) 244b0a2fdeeSScott Long { 245b0a2fdeeSScott Long struct mpt_personality *pers; 246b0a2fdeeSScott Long int error; 247b0a2fdeeSScott Long 248b0a2fdeeSScott Long pers = (struct mpt_personality *)data; 249b0a2fdeeSScott Long 250b0a2fdeeSScott Long error = 0; 251b0a2fdeeSScott Long switch (type) { 252b0a2fdeeSScott Long case MOD_LOAD: 253b0a2fdeeSScott Long { 254b0a2fdeeSScott Long mpt_load_handler_t **def_handler; 255b0a2fdeeSScott Long mpt_load_handler_t **pers_handler; 256b0a2fdeeSScott Long int i; 257b0a2fdeeSScott Long 258b0a2fdeeSScott Long for (i = 0; i < MPT_MAX_PERSONALITIES; i++) { 259b0a2fdeeSScott Long if (mpt_personalities[i] == NULL) 260b0a2fdeeSScott Long break; 261b0a2fdeeSScott Long } 262b0a2fdeeSScott Long if (i >= MPT_MAX_PERSONALITIES) { 263b0a2fdeeSScott Long error = ENOMEM; 264b0a2fdeeSScott Long break; 265b0a2fdeeSScott Long } 266b0a2fdeeSScott Long pers->id = i; 267b0a2fdeeSScott Long mpt_personalities[i] = pers; 268b0a2fdeeSScott Long 269b0a2fdeeSScott Long /* Install standard/noop handlers for any NULL entries. */ 270b0a2fdeeSScott Long def_handler = MPT_PERS_FIRST_HANDLER(&mpt_default_personality); 271b0a2fdeeSScott Long pers_handler = MPT_PERS_FIRST_HANDLER(pers); 272b0a2fdeeSScott Long while (pers_handler <= MPT_PERS_LAST_HANDLER(pers)) { 273b0a2fdeeSScott Long if (*pers_handler == NULL) 274b0a2fdeeSScott Long *pers_handler = *def_handler; 275b0a2fdeeSScott Long pers_handler++; 276b0a2fdeeSScott Long def_handler++; 277b0a2fdeeSScott Long } 278b0a2fdeeSScott Long 279b0a2fdeeSScott Long error = (pers->load(pers)); 280b0a2fdeeSScott Long if (error != 0) 281b0a2fdeeSScott Long mpt_personalities[i] = NULL; 282b0a2fdeeSScott Long break; 283b0a2fdeeSScott Long } 284b0a2fdeeSScott Long case MOD_SHUTDOWN: 285b0a2fdeeSScott Long break; 286c87e3f83SMatt Jacob #if __FreeBSD_version >= 500000 287b0a2fdeeSScott Long case MOD_QUIESCE: 288b0a2fdeeSScott Long break; 289c87e3f83SMatt Jacob #endif 290b0a2fdeeSScott Long case MOD_UNLOAD: 291b0a2fdeeSScott Long error = pers->unload(pers); 292b0a2fdeeSScott Long mpt_personalities[pers->id] = NULL; 293b0a2fdeeSScott Long break; 294b0a2fdeeSScott Long default: 295b0a2fdeeSScott Long error = EINVAL; 296b0a2fdeeSScott Long break; 297b0a2fdeeSScott Long } 298b0a2fdeeSScott Long return (error); 299b0a2fdeeSScott Long } 300b0a2fdeeSScott Long 301b0a2fdeeSScott Long int 302b0a2fdeeSScott Long mpt_stdload(struct mpt_personality *pers) 303b0a2fdeeSScott Long { 304b0a2fdeeSScott Long /* Load is always successfull. */ 305b0a2fdeeSScott Long return (0); 306b0a2fdeeSScott Long } 307b0a2fdeeSScott Long 308b0a2fdeeSScott Long int 309b0a2fdeeSScott Long mpt_stdprobe(struct mpt_softc *mpt) 310b0a2fdeeSScott Long { 311b0a2fdeeSScott Long /* Probe is always successfull. */ 312b0a2fdeeSScott Long return (0); 313b0a2fdeeSScott Long } 314b0a2fdeeSScott Long 315b0a2fdeeSScott Long int 316b0a2fdeeSScott Long mpt_stdattach(struct mpt_softc *mpt) 317b0a2fdeeSScott Long { 318b0a2fdeeSScott Long /* Attach is always successfull. */ 319b0a2fdeeSScott Long return (0); 320b0a2fdeeSScott Long } 321b0a2fdeeSScott Long 322b0a2fdeeSScott Long int 323c87e3f83SMatt Jacob mpt_stdenable(struct mpt_softc *mpt) 324c87e3f83SMatt Jacob { 325c87e3f83SMatt Jacob /* Enable is always successfull. */ 326c87e3f83SMatt Jacob return (0); 327c87e3f83SMatt Jacob } 328c87e3f83SMatt Jacob 329c87e3f83SMatt Jacob int 330444dd2b6SMatt Jacob mpt_stdevent(struct mpt_softc *mpt, request_t *req, MSG_EVENT_NOTIFY_REPLY *msg) 331b0a2fdeeSScott Long { 332444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_stdevent: 0x%x\n", msg->Event & 0xFF); 333b0a2fdeeSScott Long /* Event was not for us. */ 334b0a2fdeeSScott Long return (0); 335b0a2fdeeSScott Long } 336b0a2fdeeSScott Long 337b0a2fdeeSScott Long void 338b0a2fdeeSScott Long mpt_stdreset(struct mpt_softc *mpt, int type) 339b0a2fdeeSScott Long { 340b0a2fdeeSScott Long } 341b0a2fdeeSScott Long 342b0a2fdeeSScott Long void 343b0a2fdeeSScott Long mpt_stdshutdown(struct mpt_softc *mpt) 344b0a2fdeeSScott Long { 345b0a2fdeeSScott Long } 346b0a2fdeeSScott Long 347b0a2fdeeSScott Long void 348b0a2fdeeSScott Long mpt_stddetach(struct mpt_softc *mpt) 349b0a2fdeeSScott Long { 350b0a2fdeeSScott Long } 351b0a2fdeeSScott Long 352b0a2fdeeSScott Long int 353b0a2fdeeSScott Long mpt_stdunload(struct mpt_personality *pers) 354b0a2fdeeSScott Long { 355b0a2fdeeSScott Long /* Unload is always successfull. */ 356b0a2fdeeSScott Long return (0); 357b0a2fdeeSScott Long } 358b0a2fdeeSScott Long 359b0a2fdeeSScott Long /******************************* Bus DMA Support ******************************/ 360b0a2fdeeSScott Long void 361b0a2fdeeSScott Long mpt_map_rquest(void *arg, bus_dma_segment_t *segs, int nseg, int error) 362b0a2fdeeSScott Long { 363b0a2fdeeSScott Long struct mpt_map_info *map_info; 364b0a2fdeeSScott Long 365b0a2fdeeSScott Long map_info = (struct mpt_map_info *)arg; 366b0a2fdeeSScott Long map_info->error = error; 367b0a2fdeeSScott Long map_info->phys = segs->ds_addr; 368b0a2fdeeSScott Long } 369b0a2fdeeSScott Long 370b0a2fdeeSScott Long /**************************** Reply/Event Handling ****************************/ 371b0a2fdeeSScott Long int 372b0a2fdeeSScott Long mpt_register_handler(struct mpt_softc *mpt, mpt_handler_type type, 373b0a2fdeeSScott Long mpt_handler_t handler, uint32_t *phandler_id) 374b0a2fdeeSScott Long { 375b0a2fdeeSScott Long 376b0a2fdeeSScott Long switch (type) { 377b0a2fdeeSScott Long case MPT_HANDLER_REPLY: 378b0a2fdeeSScott Long { 379b0a2fdeeSScott Long u_int cbi; 380b0a2fdeeSScott Long u_int free_cbi; 381b0a2fdeeSScott Long 382b0a2fdeeSScott Long if (phandler_id == NULL) 383b0a2fdeeSScott Long return (EINVAL); 384b0a2fdeeSScott Long 385b0a2fdeeSScott Long free_cbi = MPT_HANDLER_ID_NONE; 386b0a2fdeeSScott Long for (cbi = 0; cbi < MPT_NUM_REPLY_HANDLERS; cbi++) { 387b0a2fdeeSScott Long /* 388b0a2fdeeSScott Long * If the same handler is registered multiple 389b0a2fdeeSScott Long * times, don't error out. Just return the 390b0a2fdeeSScott Long * index of the original registration. 391b0a2fdeeSScott Long */ 392b0a2fdeeSScott Long if (mpt_reply_handlers[cbi] == handler.reply_handler) { 393b0a2fdeeSScott Long *phandler_id = MPT_CBI_TO_HID(cbi); 394b0a2fdeeSScott Long return (0); 395b0a2fdeeSScott Long } 396b0a2fdeeSScott Long 397b0a2fdeeSScott Long /* 398b0a2fdeeSScott Long * Fill from the front in the hope that 399b0a2fdeeSScott Long * all registered handlers consume only a 400b0a2fdeeSScott Long * single cache line. 401b0a2fdeeSScott Long * 402b0a2fdeeSScott Long * We don't break on the first empty slot so 403b0a2fdeeSScott Long * that the full table is checked to see if 404b0a2fdeeSScott Long * this handler was previously registered. 405b0a2fdeeSScott Long */ 406c87e3f83SMatt Jacob if (free_cbi == MPT_HANDLER_ID_NONE && 407c87e3f83SMatt Jacob (mpt_reply_handlers[cbi] 408b0a2fdeeSScott Long == mpt_default_reply_handler)) 409b0a2fdeeSScott Long free_cbi = cbi; 410b0a2fdeeSScott Long } 411c87e3f83SMatt Jacob if (free_cbi == MPT_HANDLER_ID_NONE) { 412b0a2fdeeSScott Long return (ENOMEM); 413c87e3f83SMatt Jacob } 414b0a2fdeeSScott Long mpt_reply_handlers[free_cbi] = handler.reply_handler; 415b0a2fdeeSScott Long *phandler_id = MPT_CBI_TO_HID(free_cbi); 416b0a2fdeeSScott Long break; 417b0a2fdeeSScott Long } 418b0a2fdeeSScott Long default: 419b0a2fdeeSScott Long mpt_prt(mpt, "mpt_register_handler unknown type %d\n", type); 420b0a2fdeeSScott Long return (EINVAL); 421b0a2fdeeSScott Long } 422b0a2fdeeSScott Long return (0); 423b0a2fdeeSScott Long } 424b0a2fdeeSScott Long 425b0a2fdeeSScott Long int 426b0a2fdeeSScott Long mpt_deregister_handler(struct mpt_softc *mpt, mpt_handler_type type, 427b0a2fdeeSScott Long mpt_handler_t handler, uint32_t handler_id) 428b0a2fdeeSScott Long { 429b0a2fdeeSScott Long 430b0a2fdeeSScott Long switch (type) { 431b0a2fdeeSScott Long case MPT_HANDLER_REPLY: 432b0a2fdeeSScott Long { 433b0a2fdeeSScott Long u_int cbi; 434b0a2fdeeSScott Long 435b0a2fdeeSScott Long cbi = MPT_CBI(handler_id); 436b0a2fdeeSScott Long if (cbi >= MPT_NUM_REPLY_HANDLERS 437b0a2fdeeSScott Long || mpt_reply_handlers[cbi] != handler.reply_handler) 438b0a2fdeeSScott Long return (ENOENT); 439b0a2fdeeSScott Long mpt_reply_handlers[cbi] = mpt_default_reply_handler; 440b0a2fdeeSScott Long break; 441b0a2fdeeSScott Long } 442b0a2fdeeSScott Long default: 443b0a2fdeeSScott Long mpt_prt(mpt, "mpt_deregister_handler unknown type %d\n", type); 444b0a2fdeeSScott Long return (EINVAL); 445b0a2fdeeSScott Long } 446b0a2fdeeSScott Long return (0); 447b0a2fdeeSScott Long } 448b0a2fdeeSScott Long 449b0a2fdeeSScott Long static int 450b0a2fdeeSScott Long mpt_default_reply_handler(struct mpt_softc *mpt, request_t *req, 451c87e3f83SMatt Jacob uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 452b0a2fdeeSScott Long { 453c87e3f83SMatt Jacob mpt_prt(mpt, 454c87e3f83SMatt Jacob "Default Handler Called: req=%p:%u reply_descriptor=%x frame=%p\n", 455c87e3f83SMatt Jacob req, req->serno, reply_desc, reply_frame); 456b0a2fdeeSScott Long 457b0a2fdeeSScott Long if (reply_frame != NULL) 458b0a2fdeeSScott Long mpt_dump_reply_frame(mpt, reply_frame); 459b0a2fdeeSScott Long 460c87e3f83SMatt Jacob mpt_prt(mpt, "Reply Frame Ignored\n"); 461b0a2fdeeSScott Long 462b0a2fdeeSScott Long return (/*free_reply*/TRUE); 463b0a2fdeeSScott Long } 464b0a2fdeeSScott Long 465b0a2fdeeSScott Long static int 466b0a2fdeeSScott Long mpt_config_reply_handler(struct mpt_softc *mpt, request_t *req, 467c87e3f83SMatt Jacob uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 468b0a2fdeeSScott Long { 469b0a2fdeeSScott Long if (req != NULL) { 470b0a2fdeeSScott Long 471b0a2fdeeSScott Long if (reply_frame != NULL) { 472b0a2fdeeSScott Long MSG_CONFIG *cfgp; 473b0a2fdeeSScott Long MSG_CONFIG_REPLY *reply; 474b0a2fdeeSScott Long 475b0a2fdeeSScott Long cfgp = (MSG_CONFIG *)req->req_vbuf; 476b0a2fdeeSScott Long reply = (MSG_CONFIG_REPLY *)reply_frame; 477b0a2fdeeSScott Long req->IOCStatus = le16toh(reply_frame->IOCStatus); 478b0a2fdeeSScott Long bcopy(&reply->Header, &cfgp->Header, 479b0a2fdeeSScott Long sizeof(cfgp->Header)); 480b0a2fdeeSScott Long } 481b0a2fdeeSScott Long req->state &= ~REQ_STATE_QUEUED; 482b0a2fdeeSScott Long req->state |= REQ_STATE_DONE; 483b0a2fdeeSScott Long TAILQ_REMOVE(&mpt->request_pending_list, req, links); 4845e073106SMatt Jacob if ((req->state & REQ_STATE_NEED_WAKEUP) != 0) { 485b0a2fdeeSScott Long wakeup(req); 486b0a2fdeeSScott Long } 4875e073106SMatt Jacob } 488b0a2fdeeSScott Long 4895e073106SMatt Jacob return (TRUE); 490b0a2fdeeSScott Long } 491b0a2fdeeSScott Long 492b0a2fdeeSScott Long static int 493b0a2fdeeSScott Long mpt_handshake_reply_handler(struct mpt_softc *mpt, request_t *req, 494c87e3f83SMatt Jacob uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 495b0a2fdeeSScott Long { 496b0a2fdeeSScott Long /* Nothing to be done. */ 4975e073106SMatt Jacob return (TRUE); 498b0a2fdeeSScott Long } 499b0a2fdeeSScott Long 500b0a2fdeeSScott Long static int 501b0a2fdeeSScott Long mpt_event_reply_handler(struct mpt_softc *mpt, request_t *req, 502c87e3f83SMatt Jacob uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 503b0a2fdeeSScott Long { 504b0a2fdeeSScott Long int free_reply; 505b0a2fdeeSScott Long 5065e073106SMatt Jacob KASSERT(reply_frame != NULL, ("null reply in mpt_event_reply_handler")); 5075e073106SMatt Jacob KASSERT(req != NULL, ("null request in mpt_event_reply_handler")); 508b0a2fdeeSScott Long 509b0a2fdeeSScott Long free_reply = TRUE; 510b0a2fdeeSScott Long switch (reply_frame->Function) { 511b0a2fdeeSScott Long case MPI_FUNCTION_EVENT_NOTIFICATION: 512b0a2fdeeSScott Long { 513b0a2fdeeSScott Long MSG_EVENT_NOTIFY_REPLY *msg; 514b0a2fdeeSScott Long struct mpt_personality *pers; 515b0a2fdeeSScott Long u_int handled; 516b0a2fdeeSScott Long 517b0a2fdeeSScott Long handled = 0; 518b0a2fdeeSScott Long msg = (MSG_EVENT_NOTIFY_REPLY *)reply_frame; 519b0a2fdeeSScott Long MPT_PERS_FOREACH(mpt, pers) 520b0a2fdeeSScott Long handled += pers->event(mpt, req, msg); 521b0a2fdeeSScott Long 522444dd2b6SMatt Jacob if (handled == 0 && mpt->mpt_pers_mask == 0) { 5231977cbd6SMatt Jacob mpt_lprt(mpt, MPT_PRT_INFO, 524444dd2b6SMatt Jacob "No Handlers For Any Event Notify Frames. " 525444dd2b6SMatt Jacob "Event %#x (ACK %sequired).\n", 526444dd2b6SMatt Jacob msg->Event, msg->AckRequired? "r" : "not r"); 527444dd2b6SMatt Jacob } else if (handled == 0) { 5281977cbd6SMatt Jacob mpt_lprt(mpt, MPT_PRT_WARN, 529444dd2b6SMatt Jacob "Unhandled Event Notify Frame. Event %#x " 530444dd2b6SMatt Jacob "(ACK %sequired).\n", 531444dd2b6SMatt Jacob msg->Event, msg->AckRequired? "r" : "not r"); 532444dd2b6SMatt Jacob } 533b0a2fdeeSScott Long 534b0a2fdeeSScott Long if (msg->AckRequired) { 535b0a2fdeeSScott Long request_t *ack_req; 536b0a2fdeeSScott Long uint32_t context; 537b0a2fdeeSScott Long 538b0a2fdeeSScott Long context = htole32(req->index|MPT_REPLY_HANDLER_EVENTS); 5395e073106SMatt Jacob ack_req = mpt_get_request(mpt, FALSE); 540b0a2fdeeSScott Long if (ack_req == NULL) { 541b0a2fdeeSScott Long struct mpt_evtf_record *evtf; 542b0a2fdeeSScott Long 543b0a2fdeeSScott Long evtf = (struct mpt_evtf_record *)reply_frame; 544b0a2fdeeSScott Long evtf->context = context; 545b0a2fdeeSScott Long LIST_INSERT_HEAD(&mpt->ack_frames, evtf, links); 546b0a2fdeeSScott Long free_reply = FALSE; 547b0a2fdeeSScott Long break; 548b0a2fdeeSScott Long } 549b0a2fdeeSScott Long mpt_send_event_ack(mpt, ack_req, msg, context); 5505e073106SMatt Jacob /* 5515e073106SMatt Jacob * Don't check for CONTINUATION_REPLY here 5525e073106SMatt Jacob */ 5535e073106SMatt Jacob return (free_reply); 554b0a2fdeeSScott Long } 555b0a2fdeeSScott Long break; 556b0a2fdeeSScott Long } 557b0a2fdeeSScott Long case MPI_FUNCTION_PORT_ENABLE: 558b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG , "enable port reply\n"); 559b0a2fdeeSScott Long break; 560b0a2fdeeSScott Long case MPI_FUNCTION_EVENT_ACK: 561b0a2fdeeSScott Long break; 562b0a2fdeeSScott Long default: 5635e073106SMatt Jacob mpt_prt(mpt, "unknown event function: %x\n", 564b0a2fdeeSScott Long reply_frame->Function); 565b0a2fdeeSScott Long break; 566b0a2fdeeSScott Long } 567b0a2fdeeSScott Long 5685e073106SMatt Jacob /* 5695e073106SMatt Jacob * I'm not sure that this continuation stuff works as it should. 5705e073106SMatt Jacob * 5715e073106SMatt Jacob * I've had FC async events occur that free the frame up because 5725e073106SMatt Jacob * the continuation bit isn't set, and then additional async events 5735e073106SMatt Jacob * then occur using the same context. As you might imagine, this 5745e073106SMatt Jacob * leads to Very Bad Thing. 5755e073106SMatt Jacob * 5765e073106SMatt Jacob * Let's just be safe for now and not free them up until we figure 5775e073106SMatt Jacob * out what's actually happening here. 5785e073106SMatt Jacob */ 5795e073106SMatt Jacob #if 0 5805e073106SMatt Jacob if ((reply_frame->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) == 0) { 581b0a2fdeeSScott Long TAILQ_REMOVE(&mpt->request_pending_list, req, links); 582b0a2fdeeSScott Long mpt_free_request(mpt, req); 5835e073106SMatt Jacob mpt_prt(mpt, "event_reply %x for req %p:%u NOT a continuation", 5845e073106SMatt Jacob reply_frame->Function, req, req->serno); 5855e073106SMatt Jacob if (reply_frame->Function == MPI_FUNCTION_EVENT_NOTIFICATION) { 5865e073106SMatt Jacob MSG_EVENT_NOTIFY_REPLY *msg = 5875e073106SMatt Jacob (MSG_EVENT_NOTIFY_REPLY *)reply_frame; 5885e073106SMatt Jacob mpt_prtc(mpt, " Event=0x%x AckReq=%d", 5895e073106SMatt Jacob msg->Event, msg->AckRequired); 590b0a2fdeeSScott Long } 5915e073106SMatt Jacob } else { 5925e073106SMatt Jacob mpt_prt(mpt, "event_reply %x for %p:%u IS a continuation", 5935e073106SMatt Jacob reply_frame->Function, req, req->serno); 5945e073106SMatt Jacob if (reply_frame->Function == MPI_FUNCTION_EVENT_NOTIFICATION) { 5955e073106SMatt Jacob MSG_EVENT_NOTIFY_REPLY *msg = 5965e073106SMatt Jacob (MSG_EVENT_NOTIFY_REPLY *)reply_frame; 5975e073106SMatt Jacob mpt_prtc(mpt, " Event=0x%x AckReq=%d", 5985e073106SMatt Jacob msg->Event, msg->AckRequired); 5995e073106SMatt Jacob } 6005e073106SMatt Jacob mpt_prtc(mpt, "\n"); 6015e073106SMatt Jacob } 6025e073106SMatt Jacob #endif 603b0a2fdeeSScott Long return (free_reply); 604b0a2fdeeSScott Long } 605b0a2fdeeSScott Long 606b0a2fdeeSScott Long /* 607b0a2fdeeSScott Long * Process an asynchronous event from the IOC. 608b0a2fdeeSScott Long */ 609b0a2fdeeSScott Long static int 610b0a2fdeeSScott Long mpt_core_event(struct mpt_softc *mpt, request_t *req, 611b0a2fdeeSScott Long MSG_EVENT_NOTIFY_REPLY *msg) 612b0a2fdeeSScott Long { 613444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_core_event: 0x%x\n", 614444dd2b6SMatt Jacob msg->Event & 0xFF); 615b0a2fdeeSScott Long switch(msg->Event & 0xFF) { 616b0a2fdeeSScott Long case MPI_EVENT_NONE: 617b0a2fdeeSScott Long break; 618b0a2fdeeSScott Long case MPI_EVENT_LOG_DATA: 619b0a2fdeeSScott Long { 620b0a2fdeeSScott Long int i; 621b0a2fdeeSScott Long 622b0a2fdeeSScott Long /* Some error occured that LSI wants logged */ 623b0a2fdeeSScott Long mpt_prt(mpt, "EvtLogData: IOCLogInfo: 0x%08x\n", 624b0a2fdeeSScott Long msg->IOCLogInfo); 625b0a2fdeeSScott Long mpt_prt(mpt, "\tEvtLogData: Event Data:"); 626b0a2fdeeSScott Long for (i = 0; i < msg->EventDataLength; i++) 627b0a2fdeeSScott Long mpt_prtc(mpt, " %08x", msg->Data[i]); 628b0a2fdeeSScott Long mpt_prtc(mpt, "\n"); 629b0a2fdeeSScott Long break; 630b0a2fdeeSScott Long } 631b0a2fdeeSScott Long case MPI_EVENT_EVENT_CHANGE: 632b0a2fdeeSScott Long /* 633b0a2fdeeSScott Long * This is just an acknowledgement 634b0a2fdeeSScott Long * of our mpt_send_event_request. 635b0a2fdeeSScott Long */ 636b0a2fdeeSScott Long break; 637444dd2b6SMatt Jacob case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE: 638444dd2b6SMatt Jacob break; 639b0a2fdeeSScott Long default: 6405e073106SMatt Jacob return (0); 641b0a2fdeeSScott Long break; 642b0a2fdeeSScott Long } 6435e073106SMatt Jacob return (1); 644b0a2fdeeSScott Long } 645b0a2fdeeSScott Long 646b0a2fdeeSScott Long static void 647b0a2fdeeSScott Long mpt_send_event_ack(struct mpt_softc *mpt, request_t *ack_req, 648b0a2fdeeSScott Long MSG_EVENT_NOTIFY_REPLY *msg, uint32_t context) 649b0a2fdeeSScott Long { 650b0a2fdeeSScott Long MSG_EVENT_ACK *ackp; 651b0a2fdeeSScott Long 652b0a2fdeeSScott Long ackp = (MSG_EVENT_ACK *)ack_req->req_vbuf; 6535e073106SMatt Jacob memset(ackp, 0, sizeof (*ackp)); 654b0a2fdeeSScott Long ackp->Function = MPI_FUNCTION_EVENT_ACK; 655b0a2fdeeSScott Long ackp->Event = msg->Event; 656b0a2fdeeSScott Long ackp->EventContext = msg->EventContext; 657b0a2fdeeSScott Long ackp->MsgContext = context; 658b0a2fdeeSScott Long mpt_check_doorbell(mpt); 659b0a2fdeeSScott Long mpt_send_cmd(mpt, ack_req); 660b0a2fdeeSScott Long } 661b0a2fdeeSScott Long 662b0a2fdeeSScott Long /***************************** Interrupt Handling *****************************/ 663b0a2fdeeSScott Long void 664b0a2fdeeSScott Long mpt_intr(void *arg) 665b0a2fdeeSScott Long { 666b0a2fdeeSScott Long struct mpt_softc *mpt; 667b0a2fdeeSScott Long uint32_t reply_desc; 668c87e3f83SMatt Jacob int ntrips = 0; 669b0a2fdeeSScott Long 670b0a2fdeeSScott Long mpt = (struct mpt_softc *)arg; 6715089bd63SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG2, "enter mpt_intr\n"); 672b0a2fdeeSScott Long while ((reply_desc = mpt_pop_reply_queue(mpt)) != MPT_REPLY_EMPTY) { 673b0a2fdeeSScott Long request_t *req; 674b0a2fdeeSScott Long MSG_DEFAULT_REPLY *reply_frame; 675b0a2fdeeSScott Long uint32_t reply_baddr; 676c87e3f83SMatt Jacob uint32_t ctxt_idx; 677b0a2fdeeSScott Long u_int cb_index; 678b0a2fdeeSScott Long u_int req_index; 679b0a2fdeeSScott Long int free_rf; 680b0a2fdeeSScott Long 681b0a2fdeeSScott Long req = NULL; 682b0a2fdeeSScott Long reply_frame = NULL; 683b0a2fdeeSScott Long reply_baddr = 0; 684b0a2fdeeSScott Long if ((reply_desc & MPI_ADDRESS_REPLY_A_BIT) != 0) { 685b0a2fdeeSScott Long u_int offset; 686b0a2fdeeSScott Long /* 687b0a2fdeeSScott Long * Insure that the reply frame is coherent. 688b0a2fdeeSScott Long */ 6895e073106SMatt Jacob reply_baddr = MPT_REPLY_BADDR(reply_desc); 690b0a2fdeeSScott Long offset = reply_baddr - (mpt->reply_phys & 0xFFFFFFFF); 691c87e3f83SMatt Jacob bus_dmamap_sync_range(mpt->reply_dmat, 692c87e3f83SMatt Jacob mpt->reply_dmap, offset, MPT_REPLY_SIZE, 693b0a2fdeeSScott Long BUS_DMASYNC_POSTREAD); 694b0a2fdeeSScott Long reply_frame = MPT_REPLY_OTOV(mpt, offset); 695c87e3f83SMatt Jacob ctxt_idx = le32toh(reply_frame->MsgContext); 696c87e3f83SMatt Jacob } else { 697c87e3f83SMatt Jacob uint32_t type; 698b0a2fdeeSScott Long 699c87e3f83SMatt Jacob type = MPI_GET_CONTEXT_REPLY_TYPE(reply_desc); 700c87e3f83SMatt Jacob ctxt_idx = reply_desc; 701c87e3f83SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG1, "Context Reply: 0x%08x\n", 702c87e3f83SMatt Jacob reply_desc); 703c87e3f83SMatt Jacob 704c87e3f83SMatt Jacob switch (type) { 705c87e3f83SMatt Jacob case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT: 706c87e3f83SMatt Jacob ctxt_idx &= MPI_CONTEXT_REPLY_CONTEXT_MASK; 707c87e3f83SMatt Jacob break; 708c87e3f83SMatt Jacob case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET: 709c87e3f83SMatt Jacob ctxt_idx = GET_IO_INDEX(reply_desc); 710c87e3f83SMatt Jacob if (mpt->tgt_cmd_ptrs == NULL) { 711c87e3f83SMatt Jacob mpt_prt(mpt, 712c87e3f83SMatt Jacob "mpt_intr: no target cmd ptrs\n"); 713c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 714c87e3f83SMatt Jacob break; 715c87e3f83SMatt Jacob } 716c87e3f83SMatt Jacob if (ctxt_idx >= mpt->tgt_cmds_allocated) { 717c87e3f83SMatt Jacob mpt_prt(mpt, 718c87e3f83SMatt Jacob "mpt_intr: bad tgt cmd ctxt %u\n", 719c87e3f83SMatt Jacob ctxt_idx); 720c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 721c87e3f83SMatt Jacob ntrips = 1000; 722c87e3f83SMatt Jacob break; 723c87e3f83SMatt Jacob } 724c87e3f83SMatt Jacob req = mpt->tgt_cmd_ptrs[ctxt_idx]; 725c87e3f83SMatt Jacob if (req == NULL) { 726c87e3f83SMatt Jacob mpt_prt(mpt, "no request backpointer " 727c87e3f83SMatt Jacob "at index %u", ctxt_idx); 728c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 729c87e3f83SMatt Jacob ntrips = 1000; 730c87e3f83SMatt Jacob break; 731c87e3f83SMatt Jacob } 732c87e3f83SMatt Jacob /* 733c87e3f83SMatt Jacob * Reformulate ctxt_idx to be just as if 734c87e3f83SMatt Jacob * it were another type of context reply 735c87e3f83SMatt Jacob * so the code below will find the request 736c87e3f83SMatt Jacob * via indexing into the pool. 737c87e3f83SMatt Jacob */ 738c87e3f83SMatt Jacob ctxt_idx = 739c87e3f83SMatt Jacob req->index | mpt->scsi_tgt_handler_id; 740c87e3f83SMatt Jacob req = NULL; 741c87e3f83SMatt Jacob break; 742c87e3f83SMatt Jacob case MPI_CONTEXT_REPLY_TYPE_LAN: 743c87e3f83SMatt Jacob mpt_prt(mpt, "LAN CONTEXT REPLY: 0x%08x\n", 744c87e3f83SMatt Jacob reply_desc); 745c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 746c87e3f83SMatt Jacob break; 747c87e3f83SMatt Jacob default: 748c87e3f83SMatt Jacob mpt_prt(mpt, "Context Reply 0x%08x?\n", type); 749c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 750c87e3f83SMatt Jacob break; 751c87e3f83SMatt Jacob } 752c87e3f83SMatt Jacob if (reply_desc == MPT_REPLY_EMPTY) { 753c87e3f83SMatt Jacob if (ntrips++ > 1000) { 754c87e3f83SMatt Jacob break; 755c87e3f83SMatt Jacob } 756c87e3f83SMatt Jacob continue; 757c87e3f83SMatt Jacob } 758c87e3f83SMatt Jacob } 759c87e3f83SMatt Jacob 760c87e3f83SMatt Jacob cb_index = MPT_CONTEXT_TO_CBI(ctxt_idx); 761c87e3f83SMatt Jacob req_index = MPT_CONTEXT_TO_REQI(ctxt_idx); 762c87e3f83SMatt Jacob if (req_index < MPT_MAX_REQUESTS(mpt)) { 763c87e3f83SMatt Jacob req = &mpt->request_pool[req_index]; 7645e073106SMatt Jacob } else { 7655e073106SMatt Jacob mpt_prt(mpt, "WARN: mpt_intr index == %d (reply_desc ==" 7665e073106SMatt Jacob " 0x%x)\n", req_index, reply_desc); 767c87e3f83SMatt Jacob } 768c87e3f83SMatt Jacob 769c87e3f83SMatt Jacob free_rf = mpt_reply_handlers[cb_index](mpt, req, 770c87e3f83SMatt Jacob reply_desc, reply_frame); 771b0a2fdeeSScott Long 7725e073106SMatt Jacob if (reply_frame != NULL && free_rf) { 773b0a2fdeeSScott Long mpt_free_reply(mpt, reply_baddr); 7745e073106SMatt Jacob } 775c87e3f83SMatt Jacob 776c87e3f83SMatt Jacob /* 777c87e3f83SMatt Jacob * If we got ourselves disabled, don't get stuck in a loop 778c87e3f83SMatt Jacob */ 779c87e3f83SMatt Jacob if (mpt->disabled) { 780c87e3f83SMatt Jacob mpt_disable_ints(mpt); 781c87e3f83SMatt Jacob break; 782c87e3f83SMatt Jacob } 783c87e3f83SMatt Jacob if (ntrips++ > 1000) { 784c87e3f83SMatt Jacob break; 785c87e3f83SMatt Jacob } 786b0a2fdeeSScott Long } 7875089bd63SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG2, "exit mpt_intr\n"); 788b0a2fdeeSScott Long } 789b0a2fdeeSScott Long 790b0a2fdeeSScott Long /******************************* Error Recovery *******************************/ 791b0a2fdeeSScott Long void 792b0a2fdeeSScott Long mpt_complete_request_chain(struct mpt_softc *mpt, struct req_queue *chain, 793b0a2fdeeSScott Long u_int iocstatus) 794b0a2fdeeSScott Long { 795b0a2fdeeSScott Long MSG_DEFAULT_REPLY ioc_status_frame; 796b0a2fdeeSScott Long request_t *req; 797b0a2fdeeSScott Long 7985e073106SMatt Jacob memset(&ioc_status_frame, 0, sizeof(ioc_status_frame)); 799b0a2fdeeSScott Long ioc_status_frame.MsgLength = roundup2(sizeof(ioc_status_frame), 4); 800b0a2fdeeSScott Long ioc_status_frame.IOCStatus = iocstatus; 801b0a2fdeeSScott Long while((req = TAILQ_FIRST(chain)) != NULL) { 802b0a2fdeeSScott Long MSG_REQUEST_HEADER *msg_hdr; 803b0a2fdeeSScott Long u_int cb_index; 8045e073106SMatt Jacob 8059b7de735SMatt Jacob TAILQ_REMOVE(chain, req, links); 806b0a2fdeeSScott Long msg_hdr = (MSG_REQUEST_HEADER *)req->req_vbuf; 807b0a2fdeeSScott Long ioc_status_frame.Function = msg_hdr->Function; 808b0a2fdeeSScott Long ioc_status_frame.MsgContext = msg_hdr->MsgContext; 809b0a2fdeeSScott Long cb_index = MPT_CONTEXT_TO_CBI(le32toh(msg_hdr->MsgContext)); 810c87e3f83SMatt Jacob mpt_reply_handlers[cb_index](mpt, req, msg_hdr->MsgContext, 811c87e3f83SMatt Jacob &ioc_status_frame); 812b0a2fdeeSScott Long } 813b0a2fdeeSScott Long } 814b0a2fdeeSScott Long 815b0a2fdeeSScott Long /********************************* Diagnostics ********************************/ 816b0a2fdeeSScott Long /* 817b0a2fdeeSScott Long * Perform a diagnostic dump of a reply frame. 818b0a2fdeeSScott Long */ 819b0a2fdeeSScott Long void 820b0a2fdeeSScott Long mpt_dump_reply_frame(struct mpt_softc *mpt, MSG_DEFAULT_REPLY *reply_frame) 821b0a2fdeeSScott Long { 822b0a2fdeeSScott Long mpt_prt(mpt, "Address Reply:\n"); 823b0a2fdeeSScott Long mpt_print_reply(reply_frame); 824b0a2fdeeSScott Long } 825b0a2fdeeSScott Long 826b0a2fdeeSScott Long /******************************* Doorbell Access ******************************/ 827b0a2fdeeSScott Long static __inline uint32_t mpt_rd_db(struct mpt_softc *mpt); 828b0a2fdeeSScott Long static __inline uint32_t mpt_rd_intr(struct mpt_softc *mpt); 829b0a2fdeeSScott Long 830b0a2fdeeSScott Long static __inline uint32_t 831b0a2fdeeSScott Long mpt_rd_db(struct mpt_softc *mpt) 8329b631363SMatt Jacob { 8339b631363SMatt Jacob return mpt_read(mpt, MPT_OFFSET_DOORBELL); 8349b631363SMatt Jacob } 8359b631363SMatt Jacob 836b0a2fdeeSScott Long static __inline uint32_t 837b0a2fdeeSScott Long mpt_rd_intr(struct mpt_softc *mpt) 8389b631363SMatt Jacob { 8399b631363SMatt Jacob return mpt_read(mpt, MPT_OFFSET_INTR_STATUS); 8409b631363SMatt Jacob } 8419b631363SMatt Jacob 8429b631363SMatt Jacob /* Busy wait for a door bell to be read by IOC */ 8439b631363SMatt Jacob static int 844b0a2fdeeSScott Long mpt_wait_db_ack(struct mpt_softc *mpt) 8459b631363SMatt Jacob { 8469b631363SMatt Jacob int i; 8479b631363SMatt Jacob for (i=0; i < MPT_MAX_WAIT; i++) { 8489b631363SMatt Jacob if (!MPT_DB_IS_BUSY(mpt_rd_intr(mpt))) { 8499b631363SMatt Jacob maxwait_ack = i > maxwait_ack ? i : maxwait_ack; 850c87e3f83SMatt Jacob return (MPT_OK); 8519b631363SMatt Jacob } 852c87e3f83SMatt Jacob DELAY(200); 8539b631363SMatt Jacob } 854c87e3f83SMatt Jacob return (MPT_FAIL); 8559b631363SMatt Jacob } 8569b631363SMatt Jacob 8579b631363SMatt Jacob /* Busy wait for a door bell interrupt */ 8589b631363SMatt Jacob static int 859b0a2fdeeSScott Long mpt_wait_db_int(struct mpt_softc *mpt) 8609b631363SMatt Jacob { 8619b631363SMatt Jacob int i; 8629b631363SMatt Jacob for (i=0; i < MPT_MAX_WAIT; i++) { 8639b631363SMatt Jacob if (MPT_DB_INTR(mpt_rd_intr(mpt))) { 8649b631363SMatt Jacob maxwait_int = i > maxwait_int ? i : maxwait_int; 8659b631363SMatt Jacob return MPT_OK; 8669b631363SMatt Jacob } 8679b631363SMatt Jacob DELAY(100); 8689b631363SMatt Jacob } 869c87e3f83SMatt Jacob return (MPT_FAIL); 8709b631363SMatt Jacob } 8719b631363SMatt Jacob 8729b631363SMatt Jacob /* Wait for IOC to transition to a give state */ 8739b631363SMatt Jacob void 874b0a2fdeeSScott Long mpt_check_doorbell(struct mpt_softc *mpt) 8759b631363SMatt Jacob { 876b0a2fdeeSScott Long uint32_t db = mpt_rd_db(mpt); 8779b631363SMatt Jacob if (MPT_STATE(db) != MPT_DB_STATE_RUNNING) { 878b0a2fdeeSScott Long mpt_prt(mpt, "Device not running\n"); 8799b631363SMatt Jacob mpt_print_db(db); 8809b631363SMatt Jacob } 8819b631363SMatt Jacob } 8829b631363SMatt Jacob 8839b631363SMatt Jacob /* Wait for IOC to transition to a give state */ 8849b631363SMatt Jacob static int 885b0a2fdeeSScott Long mpt_wait_state(struct mpt_softc *mpt, enum DB_STATE_BITS state) 8869b631363SMatt Jacob { 8879b631363SMatt Jacob int i; 8889b631363SMatt Jacob 8899b631363SMatt Jacob for (i = 0; i < MPT_MAX_WAIT; i++) { 890b0a2fdeeSScott Long uint32_t db = mpt_rd_db(mpt); 8919b631363SMatt Jacob if (MPT_STATE(db) == state) { 8929b631363SMatt Jacob maxwait_state = i > maxwait_state ? i : maxwait_state; 8939b631363SMatt Jacob return (MPT_OK); 8949b631363SMatt Jacob } 8959b631363SMatt Jacob DELAY(100); 8969b631363SMatt Jacob } 8979b631363SMatt Jacob return (MPT_FAIL); 8989b631363SMatt Jacob } 8999b631363SMatt Jacob 9009b631363SMatt Jacob 901b0a2fdeeSScott Long /************************* Intialization/Configuration ************************/ 902b0a2fdeeSScott Long static int mpt_download_fw(struct mpt_softc *mpt); 903b0a2fdeeSScott Long 9049b631363SMatt Jacob /* Issue the reset COMMAND to the IOC */ 905b0a2fdeeSScott Long static int 906b0a2fdeeSScott Long mpt_soft_reset(struct mpt_softc *mpt) 9079b631363SMatt Jacob { 908b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "soft reset\n"); 9099b631363SMatt Jacob 9109b631363SMatt Jacob /* Have to use hard reset if we are not in Running state */ 9119b631363SMatt Jacob if (MPT_STATE(mpt_rd_db(mpt)) != MPT_DB_STATE_RUNNING) { 912b0a2fdeeSScott Long mpt_prt(mpt, "soft reset failed: device not running\n"); 913c87e3f83SMatt Jacob return (MPT_FAIL); 9149b631363SMatt Jacob } 9159b631363SMatt Jacob 9169b631363SMatt Jacob /* If door bell is in use we don't have a chance of getting 9179b631363SMatt Jacob * a word in since the IOC probably crashed in message 9189b631363SMatt Jacob * processing. So don't waste our time. 9199b631363SMatt Jacob */ 9209b631363SMatt Jacob if (MPT_DB_IS_IN_USE(mpt_rd_db(mpt))) { 921b0a2fdeeSScott Long mpt_prt(mpt, "soft reset failed: doorbell wedged\n"); 922c87e3f83SMatt Jacob return (MPT_FAIL); 9239b631363SMatt Jacob } 9249b631363SMatt Jacob 9259b631363SMatt Jacob /* Send the reset request to the IOC */ 9269b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_DOORBELL, 9279b631363SMatt Jacob MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET << MPI_DOORBELL_FUNCTION_SHIFT); 9289b631363SMatt Jacob if (mpt_wait_db_ack(mpt) != MPT_OK) { 929b0a2fdeeSScott Long mpt_prt(mpt, "soft reset failed: ack timeout\n"); 930c87e3f83SMatt Jacob return (MPT_FAIL); 9319b631363SMatt Jacob } 9329b631363SMatt Jacob 9339b631363SMatt Jacob /* Wait for the IOC to reload and come out of reset state */ 9349b631363SMatt Jacob if (mpt_wait_state(mpt, MPT_DB_STATE_READY) != MPT_OK) { 935b0a2fdeeSScott Long mpt_prt(mpt, "soft reset failed: device did not restart\n"); 936c87e3f83SMatt Jacob return (MPT_FAIL); 9379b631363SMatt Jacob } 9389b631363SMatt Jacob 9399b631363SMatt Jacob return MPT_OK; 9409b631363SMatt Jacob } 9419b631363SMatt Jacob 942b0a2fdeeSScott Long static int 943b0a2fdeeSScott Long mpt_enable_diag_mode(struct mpt_softc *mpt) 944b0a2fdeeSScott Long { 945b0a2fdeeSScott Long int try; 946b0a2fdeeSScott Long 947b0a2fdeeSScott Long try = 20; 948b0a2fdeeSScott Long while (--try) { 949b0a2fdeeSScott Long 950b0a2fdeeSScott Long if ((mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC) & MPI_DIAG_DRWE) != 0) 951b0a2fdeeSScott Long break; 952b0a2fdeeSScott Long 953b0a2fdeeSScott Long /* Enable diagnostic registers */ 954b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFF); 955b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_1ST_KEY_VALUE); 956b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_2ND_KEY_VALUE); 957b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_3RD_KEY_VALUE); 958b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_4TH_KEY_VALUE); 959b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_5TH_KEY_VALUE); 960b0a2fdeeSScott Long 961b0a2fdeeSScott Long DELAY(100000); 962b0a2fdeeSScott Long } 963b0a2fdeeSScott Long if (try == 0) 964b0a2fdeeSScott Long return (EIO); 965b0a2fdeeSScott Long return (0); 966b0a2fdeeSScott Long } 967b0a2fdeeSScott Long 968b0a2fdeeSScott Long static void 969b0a2fdeeSScott Long mpt_disable_diag_mode(struct mpt_softc *mpt) 970b0a2fdeeSScott Long { 971b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFFFFFFFF); 972b0a2fdeeSScott Long } 973b0a2fdeeSScott Long 9749b631363SMatt Jacob /* This is a magic diagnostic reset that resets all the ARM 9759b631363SMatt Jacob * processors in the chip. 9769b631363SMatt Jacob */ 977b0a2fdeeSScott Long static void 978b0a2fdeeSScott Long mpt_hard_reset(struct mpt_softc *mpt) 9799b631363SMatt Jacob { 980b0a2fdeeSScott Long int error; 981b0a2fdeeSScott Long int wait; 982b0a2fdeeSScott Long uint32_t diagreg; 9839b631363SMatt Jacob 984b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "hard reset\n"); 985b0a2fdeeSScott Long 986b0a2fdeeSScott Long error = mpt_enable_diag_mode(mpt); 987b0a2fdeeSScott Long if (error) { 988b0a2fdeeSScott Long mpt_prt(mpt, "WARNING - Could not enter diagnostic mode !\n"); 989b0a2fdeeSScott Long mpt_prt(mpt, "Trying to reset anyway.\n"); 990b0a2fdeeSScott Long } 991b0a2fdeeSScott Long 992b0a2fdeeSScott Long diagreg = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC); 993b0a2fdeeSScott Long 994b0a2fdeeSScott Long /* 995b0a2fdeeSScott Long * This appears to be a workaround required for some 996b0a2fdeeSScott Long * firmware or hardware revs. 997b0a2fdeeSScott Long */ 998b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, diagreg | MPI_DIAG_DISABLE_ARM); 999b0a2fdeeSScott Long DELAY(1000); 10009b631363SMatt Jacob 10019b631363SMatt Jacob /* Diag. port is now active so we can now hit the reset bit */ 1002b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, diagreg | MPI_DIAG_RESET_ADAPTER); 10039b631363SMatt Jacob 1004b0a2fdeeSScott Long /* 1005b0a2fdeeSScott Long * Ensure that the reset has finished. We delay 1ms 1006b0a2fdeeSScott Long * prior to reading the register to make sure the chip 1007b0a2fdeeSScott Long * has sufficiently completed its reset to handle register 1008b0a2fdeeSScott Long * accesses. 1009b0a2fdeeSScott Long */ 1010b0a2fdeeSScott Long wait = 5000; 1011b0a2fdeeSScott Long do { 1012b0a2fdeeSScott Long DELAY(1000); 1013b0a2fdeeSScott Long diagreg = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC); 1014b0a2fdeeSScott Long } while (--wait && (diagreg & MPI_DIAG_RESET_ADAPTER) == 0); 10159b631363SMatt Jacob 1016b0a2fdeeSScott Long if (wait == 0) { 1017b0a2fdeeSScott Long mpt_prt(mpt, "WARNING - Failed hard reset! " 1018b0a2fdeeSScott Long "Trying to initialize anyway.\n"); 10199b631363SMatt Jacob } 10209b631363SMatt Jacob 1021b0a2fdeeSScott Long /* 1022b0a2fdeeSScott Long * If we have firmware to download, it must be loaded before 1023b0a2fdeeSScott Long * the controller will become operational. Do so now. 1024b0a2fdeeSScott Long */ 1025b0a2fdeeSScott Long if (mpt->fw_image != NULL) { 1026b0a2fdeeSScott Long 1027b0a2fdeeSScott Long error = mpt_download_fw(mpt); 1028b0a2fdeeSScott Long 1029b0a2fdeeSScott Long if (error) { 1030b0a2fdeeSScott Long mpt_prt(mpt, "WARNING - Firmware Download Failed!\n"); 1031b0a2fdeeSScott Long mpt_prt(mpt, "Trying to initialize anyway.\n"); 10329b631363SMatt Jacob } 1033b0a2fdeeSScott Long } 1034b0a2fdeeSScott Long 1035b0a2fdeeSScott Long /* 1036b0a2fdeeSScott Long * Reseting the controller should have disabled write 1037b0a2fdeeSScott Long * access to the diagnostic registers, but disable 1038b0a2fdeeSScott Long * manually to be sure. 1039b0a2fdeeSScott Long */ 1040b0a2fdeeSScott Long mpt_disable_diag_mode(mpt); 1041b0a2fdeeSScott Long } 1042b0a2fdeeSScott Long 1043b0a2fdeeSScott Long static void 1044b0a2fdeeSScott Long mpt_core_ioc_reset(struct mpt_softc *mpt, int type) 1045b0a2fdeeSScott Long { 1046b0a2fdeeSScott Long /* 1047b0a2fdeeSScott Long * Complete all pending requests with a status 1048b0a2fdeeSScott Long * appropriate for an IOC reset. 1049b0a2fdeeSScott Long */ 1050b0a2fdeeSScott Long mpt_complete_request_chain(mpt, &mpt->request_pending_list, 1051b0a2fdeeSScott Long MPI_IOCSTATUS_INVALID_STATE); 1052b0a2fdeeSScott Long } 1053b0a2fdeeSScott Long 10549b631363SMatt Jacob 10559b631363SMatt Jacob /* 10569b631363SMatt Jacob * Reset the IOC when needed. Try software command first then if needed 10579b631363SMatt Jacob * poke at the magic diagnostic reset. Note that a hard reset resets 10589b631363SMatt Jacob * *both* IOCs on dual function chips (FC929 && LSI1030) as well as 10599b631363SMatt Jacob * fouls up the PCI configuration registers. 10609b631363SMatt Jacob */ 10619b631363SMatt Jacob int 1062b0a2fdeeSScott Long mpt_reset(struct mpt_softc *mpt, int reinit) 10639b631363SMatt Jacob { 1064b0a2fdeeSScott Long struct mpt_personality *pers; 10659b631363SMatt Jacob int ret; 106629ae59edSMatt Jacob int retry_cnt = 0; 10679b631363SMatt Jacob 106829ae59edSMatt Jacob /* 106929ae59edSMatt Jacob * Try a soft reset. If that fails, get out the big hammer. 107029ae59edSMatt Jacob */ 107129ae59edSMatt Jacob again: 10729b631363SMatt Jacob if ((ret = mpt_soft_reset(mpt)) != MPT_OK) { 107329ae59edSMatt Jacob int cnt; 107429ae59edSMatt Jacob for (cnt = 0; cnt < 5; cnt++) { 10759b631363SMatt Jacob /* Failed; do a hard reset */ 10769b631363SMatt Jacob mpt_hard_reset(mpt); 10779b631363SMatt Jacob 107829ae59edSMatt Jacob /* 107929ae59edSMatt Jacob * Wait for the IOC to reload 108029ae59edSMatt Jacob * and come out of reset state 108129ae59edSMatt Jacob */ 10829b631363SMatt Jacob ret = mpt_wait_state(mpt, MPT_DB_STATE_READY); 108329ae59edSMatt Jacob if (ret == MPT_OK) { 108429ae59edSMatt Jacob break; 108529ae59edSMatt Jacob } 108629ae59edSMatt Jacob /* 108729ae59edSMatt Jacob * Okay- try to check again... 108829ae59edSMatt Jacob */ 108929ae59edSMatt Jacob ret = mpt_wait_state(mpt, MPT_DB_STATE_READY); 109029ae59edSMatt Jacob if (ret == MPT_OK) { 109129ae59edSMatt Jacob break; 109229ae59edSMatt Jacob } 109329ae59edSMatt Jacob mpt_prt(mpt, "mpt_reset: failed hard reset (%d:%d)\n", 109429ae59edSMatt Jacob retry_cnt, cnt); 109529ae59edSMatt Jacob } 10969b631363SMatt Jacob } 1097b0a2fdeeSScott Long 109829ae59edSMatt Jacob if (retry_cnt == 0) { 1099b0a2fdeeSScott Long /* 1100b0a2fdeeSScott Long * Invoke reset handlers. We bump the reset count so 1101b0a2fdeeSScott Long * that mpt_wait_req() understands that regardless of 1102b0a2fdeeSScott Long * the specified wait condition, it should stop its wait. 1103b0a2fdeeSScott Long */ 1104b0a2fdeeSScott Long mpt->reset_cnt++; 1105b0a2fdeeSScott Long MPT_PERS_FOREACH(mpt, pers) 1106b0a2fdeeSScott Long pers->reset(mpt, ret); 110729ae59edSMatt Jacob } 1108b0a2fdeeSScott Long 11095e073106SMatt Jacob if (reinit) { 1110c87e3f83SMatt Jacob ret = mpt_enable_ioc(mpt, 1); 111129ae59edSMatt Jacob if (ret == MPT_OK) { 111229ae59edSMatt Jacob mpt_enable_ints(mpt); 111329ae59edSMatt Jacob } 111429ae59edSMatt Jacob } 111529ae59edSMatt Jacob if (ret != MPT_OK && retry_cnt++ < 2) { 111629ae59edSMatt Jacob goto again; 111729ae59edSMatt Jacob } 11189b631363SMatt Jacob return ret; 11199b631363SMatt Jacob } 11209b631363SMatt Jacob 11219b631363SMatt Jacob /* Return a command buffer to the free queue */ 11229b631363SMatt Jacob void 1123b0a2fdeeSScott Long mpt_free_request(struct mpt_softc *mpt, request_t *req) 11249b631363SMatt Jacob { 1125444dd2b6SMatt Jacob request_t *nxt; 1126b0a2fdeeSScott Long struct mpt_evtf_record *record; 1127b0a2fdeeSScott Long uint32_t reply_baddr; 1128b0a2fdeeSScott Long 11297dec90bcSMatt Jacob if (req == NULL || req != &mpt->request_pool[req->index]) { 11309b631363SMatt Jacob panic("mpt_free_request bad req ptr\n"); 11319b631363SMatt Jacob return; 11329b631363SMatt Jacob } 1133444dd2b6SMatt Jacob if ((nxt = req->chain) != NULL) { 1134444dd2b6SMatt Jacob req->chain = NULL; 1135444dd2b6SMatt Jacob mpt_free_request(mpt, nxt); /* NB: recursion */ 1136444dd2b6SMatt Jacob } 11375e073106SMatt Jacob KASSERT(req->state != REQ_STATE_FREE, ("freeing free request")); 11385e073106SMatt Jacob KASSERT(!(req->state & REQ_STATE_LOCKED), ("freeing locked request")); 11395089bd63SMatt Jacob KASSERT(MPT_OWNED(mpt), ("mpt_free_request: mpt not locked\n")); 11405089bd63SMatt Jacob KASSERT(mpt_req_on_free_list(mpt, req) == 0, 11415089bd63SMatt Jacob ("mpt_free_request: req %p:%u func %x already on freelist", 11425089bd63SMatt Jacob req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 11435089bd63SMatt Jacob KASSERT(mpt_req_on_pending_list(mpt, req) == 0, 11445089bd63SMatt Jacob ("mpt_free_request: req %p:%u func %x on pending list", 11455089bd63SMatt Jacob req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 11465089bd63SMatt Jacob #ifdef INVARIANTS 11475089bd63SMatt Jacob mpt_req_not_spcl(mpt, req, "mpt_free_request", __LINE__); 11485089bd63SMatt Jacob #endif 11495e073106SMatt Jacob 11509b631363SMatt Jacob req->ccb = NULL; 1151b0a2fdeeSScott Long if (LIST_EMPTY(&mpt->ack_frames)) { 1152c87e3f83SMatt Jacob /* 1153c87e3f83SMatt Jacob * Insert free ones at the tail 1154c87e3f83SMatt Jacob */ 11555e073106SMatt Jacob req->serno = 0; 11565e073106SMatt Jacob req->state = REQ_STATE_FREE; 11575089bd63SMatt Jacob #ifdef INVARIANTS 11585089bd63SMatt Jacob memset(req->req_vbuf, 0xff, sizeof (MSG_REQUEST_HEADER)); 11595089bd63SMatt Jacob #endif 1160c87e3f83SMatt Jacob TAILQ_INSERT_TAIL(&mpt->request_free_list, req, links); 1161b0a2fdeeSScott Long if (mpt->getreqwaiter != 0) { 1162b0a2fdeeSScott Long mpt->getreqwaiter = 0; 1163b0a2fdeeSScott Long wakeup(&mpt->request_free_list); 1164b0a2fdeeSScott Long } 1165b0a2fdeeSScott Long return; 1166b0a2fdeeSScott Long } 1167b0a2fdeeSScott Long 1168b0a2fdeeSScott Long /* 1169b0a2fdeeSScott Long * Process an ack frame deferred due to resource shortage. 1170b0a2fdeeSScott Long */ 1171b0a2fdeeSScott Long record = LIST_FIRST(&mpt->ack_frames); 1172b0a2fdeeSScott Long LIST_REMOVE(record, links); 11735e073106SMatt Jacob req->state = REQ_STATE_ALLOCATED; 11745089bd63SMatt Jacob mpt_assign_serno(mpt, req); 1175b0a2fdeeSScott Long mpt_send_event_ack(mpt, req, &record->reply, record->context); 1176b0a2fdeeSScott Long reply_baddr = (uint32_t)((uint8_t *)record - mpt->reply) 1177b0a2fdeeSScott Long + (mpt->reply_phys & 0xFFFFFFFF); 1178b0a2fdeeSScott Long mpt_free_reply(mpt, reply_baddr); 11799b631363SMatt Jacob } 11809b631363SMatt Jacob 11819b631363SMatt Jacob /* Get a command buffer from the free queue */ 11829b631363SMatt Jacob request_t * 1183b0a2fdeeSScott Long mpt_get_request(struct mpt_softc *mpt, int sleep_ok) 11849b631363SMatt Jacob { 11859b631363SMatt Jacob request_t *req; 1186b0a2fdeeSScott Long 1187b0a2fdeeSScott Long retry: 11885089bd63SMatt Jacob KASSERT(MPT_OWNED(mpt), ("mpt_get_request: mpt not locked\n")); 1189b0a2fdeeSScott Long req = TAILQ_FIRST(&mpt->request_free_list); 11909b631363SMatt Jacob if (req != NULL) { 1191b0a2fdeeSScott Long KASSERT(req == &mpt->request_pool[req->index], 1192b0a2fdeeSScott Long ("mpt_get_request: corrupted request free list\n")); 11935e073106SMatt Jacob KASSERT(req->state == REQ_STATE_FREE, 11945089bd63SMatt Jacob ("req %p:%u not free on free list %x index %d function %x", 11955089bd63SMatt Jacob req, req->serno, req->state, req->index, 11965089bd63SMatt Jacob ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 1197b0a2fdeeSScott Long TAILQ_REMOVE(&mpt->request_free_list, req, links); 1198b0a2fdeeSScott Long req->state = REQ_STATE_ALLOCATED; 1199444dd2b6SMatt Jacob req->chain = NULL; 12005089bd63SMatt Jacob mpt_assign_serno(mpt, req); 1201b0a2fdeeSScott Long } else if (sleep_ok != 0) { 1202b0a2fdeeSScott Long mpt->getreqwaiter = 1; 1203b0a2fdeeSScott Long mpt_sleep(mpt, &mpt->request_free_list, PUSER, "mptgreq", 0); 1204b0a2fdeeSScott Long goto retry; 12059b631363SMatt Jacob } 12065e073106SMatt Jacob return (req); 12079b631363SMatt Jacob } 12089b631363SMatt Jacob 12099b631363SMatt Jacob /* Pass the command to the IOC */ 12109b631363SMatt Jacob void 1211b0a2fdeeSScott Long mpt_send_cmd(struct mpt_softc *mpt, request_t *req) 12129b631363SMatt Jacob { 12131d79ca0eSMatt Jacob if (mpt->verbose > MPT_PRT_DEBUG2) { 12141043516dSMatt Jacob mpt_dump_request(mpt, req); 1215444dd2b6SMatt Jacob } 12169b631363SMatt Jacob bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap, 12179b631363SMatt Jacob BUS_DMASYNC_PREWRITE); 1218b0a2fdeeSScott Long req->state |= REQ_STATE_QUEUED; 12195089bd63SMatt Jacob KASSERT(mpt_req_on_free_list(mpt, req) == 0, 12205089bd63SMatt Jacob ("req %p:%u func %x on freelist list in mpt_send_cmd", 12215089bd63SMatt Jacob req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 12225089bd63SMatt Jacob KASSERT(mpt_req_on_pending_list(mpt, req) == 0, 12235089bd63SMatt Jacob ("req %p:%u func %x already on pending list in mpt_send_cmd", 12245089bd63SMatt Jacob req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 1225b0a2fdeeSScott Long TAILQ_INSERT_HEAD(&mpt->request_pending_list, req, links); 1226b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_REQUEST_Q, (uint32_t) req->req_pbuf); 12279b631363SMatt Jacob } 12289b631363SMatt Jacob 12299b631363SMatt Jacob /* 1230b0a2fdeeSScott Long * Wait for a request to complete. 1231b0a2fdeeSScott Long * 1232b0a2fdeeSScott Long * Inputs: 1233b0a2fdeeSScott Long * mpt softc of controller executing request 1234b0a2fdeeSScott Long * req request to wait for 1235b0a2fdeeSScott Long * sleep_ok nonzero implies may sleep in this context 1236b0a2fdeeSScott Long * time_ms timeout in ms. 0 implies no timeout. 1237b0a2fdeeSScott Long * 1238b0a2fdeeSScott Long * Return Values: 1239b0a2fdeeSScott Long * 0 Request completed 1240b0a2fdeeSScott Long * non-0 Timeout fired before request completion. 12419b631363SMatt Jacob */ 1242b0a2fdeeSScott Long int 1243b0a2fdeeSScott Long mpt_wait_req(struct mpt_softc *mpt, request_t *req, 1244b0a2fdeeSScott Long mpt_req_state_t state, mpt_req_state_t mask, 1245b0a2fdeeSScott Long int sleep_ok, int time_ms) 12469b631363SMatt Jacob { 1247b0a2fdeeSScott Long int error; 1248b0a2fdeeSScott Long int timeout; 1249b0a2fdeeSScott Long u_int saved_cnt; 12509b631363SMatt Jacob 1251b0a2fdeeSScott Long /* 1252b0a2fdeeSScott Long * timeout is in ms. 0 indicates infinite wait. 1253b0a2fdeeSScott Long * Convert to ticks or 500us units depending on 1254b0a2fdeeSScott Long * our sleep mode. 1255b0a2fdeeSScott Long */ 1256c87e3f83SMatt Jacob if (sleep_ok != 0) { 1257b0a2fdeeSScott Long timeout = (time_ms * hz) / 1000; 1258c87e3f83SMatt Jacob } else { 1259b0a2fdeeSScott Long timeout = time_ms * 2; 1260c87e3f83SMatt Jacob } 1261b0a2fdeeSScott Long req->state |= REQ_STATE_NEED_WAKEUP; 1262b0a2fdeeSScott Long mask &= ~REQ_STATE_NEED_WAKEUP; 1263444dd2b6SMatt Jacob saved_cnt = mpt->reset_cnt; 1264c87e3f83SMatt Jacob while ((req->state & mask) != state && mpt->reset_cnt == saved_cnt) { 1265b0a2fdeeSScott Long if (sleep_ok != 0) { 1266b0a2fdeeSScott Long error = mpt_sleep(mpt, req, PUSER, "mptreq", timeout); 1267b0a2fdeeSScott Long if (error == EWOULDBLOCK) { 1268b0a2fdeeSScott Long timeout = 0; 1269b0a2fdeeSScott Long break; 1270b0a2fdeeSScott Long } 1271b0a2fdeeSScott Long } else { 1272b0a2fdeeSScott Long if (time_ms != 0 && --timeout == 0) { 1273b0a2fdeeSScott Long break; 1274b0a2fdeeSScott Long } 1275b0a2fdeeSScott Long DELAY(500); 1276b0a2fdeeSScott Long mpt_intr(mpt); 1277b0a2fdeeSScott Long } 1278b0a2fdeeSScott Long } 1279b0a2fdeeSScott Long req->state &= ~REQ_STATE_NEED_WAKEUP; 1280c87e3f83SMatt Jacob if (mpt->reset_cnt != saved_cnt) { 1281b0a2fdeeSScott Long return (EIO); 1282c87e3f83SMatt Jacob } 1283c87e3f83SMatt Jacob if (time_ms && timeout <= 0) { 1284c87e3f83SMatt Jacob MSG_REQUEST_HEADER *msg_hdr = req->req_vbuf; 1285c87e3f83SMatt Jacob mpt_prt(mpt, "mpt_wait_req(%x) timed out\n", msg_hdr->Function); 1286b0a2fdeeSScott Long return (ETIMEDOUT); 1287c87e3f83SMatt Jacob } 1288b0a2fdeeSScott Long return (0); 12899b631363SMatt Jacob } 12909b631363SMatt Jacob 12919b631363SMatt Jacob /* 12929b631363SMatt Jacob * Send a command to the IOC via the handshake register. 12939b631363SMatt Jacob * 12949b631363SMatt Jacob * Only done at initialization time and for certain unusual 12959b631363SMatt Jacob * commands such as device/bus reset as specified by LSI. 12969b631363SMatt Jacob */ 12979b631363SMatt Jacob int 1298b0a2fdeeSScott Long mpt_send_handshake_cmd(struct mpt_softc *mpt, size_t len, void *cmd) 12999b631363SMatt Jacob { 13009b631363SMatt Jacob int i; 1301b0a2fdeeSScott Long uint32_t data, *data32; 13029b631363SMatt Jacob 13039b631363SMatt Jacob /* Check condition of the IOC */ 13049b631363SMatt Jacob data = mpt_rd_db(mpt); 1305b0a2fdeeSScott Long if ((MPT_STATE(data) != MPT_DB_STATE_READY 1306b0a2fdeeSScott Long && MPT_STATE(data) != MPT_DB_STATE_RUNNING 1307b0a2fdeeSScott Long && MPT_STATE(data) != MPT_DB_STATE_FAULT) 1308b0a2fdeeSScott Long || MPT_DB_IS_IN_USE(data)) { 1309b0a2fdeeSScott Long mpt_prt(mpt, "handshake aborted - invalid doorbell state\n"); 13109b631363SMatt Jacob mpt_print_db(data); 13119b631363SMatt Jacob return (EBUSY); 13129b631363SMatt Jacob } 13139b631363SMatt Jacob 13149b631363SMatt Jacob /* We move things in 32 bit chunks */ 13159b631363SMatt Jacob len = (len + 3) >> 2; 13169b631363SMatt Jacob data32 = cmd; 13179b631363SMatt Jacob 13189b631363SMatt Jacob /* Clear any left over pending doorbell interupts */ 13199b631363SMatt Jacob if (MPT_DB_INTR(mpt_rd_intr(mpt))) 13209b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 13219b631363SMatt Jacob 13229b631363SMatt Jacob /* 13239b631363SMatt Jacob * Tell the handshake reg. we are going to send a command 13249b631363SMatt Jacob * and how long it is going to be. 13259b631363SMatt Jacob */ 13269b631363SMatt Jacob data = (MPI_FUNCTION_HANDSHAKE << MPI_DOORBELL_FUNCTION_SHIFT) | 13279b631363SMatt Jacob (len << MPI_DOORBELL_ADD_DWORDS_SHIFT); 13289b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_DOORBELL, data); 13299b631363SMatt Jacob 13309b631363SMatt Jacob /* Wait for the chip to notice */ 13319b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1332b0a2fdeeSScott Long mpt_prt(mpt, "mpt_send_handshake_cmd timeout1\n"); 1333b0a2fdeeSScott Long return (ETIMEDOUT); 13349b631363SMatt Jacob } 13359b631363SMatt Jacob 13369b631363SMatt Jacob /* Clear the interrupt */ 13379b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 13389b631363SMatt Jacob 13399b631363SMatt Jacob if (mpt_wait_db_ack(mpt) != MPT_OK) { 1340b0a2fdeeSScott Long mpt_prt(mpt, "mpt_send_handshake_cmd timeout2\n"); 1341b0a2fdeeSScott Long return (ETIMEDOUT); 13429b631363SMatt Jacob } 13439b631363SMatt Jacob 13449b631363SMatt Jacob /* Send the command */ 13459b631363SMatt Jacob for (i = 0; i < len; i++) { 13469b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_DOORBELL, *data32++); 13479b631363SMatt Jacob if (mpt_wait_db_ack(mpt) != MPT_OK) { 1348301472c2SMatt Jacob mpt_prt(mpt, 1349b0a2fdeeSScott Long "mpt_send_handshake_cmd timeout! index = %d\n", 1350b0a2fdeeSScott Long i); 1351b0a2fdeeSScott Long return (ETIMEDOUT); 13529b631363SMatt Jacob } 13539b631363SMatt Jacob } 13549b631363SMatt Jacob return MPT_OK; 13559b631363SMatt Jacob } 13569b631363SMatt Jacob 13579b631363SMatt Jacob /* Get the response from the handshake register */ 13589b631363SMatt Jacob int 1359b0a2fdeeSScott Long mpt_recv_handshake_reply(struct mpt_softc *mpt, size_t reply_len, void *reply) 13609b631363SMatt Jacob { 13619b631363SMatt Jacob int left, reply_left; 13629b631363SMatt Jacob u_int16_t *data16; 13639b631363SMatt Jacob MSG_DEFAULT_REPLY *hdr; 13649b631363SMatt Jacob 13659b631363SMatt Jacob /* We move things out in 16 bit chunks */ 13669b631363SMatt Jacob reply_len >>= 1; 13679b631363SMatt Jacob data16 = (u_int16_t *)reply; 13689b631363SMatt Jacob 13699b631363SMatt Jacob hdr = (MSG_DEFAULT_REPLY *)reply; 13709b631363SMatt Jacob 13719b631363SMatt Jacob /* Get first word */ 13729b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1373b0a2fdeeSScott Long mpt_prt(mpt, "mpt_recv_handshake_cmd timeout1\n"); 13749b631363SMatt Jacob return ETIMEDOUT; 13759b631363SMatt Jacob } 13769b631363SMatt Jacob *data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK; 13779b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 13789b631363SMatt Jacob 13799b631363SMatt Jacob /* Get Second Word */ 13809b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1381b0a2fdeeSScott Long mpt_prt(mpt, "mpt_recv_handshake_cmd timeout2\n"); 13829b631363SMatt Jacob return ETIMEDOUT; 13839b631363SMatt Jacob } 13849b631363SMatt Jacob *data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK; 13859b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 13869b631363SMatt Jacob 13875e073106SMatt Jacob /* 13885e073106SMatt Jacob * With the second word, we can now look at the length. 13895e073106SMatt Jacob * Warn about a reply that's too short (except for IOC FACTS REPLY) 13905e073106SMatt Jacob */ 13915e073106SMatt Jacob if ((reply_len >> 1) != hdr->MsgLength && 13925e073106SMatt Jacob (hdr->Function != MPI_FUNCTION_IOC_FACTS)){ 13935e073106SMatt Jacob #if __FreeBSD_version >= 500000 1394301472c2SMatt Jacob mpt_prt(mpt, "reply length does not match message length: " 139533f31846SMatt Jacob "got %x; expected %zx for function %x\n", 13965e073106SMatt Jacob hdr->MsgLength << 2, reply_len << 1, hdr->Function); 13975e073106SMatt Jacob #else 13985e073106SMatt Jacob mpt_prt(mpt, "reply length does not match message length: " 139933f31846SMatt Jacob "got %x; expected %x for function %x\n", 14005e073106SMatt Jacob hdr->MsgLength << 2, reply_len << 1, hdr->Function); 14015e073106SMatt Jacob #endif 14029b631363SMatt Jacob } 14039b631363SMatt Jacob 14049b631363SMatt Jacob /* Get rest of the reply; but don't overflow the provided buffer */ 14059b631363SMatt Jacob left = (hdr->MsgLength << 1) - 2; 14069b631363SMatt Jacob reply_left = reply_len - 2; 14079b631363SMatt Jacob while (left--) { 14089b631363SMatt Jacob u_int16_t datum; 14099b631363SMatt Jacob 14109b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1411b0a2fdeeSScott Long mpt_prt(mpt, "mpt_recv_handshake_cmd timeout3\n"); 14129b631363SMatt Jacob return ETIMEDOUT; 14139b631363SMatt Jacob } 14149b631363SMatt Jacob datum = mpt_read(mpt, MPT_OFFSET_DOORBELL); 14159b631363SMatt Jacob 14169b631363SMatt Jacob if (reply_left-- > 0) 14179b631363SMatt Jacob *data16++ = datum & MPT_DB_DATA_MASK; 14189b631363SMatt Jacob 14199b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 14209b631363SMatt Jacob } 14219b631363SMatt Jacob 14229b631363SMatt Jacob /* One more wait & clear at the end */ 14239b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1424b0a2fdeeSScott Long mpt_prt(mpt, "mpt_recv_handshake_cmd timeout4\n"); 14259b631363SMatt Jacob return ETIMEDOUT; 14269b631363SMatt Jacob } 14279b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 14289b631363SMatt Jacob 14299b631363SMatt Jacob if ((hdr->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) { 1430b0a2fdeeSScott Long if (mpt->verbose >= MPT_PRT_TRACE) 14319b631363SMatt Jacob mpt_print_reply(hdr); 14329b631363SMatt Jacob return (MPT_FAIL | hdr->IOCStatus); 14339b631363SMatt Jacob } 14349b631363SMatt Jacob 14359b631363SMatt Jacob return (0); 14369b631363SMatt Jacob } 14379b631363SMatt Jacob 14389b631363SMatt Jacob static int 1439b0a2fdeeSScott Long mpt_get_iocfacts(struct mpt_softc *mpt, MSG_IOC_FACTS_REPLY *freplp) 14409b631363SMatt Jacob { 14419b631363SMatt Jacob MSG_IOC_FACTS f_req; 14429b631363SMatt Jacob int error; 14439b631363SMatt Jacob 14445e073106SMatt Jacob memset(&f_req, 0, sizeof f_req); 14459b631363SMatt Jacob f_req.Function = MPI_FUNCTION_IOC_FACTS; 1446b0a2fdeeSScott Long f_req.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE); 14479b631363SMatt Jacob error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req); 14489b631363SMatt Jacob if (error) 14499b631363SMatt Jacob return(error); 14509b631363SMatt Jacob error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp); 14519b631363SMatt Jacob return (error); 14529b631363SMatt Jacob } 14539b631363SMatt Jacob 14547104aeefSMatt Jacob static int 1455b0a2fdeeSScott Long mpt_get_portfacts(struct mpt_softc *mpt, MSG_PORT_FACTS_REPLY *freplp) 14567104aeefSMatt Jacob { 14577104aeefSMatt Jacob MSG_PORT_FACTS f_req; 14587104aeefSMatt Jacob int error; 14597104aeefSMatt Jacob 14607104aeefSMatt Jacob /* XXX: Only getting PORT FACTS for Port 0 */ 1461b0a2fdeeSScott Long memset(&f_req, 0, sizeof f_req); 14627104aeefSMatt Jacob f_req.Function = MPI_FUNCTION_PORT_FACTS; 1463b0a2fdeeSScott Long f_req.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE); 14647104aeefSMatt Jacob error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req); 14657104aeefSMatt Jacob if (error) 14667104aeefSMatt Jacob return(error); 14677104aeefSMatt Jacob error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp); 14687104aeefSMatt Jacob return (error); 14697104aeefSMatt Jacob } 14707104aeefSMatt Jacob 14719b631363SMatt Jacob /* 14729b631363SMatt Jacob * Send the initialization request. This is where we specify how many 14739b631363SMatt Jacob * SCSI busses and how many devices per bus we wish to emulate. 14749b631363SMatt Jacob * This is also the command that specifies the max size of the reply 14759b631363SMatt Jacob * frames from the IOC that we will be allocating. 14769b631363SMatt Jacob */ 14779b631363SMatt Jacob static int 1478b0a2fdeeSScott Long mpt_send_ioc_init(struct mpt_softc *mpt, uint32_t who) 14799b631363SMatt Jacob { 14809b631363SMatt Jacob int error = 0; 14819b631363SMatt Jacob MSG_IOC_INIT init; 14829b631363SMatt Jacob MSG_IOC_INIT_REPLY reply; 14839b631363SMatt Jacob 14845e073106SMatt Jacob memset(&init, 0, sizeof init); 14859b631363SMatt Jacob init.WhoInit = who; 14869b631363SMatt Jacob init.Function = MPI_FUNCTION_IOC_INIT; 1487444dd2b6SMatt Jacob init.MaxDevices = mpt->mpt_max_devices; 14889b631363SMatt Jacob init.MaxBuses = 1; 1489444dd2b6SMatt Jacob 1490444dd2b6SMatt Jacob init.MsgVersion = htole16(MPI_VERSION); 1491444dd2b6SMatt Jacob init.HeaderVersion = htole16(MPI_HEADER_VERSION); 1492444dd2b6SMatt Jacob init.ReplyFrameSize = htole16(MPT_REPLY_SIZE); 1493b0a2fdeeSScott Long init.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE); 14949b631363SMatt Jacob 14959b631363SMatt Jacob if ((error = mpt_send_handshake_cmd(mpt, sizeof init, &init)) != 0) { 14969b631363SMatt Jacob return(error); 14979b631363SMatt Jacob } 14989b631363SMatt Jacob 14999b631363SMatt Jacob error = mpt_recv_handshake_reply(mpt, sizeof reply, &reply); 15009b631363SMatt Jacob return (error); 15019b631363SMatt Jacob } 15029b631363SMatt Jacob 15037104aeefSMatt Jacob 15047104aeefSMatt Jacob /* 15057104aeefSMatt Jacob * Utiltity routine to read configuration headers and pages 15067104aeefSMatt Jacob */ 1507b0a2fdeeSScott Long int 1508b0a2fdeeSScott Long mpt_issue_cfg_req(struct mpt_softc *mpt, request_t *req, u_int Action, 1509b0a2fdeeSScott Long u_int PageVersion, u_int PageLength, u_int PageNumber, 1510b0a2fdeeSScott Long u_int PageType, uint32_t PageAddress, bus_addr_t addr, 1511b0a2fdeeSScott Long bus_size_t len, int sleep_ok, int timeout_ms) 15127104aeefSMatt Jacob { 15137104aeefSMatt Jacob MSG_CONFIG *cfgp; 1514b0a2fdeeSScott Long SGE_SIMPLE32 *se; 15157104aeefSMatt Jacob 15167104aeefSMatt Jacob cfgp = req->req_vbuf; 1517b0a2fdeeSScott Long memset(cfgp, 0, sizeof *cfgp); 1518b0a2fdeeSScott Long cfgp->Action = Action; 15197104aeefSMatt Jacob cfgp->Function = MPI_FUNCTION_CONFIG; 1520b0a2fdeeSScott Long cfgp->Header.PageVersion = PageVersion; 1521b0a2fdeeSScott Long cfgp->Header.PageLength = PageLength; 1522b0a2fdeeSScott Long cfgp->Header.PageNumber = PageNumber; 1523b0a2fdeeSScott Long cfgp->Header.PageType = PageType; 15247104aeefSMatt Jacob cfgp->PageAddress = PageAddress; 1525b0a2fdeeSScott Long se = (SGE_SIMPLE32 *)&cfgp->PageBufferSGE; 1526b0a2fdeeSScott Long se->Address = addr; 1527b0a2fdeeSScott Long MPI_pSGE_SET_LENGTH(se, len); 1528b0a2fdeeSScott Long MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_SIMPLE_ELEMENT | 1529b0a2fdeeSScott Long MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER | 1530b0a2fdeeSScott Long MPI_SGE_FLAGS_END_OF_LIST | 1531b0a2fdeeSScott Long ((Action == MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT 1532b0a2fdeeSScott Long || Action == MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM) 1533b0a2fdeeSScott Long ? MPI_SGE_FLAGS_HOST_TO_IOC : MPI_SGE_FLAGS_IOC_TO_HOST))); 1534b0a2fdeeSScott Long cfgp->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_CONFIG); 15357104aeefSMatt Jacob 15367104aeefSMatt Jacob mpt_check_doorbell(mpt); 15377104aeefSMatt Jacob mpt_send_cmd(mpt, req); 1538b0a2fdeeSScott Long return (mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE, 1539b0a2fdeeSScott Long sleep_ok, timeout_ms)); 15407104aeefSMatt Jacob } 15417104aeefSMatt Jacob 1542b0a2fdeeSScott Long 1543b0a2fdeeSScott Long int 1544b0a2fdeeSScott Long mpt_read_cfg_header(struct mpt_softc *mpt, int PageType, int PageNumber, 1545b0a2fdeeSScott Long uint32_t PageAddress, CONFIG_PAGE_HEADER *rslt, 1546b0a2fdeeSScott Long int sleep_ok, int timeout_ms) 1547b0a2fdeeSScott Long { 1548b0a2fdeeSScott Long request_t *req; 154929ae59edSMatt Jacob MSG_CONFIG *cfgp; 1550b0a2fdeeSScott Long int error; 1551b0a2fdeeSScott Long 1552b0a2fdeeSScott Long req = mpt_get_request(mpt, sleep_ok); 1553b0a2fdeeSScott Long if (req == NULL) { 1554b0a2fdeeSScott Long mpt_prt(mpt, "mpt_read_cfg_header: Get request failed!\n"); 155529ae59edSMatt Jacob return (ENOMEM); 15567104aeefSMatt Jacob } 1557b0a2fdeeSScott Long 1558b0a2fdeeSScott Long error = mpt_issue_cfg_req(mpt, req, MPI_CONFIG_ACTION_PAGE_HEADER, 1559b0a2fdeeSScott Long /*PageVersion*/0, /*PageLength*/0, PageNumber, 1560b0a2fdeeSScott Long PageType, PageAddress, /*addr*/0, /*len*/0, 1561b0a2fdeeSScott Long sleep_ok, timeout_ms); 1562b0a2fdeeSScott Long if (error != 0) { 156329ae59edSMatt Jacob mpt_free_request(mpt, req); 1564b0a2fdeeSScott Long mpt_prt(mpt, "read_cfg_header timed out\n"); 156529ae59edSMatt Jacob return (ETIMEDOUT); 1566b0a2fdeeSScott Long } 1567b0a2fdeeSScott Long 156829ae59edSMatt Jacob switch (req->IOCStatus & MPI_IOCSTATUS_MASK) { 156929ae59edSMatt Jacob case MPI_IOCSTATUS_SUCCESS: 1570b0a2fdeeSScott Long cfgp = req->req_vbuf; 1571b0a2fdeeSScott Long bcopy(&cfgp->Header, rslt, sizeof(*rslt)); 1572b0a2fdeeSScott Long error = 0; 157329ae59edSMatt Jacob break; 157429ae59edSMatt Jacob case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: 157529ae59edSMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, 157629ae59edSMatt Jacob "Invalid Page Type %d Number %d Addr 0x%0x\n", 157729ae59edSMatt Jacob PageType, PageNumber, PageAddress); 157829ae59edSMatt Jacob error = EINVAL; 157929ae59edSMatt Jacob break; 158029ae59edSMatt Jacob default: 158129ae59edSMatt Jacob mpt_prt(mpt, "mpt_read_cfg_header: Config Info Status %x\n", 158229ae59edSMatt Jacob req->IOCStatus); 158329ae59edSMatt Jacob error = EIO; 158429ae59edSMatt Jacob break; 1585b0a2fdeeSScott Long } 15867104aeefSMatt Jacob mpt_free_request(mpt, req); 1587b0a2fdeeSScott Long return (error); 15887104aeefSMatt Jacob } 15897104aeefSMatt Jacob 1590ce68dae5SMatt Jacob int 1591b0a2fdeeSScott Long mpt_read_cfg_page(struct mpt_softc *mpt, int Action, uint32_t PageAddress, 1592b0a2fdeeSScott Long CONFIG_PAGE_HEADER *hdr, size_t len, int sleep_ok, 1593b0a2fdeeSScott Long int timeout_ms) 15947104aeefSMatt Jacob { 15957104aeefSMatt Jacob request_t *req; 1596b0a2fdeeSScott Long int error; 15977104aeefSMatt Jacob 1598b0a2fdeeSScott Long req = mpt_get_request(mpt, sleep_ok); 1599b0a2fdeeSScott Long if (req == NULL) { 1600b0a2fdeeSScott Long mpt_prt(mpt, "mpt_read_cfg_page: Get request failed!\n"); 16017104aeefSMatt Jacob return (-1); 16027104aeefSMatt Jacob } 16037104aeefSMatt Jacob 1604b0a2fdeeSScott Long error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion, 1605b0a2fdeeSScott Long hdr->PageLength, hdr->PageNumber, 1606b0a2fdeeSScott Long hdr->PageType & MPI_CONFIG_PAGETYPE_MASK, 1607c87e3f83SMatt Jacob PageAddress, req->req_pbuf + MPT_RQSL(mpt), 1608b0a2fdeeSScott Long len, sleep_ok, timeout_ms); 1609b0a2fdeeSScott Long if (error != 0) { 1610b0a2fdeeSScott Long mpt_prt(mpt, "read_cfg_page(%d) timed out\n", Action); 16117104aeefSMatt Jacob return (-1); 16127104aeefSMatt Jacob } 1613b0a2fdeeSScott Long 1614b0a2fdeeSScott Long if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) { 1615b0a2fdeeSScott Long mpt_prt(mpt, "mpt_read_cfg_page: Config Info Status %x\n", 1616b0a2fdeeSScott Long req->IOCStatus); 1617b0a2fdeeSScott Long mpt_free_request(mpt, req); 1618b0a2fdeeSScott Long return (-1); 1619b0a2fdeeSScott Long } 16207104aeefSMatt Jacob bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap, 16217104aeefSMatt Jacob BUS_DMASYNC_POSTREAD); 1622c87e3f83SMatt Jacob memcpy(hdr, ((uint8_t *)req->req_vbuf)+MPT_RQSL(mpt), len); 16237104aeefSMatt Jacob mpt_free_request(mpt, req); 16247104aeefSMatt Jacob return (0); 16257104aeefSMatt Jacob } 16267104aeefSMatt Jacob 1627ce68dae5SMatt Jacob int 1628b0a2fdeeSScott Long mpt_write_cfg_page(struct mpt_softc *mpt, int Action, uint32_t PageAddress, 1629b0a2fdeeSScott Long CONFIG_PAGE_HEADER *hdr, size_t len, int sleep_ok, 1630b0a2fdeeSScott Long int timeout_ms) 16317104aeefSMatt Jacob { 16327104aeefSMatt Jacob request_t *req; 1633b0a2fdeeSScott Long u_int hdr_attr; 1634b0a2fdeeSScott Long int error; 16357104aeefSMatt Jacob 16367104aeefSMatt Jacob hdr_attr = hdr->PageType & MPI_CONFIG_PAGEATTR_MASK; 16377104aeefSMatt Jacob if (hdr_attr != MPI_CONFIG_PAGEATTR_CHANGEABLE && 16387104aeefSMatt Jacob hdr_attr != MPI_CONFIG_PAGEATTR_PERSISTENT) { 1639b0a2fdeeSScott Long mpt_prt(mpt, "page type 0x%x not changeable\n", 16407104aeefSMatt Jacob hdr->PageType & MPI_CONFIG_PAGETYPE_MASK); 16417104aeefSMatt Jacob return (-1); 16427104aeefSMatt Jacob } 1643b4c618c0SMatt Jacob 1644b4c618c0SMatt Jacob #if 0 1645b4c618c0SMatt Jacob /* 1646b4c618c0SMatt Jacob * We shouldn't mask off other bits here. 1647b4c618c0SMatt Jacob */ 1648b4c618c0SMatt Jacob hdr->PageType &= MPI_CONFIG_PAGETYPE_MASK; 1649b4c618c0SMatt Jacob #endif 16507104aeefSMatt Jacob 1651b0a2fdeeSScott Long req = mpt_get_request(mpt, sleep_ok); 1652b0a2fdeeSScott Long if (req == NULL) 1653b0a2fdeeSScott Long return (-1); 16547104aeefSMatt Jacob 1655c87e3f83SMatt Jacob memcpy(((caddr_t)req->req_vbuf) + MPT_RQSL(mpt), hdr, len); 1656b4c618c0SMatt Jacob 1657b4c618c0SMatt Jacob /* 1658b4c618c0SMatt Jacob * There isn't any point in restoring stripped out attributes 1659b4c618c0SMatt Jacob * if you then mask them going down to issue the request. 1660b4c618c0SMatt Jacob */ 1661b4c618c0SMatt Jacob 1662b4c618c0SMatt Jacob #if 0 1663301472c2SMatt Jacob /* Restore stripped out attributes */ 1664301472c2SMatt Jacob hdr->PageType |= hdr_attr; 16657104aeefSMatt Jacob 1666b0a2fdeeSScott Long error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion, 1667b0a2fdeeSScott Long hdr->PageLength, hdr->PageNumber, 1668b0a2fdeeSScott Long hdr->PageType & MPI_CONFIG_PAGETYPE_MASK, 1669c87e3f83SMatt Jacob PageAddress, req->req_pbuf + MPT_RQSL(mpt), 1670b0a2fdeeSScott Long len, sleep_ok, timeout_ms); 1671b4c618c0SMatt Jacob #else 1672b4c618c0SMatt Jacob error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion, 1673b4c618c0SMatt Jacob hdr->PageLength, hdr->PageNumber, 1674b4c618c0SMatt Jacob hdr->PageType, PageAddress, 1675b4c618c0SMatt Jacob req->req_pbuf + MPT_RQSL(mpt), 1676b4c618c0SMatt Jacob len, sleep_ok, timeout_ms); 1677b4c618c0SMatt Jacob #endif 1678b0a2fdeeSScott Long if (error != 0) { 1679b0a2fdeeSScott Long mpt_prt(mpt, "mpt_write_cfg_page timed out\n"); 16807104aeefSMatt Jacob return (-1); 16817104aeefSMatt Jacob } 16827104aeefSMatt Jacob 1683b0a2fdeeSScott Long if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) { 1684b0a2fdeeSScott Long mpt_prt(mpt, "mpt_write_cfg_page: Config Info Status %x\n", 1685b0a2fdeeSScott Long req->IOCStatus); 16867104aeefSMatt Jacob mpt_free_request(mpt, req); 1687b0a2fdeeSScott Long return (-1); 1688b0a2fdeeSScott Long } 1689b0a2fdeeSScott Long mpt_free_request(mpt, req); 1690b0a2fdeeSScott Long return (0); 1691b0a2fdeeSScott Long } 1692b0a2fdeeSScott Long 1693b0a2fdeeSScott Long /* 1694b0a2fdeeSScott Long * Read IOC configuration information 1695b0a2fdeeSScott Long */ 1696b0a2fdeeSScott Long static int 1697b0a2fdeeSScott Long mpt_read_config_info_ioc(struct mpt_softc *mpt) 1698b0a2fdeeSScott Long { 1699b0a2fdeeSScott Long CONFIG_PAGE_HEADER hdr; 1700b0a2fdeeSScott Long struct mpt_raid_volume *mpt_raid; 1701b0a2fdeeSScott Long int rv; 1702b0a2fdeeSScott Long int i; 1703b0a2fdeeSScott Long size_t len; 1704b0a2fdeeSScott Long 1705b0a2fdeeSScott Long rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC, 17061d79ca0eSMatt Jacob 2, 0, &hdr, FALSE, 5000); 170729ae59edSMatt Jacob /* 170829ae59edSMatt Jacob * If it's an invalid page, so what? Not a supported function.... 170929ae59edSMatt Jacob */ 17101d79ca0eSMatt Jacob if (rv == EINVAL) { 171129ae59edSMatt Jacob return (0); 17121d79ca0eSMatt Jacob } 17131d79ca0eSMatt Jacob if (rv) { 171429ae59edSMatt Jacob return (rv); 17151d79ca0eSMatt Jacob } 1716b0a2fdeeSScott Long 17175e073106SMatt Jacob #if __FreeBSD_version >= 500000 1718a529c6a2SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC Page 2 Header: ver %x, len %zx, " 1719b0a2fdeeSScott Long "num %x, type %x\n", hdr.PageVersion, 1720b0a2fdeeSScott Long hdr.PageLength * sizeof(uint32_t), 1721b0a2fdeeSScott Long hdr.PageNumber, hdr.PageType); 17225e073106SMatt Jacob #else 17235e073106SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC Page 2 Header: ver %x, len %z, " 17245e073106SMatt Jacob "num %x, type %x\n", hdr.PageVersion, 17255e073106SMatt Jacob hdr.PageLength * sizeof(uint32_t), 17265e073106SMatt Jacob hdr.PageNumber, hdr.PageType); 17275e073106SMatt Jacob #endif 1728b0a2fdeeSScott Long 1729b0a2fdeeSScott Long len = hdr.PageLength * sizeof(uint32_t); 1730a3699bcaSScott Long mpt->ioc_page2 = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 17311d79ca0eSMatt Jacob if (mpt->ioc_page2 == NULL) { 17321d79ca0eSMatt Jacob mpt_prt(mpt, "unable to allocate memory for IOC page 2\n"); 17331d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 1734b0a2fdeeSScott Long return (ENOMEM); 17351d79ca0eSMatt Jacob } 1736b0a2fdeeSScott Long memcpy(&mpt->ioc_page2->Header, &hdr, sizeof(hdr)); 17371d79ca0eSMatt Jacob rv = mpt_read_cur_cfg_page(mpt, 0, 17381d79ca0eSMatt Jacob &mpt->ioc_page2->Header, len, FALSE, 5000); 1739b0a2fdeeSScott Long if (rv) { 1740b0a2fdeeSScott Long mpt_prt(mpt, "failed to read IOC Page 2\n"); 17411d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 17421d79ca0eSMatt Jacob return (EIO); 17431d79ca0eSMatt Jacob } 17441d79ca0eSMatt Jacob 17451d79ca0eSMatt Jacob if (mpt->ioc_page2->CapabilitiesFlags != 0) { 1746b0a2fdeeSScott Long uint32_t mask; 1747b0a2fdeeSScott Long 1748b0a2fdeeSScott Long mpt_prt(mpt, "Capabilities: ("); 1749b0a2fdeeSScott Long for (mask = 1; mask != 0; mask <<= 1) { 17501d79ca0eSMatt Jacob if ((mpt->ioc_page2->CapabilitiesFlags & mask) == 0) { 1751b0a2fdeeSScott Long continue; 17521d79ca0eSMatt Jacob } 1753b0a2fdeeSScott Long switch (mask) { 1754b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT: 1755b0a2fdeeSScott Long mpt_prtc(mpt, " RAID-0"); 1756b0a2fdeeSScott Long break; 1757b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT: 1758b0a2fdeeSScott Long mpt_prtc(mpt, " RAID-1E"); 1759b0a2fdeeSScott Long break; 1760b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT: 1761b0a2fdeeSScott Long mpt_prtc(mpt, " RAID-1"); 1762b0a2fdeeSScott Long break; 1763b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_SES_SUPPORT: 1764b0a2fdeeSScott Long mpt_prtc(mpt, " SES"); 1765b0a2fdeeSScott Long break; 1766b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_SAFTE_SUPPORT: 1767b0a2fdeeSScott Long mpt_prtc(mpt, " SAFTE"); 1768b0a2fdeeSScott Long break; 1769b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_CROSS_CHANNEL_SUPPORT: 1770b0a2fdeeSScott Long mpt_prtc(mpt, " Multi-Channel-Arrays"); 1771b0a2fdeeSScott Long default: 1772b0a2fdeeSScott Long break; 1773b0a2fdeeSScott Long } 1774b0a2fdeeSScott Long } 1775b0a2fdeeSScott Long mpt_prtc(mpt, " )\n"); 1776b0a2fdeeSScott Long if ((mpt->ioc_page2->CapabilitiesFlags 1777b0a2fdeeSScott Long & (MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT 1778b0a2fdeeSScott Long | MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT 1779b0a2fdeeSScott Long | MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT)) != 0) { 1780b0a2fdeeSScott Long mpt_prt(mpt, "%d Active Volume%s(%d Max)\n", 1781b0a2fdeeSScott Long mpt->ioc_page2->NumActiveVolumes, 1782b0a2fdeeSScott Long mpt->ioc_page2->NumActiveVolumes != 1 1783b0a2fdeeSScott Long ? "s " : " ", 1784b0a2fdeeSScott Long mpt->ioc_page2->MaxVolumes); 1785b0a2fdeeSScott Long mpt_prt(mpt, "%d Hidden Drive Member%s(%d Max)\n", 1786b0a2fdeeSScott Long mpt->ioc_page2->NumActivePhysDisks, 1787b0a2fdeeSScott Long mpt->ioc_page2->NumActivePhysDisks != 1 1788b0a2fdeeSScott Long ? "s " : " ", 1789b0a2fdeeSScott Long mpt->ioc_page2->MaxPhysDisks); 1790b0a2fdeeSScott Long } 1791b0a2fdeeSScott Long } 1792b0a2fdeeSScott Long 1793b0a2fdeeSScott Long len = mpt->ioc_page2->MaxVolumes * sizeof(struct mpt_raid_volume); 17941d79ca0eSMatt Jacob mpt->raid_volumes = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 1795b0a2fdeeSScott Long if (mpt->raid_volumes == NULL) { 1796b0a2fdeeSScott Long mpt_prt(mpt, "Could not allocate RAID volume data\n"); 17971d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 17981d79ca0eSMatt Jacob return (ENOMEM); 1799b0a2fdeeSScott Long } 1800b0a2fdeeSScott Long 1801b0a2fdeeSScott Long /* 1802b0a2fdeeSScott Long * Copy critical data out of ioc_page2 so that we can 1803b0a2fdeeSScott Long * safely refresh the page without windows of unreliable 1804b0a2fdeeSScott Long * data. 1805b0a2fdeeSScott Long */ 1806b0a2fdeeSScott Long mpt->raid_max_volumes = mpt->ioc_page2->MaxVolumes; 1807b0a2fdeeSScott Long 18081d79ca0eSMatt Jacob len = sizeof(*mpt->raid_volumes->config_page) + 18091d79ca0eSMatt Jacob (sizeof (RAID_VOL0_PHYS_DISK) * (mpt->ioc_page2->MaxPhysDisks - 1)); 1810b0a2fdeeSScott Long for (i = 0; i < mpt->ioc_page2->MaxVolumes; i++) { 1811b0a2fdeeSScott Long mpt_raid = &mpt->raid_volumes[i]; 18121d79ca0eSMatt Jacob mpt_raid->config_page = 18131d79ca0eSMatt Jacob malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 1814b0a2fdeeSScott Long if (mpt_raid->config_page == NULL) { 1815b0a2fdeeSScott Long mpt_prt(mpt, "Could not allocate RAID page data\n"); 18161d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 18171d79ca0eSMatt Jacob return (ENOMEM); 1818b0a2fdeeSScott Long } 1819b0a2fdeeSScott Long } 1820b0a2fdeeSScott Long mpt->raid_page0_len = len; 1821b0a2fdeeSScott Long 1822b0a2fdeeSScott Long len = mpt->ioc_page2->MaxPhysDisks * sizeof(struct mpt_raid_disk); 18231d79ca0eSMatt Jacob mpt->raid_disks = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 1824b0a2fdeeSScott Long if (mpt->raid_disks == NULL) { 1825b0a2fdeeSScott Long mpt_prt(mpt, "Could not allocate RAID disk data\n"); 18261d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 18271d79ca0eSMatt Jacob return (ENOMEM); 1828b0a2fdeeSScott Long } 1829b0a2fdeeSScott Long mpt->raid_max_disks = mpt->ioc_page2->MaxPhysDisks; 1830b0a2fdeeSScott Long 18311d79ca0eSMatt Jacob /* 18321d79ca0eSMatt Jacob * Load page 3. 18331d79ca0eSMatt Jacob */ 1834b0a2fdeeSScott Long rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC, 18351d79ca0eSMatt Jacob 3, 0, &hdr, FALSE, 5000); 18361d79ca0eSMatt Jacob if (rv) { 18371d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 1838b0a2fdeeSScott Long return (EIO); 18391d79ca0eSMatt Jacob } 1840b0a2fdeeSScott Long 1841b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC Page 3 Header: %x %x %x %x\n", 1842b0a2fdeeSScott Long hdr.PageVersion, hdr.PageLength, hdr.PageNumber, hdr.PageType); 1843b0a2fdeeSScott Long 1844b0a2fdeeSScott Long len = hdr.PageLength * sizeof(uint32_t); 1845a3699bcaSScott Long mpt->ioc_page3 = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 18461d79ca0eSMatt Jacob if (mpt->ioc_page3 == NULL) { 18471d79ca0eSMatt Jacob mpt_prt(mpt, "unable to allocate memory for IOC page 3\n"); 18481d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 18491d79ca0eSMatt Jacob return (ENOMEM); 1850b0a2fdeeSScott Long } 18511d79ca0eSMatt Jacob memcpy(&mpt->ioc_page3->Header, &hdr, sizeof(hdr)); 18521d79ca0eSMatt Jacob rv = mpt_read_cur_cfg_page(mpt, 0, 18531d79ca0eSMatt Jacob &mpt->ioc_page3->Header, len, FALSE, 5000); 18541d79ca0eSMatt Jacob if (rv) { 18551d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 18561d79ca0eSMatt Jacob return (EIO); 18571d79ca0eSMatt Jacob } 1858b0a2fdeeSScott Long mpt_raid_wakeup(mpt); 18597104aeefSMatt Jacob return (0); 18607104aeefSMatt Jacob } 18617104aeefSMatt Jacob 18627104aeefSMatt Jacob /* 18637104aeefSMatt Jacob * Enable IOC port 18647104aeefSMatt Jacob */ 18657104aeefSMatt Jacob static int 1866b0a2fdeeSScott Long mpt_send_port_enable(struct mpt_softc *mpt, int port) 18679b631363SMatt Jacob { 18689b631363SMatt Jacob request_t *req; 18699b631363SMatt Jacob MSG_PORT_ENABLE *enable_req; 1870b0a2fdeeSScott Long int error; 18719b631363SMatt Jacob 1872b0a2fdeeSScott Long req = mpt_get_request(mpt, /*sleep_ok*/FALSE); 1873b0a2fdeeSScott Long if (req == NULL) 1874b0a2fdeeSScott Long return (-1); 18759b631363SMatt Jacob 18769b631363SMatt Jacob enable_req = req->req_vbuf; 18775e073106SMatt Jacob memset(enable_req, 0, MPT_RQSL(mpt)); 18789b631363SMatt Jacob 18799b631363SMatt Jacob enable_req->Function = MPI_FUNCTION_PORT_ENABLE; 1880b0a2fdeeSScott Long enable_req->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_CONFIG); 18819b631363SMatt Jacob enable_req->PortNumber = port; 18829b631363SMatt Jacob 18839b631363SMatt Jacob mpt_check_doorbell(mpt); 1884b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "enabling port %d\n", port); 18859b631363SMatt Jacob 1886b0a2fdeeSScott Long mpt_send_cmd(mpt, req); 1887b0a2fdeeSScott Long error = mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE, 18885089bd63SMatt Jacob FALSE, (mpt->is_sas || mpt->is_fc)? 30000 : 3000); 1889b0a2fdeeSScott Long if (error != 0) { 1890c87e3f83SMatt Jacob mpt_prt(mpt, "port %d enable timed out\n", port); 18919b631363SMatt Jacob return (-1); 18929b631363SMatt Jacob } 18939b631363SMatt Jacob mpt_free_request(mpt, req); 1894c87e3f83SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "enabled port %d\n", port); 18959b631363SMatt Jacob return (0); 18969b631363SMatt Jacob } 18979b631363SMatt Jacob 18989b631363SMatt Jacob /* 18999b631363SMatt Jacob * Enable/Disable asynchronous event reporting. 19009b631363SMatt Jacob */ 19019b631363SMatt Jacob static int 1902b0a2fdeeSScott Long mpt_send_event_request(struct mpt_softc *mpt, int onoff) 19039b631363SMatt Jacob { 19049b631363SMatt Jacob request_t *req; 19059b631363SMatt Jacob MSG_EVENT_NOTIFY *enable_req; 19069b631363SMatt Jacob 19075e073106SMatt Jacob req = mpt_get_request(mpt, FALSE); 19085e073106SMatt Jacob if (req == NULL) { 19095e073106SMatt Jacob return (ENOMEM); 19105e073106SMatt Jacob } 19119b631363SMatt Jacob enable_req = req->req_vbuf; 19125e073106SMatt Jacob memset(enable_req, 0, sizeof *enable_req); 19139b631363SMatt Jacob 19149b631363SMatt Jacob enable_req->Function = MPI_FUNCTION_EVENT_NOTIFICATION; 1915b0a2fdeeSScott Long enable_req->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_EVENTS); 19169b631363SMatt Jacob enable_req->Switch = onoff; 19179b631363SMatt Jacob 19189b631363SMatt Jacob mpt_check_doorbell(mpt); 19195e073106SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "%sabling async events\n", 19205e073106SMatt Jacob onoff ? "en" : "dis"); 19215e073106SMatt Jacob /* 19225e073106SMatt Jacob * Send the command off, but don't wait for it. 19235e073106SMatt Jacob */ 19249b631363SMatt Jacob mpt_send_cmd(mpt, req); 19259b631363SMatt Jacob return (0); 19269b631363SMatt Jacob } 19279b631363SMatt Jacob 19289b631363SMatt Jacob /* 19299b631363SMatt Jacob * Un-mask the interupts on the chip. 19309b631363SMatt Jacob */ 19319b631363SMatt Jacob void 1932b0a2fdeeSScott Long mpt_enable_ints(struct mpt_softc *mpt) 19339b631363SMatt Jacob { 19349b631363SMatt Jacob /* Unmask every thing except door bell int */ 19359b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_MASK, MPT_INTR_DB_MASK); 19369b631363SMatt Jacob } 19379b631363SMatt Jacob 19389b631363SMatt Jacob /* 19399b631363SMatt Jacob * Mask the interupts on the chip. 19409b631363SMatt Jacob */ 19419b631363SMatt Jacob void 1942b0a2fdeeSScott Long mpt_disable_ints(struct mpt_softc *mpt) 19439b631363SMatt Jacob { 19449b631363SMatt Jacob /* Mask all interrupts */ 19459b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_MASK, 19469b631363SMatt Jacob MPT_INTR_REPLY_MASK | MPT_INTR_DB_MASK); 19479b631363SMatt Jacob } 19489b631363SMatt Jacob 1949b0a2fdeeSScott Long static void 1950b0a2fdeeSScott Long mpt_sysctl_attach(struct mpt_softc *mpt) 19519b631363SMatt Jacob { 1952c87e3f83SMatt Jacob #if __FreeBSD_version >= 500000 1953b0a2fdeeSScott Long struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(mpt->dev); 1954b0a2fdeeSScott Long struct sysctl_oid *tree = device_get_sysctl_tree(mpt->dev); 19559b631363SMatt Jacob 1956b0a2fdeeSScott Long SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 1957b0a2fdeeSScott Long "debug", CTLFLAG_RW, &mpt->verbose, 0, 1958b0a2fdeeSScott Long "Debugging/Verbose level"); 1959b4c618c0SMatt Jacob SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 1960b4c618c0SMatt Jacob "role", CTLFLAG_RD, &mpt->role, 0, 1961b4c618c0SMatt Jacob "HBA role"); 1962c87e3f83SMatt Jacob #endif 19639b631363SMatt Jacob } 19649b631363SMatt Jacob 1965b0a2fdeeSScott Long int 1966b0a2fdeeSScott Long mpt_attach(struct mpt_softc *mpt) 1967b0a2fdeeSScott Long { 1968b0a2fdeeSScott Long struct mpt_personality *pers; 1969c87e3f83SMatt Jacob int i; 1970b0a2fdeeSScott Long int error; 1971b0a2fdeeSScott Long 1972c87e3f83SMatt Jacob for (i = 0; i < MPT_MAX_PERSONALITIES; i++) { 1973b0a2fdeeSScott Long pers = mpt_personalities[i]; 1974c87e3f83SMatt Jacob if (pers == NULL) { 1975b0a2fdeeSScott Long continue; 1976c87e3f83SMatt Jacob } 1977b0a2fdeeSScott Long if (pers->probe(mpt) == 0) { 1978b0a2fdeeSScott Long error = pers->attach(mpt); 1979b0a2fdeeSScott Long if (error != 0) { 1980b0a2fdeeSScott Long mpt_detach(mpt); 1981b0a2fdeeSScott Long return (error); 1982b0a2fdeeSScott Long } 1983b0a2fdeeSScott Long mpt->mpt_pers_mask |= (0x1 << pers->id); 1984b0a2fdeeSScott Long pers->use_count++; 1985b0a2fdeeSScott Long } 1986b0a2fdeeSScott Long } 1987444dd2b6SMatt Jacob 1988c87e3f83SMatt Jacob /* 1989c87e3f83SMatt Jacob * Now that we've attached everything, do the enable function 1990c87e3f83SMatt Jacob * for all of the personalities. This allows the personalities 1991c87e3f83SMatt Jacob * to do setups that are appropriate for them prior to enabling 1992c87e3f83SMatt Jacob * any ports. 1993c87e3f83SMatt Jacob */ 1994c87e3f83SMatt Jacob for (i = 0; i < MPT_MAX_PERSONALITIES; i++) { 1995c87e3f83SMatt Jacob pers = mpt_personalities[i]; 1996c87e3f83SMatt Jacob if (pers != NULL && MPT_PERS_ATTACHED(pers, mpt) != 0) { 1997c87e3f83SMatt Jacob error = pers->enable(mpt); 1998c87e3f83SMatt Jacob if (error != 0) { 1999c87e3f83SMatt Jacob mpt_prt(mpt, "personality %s attached but would" 2000c87e3f83SMatt Jacob " not enable (%d)\n", pers->name, error); 2001c87e3f83SMatt Jacob mpt_detach(mpt); 2002c87e3f83SMatt Jacob return (error); 2003c87e3f83SMatt Jacob } 2004c87e3f83SMatt Jacob } 2005c87e3f83SMatt Jacob } 2006b0a2fdeeSScott Long return (0); 2007b0a2fdeeSScott Long } 2008b0a2fdeeSScott Long 2009b0a2fdeeSScott Long int 2010b0a2fdeeSScott Long mpt_shutdown(struct mpt_softc *mpt) 2011b0a2fdeeSScott Long { 2012b0a2fdeeSScott Long struct mpt_personality *pers; 2013b0a2fdeeSScott Long 2014c87e3f83SMatt Jacob MPT_PERS_FOREACH_REVERSE(mpt, pers) { 2015b0a2fdeeSScott Long pers->shutdown(mpt); 2016c87e3f83SMatt Jacob } 2017b0a2fdeeSScott Long return (0); 2018b0a2fdeeSScott Long } 2019b0a2fdeeSScott Long 2020b0a2fdeeSScott Long int 2021b0a2fdeeSScott Long mpt_detach(struct mpt_softc *mpt) 2022b0a2fdeeSScott Long { 2023b0a2fdeeSScott Long struct mpt_personality *pers; 2024b0a2fdeeSScott Long 2025b0a2fdeeSScott Long MPT_PERS_FOREACH_REVERSE(mpt, pers) { 2026b0a2fdeeSScott Long pers->detach(mpt); 2027b0a2fdeeSScott Long mpt->mpt_pers_mask &= ~(0x1 << pers->id); 2028b0a2fdeeSScott Long pers->use_count--; 2029b0a2fdeeSScott Long } 2030b0a2fdeeSScott Long 2031b0a2fdeeSScott Long return (0); 2032b0a2fdeeSScott Long } 2033b0a2fdeeSScott Long 2034b0a2fdeeSScott Long int 2035b0a2fdeeSScott Long mpt_core_load(struct mpt_personality *pers) 2036b0a2fdeeSScott Long { 2037b0a2fdeeSScott Long int i; 2038b0a2fdeeSScott Long 2039b0a2fdeeSScott Long /* 2040b0a2fdeeSScott Long * Setup core handlers and insert the default handler 2041b0a2fdeeSScott Long * into all "empty slots". 2042b0a2fdeeSScott Long */ 2043c87e3f83SMatt Jacob for (i = 0; i < MPT_NUM_REPLY_HANDLERS; i++) { 2044b0a2fdeeSScott Long mpt_reply_handlers[i] = mpt_default_reply_handler; 2045c87e3f83SMatt Jacob } 2046b0a2fdeeSScott Long 2047b0a2fdeeSScott Long mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_EVENTS)] = 2048b0a2fdeeSScott Long mpt_event_reply_handler; 2049b0a2fdeeSScott Long mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_CONFIG)] = 2050b0a2fdeeSScott Long mpt_config_reply_handler; 2051b0a2fdeeSScott Long mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_HANDSHAKE)] = 2052b0a2fdeeSScott Long mpt_handshake_reply_handler; 2053b0a2fdeeSScott Long return (0); 20549b631363SMatt Jacob } 20559b631363SMatt Jacob 20569b631363SMatt Jacob /* 2057b0a2fdeeSScott Long * Initialize per-instance driver data and perform 2058b0a2fdeeSScott Long * initial controller configuration. 20599b631363SMatt Jacob */ 2060b0a2fdeeSScott Long int 2061b0a2fdeeSScott Long mpt_core_attach(struct mpt_softc *mpt) 2062b0a2fdeeSScott Long { 2063b0a2fdeeSScott Long int val; 2064b0a2fdeeSScott Long int error; 2065b0a2fdeeSScott Long 2066c87e3f83SMatt Jacob 2067b0a2fdeeSScott Long LIST_INIT(&mpt->ack_frames); 2068b0a2fdeeSScott Long 2069b0a2fdeeSScott Long /* Put all request buffers on the free list */ 2070b0a2fdeeSScott Long TAILQ_INIT(&mpt->request_pending_list); 2071b0a2fdeeSScott Long TAILQ_INIT(&mpt->request_free_list); 20725e073106SMatt Jacob TAILQ_INIT(&mpt->request_timeout_list); 2073c87e3f83SMatt Jacob for (val = 0; val < MPT_MAX_REQUESTS(mpt); val++) { 20745e073106SMatt Jacob request_t *req = &mpt->request_pool[val]; 20755e073106SMatt Jacob req->state = REQ_STATE_ALLOCATED; 20765e073106SMatt Jacob mpt_free_request(mpt, req); 2077c87e3f83SMatt Jacob } 2078c87e3f83SMatt Jacob 2079c87e3f83SMatt Jacob for (val = 0; val < MPT_MAX_LUNS; val++) { 2080c87e3f83SMatt Jacob STAILQ_INIT(&mpt->trt[val].atios); 2081c87e3f83SMatt Jacob STAILQ_INIT(&mpt->trt[val].inots); 2082c87e3f83SMatt Jacob } 2083c87e3f83SMatt Jacob STAILQ_INIT(&mpt->trt_wildcard.atios); 2084c87e3f83SMatt Jacob STAILQ_INIT(&mpt->trt_wildcard.inots); 2085c87e3f83SMatt Jacob 2086c87e3f83SMatt Jacob mpt->scsi_tgt_handler_id = MPT_HANDLER_ID_NONE; 2087b0a2fdeeSScott Long 2088b0a2fdeeSScott Long mpt_sysctl_attach(mpt); 2089b0a2fdeeSScott Long 2090b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "doorbell req = %s\n", 2091b0a2fdeeSScott Long mpt_ioc_diag(mpt_read(mpt, MPT_OFFSET_DOORBELL))); 2092b0a2fdeeSScott Long 2093b0a2fdeeSScott Long error = mpt_configure_ioc(mpt); 2094b0a2fdeeSScott Long 2095b0a2fdeeSScott Long return (error); 20969b631363SMatt Jacob } 20979b631363SMatt Jacob 2098c87e3f83SMatt Jacob int 2099c87e3f83SMatt Jacob mpt_core_enable(struct mpt_softc *mpt) 2100c87e3f83SMatt Jacob { 2101c87e3f83SMatt Jacob /* 2102c87e3f83SMatt Jacob * We enter with the IOC enabled, but async events 2103c87e3f83SMatt Jacob * not enabled, ports not enabled and interrupts 2104c87e3f83SMatt Jacob * not enabled. 2105c87e3f83SMatt Jacob */ 2106c87e3f83SMatt Jacob 2107c87e3f83SMatt Jacob /* 2108c87e3f83SMatt Jacob * Enable asynchronous event reporting- all personalities 2109c87e3f83SMatt Jacob * have attached so that they should be able to now field 2110c87e3f83SMatt Jacob * async events. 2111c87e3f83SMatt Jacob */ 2112c87e3f83SMatt Jacob mpt_send_event_request(mpt, 1); 2113c87e3f83SMatt Jacob 2114c87e3f83SMatt Jacob /* 2115c87e3f83SMatt Jacob * Catch any pending interrupts 2116c87e3f83SMatt Jacob * 2117c87e3f83SMatt Jacob * This seems to be crucial- otherwise 2118c87e3f83SMatt Jacob * the portenable below times out. 2119c87e3f83SMatt Jacob */ 2120c87e3f83SMatt Jacob mpt_intr(mpt); 2121c87e3f83SMatt Jacob 2122c87e3f83SMatt Jacob /* 2123c87e3f83SMatt Jacob * Enable Interrupts 2124c87e3f83SMatt Jacob */ 2125c87e3f83SMatt Jacob mpt_enable_ints(mpt); 2126c87e3f83SMatt Jacob 2127c87e3f83SMatt Jacob /* 2128c87e3f83SMatt Jacob * Catch any pending interrupts 2129c87e3f83SMatt Jacob * 2130c87e3f83SMatt Jacob * This seems to be crucial- otherwise 2131c87e3f83SMatt Jacob * the portenable below times out. 2132c87e3f83SMatt Jacob */ 2133c87e3f83SMatt Jacob mpt_intr(mpt); 2134c87e3f83SMatt Jacob 2135c87e3f83SMatt Jacob /* 21365089bd63SMatt Jacob * Enable the port. 2137c87e3f83SMatt Jacob */ 2138c87e3f83SMatt Jacob if (mpt_send_port_enable(mpt, 0) != MPT_OK) { 2139c87e3f83SMatt Jacob mpt_prt(mpt, "failed to enable port 0\n"); 2140c87e3f83SMatt Jacob return (ENXIO); 2141c87e3f83SMatt Jacob } 2142c87e3f83SMatt Jacob return (0); 2143c87e3f83SMatt Jacob } 2144c87e3f83SMatt Jacob 2145b0a2fdeeSScott Long void 2146b0a2fdeeSScott Long mpt_core_shutdown(struct mpt_softc *mpt) 2147b0a2fdeeSScott Long { 2148c87e3f83SMatt Jacob mpt_disable_ints(mpt); 2149b0a2fdeeSScott Long } 2150b0a2fdeeSScott Long 2151b0a2fdeeSScott Long void 2152b0a2fdeeSScott Long mpt_core_detach(struct mpt_softc *mpt) 2153b0a2fdeeSScott Long { 2154c87e3f83SMatt Jacob mpt_disable_ints(mpt); 2155b0a2fdeeSScott Long } 2156b0a2fdeeSScott Long 2157b0a2fdeeSScott Long int 2158b0a2fdeeSScott Long mpt_core_unload(struct mpt_personality *pers) 2159b0a2fdeeSScott Long { 2160b0a2fdeeSScott Long /* Unload is always successfull. */ 2161b0a2fdeeSScott Long return (0); 2162b0a2fdeeSScott Long } 2163b0a2fdeeSScott Long 2164b0a2fdeeSScott Long #define FW_UPLOAD_REQ_SIZE \ 2165b0a2fdeeSScott Long (sizeof(MSG_FW_UPLOAD) - sizeof(SGE_MPI_UNION) \ 2166b0a2fdeeSScott Long + sizeof(FW_UPLOAD_TCSGE) + sizeof(SGE_SIMPLE32)) 2167b0a2fdeeSScott Long 2168b0a2fdeeSScott Long static int 2169b0a2fdeeSScott Long mpt_upload_fw(struct mpt_softc *mpt) 2170b0a2fdeeSScott Long { 2171b0a2fdeeSScott Long uint8_t fw_req_buf[FW_UPLOAD_REQ_SIZE]; 2172b0a2fdeeSScott Long MSG_FW_UPLOAD_REPLY fw_reply; 2173b0a2fdeeSScott Long MSG_FW_UPLOAD *fw_req; 2174b0a2fdeeSScott Long FW_UPLOAD_TCSGE *tsge; 2175b0a2fdeeSScott Long SGE_SIMPLE32 *sge; 2176b0a2fdeeSScott Long uint32_t flags; 2177b0a2fdeeSScott Long int error; 2178b0a2fdeeSScott Long 2179b0a2fdeeSScott Long memset(&fw_req_buf, 0, sizeof(fw_req_buf)); 2180b0a2fdeeSScott Long fw_req = (MSG_FW_UPLOAD *)fw_req_buf; 2181b0a2fdeeSScott Long fw_req->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM; 2182b0a2fdeeSScott Long fw_req->Function = MPI_FUNCTION_FW_UPLOAD; 2183b0a2fdeeSScott Long fw_req->MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE); 2184b0a2fdeeSScott Long tsge = (FW_UPLOAD_TCSGE *)&fw_req->SGL; 2185b0a2fdeeSScott Long tsge->DetailsLength = 12; 2186b0a2fdeeSScott Long tsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT; 2187b0a2fdeeSScott Long tsge->ImageSize = htole32(mpt->fw_image_size); 2188b0a2fdeeSScott Long sge = (SGE_SIMPLE32 *)(tsge + 1); 2189b0a2fdeeSScott Long flags = (MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER 2190b0a2fdeeSScott Long | MPI_SGE_FLAGS_END_OF_LIST | MPI_SGE_FLAGS_SIMPLE_ELEMENT 2191b0a2fdeeSScott Long | MPI_SGE_FLAGS_32_BIT_ADDRESSING | MPI_SGE_FLAGS_IOC_TO_HOST); 2192b0a2fdeeSScott Long flags <<= MPI_SGE_FLAGS_SHIFT; 2193b0a2fdeeSScott Long sge->FlagsLength = htole32(flags | mpt->fw_image_size); 2194b0a2fdeeSScott Long sge->Address = htole32(mpt->fw_phys); 2195b0a2fdeeSScott Long error = mpt_send_handshake_cmd(mpt, sizeof(fw_req_buf), &fw_req_buf); 2196b0a2fdeeSScott Long if (error) 2197b0a2fdeeSScott Long return(error); 2198b0a2fdeeSScott Long error = mpt_recv_handshake_reply(mpt, sizeof(fw_reply), &fw_reply); 2199b0a2fdeeSScott Long return (error); 2200b0a2fdeeSScott Long } 2201b0a2fdeeSScott Long 2202b0a2fdeeSScott Long static void 2203b0a2fdeeSScott Long mpt_diag_outsl(struct mpt_softc *mpt, uint32_t addr, 2204b0a2fdeeSScott Long uint32_t *data, bus_size_t len) 2205b0a2fdeeSScott Long { 2206b0a2fdeeSScott Long uint32_t *data_end; 2207b0a2fdeeSScott Long 2208b0a2fdeeSScott Long data_end = data + (roundup2(len, sizeof(uint32_t)) / 4); 22099fe6d254SMatt Jacob if (mpt->is_sas) { 2210444dd2b6SMatt Jacob pci_enable_io(mpt->dev, SYS_RES_IOPORT); 22119fe6d254SMatt Jacob } 2212b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, addr); 2213b0a2fdeeSScott Long while (data != data_end) { 2214b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, *data); 2215b0a2fdeeSScott Long data++; 2216b0a2fdeeSScott Long } 22179fe6d254SMatt Jacob if (mpt->is_sas) { 2218444dd2b6SMatt Jacob pci_disable_io(mpt->dev, SYS_RES_IOPORT); 2219b0a2fdeeSScott Long } 22209fe6d254SMatt Jacob } 2221b0a2fdeeSScott Long 2222b0a2fdeeSScott Long static int 2223b0a2fdeeSScott Long mpt_download_fw(struct mpt_softc *mpt) 2224b0a2fdeeSScott Long { 2225b0a2fdeeSScott Long MpiFwHeader_t *fw_hdr; 2226b0a2fdeeSScott Long int error; 2227b0a2fdeeSScott Long uint32_t ext_offset; 2228b0a2fdeeSScott Long uint32_t data; 2229b0a2fdeeSScott Long 2230b0a2fdeeSScott Long mpt_prt(mpt, "Downloading Firmware - Image Size %d\n", 2231b0a2fdeeSScott Long mpt->fw_image_size); 2232b0a2fdeeSScott Long 2233b0a2fdeeSScott Long error = mpt_enable_diag_mode(mpt); 2234b0a2fdeeSScott Long if (error != 0) { 2235b0a2fdeeSScott Long mpt_prt(mpt, "Could not enter diagnostic mode!\n"); 2236b0a2fdeeSScott Long return (EIO); 2237b0a2fdeeSScott Long } 2238b0a2fdeeSScott Long 2239b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, 2240b0a2fdeeSScott Long MPI_DIAG_RW_ENABLE|MPI_DIAG_DISABLE_ARM); 2241b0a2fdeeSScott Long 2242b0a2fdeeSScott Long fw_hdr = (MpiFwHeader_t *)mpt->fw_image; 2243b0a2fdeeSScott Long mpt_diag_outsl(mpt, fw_hdr->LoadStartAddress, (uint32_t*)fw_hdr, 2244b0a2fdeeSScott Long fw_hdr->ImageSize); 2245b0a2fdeeSScott Long 2246b0a2fdeeSScott Long ext_offset = fw_hdr->NextImageHeaderOffset; 2247b0a2fdeeSScott Long while (ext_offset != 0) { 2248b0a2fdeeSScott Long MpiExtImageHeader_t *ext; 2249b0a2fdeeSScott Long 2250b0a2fdeeSScott Long ext = (MpiExtImageHeader_t *)((uintptr_t)fw_hdr + ext_offset); 2251b0a2fdeeSScott Long ext_offset = ext->NextImageHeaderOffset; 2252b0a2fdeeSScott Long 2253b0a2fdeeSScott Long mpt_diag_outsl(mpt, ext->LoadStartAddress, (uint32_t*)ext, 2254b0a2fdeeSScott Long ext->ImageSize); 2255b0a2fdeeSScott Long } 2256b0a2fdeeSScott Long 22579fe6d254SMatt Jacob if (mpt->is_sas) { 2258444dd2b6SMatt Jacob pci_enable_io(mpt->dev, SYS_RES_IOPORT); 22599fe6d254SMatt Jacob } 2260b0a2fdeeSScott Long /* Setup the address to jump to on reset. */ 2261b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, fw_hdr->IopResetRegAddr); 2262b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, fw_hdr->IopResetVectorValue); 2263b0a2fdeeSScott Long 2264b0a2fdeeSScott Long /* 2265b0a2fdeeSScott Long * The controller sets the "flash bad" status after attempting 2266b0a2fdeeSScott Long * to auto-boot from flash. Clear the status so that the controller 2267b0a2fdeeSScott Long * will continue the boot process with our newly installed firmware. 2268b0a2fdeeSScott Long */ 2269b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, MPT_DIAG_MEM_CFG_BASE); 2270b0a2fdeeSScott Long data = mpt_pio_read(mpt, MPT_OFFSET_DIAG_DATA) | MPT_DIAG_MEM_CFG_BADFL; 2271b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, MPT_DIAG_MEM_CFG_BASE); 2272b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, data); 2273b0a2fdeeSScott Long 22749fe6d254SMatt Jacob if (mpt->is_sas) { 2275444dd2b6SMatt Jacob pci_disable_io(mpt->dev, SYS_RES_IOPORT); 22769fe6d254SMatt Jacob } 2277444dd2b6SMatt Jacob 2278b0a2fdeeSScott Long /* 2279b0a2fdeeSScott Long * Re-enable the processor and clear the boot halt flag. 2280b0a2fdeeSScott Long */ 2281b0a2fdeeSScott Long data = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC); 2282b0a2fdeeSScott Long data &= ~(MPI_DIAG_PREVENT_IOC_BOOT|MPI_DIAG_DISABLE_ARM); 2283b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, data); 2284b0a2fdeeSScott Long 2285b0a2fdeeSScott Long mpt_disable_diag_mode(mpt); 2286b0a2fdeeSScott Long return (0); 2287b0a2fdeeSScott Long } 2288b0a2fdeeSScott Long 2289b0a2fdeeSScott Long /* 2290b0a2fdeeSScott Long * Allocate/Initialize data structures for the controller. Called 2291b0a2fdeeSScott Long * once at instance startup. 2292b0a2fdeeSScott Long */ 2293b0a2fdeeSScott Long static int 2294b0a2fdeeSScott Long mpt_configure_ioc(struct mpt_softc *mpt) 2295b0a2fdeeSScott Long { 2296b0a2fdeeSScott Long MSG_PORT_FACTS_REPLY pfp; 2297b0a2fdeeSScott Long MSG_IOC_FACTS_REPLY facts; 2298b0a2fdeeSScott Long int try; 2299b0a2fdeeSScott Long int needreset; 2300444dd2b6SMatt Jacob uint32_t max_chain_depth; 2301b0a2fdeeSScott Long 2302b0a2fdeeSScott Long needreset = 0; 23039b631363SMatt Jacob for (try = 0; try < MPT_MAX_TRYS; try++) { 2304b0a2fdeeSScott Long 23059b631363SMatt Jacob /* 23069b631363SMatt Jacob * No need to reset if the IOC is already in the READY state. 23079b631363SMatt Jacob * 23089b631363SMatt Jacob * Force reset if initialization failed previously. 23099b631363SMatt Jacob * Note that a hard_reset of the second channel of a '929 23109b631363SMatt Jacob * will stop operation of the first channel. Hopefully, if the 23119b631363SMatt Jacob * first channel is ok, the second will not require a hard 23129b631363SMatt Jacob * reset. 23139b631363SMatt Jacob */ 2314c87e3f83SMatt Jacob if (needreset || MPT_STATE(mpt_rd_db(mpt)) != 23159b631363SMatt Jacob MPT_DB_STATE_READY) { 2316c87e3f83SMatt Jacob if (mpt_reset(mpt, FALSE) != MPT_OK) { 23179b631363SMatt Jacob continue; 23189b631363SMatt Jacob } 2319c87e3f83SMatt Jacob } 2320b0a2fdeeSScott Long needreset = 0; 23219b631363SMatt Jacob 23229b631363SMatt Jacob if (mpt_get_iocfacts(mpt, &facts) != MPT_OK) { 2323b0a2fdeeSScott Long mpt_prt(mpt, "mpt_get_iocfacts failed\n"); 2324b0a2fdeeSScott Long needreset = 1; 23259b631363SMatt Jacob continue; 23267104aeefSMatt Jacob } 23277104aeefSMatt Jacob 2328b0a2fdeeSScott Long mpt->mpt_global_credits = le16toh(facts.GlobalCredits); 2329b0a2fdeeSScott Long mpt->request_frame_size = le16toh(facts.RequestFrameSize); 2330444dd2b6SMatt Jacob mpt->ioc_facts_flags = facts.Flags; 2331b0a2fdeeSScott Long mpt_prt(mpt, "MPI Version=%d.%d.%d.%d\n", 2332b0a2fdeeSScott Long le16toh(facts.MsgVersion) >> 8, 2333b0a2fdeeSScott Long le16toh(facts.MsgVersion) & 0xFF, 2334b0a2fdeeSScott Long le16toh(facts.HeaderVersion) >> 8, 2335b0a2fdeeSScott Long le16toh(facts.HeaderVersion) & 0xFF); 2336444dd2b6SMatt Jacob 2337444dd2b6SMatt Jacob /* 2338444dd2b6SMatt Jacob * Now that we know request frame size, we can calculate 2339444dd2b6SMatt Jacob * the actual (reasonable) segment limit for read/write I/O. 2340444dd2b6SMatt Jacob * 2341444dd2b6SMatt Jacob * This limit is constrained by: 2342444dd2b6SMatt Jacob * 2343444dd2b6SMatt Jacob * + The size of each area we allocate per command (and how 2344444dd2b6SMatt Jacob * many chain segments we can fit into it). 2345444dd2b6SMatt Jacob * + The total number of areas we've set up. 2346444dd2b6SMatt Jacob * + The actual chain depth the card will allow. 2347444dd2b6SMatt Jacob * 2348444dd2b6SMatt Jacob * The first area's segment count is limited by the I/O request 2349444dd2b6SMatt Jacob * at the head of it. We cannot allocate realistically more 2350444dd2b6SMatt Jacob * than MPT_MAX_REQUESTS areas. Therefore, to account for both 2351444dd2b6SMatt Jacob * conditions, we'll just start out with MPT_MAX_REQUESTS-2. 2352444dd2b6SMatt Jacob * 2353444dd2b6SMatt Jacob */ 2354444dd2b6SMatt Jacob max_chain_depth = facts.MaxChainDepth; 2355444dd2b6SMatt Jacob 2356444dd2b6SMatt Jacob /* total number of request areas we (can) allocate */ 2357444dd2b6SMatt Jacob mpt->max_seg_cnt = MPT_MAX_REQUESTS(mpt) - 2; 2358444dd2b6SMatt Jacob 2359444dd2b6SMatt Jacob /* converted to the number of chain areas possible */ 2360444dd2b6SMatt Jacob mpt->max_seg_cnt *= MPT_NRFM(mpt); 2361444dd2b6SMatt Jacob 2362444dd2b6SMatt Jacob /* limited by the number of chain areas the card will support */ 2363444dd2b6SMatt Jacob if (mpt->max_seg_cnt > max_chain_depth) { 2364444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, 2365444dd2b6SMatt Jacob "chain depth limited to %u (from %u)\n", 2366444dd2b6SMatt Jacob max_chain_depth, mpt->max_seg_cnt); 2367444dd2b6SMatt Jacob mpt->max_seg_cnt = max_chain_depth; 2368444dd2b6SMatt Jacob } 2369444dd2b6SMatt Jacob 2370444dd2b6SMatt Jacob /* converted to the number of simple sges in chain segments. */ 2371444dd2b6SMatt Jacob mpt->max_seg_cnt *= (MPT_NSGL(mpt) - 1); 2372444dd2b6SMatt Jacob 2373444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, 2374444dd2b6SMatt Jacob "Maximum Segment Count: %u\n", mpt->max_seg_cnt); 2375b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, 2376b0a2fdeeSScott Long "MsgLength=%u IOCNumber = %d\n", 2377b0a2fdeeSScott Long facts.MsgLength, facts.IOCNumber); 2378b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, 2379444dd2b6SMatt Jacob "IOCFACTS: GlobalCredits=%d BlockSize=%u bytes " 2380444dd2b6SMatt Jacob "Request Frame Size %u bytes Max Chain Depth %u\n", 2381444dd2b6SMatt Jacob mpt->mpt_global_credits, facts.BlockSize, 2382444dd2b6SMatt Jacob mpt->request_frame_size << 2, max_chain_depth); 2383b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, 2384b0a2fdeeSScott Long "IOCFACTS: Num Ports %d, FWImageSize %d, " 2385b0a2fdeeSScott Long "Flags=%#x\n", facts.NumberOfPorts, 2386b0a2fdeeSScott Long le32toh(facts.FWImageSize), facts.Flags); 2387b0a2fdeeSScott Long 2388444dd2b6SMatt Jacob 2389b0a2fdeeSScott Long if ((facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT) != 0) { 2390b0a2fdeeSScott Long struct mpt_map_info mi; 2391b0a2fdeeSScott Long int error; 2392b0a2fdeeSScott Long 2393b0a2fdeeSScott Long /* 2394b0a2fdeeSScott Long * In some configurations, the IOC's firmware is 2395b0a2fdeeSScott Long * stored in a shared piece of system NVRAM that 2396b0a2fdeeSScott Long * is only accessable via the BIOS. In this 2397b0a2fdeeSScott Long * case, the firmware keeps a copy of firmware in 2398b0a2fdeeSScott Long * RAM until the OS driver retrieves it. Once 2399b0a2fdeeSScott Long * retrieved, we are responsible for re-downloading 2400b0a2fdeeSScott Long * the firmware after any hard-reset. 2401b0a2fdeeSScott Long */ 2402b0a2fdeeSScott Long mpt->fw_image_size = le32toh(facts.FWImageSize); 2403b0a2fdeeSScott Long error = mpt_dma_tag_create(mpt, mpt->parent_dmat, 2404b0a2fdeeSScott Long /*alignment*/1, /*boundary*/0, 2405b0a2fdeeSScott Long /*lowaddr*/BUS_SPACE_MAXADDR_32BIT, 2406b0a2fdeeSScott Long /*highaddr*/BUS_SPACE_MAXADDR, /*filter*/NULL, 2407b0a2fdeeSScott Long /*filterarg*/NULL, mpt->fw_image_size, 2408b0a2fdeeSScott Long /*nsegments*/1, /*maxsegsz*/mpt->fw_image_size, 2409b0a2fdeeSScott Long /*flags*/0, &mpt->fw_dmat); 2410b0a2fdeeSScott Long if (error != 0) { 2411b0a2fdeeSScott Long mpt_prt(mpt, "cannot create fw dma tag\n"); 2412b0a2fdeeSScott Long return (ENOMEM); 24139b631363SMatt Jacob } 2414b0a2fdeeSScott Long error = bus_dmamem_alloc(mpt->fw_dmat, 2415b0a2fdeeSScott Long (void **)&mpt->fw_image, BUS_DMA_NOWAIT, 2416b0a2fdeeSScott Long &mpt->fw_dmap); 2417b0a2fdeeSScott Long if (error != 0) { 2418b0a2fdeeSScott Long mpt_prt(mpt, "cannot allocate fw mem.\n"); 2419b0a2fdeeSScott Long bus_dma_tag_destroy(mpt->fw_dmat); 2420b0a2fdeeSScott Long return (ENOMEM); 2421b0a2fdeeSScott Long } 2422b0a2fdeeSScott Long mi.mpt = mpt; 2423b0a2fdeeSScott Long mi.error = 0; 2424b0a2fdeeSScott Long bus_dmamap_load(mpt->fw_dmat, mpt->fw_dmap, 2425b0a2fdeeSScott Long mpt->fw_image, mpt->fw_image_size, mpt_map_rquest, 2426b0a2fdeeSScott Long &mi, 0); 2427b0a2fdeeSScott Long mpt->fw_phys = mi.phys; 2428b0a2fdeeSScott Long 2429b0a2fdeeSScott Long error = mpt_upload_fw(mpt); 2430b0a2fdeeSScott Long if (error != 0) { 2431b0a2fdeeSScott Long mpt_prt(mpt, "fw upload failed.\n"); 2432b0a2fdeeSScott Long bus_dmamap_unload(mpt->fw_dmat, mpt->fw_dmap); 2433b0a2fdeeSScott Long bus_dmamem_free(mpt->fw_dmat, mpt->fw_image, 2434b0a2fdeeSScott Long mpt->fw_dmap); 2435b0a2fdeeSScott Long bus_dma_tag_destroy(mpt->fw_dmat); 2436b0a2fdeeSScott Long mpt->fw_image = NULL; 2437b0a2fdeeSScott Long return (EIO); 2438b0a2fdeeSScott Long } 2439b0a2fdeeSScott Long } 24409b631363SMatt Jacob 24417104aeefSMatt Jacob if (mpt_get_portfacts(mpt, &pfp) != MPT_OK) { 2442b0a2fdeeSScott Long mpt_prt(mpt, "mpt_get_portfacts failed\n"); 2443b0a2fdeeSScott Long needreset = 1; 24447104aeefSMatt Jacob continue; 24457104aeefSMatt Jacob } 24467104aeefSMatt Jacob 2447b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, 24487dec90bcSMatt Jacob "PORTFACTS: Type %x PFlags %x IID %d MaxDev %d\n", 24497dec90bcSMatt Jacob pfp.PortType, pfp.ProtocolFlags, pfp.PortSCSIID, 24507dec90bcSMatt Jacob pfp.MaxDevices); 24517104aeefSMatt Jacob 2452b0a2fdeeSScott Long mpt->mpt_port_type = pfp.PortType; 2453b0a2fdeeSScott Long mpt->mpt_proto_flags = pfp.ProtocolFlags; 24547104aeefSMatt Jacob if (pfp.PortType != MPI_PORTFACTS_PORTTYPE_SCSI && 2455444dd2b6SMatt Jacob pfp.PortType != MPI_PORTFACTS_PORTTYPE_SAS && 24567104aeefSMatt Jacob pfp.PortType != MPI_PORTFACTS_PORTTYPE_FC) { 2457b0a2fdeeSScott Long mpt_prt(mpt, "Unsupported Port Type (%x)\n", 24587104aeefSMatt Jacob pfp.PortType); 24597104aeefSMatt Jacob return (ENXIO); 24607104aeefSMatt Jacob } 2461c87e3f83SMatt Jacob mpt->mpt_max_tgtcmds = le16toh(pfp.MaxPostedCmdBuffers); 2462c87e3f83SMatt Jacob 24637104aeefSMatt Jacob if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_FC) { 24647104aeefSMatt Jacob mpt->is_fc = 1; 2465444dd2b6SMatt Jacob mpt->is_sas = 0; 24665580ce96SMatt Jacob mpt->is_spi = 0; 2467444dd2b6SMatt Jacob } else if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_SAS) { 2468444dd2b6SMatt Jacob mpt->is_fc = 0; 2469444dd2b6SMatt Jacob mpt->is_sas = 1; 24705580ce96SMatt Jacob mpt->is_spi = 0; 24717104aeefSMatt Jacob } else { 24727104aeefSMatt Jacob mpt->is_fc = 0; 2473444dd2b6SMatt Jacob mpt->is_sas = 0; 24745580ce96SMatt Jacob mpt->is_spi = 1; 24757104aeefSMatt Jacob } 24767104aeefSMatt Jacob mpt->mpt_ini_id = pfp.PortSCSIID; 2477444dd2b6SMatt Jacob mpt->mpt_max_devices = pfp.MaxDevices; 24787104aeefSMatt Jacob 2479c87e3f83SMatt Jacob /* 2480b4c618c0SMatt Jacob * Set our role with what this port supports. 2481b4c618c0SMatt Jacob * 2482b4c618c0SMatt Jacob * Note this might be changed later in different modules 2483b4c618c0SMatt Jacob * if this is different from what is wanted. 2484c87e3f83SMatt Jacob */ 24855089bd63SMatt Jacob mpt->role = MPT_ROLE_NONE; 2486c87e3f83SMatt Jacob if (pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) { 24875089bd63SMatt Jacob mpt->role |= MPT_ROLE_INITIATOR; 2488c87e3f83SMatt Jacob } 2489c87e3f83SMatt Jacob if (pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) { 24905089bd63SMatt Jacob mpt->role |= MPT_ROLE_TARGET; 2491c87e3f83SMatt Jacob } 2492c87e3f83SMatt Jacob if (mpt_enable_ioc(mpt, 0) != MPT_OK) { 2493c87e3f83SMatt Jacob mpt_prt(mpt, "unable to initialize IOC\n"); 2494b0a2fdeeSScott Long return (ENXIO); 24957104aeefSMatt Jacob } 24967104aeefSMatt Jacob 2497b0a2fdeeSScott Long /* 2498c87e3f83SMatt Jacob * Read IOC configuration information. 24991d79ca0eSMatt Jacob * 25001d79ca0eSMatt Jacob * We need this to determine whether or not we have certain 25011d79ca0eSMatt Jacob * settings for Integrated Mirroring (e.g.). 2502b0a2fdeeSScott Long */ 2503b0a2fdeeSScott Long mpt_read_config_info_ioc(mpt); 2504b0a2fdeeSScott Long 2505b0a2fdeeSScott Long /* Everything worked */ 2506b0a2fdeeSScott Long break; 2507b0a2fdeeSScott Long } 2508b0a2fdeeSScott Long 2509b0a2fdeeSScott Long if (try >= MPT_MAX_TRYS) { 2510b0a2fdeeSScott Long mpt_prt(mpt, "failed to initialize IOC"); 2511b0a2fdeeSScott Long return (EIO); 2512b0a2fdeeSScott Long } 2513b0a2fdeeSScott Long 2514b0a2fdeeSScott Long return (0); 2515b0a2fdeeSScott Long } 2516b0a2fdeeSScott Long 2517b0a2fdeeSScott Long static int 2518c87e3f83SMatt Jacob mpt_enable_ioc(struct mpt_softc *mpt, int portenable) 2519b0a2fdeeSScott Long { 2520b0a2fdeeSScott Long uint32_t pptr; 2521b0a2fdeeSScott Long int val; 2522b0a2fdeeSScott Long 2523444dd2b6SMatt Jacob if (mpt_send_ioc_init(mpt, MPI_WHOINIT_HOST_DRIVER) != MPT_OK) { 2524b0a2fdeeSScott Long mpt_prt(mpt, "mpt_send_ioc_init failed\n"); 2525b0a2fdeeSScott Long return (EIO); 2526b0a2fdeeSScott Long } 2527b0a2fdeeSScott Long 2528b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_send_ioc_init ok\n"); 25299b631363SMatt Jacob 25309b631363SMatt Jacob if (mpt_wait_state(mpt, MPT_DB_STATE_RUNNING) != MPT_OK) { 2531b0a2fdeeSScott Long mpt_prt(mpt, "IOC failed to go to run state\n"); 2532b0a2fdeeSScott Long return (ENXIO); 25337104aeefSMatt Jacob } 2534444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC now at RUNSTATE\n"); 25359b631363SMatt Jacob 25369b631363SMatt Jacob /* 25379b631363SMatt Jacob * Give it reply buffers 25389b631363SMatt Jacob * 2539b0a2fdeeSScott Long * Do *not* exceed global credits. 25409b631363SMatt Jacob */ 25419b631363SMatt Jacob for (val = 0, pptr = mpt->reply_phys; 25429b631363SMatt Jacob (pptr + MPT_REPLY_SIZE) < (mpt->reply_phys + PAGE_SIZE); 25439b631363SMatt Jacob pptr += MPT_REPLY_SIZE) { 25449b631363SMatt Jacob mpt_free_reply(mpt, pptr); 25459b631363SMatt Jacob if (++val == mpt->mpt_global_credits - 1) 25469b631363SMatt Jacob break; 25479b631363SMatt Jacob } 25489b631363SMatt Jacob 2549c87e3f83SMatt Jacob 2550c87e3f83SMatt Jacob /* 25515e073106SMatt Jacob * Enable the port if asked. This is only done if we're resetting 25525e073106SMatt Jacob * the IOC after initial startup. 2553c87e3f83SMatt Jacob */ 2554c87e3f83SMatt Jacob if (portenable) { 25557104aeefSMatt Jacob /* 25567104aeefSMatt Jacob * Enable asynchronous event reporting 25577104aeefSMatt Jacob */ 25589b631363SMatt Jacob mpt_send_event_request(mpt, 1); 25599b631363SMatt Jacob 25609b631363SMatt Jacob if (mpt_send_port_enable(mpt, 0) != MPT_OK) { 2561b0a2fdeeSScott Long mpt_prt(mpt, "failed to enable port 0\n"); 2562b0a2fdeeSScott Long return (ENXIO); 25637104aeefSMatt Jacob } 2564c87e3f83SMatt Jacob } 256529ae59edSMatt Jacob return (MPT_OK); 25669b631363SMatt Jacob } 2567