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. 600b80d21bSMatt Jacob */ 610b80d21bSMatt Jacob /*- 62b0a2fdeeSScott Long * Copyright (c) 2004, Avid Technology, Inc. and its contributors. 63b0a2fdeeSScott Long * Copyright (c) 2005, WHEEL Sp. z o.o. 64b0a2fdeeSScott Long * Copyright (c) 2004, 2005 Justin T. Gibbs 65b0a2fdeeSScott Long * All rights reserved. 66b0a2fdeeSScott Long * 67b0a2fdeeSScott Long * Redistribution and use in source and binary forms, with or without 68b0a2fdeeSScott Long * modification, are permitted provided that the following conditions are 69b0a2fdeeSScott Long * met: 70b0a2fdeeSScott Long * 1. Redistributions of source code must retain the above copyright 71b0a2fdeeSScott Long * notice, this list of conditions and the following disclaimer. 72b0a2fdeeSScott Long * 2. Redistributions in binary form must reproduce at minimum a disclaimer 73b0a2fdeeSScott Long * substantially similar to the "NO WARRANTY" disclaimer below 74b0a2fdeeSScott Long * ("Disclaimer") and any redistribution must be conditioned upon including 75b0a2fdeeSScott Long * a substantially similar Disclaimer requirement for further binary 76b0a2fdeeSScott Long * redistribution. 77286e947fSJustin T. Gibbs * 3. Neither the names of the above listed copyright holders nor the names 78286e947fSJustin T. Gibbs * of any contributors may be used to endorse or promote products derived 79286e947fSJustin T. Gibbs * from this software without specific prior written permission. 80b0a2fdeeSScott Long * 81b0a2fdeeSScott Long * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 82b0a2fdeeSScott Long * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 83b0a2fdeeSScott Long * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 84b0a2fdeeSScott Long * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 85b0a2fdeeSScott Long * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 86b0a2fdeeSScott Long * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 87b0a2fdeeSScott Long * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 88b0a2fdeeSScott Long * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 89b0a2fdeeSScott Long * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 90b0a2fdeeSScott Long * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF THE COPYRIGHT 91b0a2fdeeSScott Long * OWNER OR CONTRIBUTOR IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 929b631363SMatt Jacob */ 939b631363SMatt Jacob 949295c6c5SDavid E. O'Brien #include <sys/cdefs.h> 959295c6c5SDavid E. O'Brien __FBSDID("$FreeBSD$"); 969295c6c5SDavid E. O'Brien 97b0a2fdeeSScott Long #include <dev/mpt/mpt.h> 98b0a2fdeeSScott Long #include <dev/mpt/mpt_cam.h> /* XXX For static handler registration */ 99b0a2fdeeSScott Long #include <dev/mpt/mpt_raid.h> /* XXX For static handler registration */ 100b0a2fdeeSScott Long 101b0a2fdeeSScott Long #include <dev/mpt/mpilib/mpi.h> 102b0a2fdeeSScott Long #include <dev/mpt/mpilib/mpi_ioc.h> 103c87e3f83SMatt Jacob #include <dev/mpt/mpilib/mpi_fc.h> 104c87e3f83SMatt Jacob #include <dev/mpt/mpilib/mpi_targ.h> 105b0a2fdeeSScott Long 106b0a2fdeeSScott Long #include <sys/sysctl.h> 1077104aeefSMatt Jacob 1089b631363SMatt Jacob #define MPT_MAX_TRYS 3 1099b631363SMatt Jacob #define MPT_MAX_WAIT 300000 1109b631363SMatt Jacob 1119b631363SMatt Jacob static int maxwait_ack = 0; 1129b631363SMatt Jacob static int maxwait_int = 0; 1139b631363SMatt Jacob static int maxwait_state = 0; 1149b631363SMatt Jacob 115b0a2fdeeSScott Long TAILQ_HEAD(, mpt_softc) mpt_tailq = TAILQ_HEAD_INITIALIZER(mpt_tailq); 116b0a2fdeeSScott Long mpt_reply_handler_t *mpt_reply_handlers[MPT_NUM_REPLY_HANDLERS]; 1179b631363SMatt Jacob 118b0a2fdeeSScott Long static mpt_reply_handler_t mpt_default_reply_handler; 119b0a2fdeeSScott Long static mpt_reply_handler_t mpt_config_reply_handler; 120b0a2fdeeSScott Long static mpt_reply_handler_t mpt_handshake_reply_handler; 121b0a2fdeeSScott Long static mpt_reply_handler_t mpt_event_reply_handler; 122b0a2fdeeSScott Long static void mpt_send_event_ack(struct mpt_softc *mpt, request_t *ack_req, 123b0a2fdeeSScott Long MSG_EVENT_NOTIFY_REPLY *msg, uint32_t context); 124444dd2b6SMatt Jacob static int mpt_send_event_request(struct mpt_softc *mpt, int onoff); 125b0a2fdeeSScott Long static int mpt_soft_reset(struct mpt_softc *mpt); 126b0a2fdeeSScott Long static void mpt_hard_reset(struct mpt_softc *mpt); 127b0a2fdeeSScott Long static int mpt_configure_ioc(struct mpt_softc *mpt); 128c87e3f83SMatt Jacob static int mpt_enable_ioc(struct mpt_softc *mpt, int); 129b0a2fdeeSScott Long 130b0a2fdeeSScott Long /************************* Personality Module Support *************************/ 131b0a2fdeeSScott Long /* 132b0a2fdeeSScott Long * We include one extra entry that is guaranteed to be NULL 133b0a2fdeeSScott Long * to simplify our itterator. 134b0a2fdeeSScott Long */ 135b0a2fdeeSScott Long static struct mpt_personality *mpt_personalities[MPT_MAX_PERSONALITIES + 1]; 136b0a2fdeeSScott Long static __inline struct mpt_personality* 137b0a2fdeeSScott Long mpt_pers_find(struct mpt_softc *, u_int); 138b0a2fdeeSScott Long static __inline struct mpt_personality* 139b0a2fdeeSScott Long mpt_pers_find_reverse(struct mpt_softc *, u_int); 140b0a2fdeeSScott Long 141b0a2fdeeSScott Long static __inline struct mpt_personality * 142b0a2fdeeSScott Long mpt_pers_find(struct mpt_softc *mpt, u_int start_at) 143b0a2fdeeSScott Long { 144b0a2fdeeSScott Long KASSERT(start_at <= MPT_MAX_PERSONALITIES, 145b0a2fdeeSScott Long ("mpt_pers_find: starting position out of range\n")); 146b0a2fdeeSScott Long 147b0a2fdeeSScott Long while (start_at < MPT_MAX_PERSONALITIES 148b0a2fdeeSScott Long && (mpt->mpt_pers_mask & (0x1 << start_at)) == 0) { 149b0a2fdeeSScott Long start_at++; 150b0a2fdeeSScott Long } 151b0a2fdeeSScott Long return (mpt_personalities[start_at]); 152b0a2fdeeSScott Long } 153b0a2fdeeSScott Long 154b0a2fdeeSScott Long /* 155c87e3f83SMatt Jacob * Used infrequently, so no need to optimize like a forward 156b0a2fdeeSScott Long * traversal where we use the MAX+1 is guaranteed to be NULL 157b0a2fdeeSScott Long * trick. 158b0a2fdeeSScott Long */ 159b0a2fdeeSScott Long static __inline struct mpt_personality * 160b0a2fdeeSScott Long mpt_pers_find_reverse(struct mpt_softc *mpt, u_int start_at) 161b0a2fdeeSScott Long { 162b0a2fdeeSScott Long while (start_at < MPT_MAX_PERSONALITIES 163b0a2fdeeSScott Long && (mpt->mpt_pers_mask & (0x1 << start_at)) == 0) { 164b0a2fdeeSScott Long start_at--; 165b0a2fdeeSScott Long } 166b0a2fdeeSScott Long if (start_at < MPT_MAX_PERSONALITIES) 167b0a2fdeeSScott Long return (mpt_personalities[start_at]); 168b0a2fdeeSScott Long return (NULL); 169b0a2fdeeSScott Long } 170b0a2fdeeSScott Long 171b0a2fdeeSScott Long #define MPT_PERS_FOREACH(mpt, pers) \ 172b0a2fdeeSScott Long for (pers = mpt_pers_find(mpt, /*start_at*/0); \ 173b0a2fdeeSScott Long pers != NULL; \ 174b0a2fdeeSScott Long pers = mpt_pers_find(mpt, /*start_at*/pers->id+1)) 175b0a2fdeeSScott Long 176b0a2fdeeSScott Long #define MPT_PERS_FOREACH_REVERSE(mpt, pers) \ 177b0a2fdeeSScott Long for (pers = mpt_pers_find_reverse(mpt, MPT_MAX_PERSONALITIES-1);\ 178b0a2fdeeSScott Long pers != NULL; \ 179b0a2fdeeSScott Long pers = mpt_pers_find_reverse(mpt, /*start_at*/pers->id-1)) 180b0a2fdeeSScott Long 181b0a2fdeeSScott Long static mpt_load_handler_t mpt_stdload; 182b0a2fdeeSScott Long static mpt_probe_handler_t mpt_stdprobe; 183b0a2fdeeSScott Long static mpt_attach_handler_t mpt_stdattach; 184c87e3f83SMatt Jacob static mpt_enable_handler_t mpt_stdenable; 185b0a2fdeeSScott Long static mpt_event_handler_t mpt_stdevent; 186b0a2fdeeSScott Long static mpt_reset_handler_t mpt_stdreset; 187b0a2fdeeSScott Long static mpt_shutdown_handler_t mpt_stdshutdown; 188b0a2fdeeSScott Long static mpt_detach_handler_t mpt_stddetach; 189b0a2fdeeSScott Long static mpt_unload_handler_t mpt_stdunload; 190b0a2fdeeSScott Long static struct mpt_personality mpt_default_personality = 191b0a2fdeeSScott Long { 192b0a2fdeeSScott Long .load = mpt_stdload, 193b0a2fdeeSScott Long .probe = mpt_stdprobe, 194b0a2fdeeSScott Long .attach = mpt_stdattach, 195c87e3f83SMatt Jacob .enable = mpt_stdenable, 196b0a2fdeeSScott Long .event = mpt_stdevent, 197b0a2fdeeSScott Long .reset = mpt_stdreset, 198b0a2fdeeSScott Long .shutdown = mpt_stdshutdown, 199b0a2fdeeSScott Long .detach = mpt_stddetach, 200b0a2fdeeSScott Long .unload = mpt_stdunload 201b0a2fdeeSScott Long }; 202b0a2fdeeSScott Long 203b0a2fdeeSScott Long static mpt_load_handler_t mpt_core_load; 204b0a2fdeeSScott Long static mpt_attach_handler_t mpt_core_attach; 205c87e3f83SMatt Jacob static mpt_enable_handler_t mpt_core_enable; 206b0a2fdeeSScott Long static mpt_reset_handler_t mpt_core_ioc_reset; 207b0a2fdeeSScott Long static mpt_event_handler_t mpt_core_event; 208b0a2fdeeSScott Long static mpt_shutdown_handler_t mpt_core_shutdown; 209b0a2fdeeSScott Long static mpt_shutdown_handler_t mpt_core_detach; 210b0a2fdeeSScott Long static mpt_unload_handler_t mpt_core_unload; 211b0a2fdeeSScott Long static struct mpt_personality mpt_core_personality = 212b0a2fdeeSScott Long { 213b0a2fdeeSScott Long .name = "mpt_core", 214b0a2fdeeSScott Long .load = mpt_core_load, 215b0a2fdeeSScott Long .attach = mpt_core_attach, 216c87e3f83SMatt Jacob .enable = mpt_core_enable, 217b0a2fdeeSScott Long .event = mpt_core_event, 218b0a2fdeeSScott Long .reset = mpt_core_ioc_reset, 219b0a2fdeeSScott Long .shutdown = mpt_core_shutdown, 220b0a2fdeeSScott Long .detach = mpt_core_detach, 221b0a2fdeeSScott Long .unload = mpt_core_unload, 222b0a2fdeeSScott Long }; 223b0a2fdeeSScott Long 224b0a2fdeeSScott Long /* 225b0a2fdeeSScott Long * Manual declaration so that DECLARE_MPT_PERSONALITY doesn't need 226b0a2fdeeSScott Long * ordering information. We want the core to always register FIRST. 227b0a2fdeeSScott Long * other modules are set to SI_ORDER_SECOND. 228b0a2fdeeSScott Long */ 229b0a2fdeeSScott Long static moduledata_t mpt_core_mod = { 230b0a2fdeeSScott Long "mpt_core", mpt_modevent, &mpt_core_personality 231b0a2fdeeSScott Long }; 232b0a2fdeeSScott Long DECLARE_MODULE(mpt_core, mpt_core_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST); 233b0a2fdeeSScott Long MODULE_VERSION(mpt_core, 1); 234b0a2fdeeSScott Long 235c87e3f83SMatt Jacob #define MPT_PERS_ATTACHED(pers, mpt) ((mpt)->mpt_pers_mask & (0x1 << pers->id)) 236b0a2fdeeSScott Long 237b0a2fdeeSScott Long 238b0a2fdeeSScott Long int 239b0a2fdeeSScott Long mpt_modevent(module_t mod, int type, void *data) 240b0a2fdeeSScott Long { 241b0a2fdeeSScott Long struct mpt_personality *pers; 242b0a2fdeeSScott Long int error; 243b0a2fdeeSScott Long 244b0a2fdeeSScott Long pers = (struct mpt_personality *)data; 245b0a2fdeeSScott Long 246b0a2fdeeSScott Long error = 0; 247b0a2fdeeSScott Long switch (type) { 248b0a2fdeeSScott Long case MOD_LOAD: 249b0a2fdeeSScott Long { 250b0a2fdeeSScott Long mpt_load_handler_t **def_handler; 251b0a2fdeeSScott Long mpt_load_handler_t **pers_handler; 252b0a2fdeeSScott Long int i; 253b0a2fdeeSScott Long 254b0a2fdeeSScott Long for (i = 0; i < MPT_MAX_PERSONALITIES; i++) { 255b0a2fdeeSScott Long if (mpt_personalities[i] == NULL) 256b0a2fdeeSScott Long break; 257b0a2fdeeSScott Long } 258b0a2fdeeSScott Long if (i >= MPT_MAX_PERSONALITIES) { 259b0a2fdeeSScott Long error = ENOMEM; 260b0a2fdeeSScott Long break; 261b0a2fdeeSScott Long } 262b0a2fdeeSScott Long pers->id = i; 263b0a2fdeeSScott Long mpt_personalities[i] = pers; 264b0a2fdeeSScott Long 265b0a2fdeeSScott Long /* Install standard/noop handlers for any NULL entries. */ 266b0a2fdeeSScott Long def_handler = MPT_PERS_FIRST_HANDLER(&mpt_default_personality); 267b0a2fdeeSScott Long pers_handler = MPT_PERS_FIRST_HANDLER(pers); 268b0a2fdeeSScott Long while (pers_handler <= MPT_PERS_LAST_HANDLER(pers)) { 269b0a2fdeeSScott Long if (*pers_handler == NULL) 270b0a2fdeeSScott Long *pers_handler = *def_handler; 271b0a2fdeeSScott Long pers_handler++; 272b0a2fdeeSScott Long def_handler++; 273b0a2fdeeSScott Long } 274b0a2fdeeSScott Long 275b0a2fdeeSScott Long error = (pers->load(pers)); 276b0a2fdeeSScott Long if (error != 0) 277b0a2fdeeSScott Long mpt_personalities[i] = NULL; 278b0a2fdeeSScott Long break; 279b0a2fdeeSScott Long } 280b0a2fdeeSScott Long case MOD_SHUTDOWN: 281b0a2fdeeSScott Long break; 282c87e3f83SMatt Jacob #if __FreeBSD_version >= 500000 283b0a2fdeeSScott Long case MOD_QUIESCE: 284b0a2fdeeSScott Long break; 285c87e3f83SMatt Jacob #endif 286b0a2fdeeSScott Long case MOD_UNLOAD: 287b0a2fdeeSScott Long error = pers->unload(pers); 288b0a2fdeeSScott Long mpt_personalities[pers->id] = NULL; 289b0a2fdeeSScott Long break; 290b0a2fdeeSScott Long default: 291b0a2fdeeSScott Long error = EINVAL; 292b0a2fdeeSScott Long break; 293b0a2fdeeSScott Long } 294b0a2fdeeSScott Long return (error); 295b0a2fdeeSScott Long } 296b0a2fdeeSScott Long 297b0a2fdeeSScott Long int 298b0a2fdeeSScott Long mpt_stdload(struct mpt_personality *pers) 299b0a2fdeeSScott Long { 300b0a2fdeeSScott Long /* Load is always successfull. */ 301b0a2fdeeSScott Long return (0); 302b0a2fdeeSScott Long } 303b0a2fdeeSScott Long 304b0a2fdeeSScott Long int 305b0a2fdeeSScott Long mpt_stdprobe(struct mpt_softc *mpt) 306b0a2fdeeSScott Long { 307b0a2fdeeSScott Long /* Probe is always successfull. */ 308b0a2fdeeSScott Long return (0); 309b0a2fdeeSScott Long } 310b0a2fdeeSScott Long 311b0a2fdeeSScott Long int 312b0a2fdeeSScott Long mpt_stdattach(struct mpt_softc *mpt) 313b0a2fdeeSScott Long { 314b0a2fdeeSScott Long /* Attach is always successfull. */ 315b0a2fdeeSScott Long return (0); 316b0a2fdeeSScott Long } 317b0a2fdeeSScott Long 318b0a2fdeeSScott Long int 319c87e3f83SMatt Jacob mpt_stdenable(struct mpt_softc *mpt) 320c87e3f83SMatt Jacob { 321c87e3f83SMatt Jacob /* Enable is always successfull. */ 322c87e3f83SMatt Jacob return (0); 323c87e3f83SMatt Jacob } 324c87e3f83SMatt Jacob 325c87e3f83SMatt Jacob int 326444dd2b6SMatt Jacob mpt_stdevent(struct mpt_softc *mpt, request_t *req, MSG_EVENT_NOTIFY_REPLY *msg) 327b0a2fdeeSScott Long { 328444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_stdevent: 0x%x\n", msg->Event & 0xFF); 329b0a2fdeeSScott Long /* Event was not for us. */ 330b0a2fdeeSScott Long return (0); 331b0a2fdeeSScott Long } 332b0a2fdeeSScott Long 333b0a2fdeeSScott Long void 334b0a2fdeeSScott Long mpt_stdreset(struct mpt_softc *mpt, int type) 335b0a2fdeeSScott Long { 336b0a2fdeeSScott Long } 337b0a2fdeeSScott Long 338b0a2fdeeSScott Long void 339b0a2fdeeSScott Long mpt_stdshutdown(struct mpt_softc *mpt) 340b0a2fdeeSScott Long { 341b0a2fdeeSScott Long } 342b0a2fdeeSScott Long 343b0a2fdeeSScott Long void 344b0a2fdeeSScott Long mpt_stddetach(struct mpt_softc *mpt) 345b0a2fdeeSScott Long { 346b0a2fdeeSScott Long } 347b0a2fdeeSScott Long 348b0a2fdeeSScott Long int 349b0a2fdeeSScott Long mpt_stdunload(struct mpt_personality *pers) 350b0a2fdeeSScott Long { 351b0a2fdeeSScott Long /* Unload is always successfull. */ 352b0a2fdeeSScott Long return (0); 353b0a2fdeeSScott Long } 354b0a2fdeeSScott Long 355b0a2fdeeSScott Long /******************************* Bus DMA Support ******************************/ 356b0a2fdeeSScott Long void 357b0a2fdeeSScott Long mpt_map_rquest(void *arg, bus_dma_segment_t *segs, int nseg, int error) 358b0a2fdeeSScott Long { 359b0a2fdeeSScott Long struct mpt_map_info *map_info; 360b0a2fdeeSScott Long 361b0a2fdeeSScott Long map_info = (struct mpt_map_info *)arg; 362b0a2fdeeSScott Long map_info->error = error; 363b0a2fdeeSScott Long map_info->phys = segs->ds_addr; 364b0a2fdeeSScott Long } 365b0a2fdeeSScott Long 366b0a2fdeeSScott Long /**************************** Reply/Event Handling ****************************/ 367b0a2fdeeSScott Long int 368b0a2fdeeSScott Long mpt_register_handler(struct mpt_softc *mpt, mpt_handler_type type, 369b0a2fdeeSScott Long mpt_handler_t handler, uint32_t *phandler_id) 370b0a2fdeeSScott Long { 371b0a2fdeeSScott Long 372b0a2fdeeSScott Long switch (type) { 373b0a2fdeeSScott Long case MPT_HANDLER_REPLY: 374b0a2fdeeSScott Long { 375b0a2fdeeSScott Long u_int cbi; 376b0a2fdeeSScott Long u_int free_cbi; 377b0a2fdeeSScott Long 378b0a2fdeeSScott Long if (phandler_id == NULL) 379b0a2fdeeSScott Long return (EINVAL); 380b0a2fdeeSScott Long 381b0a2fdeeSScott Long free_cbi = MPT_HANDLER_ID_NONE; 382b0a2fdeeSScott Long for (cbi = 0; cbi < MPT_NUM_REPLY_HANDLERS; cbi++) { 383b0a2fdeeSScott Long /* 384b0a2fdeeSScott Long * If the same handler is registered multiple 385b0a2fdeeSScott Long * times, don't error out. Just return the 386b0a2fdeeSScott Long * index of the original registration. 387b0a2fdeeSScott Long */ 388b0a2fdeeSScott Long if (mpt_reply_handlers[cbi] == handler.reply_handler) { 389b0a2fdeeSScott Long *phandler_id = MPT_CBI_TO_HID(cbi); 390b0a2fdeeSScott Long return (0); 391b0a2fdeeSScott Long } 392b0a2fdeeSScott Long 393b0a2fdeeSScott Long /* 394b0a2fdeeSScott Long * Fill from the front in the hope that 395b0a2fdeeSScott Long * all registered handlers consume only a 396b0a2fdeeSScott Long * single cache line. 397b0a2fdeeSScott Long * 398b0a2fdeeSScott Long * We don't break on the first empty slot so 399b0a2fdeeSScott Long * that the full table is checked to see if 400b0a2fdeeSScott Long * this handler was previously registered. 401b0a2fdeeSScott Long */ 402c87e3f83SMatt Jacob if (free_cbi == MPT_HANDLER_ID_NONE && 403c87e3f83SMatt Jacob (mpt_reply_handlers[cbi] 404b0a2fdeeSScott Long == mpt_default_reply_handler)) 405b0a2fdeeSScott Long free_cbi = cbi; 406b0a2fdeeSScott Long } 407c87e3f83SMatt Jacob if (free_cbi == MPT_HANDLER_ID_NONE) { 408b0a2fdeeSScott Long return (ENOMEM); 409c87e3f83SMatt Jacob } 410b0a2fdeeSScott Long mpt_reply_handlers[free_cbi] = handler.reply_handler; 411b0a2fdeeSScott Long *phandler_id = MPT_CBI_TO_HID(free_cbi); 412b0a2fdeeSScott Long break; 413b0a2fdeeSScott Long } 414b0a2fdeeSScott Long default: 415b0a2fdeeSScott Long mpt_prt(mpt, "mpt_register_handler unknown type %d\n", type); 416b0a2fdeeSScott Long return (EINVAL); 417b0a2fdeeSScott Long } 418b0a2fdeeSScott Long return (0); 419b0a2fdeeSScott Long } 420b0a2fdeeSScott Long 421b0a2fdeeSScott Long int 422b0a2fdeeSScott Long mpt_deregister_handler(struct mpt_softc *mpt, mpt_handler_type type, 423b0a2fdeeSScott Long mpt_handler_t handler, uint32_t handler_id) 424b0a2fdeeSScott Long { 425b0a2fdeeSScott Long 426b0a2fdeeSScott Long switch (type) { 427b0a2fdeeSScott Long case MPT_HANDLER_REPLY: 428b0a2fdeeSScott Long { 429b0a2fdeeSScott Long u_int cbi; 430b0a2fdeeSScott Long 431b0a2fdeeSScott Long cbi = MPT_CBI(handler_id); 432b0a2fdeeSScott Long if (cbi >= MPT_NUM_REPLY_HANDLERS 433b0a2fdeeSScott Long || mpt_reply_handlers[cbi] != handler.reply_handler) 434b0a2fdeeSScott Long return (ENOENT); 435b0a2fdeeSScott Long mpt_reply_handlers[cbi] = mpt_default_reply_handler; 436b0a2fdeeSScott Long break; 437b0a2fdeeSScott Long } 438b0a2fdeeSScott Long default: 439b0a2fdeeSScott Long mpt_prt(mpt, "mpt_deregister_handler unknown type %d\n", type); 440b0a2fdeeSScott Long return (EINVAL); 441b0a2fdeeSScott Long } 442b0a2fdeeSScott Long return (0); 443b0a2fdeeSScott Long } 444b0a2fdeeSScott Long 445b0a2fdeeSScott Long static int 446b0a2fdeeSScott Long mpt_default_reply_handler(struct mpt_softc *mpt, request_t *req, 447c87e3f83SMatt Jacob uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 448b0a2fdeeSScott Long { 449c87e3f83SMatt Jacob mpt_prt(mpt, 450c87e3f83SMatt Jacob "Default Handler Called: req=%p:%u reply_descriptor=%x frame=%p\n", 451c87e3f83SMatt Jacob req, req->serno, reply_desc, reply_frame); 452b0a2fdeeSScott Long 453b0a2fdeeSScott Long if (reply_frame != NULL) 454b0a2fdeeSScott Long mpt_dump_reply_frame(mpt, reply_frame); 455b0a2fdeeSScott Long 456c87e3f83SMatt Jacob mpt_prt(mpt, "Reply Frame Ignored\n"); 457b0a2fdeeSScott Long 458b0a2fdeeSScott Long return (/*free_reply*/TRUE); 459b0a2fdeeSScott Long } 460b0a2fdeeSScott Long 461b0a2fdeeSScott Long static int 462b0a2fdeeSScott Long mpt_config_reply_handler(struct mpt_softc *mpt, request_t *req, 463c87e3f83SMatt Jacob uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 464b0a2fdeeSScott Long { 465b0a2fdeeSScott Long if (req != NULL) { 466b0a2fdeeSScott Long 467b0a2fdeeSScott Long if (reply_frame != NULL) { 468b0a2fdeeSScott Long MSG_CONFIG *cfgp; 469b0a2fdeeSScott Long MSG_CONFIG_REPLY *reply; 470b0a2fdeeSScott Long 471b0a2fdeeSScott Long cfgp = (MSG_CONFIG *)req->req_vbuf; 472b0a2fdeeSScott Long reply = (MSG_CONFIG_REPLY *)reply_frame; 473b0a2fdeeSScott Long req->IOCStatus = le16toh(reply_frame->IOCStatus); 474b0a2fdeeSScott Long bcopy(&reply->Header, &cfgp->Header, 475b0a2fdeeSScott Long sizeof(cfgp->Header)); 476b0a2fdeeSScott Long } 477b0a2fdeeSScott Long req->state &= ~REQ_STATE_QUEUED; 478b0a2fdeeSScott Long req->state |= REQ_STATE_DONE; 479b0a2fdeeSScott Long TAILQ_REMOVE(&mpt->request_pending_list, req, links); 4805e073106SMatt Jacob if ((req->state & REQ_STATE_NEED_WAKEUP) != 0) { 481b0a2fdeeSScott Long wakeup(req); 482b0a2fdeeSScott Long } 4835e073106SMatt Jacob } 484b0a2fdeeSScott Long 4855e073106SMatt Jacob return (TRUE); 486b0a2fdeeSScott Long } 487b0a2fdeeSScott Long 488b0a2fdeeSScott Long static int 489b0a2fdeeSScott Long mpt_handshake_reply_handler(struct mpt_softc *mpt, request_t *req, 490c87e3f83SMatt Jacob uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 491b0a2fdeeSScott Long { 492b0a2fdeeSScott Long /* Nothing to be done. */ 4935e073106SMatt Jacob return (TRUE); 494b0a2fdeeSScott Long } 495b0a2fdeeSScott Long 496b0a2fdeeSScott Long static int 497b0a2fdeeSScott Long mpt_event_reply_handler(struct mpt_softc *mpt, request_t *req, 498c87e3f83SMatt Jacob uint32_t reply_desc, MSG_DEFAULT_REPLY *reply_frame) 499b0a2fdeeSScott Long { 500b0a2fdeeSScott Long int free_reply; 501b0a2fdeeSScott Long 5025e073106SMatt Jacob KASSERT(reply_frame != NULL, ("null reply in mpt_event_reply_handler")); 5035e073106SMatt Jacob KASSERT(req != NULL, ("null request in mpt_event_reply_handler")); 504b0a2fdeeSScott Long 505b0a2fdeeSScott Long free_reply = TRUE; 506b0a2fdeeSScott Long switch (reply_frame->Function) { 507b0a2fdeeSScott Long case MPI_FUNCTION_EVENT_NOTIFICATION: 508b0a2fdeeSScott Long { 509b0a2fdeeSScott Long MSG_EVENT_NOTIFY_REPLY *msg; 510b0a2fdeeSScott Long struct mpt_personality *pers; 511b0a2fdeeSScott Long u_int handled; 512b0a2fdeeSScott Long 513b0a2fdeeSScott Long handled = 0; 514b0a2fdeeSScott Long msg = (MSG_EVENT_NOTIFY_REPLY *)reply_frame; 515b0a2fdeeSScott Long MPT_PERS_FOREACH(mpt, pers) 516b0a2fdeeSScott Long handled += pers->event(mpt, req, msg); 517b0a2fdeeSScott Long 518444dd2b6SMatt Jacob if (handled == 0 && mpt->mpt_pers_mask == 0) { 5191977cbd6SMatt Jacob mpt_lprt(mpt, MPT_PRT_INFO, 520444dd2b6SMatt Jacob "No Handlers For Any Event Notify Frames. " 521444dd2b6SMatt Jacob "Event %#x (ACK %sequired).\n", 522444dd2b6SMatt Jacob msg->Event, msg->AckRequired? "r" : "not r"); 523444dd2b6SMatt Jacob } else if (handled == 0) { 5241977cbd6SMatt Jacob mpt_lprt(mpt, MPT_PRT_WARN, 525444dd2b6SMatt Jacob "Unhandled Event Notify Frame. Event %#x " 526444dd2b6SMatt Jacob "(ACK %sequired).\n", 527444dd2b6SMatt Jacob msg->Event, msg->AckRequired? "r" : "not r"); 528444dd2b6SMatt Jacob } 529b0a2fdeeSScott Long 530b0a2fdeeSScott Long if (msg->AckRequired) { 531b0a2fdeeSScott Long request_t *ack_req; 532b0a2fdeeSScott Long uint32_t context; 533b0a2fdeeSScott Long 534b0a2fdeeSScott Long context = htole32(req->index|MPT_REPLY_HANDLER_EVENTS); 5355e073106SMatt Jacob ack_req = mpt_get_request(mpt, FALSE); 536b0a2fdeeSScott Long if (ack_req == NULL) { 537b0a2fdeeSScott Long struct mpt_evtf_record *evtf; 538b0a2fdeeSScott Long 539b0a2fdeeSScott Long evtf = (struct mpt_evtf_record *)reply_frame; 540b0a2fdeeSScott Long evtf->context = context; 541b0a2fdeeSScott Long LIST_INSERT_HEAD(&mpt->ack_frames, evtf, links); 542b0a2fdeeSScott Long free_reply = FALSE; 543b0a2fdeeSScott Long break; 544b0a2fdeeSScott Long } 545b0a2fdeeSScott Long mpt_send_event_ack(mpt, ack_req, msg, context); 5465e073106SMatt Jacob /* 5475e073106SMatt Jacob * Don't check for CONTINUATION_REPLY here 5485e073106SMatt Jacob */ 5495e073106SMatt Jacob return (free_reply); 550b0a2fdeeSScott Long } 551b0a2fdeeSScott Long break; 552b0a2fdeeSScott Long } 553b0a2fdeeSScott Long case MPI_FUNCTION_PORT_ENABLE: 554b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG , "enable port reply\n"); 555b0a2fdeeSScott Long break; 556b0a2fdeeSScott Long case MPI_FUNCTION_EVENT_ACK: 557b0a2fdeeSScott Long break; 558b0a2fdeeSScott Long default: 5595e073106SMatt Jacob mpt_prt(mpt, "unknown event function: %x\n", 560b0a2fdeeSScott Long reply_frame->Function); 561b0a2fdeeSScott Long break; 562b0a2fdeeSScott Long } 563b0a2fdeeSScott Long 5645e073106SMatt Jacob /* 5655e073106SMatt Jacob * I'm not sure that this continuation stuff works as it should. 5665e073106SMatt Jacob * 5675e073106SMatt Jacob * I've had FC async events occur that free the frame up because 5685e073106SMatt Jacob * the continuation bit isn't set, and then additional async events 5695e073106SMatt Jacob * then occur using the same context. As you might imagine, this 5705e073106SMatt Jacob * leads to Very Bad Thing. 5715e073106SMatt Jacob * 5725e073106SMatt Jacob * Let's just be safe for now and not free them up until we figure 5735e073106SMatt Jacob * out what's actually happening here. 5745e073106SMatt Jacob */ 5755e073106SMatt Jacob #if 0 5765e073106SMatt Jacob if ((reply_frame->MsgFlags & MPI_MSGFLAGS_CONTINUATION_REPLY) == 0) { 577b0a2fdeeSScott Long TAILQ_REMOVE(&mpt->request_pending_list, req, links); 578b0a2fdeeSScott Long mpt_free_request(mpt, req); 5795e073106SMatt Jacob mpt_prt(mpt, "event_reply %x for req %p:%u NOT a continuation", 5805e073106SMatt Jacob reply_frame->Function, req, req->serno); 5815e073106SMatt Jacob if (reply_frame->Function == MPI_FUNCTION_EVENT_NOTIFICATION) { 5825e073106SMatt Jacob MSG_EVENT_NOTIFY_REPLY *msg = 5835e073106SMatt Jacob (MSG_EVENT_NOTIFY_REPLY *)reply_frame; 5845e073106SMatt Jacob mpt_prtc(mpt, " Event=0x%x AckReq=%d", 5855e073106SMatt Jacob msg->Event, msg->AckRequired); 586b0a2fdeeSScott Long } 5875e073106SMatt Jacob } else { 5885e073106SMatt Jacob mpt_prt(mpt, "event_reply %x for %p:%u IS a continuation", 5895e073106SMatt Jacob reply_frame->Function, req, req->serno); 5905e073106SMatt Jacob if (reply_frame->Function == MPI_FUNCTION_EVENT_NOTIFICATION) { 5915e073106SMatt Jacob MSG_EVENT_NOTIFY_REPLY *msg = 5925e073106SMatt Jacob (MSG_EVENT_NOTIFY_REPLY *)reply_frame; 5935e073106SMatt Jacob mpt_prtc(mpt, " Event=0x%x AckReq=%d", 5945e073106SMatt Jacob msg->Event, msg->AckRequired); 5955e073106SMatt Jacob } 5965e073106SMatt Jacob mpt_prtc(mpt, "\n"); 5975e073106SMatt Jacob } 5985e073106SMatt Jacob #endif 599b0a2fdeeSScott Long return (free_reply); 600b0a2fdeeSScott Long } 601b0a2fdeeSScott Long 602b0a2fdeeSScott Long /* 603b0a2fdeeSScott Long * Process an asynchronous event from the IOC. 604b0a2fdeeSScott Long */ 605b0a2fdeeSScott Long static int 606b0a2fdeeSScott Long mpt_core_event(struct mpt_softc *mpt, request_t *req, 607b0a2fdeeSScott Long MSG_EVENT_NOTIFY_REPLY *msg) 608b0a2fdeeSScott Long { 609444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_core_event: 0x%x\n", 610444dd2b6SMatt Jacob msg->Event & 0xFF); 611b0a2fdeeSScott Long switch(msg->Event & 0xFF) { 612b0a2fdeeSScott Long case MPI_EVENT_NONE: 613b0a2fdeeSScott Long break; 614b0a2fdeeSScott Long case MPI_EVENT_LOG_DATA: 615b0a2fdeeSScott Long { 616b0a2fdeeSScott Long int i; 617b0a2fdeeSScott Long 618b0a2fdeeSScott Long /* Some error occured that LSI wants logged */ 619b0a2fdeeSScott Long mpt_prt(mpt, "EvtLogData: IOCLogInfo: 0x%08x\n", 620b0a2fdeeSScott Long msg->IOCLogInfo); 621b0a2fdeeSScott Long mpt_prt(mpt, "\tEvtLogData: Event Data:"); 622b0a2fdeeSScott Long for (i = 0; i < msg->EventDataLength; i++) 623b0a2fdeeSScott Long mpt_prtc(mpt, " %08x", msg->Data[i]); 624b0a2fdeeSScott Long mpt_prtc(mpt, "\n"); 625b0a2fdeeSScott Long break; 626b0a2fdeeSScott Long } 627b0a2fdeeSScott Long case MPI_EVENT_EVENT_CHANGE: 628b0a2fdeeSScott Long /* 629b0a2fdeeSScott Long * This is just an acknowledgement 630b0a2fdeeSScott Long * of our mpt_send_event_request. 631b0a2fdeeSScott Long */ 632b0a2fdeeSScott Long break; 633444dd2b6SMatt Jacob case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE: 634444dd2b6SMatt Jacob break; 635b0a2fdeeSScott Long default: 6365e073106SMatt Jacob return (0); 637b0a2fdeeSScott Long break; 638b0a2fdeeSScott Long } 6395e073106SMatt Jacob return (1); 640b0a2fdeeSScott Long } 641b0a2fdeeSScott Long 642b0a2fdeeSScott Long static void 643b0a2fdeeSScott Long mpt_send_event_ack(struct mpt_softc *mpt, request_t *ack_req, 644b0a2fdeeSScott Long MSG_EVENT_NOTIFY_REPLY *msg, uint32_t context) 645b0a2fdeeSScott Long { 646b0a2fdeeSScott Long MSG_EVENT_ACK *ackp; 647b0a2fdeeSScott Long 648b0a2fdeeSScott Long ackp = (MSG_EVENT_ACK *)ack_req->req_vbuf; 6495e073106SMatt Jacob memset(ackp, 0, sizeof (*ackp)); 650b0a2fdeeSScott Long ackp->Function = MPI_FUNCTION_EVENT_ACK; 651b0a2fdeeSScott Long ackp->Event = msg->Event; 652b0a2fdeeSScott Long ackp->EventContext = msg->EventContext; 653b0a2fdeeSScott Long ackp->MsgContext = context; 654b0a2fdeeSScott Long mpt_check_doorbell(mpt); 655b0a2fdeeSScott Long mpt_send_cmd(mpt, ack_req); 656b0a2fdeeSScott Long } 657b0a2fdeeSScott Long 658b0a2fdeeSScott Long /***************************** Interrupt Handling *****************************/ 659b0a2fdeeSScott Long void 660b0a2fdeeSScott Long mpt_intr(void *arg) 661b0a2fdeeSScott Long { 662b0a2fdeeSScott Long struct mpt_softc *mpt; 663b0a2fdeeSScott Long uint32_t reply_desc; 664c87e3f83SMatt Jacob int ntrips = 0; 665b0a2fdeeSScott Long 666b0a2fdeeSScott Long mpt = (struct mpt_softc *)arg; 6675089bd63SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG2, "enter mpt_intr\n"); 668b0a2fdeeSScott Long while ((reply_desc = mpt_pop_reply_queue(mpt)) != MPT_REPLY_EMPTY) { 669b0a2fdeeSScott Long request_t *req; 670b0a2fdeeSScott Long MSG_DEFAULT_REPLY *reply_frame; 671b0a2fdeeSScott Long uint32_t reply_baddr; 672c87e3f83SMatt Jacob uint32_t ctxt_idx; 673b0a2fdeeSScott Long u_int cb_index; 674b0a2fdeeSScott Long u_int req_index; 675b0a2fdeeSScott Long int free_rf; 676b0a2fdeeSScott Long 677b0a2fdeeSScott Long req = NULL; 678b0a2fdeeSScott Long reply_frame = NULL; 679b0a2fdeeSScott Long reply_baddr = 0; 680b0a2fdeeSScott Long if ((reply_desc & MPI_ADDRESS_REPLY_A_BIT) != 0) { 681b0a2fdeeSScott Long u_int offset; 682b0a2fdeeSScott Long /* 683b0a2fdeeSScott Long * Insure that the reply frame is coherent. 684b0a2fdeeSScott Long */ 6855e073106SMatt Jacob reply_baddr = MPT_REPLY_BADDR(reply_desc); 686b0a2fdeeSScott Long offset = reply_baddr - (mpt->reply_phys & 0xFFFFFFFF); 687c87e3f83SMatt Jacob bus_dmamap_sync_range(mpt->reply_dmat, 688c87e3f83SMatt Jacob mpt->reply_dmap, offset, MPT_REPLY_SIZE, 689b0a2fdeeSScott Long BUS_DMASYNC_POSTREAD); 690b0a2fdeeSScott Long reply_frame = MPT_REPLY_OTOV(mpt, offset); 691c87e3f83SMatt Jacob ctxt_idx = le32toh(reply_frame->MsgContext); 692c87e3f83SMatt Jacob } else { 693c87e3f83SMatt Jacob uint32_t type; 694b0a2fdeeSScott Long 695c87e3f83SMatt Jacob type = MPI_GET_CONTEXT_REPLY_TYPE(reply_desc); 696c87e3f83SMatt Jacob ctxt_idx = reply_desc; 697c87e3f83SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG1, "Context Reply: 0x%08x\n", 698c87e3f83SMatt Jacob reply_desc); 699c87e3f83SMatt Jacob 700c87e3f83SMatt Jacob switch (type) { 701c87e3f83SMatt Jacob case MPI_CONTEXT_REPLY_TYPE_SCSI_INIT: 702c87e3f83SMatt Jacob ctxt_idx &= MPI_CONTEXT_REPLY_CONTEXT_MASK; 703c87e3f83SMatt Jacob break; 704c87e3f83SMatt Jacob case MPI_CONTEXT_REPLY_TYPE_SCSI_TARGET: 705c87e3f83SMatt Jacob ctxt_idx = GET_IO_INDEX(reply_desc); 706c87e3f83SMatt Jacob if (mpt->tgt_cmd_ptrs == NULL) { 707c87e3f83SMatt Jacob mpt_prt(mpt, 708c87e3f83SMatt Jacob "mpt_intr: no target cmd ptrs\n"); 709c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 710c87e3f83SMatt Jacob break; 711c87e3f83SMatt Jacob } 712c87e3f83SMatt Jacob if (ctxt_idx >= mpt->tgt_cmds_allocated) { 713c87e3f83SMatt Jacob mpt_prt(mpt, 714c87e3f83SMatt Jacob "mpt_intr: bad tgt cmd ctxt %u\n", 715c87e3f83SMatt Jacob ctxt_idx); 716c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 717c87e3f83SMatt Jacob ntrips = 1000; 718c87e3f83SMatt Jacob break; 719c87e3f83SMatt Jacob } 720c87e3f83SMatt Jacob req = mpt->tgt_cmd_ptrs[ctxt_idx]; 721c87e3f83SMatt Jacob if (req == NULL) { 722c87e3f83SMatt Jacob mpt_prt(mpt, "no request backpointer " 723c87e3f83SMatt Jacob "at index %u", ctxt_idx); 724c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 725c87e3f83SMatt Jacob ntrips = 1000; 726c87e3f83SMatt Jacob break; 727c87e3f83SMatt Jacob } 728c87e3f83SMatt Jacob /* 729c87e3f83SMatt Jacob * Reformulate ctxt_idx to be just as if 730c87e3f83SMatt Jacob * it were another type of context reply 731c87e3f83SMatt Jacob * so the code below will find the request 732c87e3f83SMatt Jacob * via indexing into the pool. 733c87e3f83SMatt Jacob */ 734c87e3f83SMatt Jacob ctxt_idx = 735c87e3f83SMatt Jacob req->index | mpt->scsi_tgt_handler_id; 736c87e3f83SMatt Jacob req = NULL; 737c87e3f83SMatt Jacob break; 738c87e3f83SMatt Jacob case MPI_CONTEXT_REPLY_TYPE_LAN: 739c87e3f83SMatt Jacob mpt_prt(mpt, "LAN CONTEXT REPLY: 0x%08x\n", 740c87e3f83SMatt Jacob reply_desc); 741c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 742c87e3f83SMatt Jacob break; 743c87e3f83SMatt Jacob default: 744c87e3f83SMatt Jacob mpt_prt(mpt, "Context Reply 0x%08x?\n", type); 745c87e3f83SMatt Jacob reply_desc = MPT_REPLY_EMPTY; 746c87e3f83SMatt Jacob break; 747c87e3f83SMatt Jacob } 748c87e3f83SMatt Jacob if (reply_desc == MPT_REPLY_EMPTY) { 749c87e3f83SMatt Jacob if (ntrips++ > 1000) { 750c87e3f83SMatt Jacob break; 751c87e3f83SMatt Jacob } 752c87e3f83SMatt Jacob continue; 753c87e3f83SMatt Jacob } 754c87e3f83SMatt Jacob } 755c87e3f83SMatt Jacob 756c87e3f83SMatt Jacob cb_index = MPT_CONTEXT_TO_CBI(ctxt_idx); 757c87e3f83SMatt Jacob req_index = MPT_CONTEXT_TO_REQI(ctxt_idx); 758c87e3f83SMatt Jacob if (req_index < MPT_MAX_REQUESTS(mpt)) { 759c87e3f83SMatt Jacob req = &mpt->request_pool[req_index]; 7605e073106SMatt Jacob } else { 7615e073106SMatt Jacob mpt_prt(mpt, "WARN: mpt_intr index == %d (reply_desc ==" 7625e073106SMatt Jacob " 0x%x)\n", req_index, reply_desc); 763c87e3f83SMatt Jacob } 764c87e3f83SMatt Jacob 765c87e3f83SMatt Jacob free_rf = mpt_reply_handlers[cb_index](mpt, req, 766c87e3f83SMatt Jacob reply_desc, reply_frame); 767b0a2fdeeSScott Long 7685e073106SMatt Jacob if (reply_frame != NULL && free_rf) { 769b0a2fdeeSScott Long mpt_free_reply(mpt, reply_baddr); 7705e073106SMatt Jacob } 771c87e3f83SMatt Jacob 772c87e3f83SMatt Jacob /* 773c87e3f83SMatt Jacob * If we got ourselves disabled, don't get stuck in a loop 774c87e3f83SMatt Jacob */ 775c87e3f83SMatt Jacob if (mpt->disabled) { 776c87e3f83SMatt Jacob mpt_disable_ints(mpt); 777c87e3f83SMatt Jacob break; 778c87e3f83SMatt Jacob } 779c87e3f83SMatt Jacob if (ntrips++ > 1000) { 780c87e3f83SMatt Jacob break; 781c87e3f83SMatt Jacob } 782b0a2fdeeSScott Long } 7835089bd63SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG2, "exit mpt_intr\n"); 784b0a2fdeeSScott Long } 785b0a2fdeeSScott Long 786b0a2fdeeSScott Long /******************************* Error Recovery *******************************/ 787b0a2fdeeSScott Long void 788b0a2fdeeSScott Long mpt_complete_request_chain(struct mpt_softc *mpt, struct req_queue *chain, 789b0a2fdeeSScott Long u_int iocstatus) 790b0a2fdeeSScott Long { 791b0a2fdeeSScott Long MSG_DEFAULT_REPLY ioc_status_frame; 792b0a2fdeeSScott Long request_t *req; 793b0a2fdeeSScott Long 7945e073106SMatt Jacob memset(&ioc_status_frame, 0, sizeof(ioc_status_frame)); 795b0a2fdeeSScott Long ioc_status_frame.MsgLength = roundup2(sizeof(ioc_status_frame), 4); 796b0a2fdeeSScott Long ioc_status_frame.IOCStatus = iocstatus; 797b0a2fdeeSScott Long while((req = TAILQ_FIRST(chain)) != NULL) { 798b0a2fdeeSScott Long MSG_REQUEST_HEADER *msg_hdr; 799b0a2fdeeSScott Long u_int cb_index; 8005e073106SMatt Jacob 8019b7de735SMatt Jacob TAILQ_REMOVE(chain, req, links); 802b0a2fdeeSScott Long msg_hdr = (MSG_REQUEST_HEADER *)req->req_vbuf; 803b0a2fdeeSScott Long ioc_status_frame.Function = msg_hdr->Function; 804b0a2fdeeSScott Long ioc_status_frame.MsgContext = msg_hdr->MsgContext; 805b0a2fdeeSScott Long cb_index = MPT_CONTEXT_TO_CBI(le32toh(msg_hdr->MsgContext)); 806c87e3f83SMatt Jacob mpt_reply_handlers[cb_index](mpt, req, msg_hdr->MsgContext, 807c87e3f83SMatt Jacob &ioc_status_frame); 808b0a2fdeeSScott Long } 809b0a2fdeeSScott Long } 810b0a2fdeeSScott Long 811b0a2fdeeSScott Long /********************************* Diagnostics ********************************/ 812b0a2fdeeSScott Long /* 813b0a2fdeeSScott Long * Perform a diagnostic dump of a reply frame. 814b0a2fdeeSScott Long */ 815b0a2fdeeSScott Long void 816b0a2fdeeSScott Long mpt_dump_reply_frame(struct mpt_softc *mpt, MSG_DEFAULT_REPLY *reply_frame) 817b0a2fdeeSScott Long { 818b0a2fdeeSScott Long mpt_prt(mpt, "Address Reply:\n"); 819b0a2fdeeSScott Long mpt_print_reply(reply_frame); 820b0a2fdeeSScott Long } 821b0a2fdeeSScott Long 822b0a2fdeeSScott Long /******************************* Doorbell Access ******************************/ 823b0a2fdeeSScott Long static __inline uint32_t mpt_rd_db(struct mpt_softc *mpt); 824b0a2fdeeSScott Long static __inline uint32_t mpt_rd_intr(struct mpt_softc *mpt); 825b0a2fdeeSScott Long 826b0a2fdeeSScott Long static __inline uint32_t 827b0a2fdeeSScott Long mpt_rd_db(struct mpt_softc *mpt) 8289b631363SMatt Jacob { 8299b631363SMatt Jacob return mpt_read(mpt, MPT_OFFSET_DOORBELL); 8309b631363SMatt Jacob } 8319b631363SMatt Jacob 832b0a2fdeeSScott Long static __inline uint32_t 833b0a2fdeeSScott Long mpt_rd_intr(struct mpt_softc *mpt) 8349b631363SMatt Jacob { 8359b631363SMatt Jacob return mpt_read(mpt, MPT_OFFSET_INTR_STATUS); 8369b631363SMatt Jacob } 8379b631363SMatt Jacob 8389b631363SMatt Jacob /* Busy wait for a door bell to be read by IOC */ 8399b631363SMatt Jacob static int 840b0a2fdeeSScott Long mpt_wait_db_ack(struct mpt_softc *mpt) 8419b631363SMatt Jacob { 8429b631363SMatt Jacob int i; 8439b631363SMatt Jacob for (i=0; i < MPT_MAX_WAIT; i++) { 8449b631363SMatt Jacob if (!MPT_DB_IS_BUSY(mpt_rd_intr(mpt))) { 8459b631363SMatt Jacob maxwait_ack = i > maxwait_ack ? i : maxwait_ack; 846c87e3f83SMatt Jacob return (MPT_OK); 8479b631363SMatt Jacob } 848c87e3f83SMatt Jacob DELAY(200); 8499b631363SMatt Jacob } 850c87e3f83SMatt Jacob return (MPT_FAIL); 8519b631363SMatt Jacob } 8529b631363SMatt Jacob 8539b631363SMatt Jacob /* Busy wait for a door bell interrupt */ 8549b631363SMatt Jacob static int 855b0a2fdeeSScott Long mpt_wait_db_int(struct mpt_softc *mpt) 8569b631363SMatt Jacob { 8579b631363SMatt Jacob int i; 8589b631363SMatt Jacob for (i=0; i < MPT_MAX_WAIT; i++) { 8599b631363SMatt Jacob if (MPT_DB_INTR(mpt_rd_intr(mpt))) { 8609b631363SMatt Jacob maxwait_int = i > maxwait_int ? i : maxwait_int; 8619b631363SMatt Jacob return MPT_OK; 8629b631363SMatt Jacob } 8639b631363SMatt Jacob DELAY(100); 8649b631363SMatt Jacob } 865c87e3f83SMatt Jacob return (MPT_FAIL); 8669b631363SMatt Jacob } 8679b631363SMatt Jacob 8689b631363SMatt Jacob /* Wait for IOC to transition to a give state */ 8699b631363SMatt Jacob void 870b0a2fdeeSScott Long mpt_check_doorbell(struct mpt_softc *mpt) 8719b631363SMatt Jacob { 872b0a2fdeeSScott Long uint32_t db = mpt_rd_db(mpt); 8739b631363SMatt Jacob if (MPT_STATE(db) != MPT_DB_STATE_RUNNING) { 874b0a2fdeeSScott Long mpt_prt(mpt, "Device not running\n"); 8759b631363SMatt Jacob mpt_print_db(db); 8769b631363SMatt Jacob } 8779b631363SMatt Jacob } 8789b631363SMatt Jacob 8799b631363SMatt Jacob /* Wait for IOC to transition to a give state */ 8809b631363SMatt Jacob static int 881b0a2fdeeSScott Long mpt_wait_state(struct mpt_softc *mpt, enum DB_STATE_BITS state) 8829b631363SMatt Jacob { 8839b631363SMatt Jacob int i; 8849b631363SMatt Jacob 8859b631363SMatt Jacob for (i = 0; i < MPT_MAX_WAIT; i++) { 886b0a2fdeeSScott Long uint32_t db = mpt_rd_db(mpt); 8879b631363SMatt Jacob if (MPT_STATE(db) == state) { 8889b631363SMatt Jacob maxwait_state = i > maxwait_state ? i : maxwait_state; 8899b631363SMatt Jacob return (MPT_OK); 8909b631363SMatt Jacob } 8919b631363SMatt Jacob DELAY(100); 8929b631363SMatt Jacob } 8939b631363SMatt Jacob return (MPT_FAIL); 8949b631363SMatt Jacob } 8959b631363SMatt Jacob 8969b631363SMatt Jacob 897b0a2fdeeSScott Long /************************* Intialization/Configuration ************************/ 898b0a2fdeeSScott Long static int mpt_download_fw(struct mpt_softc *mpt); 899b0a2fdeeSScott Long 9009b631363SMatt Jacob /* Issue the reset COMMAND to the IOC */ 901b0a2fdeeSScott Long static int 902b0a2fdeeSScott Long mpt_soft_reset(struct mpt_softc *mpt) 9039b631363SMatt Jacob { 904b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "soft reset\n"); 9059b631363SMatt Jacob 9069b631363SMatt Jacob /* Have to use hard reset if we are not in Running state */ 9079b631363SMatt Jacob if (MPT_STATE(mpt_rd_db(mpt)) != MPT_DB_STATE_RUNNING) { 908b0a2fdeeSScott Long mpt_prt(mpt, "soft reset failed: device not running\n"); 909c87e3f83SMatt Jacob return (MPT_FAIL); 9109b631363SMatt Jacob } 9119b631363SMatt Jacob 9129b631363SMatt Jacob /* If door bell is in use we don't have a chance of getting 9139b631363SMatt Jacob * a word in since the IOC probably crashed in message 9149b631363SMatt Jacob * processing. So don't waste our time. 9159b631363SMatt Jacob */ 9169b631363SMatt Jacob if (MPT_DB_IS_IN_USE(mpt_rd_db(mpt))) { 917b0a2fdeeSScott Long mpt_prt(mpt, "soft reset failed: doorbell wedged\n"); 918c87e3f83SMatt Jacob return (MPT_FAIL); 9199b631363SMatt Jacob } 9209b631363SMatt Jacob 9219b631363SMatt Jacob /* Send the reset request to the IOC */ 9229b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_DOORBELL, 9239b631363SMatt Jacob MPI_FUNCTION_IOC_MESSAGE_UNIT_RESET << MPI_DOORBELL_FUNCTION_SHIFT); 9249b631363SMatt Jacob if (mpt_wait_db_ack(mpt) != MPT_OK) { 925b0a2fdeeSScott Long mpt_prt(mpt, "soft reset failed: ack timeout\n"); 926c87e3f83SMatt Jacob return (MPT_FAIL); 9279b631363SMatt Jacob } 9289b631363SMatt Jacob 9299b631363SMatt Jacob /* Wait for the IOC to reload and come out of reset state */ 9309b631363SMatt Jacob if (mpt_wait_state(mpt, MPT_DB_STATE_READY) != MPT_OK) { 931b0a2fdeeSScott Long mpt_prt(mpt, "soft reset failed: device did not restart\n"); 932c87e3f83SMatt Jacob return (MPT_FAIL); 9339b631363SMatt Jacob } 9349b631363SMatt Jacob 9359b631363SMatt Jacob return MPT_OK; 9369b631363SMatt Jacob } 9379b631363SMatt Jacob 938b0a2fdeeSScott Long static int 939b0a2fdeeSScott Long mpt_enable_diag_mode(struct mpt_softc *mpt) 940b0a2fdeeSScott Long { 941b0a2fdeeSScott Long int try; 942b0a2fdeeSScott Long 943b0a2fdeeSScott Long try = 20; 944b0a2fdeeSScott Long while (--try) { 945b0a2fdeeSScott Long 946b0a2fdeeSScott Long if ((mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC) & MPI_DIAG_DRWE) != 0) 947b0a2fdeeSScott Long break; 948b0a2fdeeSScott Long 949b0a2fdeeSScott Long /* Enable diagnostic registers */ 950b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFF); 951b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_1ST_KEY_VALUE); 952b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_2ND_KEY_VALUE); 953b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_3RD_KEY_VALUE); 954b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_4TH_KEY_VALUE); 955b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, MPI_WRSEQ_5TH_KEY_VALUE); 956b0a2fdeeSScott Long 957b0a2fdeeSScott Long DELAY(100000); 958b0a2fdeeSScott Long } 959b0a2fdeeSScott Long if (try == 0) 960b0a2fdeeSScott Long return (EIO); 961b0a2fdeeSScott Long return (0); 962b0a2fdeeSScott Long } 963b0a2fdeeSScott Long 964b0a2fdeeSScott Long static void 965b0a2fdeeSScott Long mpt_disable_diag_mode(struct mpt_softc *mpt) 966b0a2fdeeSScott Long { 967b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_SEQUENCE, 0xFFFFFFFF); 968b0a2fdeeSScott Long } 969b0a2fdeeSScott Long 9709b631363SMatt Jacob /* This is a magic diagnostic reset that resets all the ARM 9719b631363SMatt Jacob * processors in the chip. 9729b631363SMatt Jacob */ 973b0a2fdeeSScott Long static void 974b0a2fdeeSScott Long mpt_hard_reset(struct mpt_softc *mpt) 9759b631363SMatt Jacob { 976b0a2fdeeSScott Long int error; 977b0a2fdeeSScott Long int wait; 978b0a2fdeeSScott Long uint32_t diagreg; 9799b631363SMatt Jacob 980b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "hard reset\n"); 981b0a2fdeeSScott Long 982b0a2fdeeSScott Long error = mpt_enable_diag_mode(mpt); 983b0a2fdeeSScott Long if (error) { 984b0a2fdeeSScott Long mpt_prt(mpt, "WARNING - Could not enter diagnostic mode !\n"); 985b0a2fdeeSScott Long mpt_prt(mpt, "Trying to reset anyway.\n"); 986b0a2fdeeSScott Long } 987b0a2fdeeSScott Long 988b0a2fdeeSScott Long diagreg = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC); 989b0a2fdeeSScott Long 990b0a2fdeeSScott Long /* 991b0a2fdeeSScott Long * This appears to be a workaround required for some 992b0a2fdeeSScott Long * firmware or hardware revs. 993b0a2fdeeSScott Long */ 994b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, diagreg | MPI_DIAG_DISABLE_ARM); 995b0a2fdeeSScott Long DELAY(1000); 9969b631363SMatt Jacob 9979b631363SMatt Jacob /* Diag. port is now active so we can now hit the reset bit */ 998b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, diagreg | MPI_DIAG_RESET_ADAPTER); 9999b631363SMatt Jacob 1000b0a2fdeeSScott Long /* 1001b0a2fdeeSScott Long * Ensure that the reset has finished. We delay 1ms 1002b0a2fdeeSScott Long * prior to reading the register to make sure the chip 1003b0a2fdeeSScott Long * has sufficiently completed its reset to handle register 1004b0a2fdeeSScott Long * accesses. 1005b0a2fdeeSScott Long */ 1006b0a2fdeeSScott Long wait = 5000; 1007b0a2fdeeSScott Long do { 1008b0a2fdeeSScott Long DELAY(1000); 1009b0a2fdeeSScott Long diagreg = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC); 1010b0a2fdeeSScott Long } while (--wait && (diagreg & MPI_DIAG_RESET_ADAPTER) == 0); 10119b631363SMatt Jacob 1012b0a2fdeeSScott Long if (wait == 0) { 1013b0a2fdeeSScott Long mpt_prt(mpt, "WARNING - Failed hard reset! " 1014b0a2fdeeSScott Long "Trying to initialize anyway.\n"); 10159b631363SMatt Jacob } 10169b631363SMatt Jacob 1017b0a2fdeeSScott Long /* 1018b0a2fdeeSScott Long * If we have firmware to download, it must be loaded before 1019b0a2fdeeSScott Long * the controller will become operational. Do so now. 1020b0a2fdeeSScott Long */ 1021b0a2fdeeSScott Long if (mpt->fw_image != NULL) { 1022b0a2fdeeSScott Long 1023b0a2fdeeSScott Long error = mpt_download_fw(mpt); 1024b0a2fdeeSScott Long 1025b0a2fdeeSScott Long if (error) { 1026b0a2fdeeSScott Long mpt_prt(mpt, "WARNING - Firmware Download Failed!\n"); 1027b0a2fdeeSScott Long mpt_prt(mpt, "Trying to initialize anyway.\n"); 10289b631363SMatt Jacob } 1029b0a2fdeeSScott Long } 1030b0a2fdeeSScott Long 1031b0a2fdeeSScott Long /* 1032b0a2fdeeSScott Long * Reseting the controller should have disabled write 1033b0a2fdeeSScott Long * access to the diagnostic registers, but disable 1034b0a2fdeeSScott Long * manually to be sure. 1035b0a2fdeeSScott Long */ 1036b0a2fdeeSScott Long mpt_disable_diag_mode(mpt); 1037b0a2fdeeSScott Long } 1038b0a2fdeeSScott Long 1039b0a2fdeeSScott Long static void 1040b0a2fdeeSScott Long mpt_core_ioc_reset(struct mpt_softc *mpt, int type) 1041b0a2fdeeSScott Long { 1042b0a2fdeeSScott Long /* 1043b0a2fdeeSScott Long * Complete all pending requests with a status 1044b0a2fdeeSScott Long * appropriate for an IOC reset. 1045b0a2fdeeSScott Long */ 1046b0a2fdeeSScott Long mpt_complete_request_chain(mpt, &mpt->request_pending_list, 1047b0a2fdeeSScott Long MPI_IOCSTATUS_INVALID_STATE); 1048b0a2fdeeSScott Long } 1049b0a2fdeeSScott Long 10509b631363SMatt Jacob 10519b631363SMatt Jacob /* 10529b631363SMatt Jacob * Reset the IOC when needed. Try software command first then if needed 10539b631363SMatt Jacob * poke at the magic diagnostic reset. Note that a hard reset resets 10549b631363SMatt Jacob * *both* IOCs on dual function chips (FC929 && LSI1030) as well as 10559b631363SMatt Jacob * fouls up the PCI configuration registers. 10569b631363SMatt Jacob */ 10579b631363SMatt Jacob int 1058b0a2fdeeSScott Long mpt_reset(struct mpt_softc *mpt, int reinit) 10599b631363SMatt Jacob { 1060b0a2fdeeSScott Long struct mpt_personality *pers; 10619b631363SMatt Jacob int ret; 106229ae59edSMatt Jacob int retry_cnt = 0; 10639b631363SMatt Jacob 106429ae59edSMatt Jacob /* 106529ae59edSMatt Jacob * Try a soft reset. If that fails, get out the big hammer. 106629ae59edSMatt Jacob */ 106729ae59edSMatt Jacob again: 10689b631363SMatt Jacob if ((ret = mpt_soft_reset(mpt)) != MPT_OK) { 106929ae59edSMatt Jacob int cnt; 107029ae59edSMatt Jacob for (cnt = 0; cnt < 5; cnt++) { 10719b631363SMatt Jacob /* Failed; do a hard reset */ 10729b631363SMatt Jacob mpt_hard_reset(mpt); 10739b631363SMatt Jacob 107429ae59edSMatt Jacob /* 107529ae59edSMatt Jacob * Wait for the IOC to reload 107629ae59edSMatt Jacob * and come out of reset state 107729ae59edSMatt Jacob */ 10789b631363SMatt Jacob ret = mpt_wait_state(mpt, MPT_DB_STATE_READY); 107929ae59edSMatt Jacob if (ret == MPT_OK) { 108029ae59edSMatt Jacob break; 108129ae59edSMatt Jacob } 108229ae59edSMatt Jacob /* 108329ae59edSMatt Jacob * Okay- try to check again... 108429ae59edSMatt Jacob */ 108529ae59edSMatt Jacob ret = mpt_wait_state(mpt, MPT_DB_STATE_READY); 108629ae59edSMatt Jacob if (ret == MPT_OK) { 108729ae59edSMatt Jacob break; 108829ae59edSMatt Jacob } 108929ae59edSMatt Jacob mpt_prt(mpt, "mpt_reset: failed hard reset (%d:%d)\n", 109029ae59edSMatt Jacob retry_cnt, cnt); 109129ae59edSMatt Jacob } 10929b631363SMatt Jacob } 1093b0a2fdeeSScott Long 109429ae59edSMatt Jacob if (retry_cnt == 0) { 1095b0a2fdeeSScott Long /* 1096b0a2fdeeSScott Long * Invoke reset handlers. We bump the reset count so 1097b0a2fdeeSScott Long * that mpt_wait_req() understands that regardless of 1098b0a2fdeeSScott Long * the specified wait condition, it should stop its wait. 1099b0a2fdeeSScott Long */ 1100b0a2fdeeSScott Long mpt->reset_cnt++; 1101b0a2fdeeSScott Long MPT_PERS_FOREACH(mpt, pers) 1102b0a2fdeeSScott Long pers->reset(mpt, ret); 110329ae59edSMatt Jacob } 1104b0a2fdeeSScott Long 11055e073106SMatt Jacob if (reinit) { 1106c87e3f83SMatt Jacob ret = mpt_enable_ioc(mpt, 1); 110729ae59edSMatt Jacob if (ret == MPT_OK) { 110829ae59edSMatt Jacob mpt_enable_ints(mpt); 110929ae59edSMatt Jacob } 111029ae59edSMatt Jacob } 111129ae59edSMatt Jacob if (ret != MPT_OK && retry_cnt++ < 2) { 111229ae59edSMatt Jacob goto again; 111329ae59edSMatt Jacob } 11149b631363SMatt Jacob return ret; 11159b631363SMatt Jacob } 11169b631363SMatt Jacob 11179b631363SMatt Jacob /* Return a command buffer to the free queue */ 11189b631363SMatt Jacob void 1119b0a2fdeeSScott Long mpt_free_request(struct mpt_softc *mpt, request_t *req) 11209b631363SMatt Jacob { 1121444dd2b6SMatt Jacob request_t *nxt; 1122b0a2fdeeSScott Long struct mpt_evtf_record *record; 1123b0a2fdeeSScott Long uint32_t reply_baddr; 1124b0a2fdeeSScott Long 11257dec90bcSMatt Jacob if (req == NULL || req != &mpt->request_pool[req->index]) { 11269b631363SMatt Jacob panic("mpt_free_request bad req ptr\n"); 11279b631363SMatt Jacob return; 11289b631363SMatt Jacob } 1129444dd2b6SMatt Jacob if ((nxt = req->chain) != NULL) { 1130444dd2b6SMatt Jacob req->chain = NULL; 1131444dd2b6SMatt Jacob mpt_free_request(mpt, nxt); /* NB: recursion */ 1132444dd2b6SMatt Jacob } 11335e073106SMatt Jacob KASSERT(req->state != REQ_STATE_FREE, ("freeing free request")); 11345e073106SMatt Jacob KASSERT(!(req->state & REQ_STATE_LOCKED), ("freeing locked request")); 11355089bd63SMatt Jacob KASSERT(MPT_OWNED(mpt), ("mpt_free_request: mpt not locked\n")); 11365089bd63SMatt Jacob KASSERT(mpt_req_on_free_list(mpt, req) == 0, 11375089bd63SMatt Jacob ("mpt_free_request: req %p:%u func %x already on freelist", 11385089bd63SMatt Jacob req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 11395089bd63SMatt Jacob KASSERT(mpt_req_on_pending_list(mpt, req) == 0, 11405089bd63SMatt Jacob ("mpt_free_request: req %p:%u func %x on pending list", 11415089bd63SMatt Jacob req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 11425089bd63SMatt Jacob #ifdef INVARIANTS 11435089bd63SMatt Jacob mpt_req_not_spcl(mpt, req, "mpt_free_request", __LINE__); 11445089bd63SMatt Jacob #endif 11455e073106SMatt Jacob 11469b631363SMatt Jacob req->ccb = NULL; 1147b0a2fdeeSScott Long if (LIST_EMPTY(&mpt->ack_frames)) { 1148c87e3f83SMatt Jacob /* 1149c87e3f83SMatt Jacob * Insert free ones at the tail 1150c87e3f83SMatt Jacob */ 11515e073106SMatt Jacob req->serno = 0; 11525e073106SMatt Jacob req->state = REQ_STATE_FREE; 11535089bd63SMatt Jacob #ifdef INVARIANTS 11545089bd63SMatt Jacob memset(req->req_vbuf, 0xff, sizeof (MSG_REQUEST_HEADER)); 11555089bd63SMatt Jacob #endif 1156c87e3f83SMatt Jacob TAILQ_INSERT_TAIL(&mpt->request_free_list, req, links); 1157b0a2fdeeSScott Long if (mpt->getreqwaiter != 0) { 1158b0a2fdeeSScott Long mpt->getreqwaiter = 0; 1159b0a2fdeeSScott Long wakeup(&mpt->request_free_list); 1160b0a2fdeeSScott Long } 1161b0a2fdeeSScott Long return; 1162b0a2fdeeSScott Long } 1163b0a2fdeeSScott Long 1164b0a2fdeeSScott Long /* 1165b0a2fdeeSScott Long * Process an ack frame deferred due to resource shortage. 1166b0a2fdeeSScott Long */ 1167b0a2fdeeSScott Long record = LIST_FIRST(&mpt->ack_frames); 1168b0a2fdeeSScott Long LIST_REMOVE(record, links); 11695e073106SMatt Jacob req->state = REQ_STATE_ALLOCATED; 11705089bd63SMatt Jacob mpt_assign_serno(mpt, req); 1171b0a2fdeeSScott Long mpt_send_event_ack(mpt, req, &record->reply, record->context); 1172b0a2fdeeSScott Long reply_baddr = (uint32_t)((uint8_t *)record - mpt->reply) 1173b0a2fdeeSScott Long + (mpt->reply_phys & 0xFFFFFFFF); 1174b0a2fdeeSScott Long mpt_free_reply(mpt, reply_baddr); 11759b631363SMatt Jacob } 11769b631363SMatt Jacob 11779b631363SMatt Jacob /* Get a command buffer from the free queue */ 11789b631363SMatt Jacob request_t * 1179b0a2fdeeSScott Long mpt_get_request(struct mpt_softc *mpt, int sleep_ok) 11809b631363SMatt Jacob { 11819b631363SMatt Jacob request_t *req; 1182b0a2fdeeSScott Long 1183b0a2fdeeSScott Long retry: 11845089bd63SMatt Jacob KASSERT(MPT_OWNED(mpt), ("mpt_get_request: mpt not locked\n")); 1185b0a2fdeeSScott Long req = TAILQ_FIRST(&mpt->request_free_list); 11869b631363SMatt Jacob if (req != NULL) { 1187b0a2fdeeSScott Long KASSERT(req == &mpt->request_pool[req->index], 1188b0a2fdeeSScott Long ("mpt_get_request: corrupted request free list\n")); 11895e073106SMatt Jacob KASSERT(req->state == REQ_STATE_FREE, 11905089bd63SMatt Jacob ("req %p:%u not free on free list %x index %d function %x", 11915089bd63SMatt Jacob req, req->serno, req->state, req->index, 11925089bd63SMatt Jacob ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 1193b0a2fdeeSScott Long TAILQ_REMOVE(&mpt->request_free_list, req, links); 1194b0a2fdeeSScott Long req->state = REQ_STATE_ALLOCATED; 1195444dd2b6SMatt Jacob req->chain = NULL; 11965089bd63SMatt Jacob mpt_assign_serno(mpt, req); 1197b0a2fdeeSScott Long } else if (sleep_ok != 0) { 1198b0a2fdeeSScott Long mpt->getreqwaiter = 1; 1199b0a2fdeeSScott Long mpt_sleep(mpt, &mpt->request_free_list, PUSER, "mptgreq", 0); 1200b0a2fdeeSScott Long goto retry; 12019b631363SMatt Jacob } 12025e073106SMatt Jacob return (req); 12039b631363SMatt Jacob } 12049b631363SMatt Jacob 12059b631363SMatt Jacob /* Pass the command to the IOC */ 12069b631363SMatt Jacob void 1207b0a2fdeeSScott Long mpt_send_cmd(struct mpt_softc *mpt, request_t *req) 12089b631363SMatt Jacob { 12091d79ca0eSMatt Jacob if (mpt->verbose > MPT_PRT_DEBUG2) { 12101043516dSMatt Jacob mpt_dump_request(mpt, req); 1211444dd2b6SMatt Jacob } 12129b631363SMatt Jacob bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap, 12139b631363SMatt Jacob BUS_DMASYNC_PREWRITE); 1214b0a2fdeeSScott Long req->state |= REQ_STATE_QUEUED; 12155089bd63SMatt Jacob KASSERT(mpt_req_on_free_list(mpt, req) == 0, 12165089bd63SMatt Jacob ("req %p:%u func %x on freelist list in mpt_send_cmd", 12175089bd63SMatt Jacob req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 12185089bd63SMatt Jacob KASSERT(mpt_req_on_pending_list(mpt, req) == 0, 12195089bd63SMatt Jacob ("req %p:%u func %x already on pending list in mpt_send_cmd", 12205089bd63SMatt Jacob req, req->serno, ((MSG_REQUEST_HEADER *)req->req_vbuf)->Function)); 1221b0a2fdeeSScott Long TAILQ_INSERT_HEAD(&mpt->request_pending_list, req, links); 1222b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_REQUEST_Q, (uint32_t) req->req_pbuf); 12239b631363SMatt Jacob } 12249b631363SMatt Jacob 12259b631363SMatt Jacob /* 1226b0a2fdeeSScott Long * Wait for a request to complete. 1227b0a2fdeeSScott Long * 1228b0a2fdeeSScott Long * Inputs: 1229b0a2fdeeSScott Long * mpt softc of controller executing request 1230b0a2fdeeSScott Long * req request to wait for 1231b0a2fdeeSScott Long * sleep_ok nonzero implies may sleep in this context 1232b0a2fdeeSScott Long * time_ms timeout in ms. 0 implies no timeout. 1233b0a2fdeeSScott Long * 1234b0a2fdeeSScott Long * Return Values: 1235b0a2fdeeSScott Long * 0 Request completed 1236b0a2fdeeSScott Long * non-0 Timeout fired before request completion. 12379b631363SMatt Jacob */ 1238b0a2fdeeSScott Long int 1239b0a2fdeeSScott Long mpt_wait_req(struct mpt_softc *mpt, request_t *req, 1240b0a2fdeeSScott Long mpt_req_state_t state, mpt_req_state_t mask, 1241b0a2fdeeSScott Long int sleep_ok, int time_ms) 12429b631363SMatt Jacob { 1243b0a2fdeeSScott Long int error; 1244b0a2fdeeSScott Long int timeout; 1245b0a2fdeeSScott Long u_int saved_cnt; 12469b631363SMatt Jacob 1247b0a2fdeeSScott Long /* 1248b0a2fdeeSScott Long * timeout is in ms. 0 indicates infinite wait. 1249b0a2fdeeSScott Long * Convert to ticks or 500us units depending on 1250b0a2fdeeSScott Long * our sleep mode. 1251b0a2fdeeSScott Long */ 1252c87e3f83SMatt Jacob if (sleep_ok != 0) { 1253b0a2fdeeSScott Long timeout = (time_ms * hz) / 1000; 1254c87e3f83SMatt Jacob } else { 1255b0a2fdeeSScott Long timeout = time_ms * 2; 1256c87e3f83SMatt Jacob } 1257b0a2fdeeSScott Long req->state |= REQ_STATE_NEED_WAKEUP; 1258b0a2fdeeSScott Long mask &= ~REQ_STATE_NEED_WAKEUP; 1259444dd2b6SMatt Jacob saved_cnt = mpt->reset_cnt; 1260c87e3f83SMatt Jacob while ((req->state & mask) != state && mpt->reset_cnt == saved_cnt) { 1261b0a2fdeeSScott Long if (sleep_ok != 0) { 1262b0a2fdeeSScott Long error = mpt_sleep(mpt, req, PUSER, "mptreq", timeout); 1263b0a2fdeeSScott Long if (error == EWOULDBLOCK) { 1264b0a2fdeeSScott Long timeout = 0; 1265b0a2fdeeSScott Long break; 1266b0a2fdeeSScott Long } 1267b0a2fdeeSScott Long } else { 1268b0a2fdeeSScott Long if (time_ms != 0 && --timeout == 0) { 1269b0a2fdeeSScott Long break; 1270b0a2fdeeSScott Long } 1271b0a2fdeeSScott Long DELAY(500); 1272b0a2fdeeSScott Long mpt_intr(mpt); 1273b0a2fdeeSScott Long } 1274b0a2fdeeSScott Long } 1275b0a2fdeeSScott Long req->state &= ~REQ_STATE_NEED_WAKEUP; 1276c87e3f83SMatt Jacob if (mpt->reset_cnt != saved_cnt) { 1277b0a2fdeeSScott Long return (EIO); 1278c87e3f83SMatt Jacob } 1279c87e3f83SMatt Jacob if (time_ms && timeout <= 0) { 1280c87e3f83SMatt Jacob MSG_REQUEST_HEADER *msg_hdr = req->req_vbuf; 1281c87e3f83SMatt Jacob mpt_prt(mpt, "mpt_wait_req(%x) timed out\n", msg_hdr->Function); 1282b0a2fdeeSScott Long return (ETIMEDOUT); 1283c87e3f83SMatt Jacob } 1284b0a2fdeeSScott Long return (0); 12859b631363SMatt Jacob } 12869b631363SMatt Jacob 12879b631363SMatt Jacob /* 12889b631363SMatt Jacob * Send a command to the IOC via the handshake register. 12899b631363SMatt Jacob * 12909b631363SMatt Jacob * Only done at initialization time and for certain unusual 12919b631363SMatt Jacob * commands such as device/bus reset as specified by LSI. 12929b631363SMatt Jacob */ 12939b631363SMatt Jacob int 1294b0a2fdeeSScott Long mpt_send_handshake_cmd(struct mpt_softc *mpt, size_t len, void *cmd) 12959b631363SMatt Jacob { 12969b631363SMatt Jacob int i; 1297b0a2fdeeSScott Long uint32_t data, *data32; 12989b631363SMatt Jacob 12999b631363SMatt Jacob /* Check condition of the IOC */ 13009b631363SMatt Jacob data = mpt_rd_db(mpt); 1301b0a2fdeeSScott Long if ((MPT_STATE(data) != MPT_DB_STATE_READY 1302b0a2fdeeSScott Long && MPT_STATE(data) != MPT_DB_STATE_RUNNING 1303b0a2fdeeSScott Long && MPT_STATE(data) != MPT_DB_STATE_FAULT) 1304b0a2fdeeSScott Long || MPT_DB_IS_IN_USE(data)) { 1305b0a2fdeeSScott Long mpt_prt(mpt, "handshake aborted - invalid doorbell state\n"); 13069b631363SMatt Jacob mpt_print_db(data); 13079b631363SMatt Jacob return (EBUSY); 13089b631363SMatt Jacob } 13099b631363SMatt Jacob 13109b631363SMatt Jacob /* We move things in 32 bit chunks */ 13119b631363SMatt Jacob len = (len + 3) >> 2; 13129b631363SMatt Jacob data32 = cmd; 13139b631363SMatt Jacob 13149b631363SMatt Jacob /* Clear any left over pending doorbell interupts */ 13159b631363SMatt Jacob if (MPT_DB_INTR(mpt_rd_intr(mpt))) 13169b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 13179b631363SMatt Jacob 13189b631363SMatt Jacob /* 13199b631363SMatt Jacob * Tell the handshake reg. we are going to send a command 13209b631363SMatt Jacob * and how long it is going to be. 13219b631363SMatt Jacob */ 13229b631363SMatt Jacob data = (MPI_FUNCTION_HANDSHAKE << MPI_DOORBELL_FUNCTION_SHIFT) | 13239b631363SMatt Jacob (len << MPI_DOORBELL_ADD_DWORDS_SHIFT); 13249b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_DOORBELL, data); 13259b631363SMatt Jacob 13269b631363SMatt Jacob /* Wait for the chip to notice */ 13279b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1328b0a2fdeeSScott Long mpt_prt(mpt, "mpt_send_handshake_cmd timeout1\n"); 1329b0a2fdeeSScott Long return (ETIMEDOUT); 13309b631363SMatt Jacob } 13319b631363SMatt Jacob 13329b631363SMatt Jacob /* Clear the interrupt */ 13339b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 13349b631363SMatt Jacob 13359b631363SMatt Jacob if (mpt_wait_db_ack(mpt) != MPT_OK) { 1336b0a2fdeeSScott Long mpt_prt(mpt, "mpt_send_handshake_cmd timeout2\n"); 1337b0a2fdeeSScott Long return (ETIMEDOUT); 13389b631363SMatt Jacob } 13399b631363SMatt Jacob 13409b631363SMatt Jacob /* Send the command */ 13419b631363SMatt Jacob for (i = 0; i < len; i++) { 13429b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_DOORBELL, *data32++); 13439b631363SMatt Jacob if (mpt_wait_db_ack(mpt) != MPT_OK) { 1344301472c2SMatt Jacob mpt_prt(mpt, 1345b0a2fdeeSScott Long "mpt_send_handshake_cmd timeout! index = %d\n", 1346b0a2fdeeSScott Long i); 1347b0a2fdeeSScott Long return (ETIMEDOUT); 13489b631363SMatt Jacob } 13499b631363SMatt Jacob } 13509b631363SMatt Jacob return MPT_OK; 13519b631363SMatt Jacob } 13529b631363SMatt Jacob 13539b631363SMatt Jacob /* Get the response from the handshake register */ 13549b631363SMatt Jacob int 1355b0a2fdeeSScott Long mpt_recv_handshake_reply(struct mpt_softc *mpt, size_t reply_len, void *reply) 13569b631363SMatt Jacob { 13579b631363SMatt Jacob int left, reply_left; 13589b631363SMatt Jacob u_int16_t *data16; 13599b631363SMatt Jacob MSG_DEFAULT_REPLY *hdr; 13609b631363SMatt Jacob 13619b631363SMatt Jacob /* We move things out in 16 bit chunks */ 13629b631363SMatt Jacob reply_len >>= 1; 13639b631363SMatt Jacob data16 = (u_int16_t *)reply; 13649b631363SMatt Jacob 13659b631363SMatt Jacob hdr = (MSG_DEFAULT_REPLY *)reply; 13669b631363SMatt Jacob 13679b631363SMatt Jacob /* Get first word */ 13689b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1369b0a2fdeeSScott Long mpt_prt(mpt, "mpt_recv_handshake_cmd timeout1\n"); 13709b631363SMatt Jacob return ETIMEDOUT; 13719b631363SMatt Jacob } 13729b631363SMatt Jacob *data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK; 13739b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 13749b631363SMatt Jacob 13759b631363SMatt Jacob /* Get Second Word */ 13769b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1377b0a2fdeeSScott Long mpt_prt(mpt, "mpt_recv_handshake_cmd timeout2\n"); 13789b631363SMatt Jacob return ETIMEDOUT; 13799b631363SMatt Jacob } 13809b631363SMatt Jacob *data16++ = mpt_read(mpt, MPT_OFFSET_DOORBELL) & MPT_DB_DATA_MASK; 13819b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 13829b631363SMatt Jacob 13835e073106SMatt Jacob /* 13845e073106SMatt Jacob * With the second word, we can now look at the length. 13855e073106SMatt Jacob * Warn about a reply that's too short (except for IOC FACTS REPLY) 13865e073106SMatt Jacob */ 13875e073106SMatt Jacob if ((reply_len >> 1) != hdr->MsgLength && 13885e073106SMatt Jacob (hdr->Function != MPI_FUNCTION_IOC_FACTS)){ 13895e073106SMatt Jacob #if __FreeBSD_version >= 500000 1390301472c2SMatt Jacob mpt_prt(mpt, "reply length does not match message length: " 139133f31846SMatt Jacob "got %x; expected %zx for function %x\n", 13925e073106SMatt Jacob hdr->MsgLength << 2, reply_len << 1, hdr->Function); 13935e073106SMatt Jacob #else 13945e073106SMatt Jacob mpt_prt(mpt, "reply length does not match message length: " 139533f31846SMatt Jacob "got %x; expected %x for function %x\n", 13965e073106SMatt Jacob hdr->MsgLength << 2, reply_len << 1, hdr->Function); 13975e073106SMatt Jacob #endif 13989b631363SMatt Jacob } 13999b631363SMatt Jacob 14009b631363SMatt Jacob /* Get rest of the reply; but don't overflow the provided buffer */ 14019b631363SMatt Jacob left = (hdr->MsgLength << 1) - 2; 14029b631363SMatt Jacob reply_left = reply_len - 2; 14039b631363SMatt Jacob while (left--) { 14049b631363SMatt Jacob u_int16_t datum; 14059b631363SMatt Jacob 14069b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1407b0a2fdeeSScott Long mpt_prt(mpt, "mpt_recv_handshake_cmd timeout3\n"); 14089b631363SMatt Jacob return ETIMEDOUT; 14099b631363SMatt Jacob } 14109b631363SMatt Jacob datum = mpt_read(mpt, MPT_OFFSET_DOORBELL); 14119b631363SMatt Jacob 14129b631363SMatt Jacob if (reply_left-- > 0) 14139b631363SMatt Jacob *data16++ = datum & MPT_DB_DATA_MASK; 14149b631363SMatt Jacob 14159b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 14169b631363SMatt Jacob } 14179b631363SMatt Jacob 14189b631363SMatt Jacob /* One more wait & clear at the end */ 14199b631363SMatt Jacob if (mpt_wait_db_int(mpt) != MPT_OK) { 1420b0a2fdeeSScott Long mpt_prt(mpt, "mpt_recv_handshake_cmd timeout4\n"); 14219b631363SMatt Jacob return ETIMEDOUT; 14229b631363SMatt Jacob } 14239b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_STATUS, 0); 14249b631363SMatt Jacob 14259b631363SMatt Jacob if ((hdr->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) { 1426b0a2fdeeSScott Long if (mpt->verbose >= MPT_PRT_TRACE) 14279b631363SMatt Jacob mpt_print_reply(hdr); 14289b631363SMatt Jacob return (MPT_FAIL | hdr->IOCStatus); 14299b631363SMatt Jacob } 14309b631363SMatt Jacob 14319b631363SMatt Jacob return (0); 14329b631363SMatt Jacob } 14339b631363SMatt Jacob 14349b631363SMatt Jacob static int 1435b0a2fdeeSScott Long mpt_get_iocfacts(struct mpt_softc *mpt, MSG_IOC_FACTS_REPLY *freplp) 14369b631363SMatt Jacob { 14379b631363SMatt Jacob MSG_IOC_FACTS f_req; 14389b631363SMatt Jacob int error; 14399b631363SMatt Jacob 14405e073106SMatt Jacob memset(&f_req, 0, sizeof f_req); 14419b631363SMatt Jacob f_req.Function = MPI_FUNCTION_IOC_FACTS; 1442b0a2fdeeSScott Long f_req.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE); 14439b631363SMatt Jacob error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req); 14449b631363SMatt Jacob if (error) 14459b631363SMatt Jacob return(error); 14469b631363SMatt Jacob error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp); 14479b631363SMatt Jacob return (error); 14489b631363SMatt Jacob } 14499b631363SMatt Jacob 14507104aeefSMatt Jacob static int 1451b0a2fdeeSScott Long mpt_get_portfacts(struct mpt_softc *mpt, MSG_PORT_FACTS_REPLY *freplp) 14527104aeefSMatt Jacob { 14537104aeefSMatt Jacob MSG_PORT_FACTS f_req; 14547104aeefSMatt Jacob int error; 14557104aeefSMatt Jacob 14567104aeefSMatt Jacob /* XXX: Only getting PORT FACTS for Port 0 */ 1457b0a2fdeeSScott Long memset(&f_req, 0, sizeof f_req); 14587104aeefSMatt Jacob f_req.Function = MPI_FUNCTION_PORT_FACTS; 1459b0a2fdeeSScott Long f_req.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE); 14607104aeefSMatt Jacob error = mpt_send_handshake_cmd(mpt, sizeof f_req, &f_req); 14617104aeefSMatt Jacob if (error) 14627104aeefSMatt Jacob return(error); 14637104aeefSMatt Jacob error = mpt_recv_handshake_reply(mpt, sizeof (*freplp), freplp); 14647104aeefSMatt Jacob return (error); 14657104aeefSMatt Jacob } 14667104aeefSMatt Jacob 14679b631363SMatt Jacob /* 14689b631363SMatt Jacob * Send the initialization request. This is where we specify how many 14699b631363SMatt Jacob * SCSI busses and how many devices per bus we wish to emulate. 14709b631363SMatt Jacob * This is also the command that specifies the max size of the reply 14719b631363SMatt Jacob * frames from the IOC that we will be allocating. 14729b631363SMatt Jacob */ 14739b631363SMatt Jacob static int 1474b0a2fdeeSScott Long mpt_send_ioc_init(struct mpt_softc *mpt, uint32_t who) 14759b631363SMatt Jacob { 14769b631363SMatt Jacob int error = 0; 14779b631363SMatt Jacob MSG_IOC_INIT init; 14789b631363SMatt Jacob MSG_IOC_INIT_REPLY reply; 14799b631363SMatt Jacob 14805e073106SMatt Jacob memset(&init, 0, sizeof init); 14819b631363SMatt Jacob init.WhoInit = who; 14829b631363SMatt Jacob init.Function = MPI_FUNCTION_IOC_INIT; 14839b631363SMatt Jacob if (mpt->is_fc) { 14849b631363SMatt Jacob init.MaxDevices = 255; 1485444dd2b6SMatt Jacob } else if (mpt->is_sas) { 1486444dd2b6SMatt Jacob init.MaxDevices = mpt->mpt_max_devices; 14879b631363SMatt Jacob } else { 14889b631363SMatt Jacob init.MaxDevices = 16; 14899b631363SMatt Jacob } 14909b631363SMatt Jacob init.MaxBuses = 1; 1491444dd2b6SMatt Jacob 1492444dd2b6SMatt Jacob init.MsgVersion = htole16(MPI_VERSION); 1493444dd2b6SMatt Jacob init.HeaderVersion = htole16(MPI_HEADER_VERSION); 1494444dd2b6SMatt Jacob init.ReplyFrameSize = htole16(MPT_REPLY_SIZE); 1495b0a2fdeeSScott Long init.MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE); 14969b631363SMatt Jacob 14979b631363SMatt Jacob if ((error = mpt_send_handshake_cmd(mpt, sizeof init, &init)) != 0) { 14989b631363SMatt Jacob return(error); 14999b631363SMatt Jacob } 15009b631363SMatt Jacob 15019b631363SMatt Jacob error = mpt_recv_handshake_reply(mpt, sizeof reply, &reply); 15029b631363SMatt Jacob return (error); 15039b631363SMatt Jacob } 15049b631363SMatt Jacob 15057104aeefSMatt Jacob 15067104aeefSMatt Jacob /* 15077104aeefSMatt Jacob * Utiltity routine to read configuration headers and pages 15087104aeefSMatt Jacob */ 1509b0a2fdeeSScott Long int 1510b0a2fdeeSScott Long mpt_issue_cfg_req(struct mpt_softc *mpt, request_t *req, u_int Action, 1511b0a2fdeeSScott Long u_int PageVersion, u_int PageLength, u_int PageNumber, 1512b0a2fdeeSScott Long u_int PageType, uint32_t PageAddress, bus_addr_t addr, 1513b0a2fdeeSScott Long bus_size_t len, int sleep_ok, int timeout_ms) 15147104aeefSMatt Jacob { 15157104aeefSMatt Jacob MSG_CONFIG *cfgp; 1516b0a2fdeeSScott Long SGE_SIMPLE32 *se; 15177104aeefSMatt Jacob 15187104aeefSMatt Jacob cfgp = req->req_vbuf; 1519b0a2fdeeSScott Long memset(cfgp, 0, sizeof *cfgp); 1520b0a2fdeeSScott Long cfgp->Action = Action; 15217104aeefSMatt Jacob cfgp->Function = MPI_FUNCTION_CONFIG; 1522b0a2fdeeSScott Long cfgp->Header.PageVersion = PageVersion; 1523b0a2fdeeSScott Long cfgp->Header.PageLength = PageLength; 1524b0a2fdeeSScott Long cfgp->Header.PageNumber = PageNumber; 1525b0a2fdeeSScott Long cfgp->Header.PageType = PageType; 15267104aeefSMatt Jacob cfgp->PageAddress = PageAddress; 1527b0a2fdeeSScott Long se = (SGE_SIMPLE32 *)&cfgp->PageBufferSGE; 1528b0a2fdeeSScott Long se->Address = addr; 1529b0a2fdeeSScott Long MPI_pSGE_SET_LENGTH(se, len); 1530b0a2fdeeSScott Long MPI_pSGE_SET_FLAGS(se, (MPI_SGE_FLAGS_SIMPLE_ELEMENT | 1531b0a2fdeeSScott Long MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER | 1532b0a2fdeeSScott Long MPI_SGE_FLAGS_END_OF_LIST | 1533b0a2fdeeSScott Long ((Action == MPI_CONFIG_ACTION_PAGE_WRITE_CURRENT 1534b0a2fdeeSScott Long || Action == MPI_CONFIG_ACTION_PAGE_WRITE_NVRAM) 1535b0a2fdeeSScott Long ? MPI_SGE_FLAGS_HOST_TO_IOC : MPI_SGE_FLAGS_IOC_TO_HOST))); 1536b0a2fdeeSScott Long cfgp->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_CONFIG); 15377104aeefSMatt Jacob 15387104aeefSMatt Jacob mpt_check_doorbell(mpt); 15397104aeefSMatt Jacob mpt_send_cmd(mpt, req); 1540b0a2fdeeSScott Long return (mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE, 1541b0a2fdeeSScott Long sleep_ok, timeout_ms)); 15427104aeefSMatt Jacob } 15437104aeefSMatt Jacob 1544b0a2fdeeSScott Long 1545b0a2fdeeSScott Long int 1546b0a2fdeeSScott Long mpt_read_cfg_header(struct mpt_softc *mpt, int PageType, int PageNumber, 1547b0a2fdeeSScott Long uint32_t PageAddress, CONFIG_PAGE_HEADER *rslt, 1548b0a2fdeeSScott Long int sleep_ok, int timeout_ms) 1549b0a2fdeeSScott Long { 1550b0a2fdeeSScott Long request_t *req; 155129ae59edSMatt Jacob MSG_CONFIG *cfgp; 1552b0a2fdeeSScott Long int error; 1553b0a2fdeeSScott Long 1554b0a2fdeeSScott Long req = mpt_get_request(mpt, sleep_ok); 1555b0a2fdeeSScott Long if (req == NULL) { 1556b0a2fdeeSScott Long mpt_prt(mpt, "mpt_read_cfg_header: Get request failed!\n"); 155729ae59edSMatt Jacob return (ENOMEM); 15587104aeefSMatt Jacob } 1559b0a2fdeeSScott Long 1560b0a2fdeeSScott Long error = mpt_issue_cfg_req(mpt, req, MPI_CONFIG_ACTION_PAGE_HEADER, 1561b0a2fdeeSScott Long /*PageVersion*/0, /*PageLength*/0, PageNumber, 1562b0a2fdeeSScott Long PageType, PageAddress, /*addr*/0, /*len*/0, 1563b0a2fdeeSScott Long sleep_ok, timeout_ms); 1564b0a2fdeeSScott Long if (error != 0) { 156529ae59edSMatt Jacob mpt_free_request(mpt, req); 1566b0a2fdeeSScott Long mpt_prt(mpt, "read_cfg_header timed out\n"); 156729ae59edSMatt Jacob return (ETIMEDOUT); 1568b0a2fdeeSScott Long } 1569b0a2fdeeSScott Long 157029ae59edSMatt Jacob switch (req->IOCStatus & MPI_IOCSTATUS_MASK) { 157129ae59edSMatt Jacob case MPI_IOCSTATUS_SUCCESS: 1572b0a2fdeeSScott Long cfgp = req->req_vbuf; 1573b0a2fdeeSScott Long bcopy(&cfgp->Header, rslt, sizeof(*rslt)); 1574b0a2fdeeSScott Long error = 0; 157529ae59edSMatt Jacob break; 157629ae59edSMatt Jacob case MPI_IOCSTATUS_CONFIG_INVALID_PAGE: 157729ae59edSMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, 157829ae59edSMatt Jacob "Invalid Page Type %d Number %d Addr 0x%0x\n", 157929ae59edSMatt Jacob PageType, PageNumber, PageAddress); 158029ae59edSMatt Jacob error = EINVAL; 158129ae59edSMatt Jacob break; 158229ae59edSMatt Jacob default: 158329ae59edSMatt Jacob mpt_prt(mpt, "mpt_read_cfg_header: Config Info Status %x\n", 158429ae59edSMatt Jacob req->IOCStatus); 158529ae59edSMatt Jacob error = EIO; 158629ae59edSMatt Jacob break; 1587b0a2fdeeSScott Long } 15887104aeefSMatt Jacob mpt_free_request(mpt, req); 1589b0a2fdeeSScott Long return (error); 15907104aeefSMatt Jacob } 15917104aeefSMatt Jacob 1592ce68dae5SMatt Jacob int 1593b0a2fdeeSScott Long mpt_read_cfg_page(struct mpt_softc *mpt, int Action, uint32_t PageAddress, 1594b0a2fdeeSScott Long CONFIG_PAGE_HEADER *hdr, size_t len, int sleep_ok, 1595b0a2fdeeSScott Long int timeout_ms) 15967104aeefSMatt Jacob { 15977104aeefSMatt Jacob request_t *req; 1598b0a2fdeeSScott Long int error; 15997104aeefSMatt Jacob 1600b0a2fdeeSScott Long req = mpt_get_request(mpt, sleep_ok); 1601b0a2fdeeSScott Long if (req == NULL) { 1602b0a2fdeeSScott Long mpt_prt(mpt, "mpt_read_cfg_page: Get request failed!\n"); 16037104aeefSMatt Jacob return (-1); 16047104aeefSMatt Jacob } 16057104aeefSMatt Jacob 1606b0a2fdeeSScott Long error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion, 1607b0a2fdeeSScott Long hdr->PageLength, hdr->PageNumber, 1608b0a2fdeeSScott Long hdr->PageType & MPI_CONFIG_PAGETYPE_MASK, 1609c87e3f83SMatt Jacob PageAddress, req->req_pbuf + MPT_RQSL(mpt), 1610b0a2fdeeSScott Long len, sleep_ok, timeout_ms); 1611b0a2fdeeSScott Long if (error != 0) { 1612b0a2fdeeSScott Long mpt_prt(mpt, "read_cfg_page(%d) timed out\n", Action); 16137104aeefSMatt Jacob return (-1); 16147104aeefSMatt Jacob } 1615b0a2fdeeSScott Long 1616b0a2fdeeSScott Long if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) { 1617b0a2fdeeSScott Long mpt_prt(mpt, "mpt_read_cfg_page: Config Info Status %x\n", 1618b0a2fdeeSScott Long req->IOCStatus); 1619b0a2fdeeSScott Long mpt_free_request(mpt, req); 1620b0a2fdeeSScott Long return (-1); 1621b0a2fdeeSScott Long } 16227104aeefSMatt Jacob bus_dmamap_sync(mpt->request_dmat, mpt->request_dmap, 16237104aeefSMatt Jacob BUS_DMASYNC_POSTREAD); 1624c87e3f83SMatt Jacob memcpy(hdr, ((uint8_t *)req->req_vbuf)+MPT_RQSL(mpt), len); 16257104aeefSMatt Jacob mpt_free_request(mpt, req); 16267104aeefSMatt Jacob return (0); 16277104aeefSMatt Jacob } 16287104aeefSMatt Jacob 1629ce68dae5SMatt Jacob int 1630b0a2fdeeSScott Long mpt_write_cfg_page(struct mpt_softc *mpt, int Action, uint32_t PageAddress, 1631b0a2fdeeSScott Long CONFIG_PAGE_HEADER *hdr, size_t len, int sleep_ok, 1632b0a2fdeeSScott Long int timeout_ms) 16337104aeefSMatt Jacob { 16347104aeefSMatt Jacob request_t *req; 1635b0a2fdeeSScott Long u_int hdr_attr; 1636b0a2fdeeSScott Long int error; 16377104aeefSMatt Jacob 16387104aeefSMatt Jacob hdr_attr = hdr->PageType & MPI_CONFIG_PAGEATTR_MASK; 16397104aeefSMatt Jacob if (hdr_attr != MPI_CONFIG_PAGEATTR_CHANGEABLE && 16407104aeefSMatt Jacob hdr_attr != MPI_CONFIG_PAGEATTR_PERSISTENT) { 1641b0a2fdeeSScott Long mpt_prt(mpt, "page type 0x%x not changeable\n", 16427104aeefSMatt Jacob hdr->PageType & MPI_CONFIG_PAGETYPE_MASK); 16437104aeefSMatt Jacob return (-1); 16447104aeefSMatt Jacob } 1645b0a2fdeeSScott Long hdr->PageType &= MPI_CONFIG_PAGETYPE_MASK, 16467104aeefSMatt Jacob 1647b0a2fdeeSScott Long req = mpt_get_request(mpt, sleep_ok); 1648b0a2fdeeSScott Long if (req == NULL) 1649b0a2fdeeSScott Long return (-1); 16507104aeefSMatt Jacob 1651c87e3f83SMatt Jacob memcpy(((caddr_t)req->req_vbuf)+MPT_RQSL(mpt), hdr, len); 1652301472c2SMatt Jacob /* Restore stripped out attributes */ 1653301472c2SMatt Jacob hdr->PageType |= hdr_attr; 16547104aeefSMatt Jacob 1655b0a2fdeeSScott Long error = mpt_issue_cfg_req(mpt, req, Action, hdr->PageVersion, 1656b0a2fdeeSScott Long hdr->PageLength, hdr->PageNumber, 1657b0a2fdeeSScott Long hdr->PageType & MPI_CONFIG_PAGETYPE_MASK, 1658c87e3f83SMatt Jacob PageAddress, req->req_pbuf + MPT_RQSL(mpt), 1659b0a2fdeeSScott Long len, sleep_ok, timeout_ms); 1660b0a2fdeeSScott Long if (error != 0) { 1661b0a2fdeeSScott Long mpt_prt(mpt, "mpt_write_cfg_page timed out\n"); 16627104aeefSMatt Jacob return (-1); 16637104aeefSMatt Jacob } 16647104aeefSMatt Jacob 1665b0a2fdeeSScott Long if ((req->IOCStatus & MPI_IOCSTATUS_MASK) != MPI_IOCSTATUS_SUCCESS) { 1666b0a2fdeeSScott Long mpt_prt(mpt, "mpt_write_cfg_page: Config Info Status %x\n", 1667b0a2fdeeSScott Long req->IOCStatus); 16687104aeefSMatt Jacob mpt_free_request(mpt, req); 1669b0a2fdeeSScott Long return (-1); 1670b0a2fdeeSScott Long } 1671b0a2fdeeSScott Long mpt_free_request(mpt, req); 1672b0a2fdeeSScott Long return (0); 1673b0a2fdeeSScott Long } 1674b0a2fdeeSScott Long 1675b0a2fdeeSScott Long /* 1676b0a2fdeeSScott Long * Read IOC configuration information 1677b0a2fdeeSScott Long */ 1678b0a2fdeeSScott Long static int 1679b0a2fdeeSScott Long mpt_read_config_info_ioc(struct mpt_softc *mpt) 1680b0a2fdeeSScott Long { 1681b0a2fdeeSScott Long CONFIG_PAGE_HEADER hdr; 1682b0a2fdeeSScott Long struct mpt_raid_volume *mpt_raid; 1683b0a2fdeeSScott Long int rv; 1684b0a2fdeeSScott Long int i; 1685b0a2fdeeSScott Long size_t len; 1686b0a2fdeeSScott Long 1687b0a2fdeeSScott Long rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC, 16881d79ca0eSMatt Jacob 2, 0, &hdr, FALSE, 5000); 168929ae59edSMatt Jacob /* 169029ae59edSMatt Jacob * If it's an invalid page, so what? Not a supported function.... 169129ae59edSMatt Jacob */ 16921d79ca0eSMatt Jacob if (rv == EINVAL) { 169329ae59edSMatt Jacob return (0); 16941d79ca0eSMatt Jacob } 16951d79ca0eSMatt Jacob if (rv) { 169629ae59edSMatt Jacob return (rv); 16971d79ca0eSMatt Jacob } 1698b0a2fdeeSScott Long 16995e073106SMatt Jacob #if __FreeBSD_version >= 500000 1700a529c6a2SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC Page 2 Header: ver %x, len %zx, " 1701b0a2fdeeSScott Long "num %x, type %x\n", hdr.PageVersion, 1702b0a2fdeeSScott Long hdr.PageLength * sizeof(uint32_t), 1703b0a2fdeeSScott Long hdr.PageNumber, hdr.PageType); 17045e073106SMatt Jacob #else 17055e073106SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC Page 2 Header: ver %x, len %z, " 17065e073106SMatt Jacob "num %x, type %x\n", hdr.PageVersion, 17075e073106SMatt Jacob hdr.PageLength * sizeof(uint32_t), 17085e073106SMatt Jacob hdr.PageNumber, hdr.PageType); 17095e073106SMatt Jacob #endif 1710b0a2fdeeSScott Long 1711b0a2fdeeSScott Long len = hdr.PageLength * sizeof(uint32_t); 1712a3699bcaSScott Long mpt->ioc_page2 = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 17131d79ca0eSMatt Jacob if (mpt->ioc_page2 == NULL) { 17141d79ca0eSMatt Jacob mpt_prt(mpt, "unable to allocate memory for IOC page 2\n"); 17151d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 1716b0a2fdeeSScott Long return (ENOMEM); 17171d79ca0eSMatt Jacob } 1718b0a2fdeeSScott Long memcpy(&mpt->ioc_page2->Header, &hdr, sizeof(hdr)); 17191d79ca0eSMatt Jacob rv = mpt_read_cur_cfg_page(mpt, 0, 17201d79ca0eSMatt Jacob &mpt->ioc_page2->Header, len, FALSE, 5000); 1721b0a2fdeeSScott Long if (rv) { 1722b0a2fdeeSScott Long mpt_prt(mpt, "failed to read IOC Page 2\n"); 17231d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 17241d79ca0eSMatt Jacob return (EIO); 17251d79ca0eSMatt Jacob } 17261d79ca0eSMatt Jacob 17271d79ca0eSMatt Jacob if (mpt->ioc_page2->CapabilitiesFlags != 0) { 1728b0a2fdeeSScott Long uint32_t mask; 1729b0a2fdeeSScott Long 1730b0a2fdeeSScott Long mpt_prt(mpt, "Capabilities: ("); 1731b0a2fdeeSScott Long for (mask = 1; mask != 0; mask <<= 1) { 17321d79ca0eSMatt Jacob if ((mpt->ioc_page2->CapabilitiesFlags & mask) == 0) { 1733b0a2fdeeSScott Long continue; 17341d79ca0eSMatt Jacob } 1735b0a2fdeeSScott Long switch (mask) { 1736b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT: 1737b0a2fdeeSScott Long mpt_prtc(mpt, " RAID-0"); 1738b0a2fdeeSScott Long break; 1739b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT: 1740b0a2fdeeSScott Long mpt_prtc(mpt, " RAID-1E"); 1741b0a2fdeeSScott Long break; 1742b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT: 1743b0a2fdeeSScott Long mpt_prtc(mpt, " RAID-1"); 1744b0a2fdeeSScott Long break; 1745b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_SES_SUPPORT: 1746b0a2fdeeSScott Long mpt_prtc(mpt, " SES"); 1747b0a2fdeeSScott Long break; 1748b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_SAFTE_SUPPORT: 1749b0a2fdeeSScott Long mpt_prtc(mpt, " SAFTE"); 1750b0a2fdeeSScott Long break; 1751b0a2fdeeSScott Long case MPI_IOCPAGE2_CAP_FLAGS_CROSS_CHANNEL_SUPPORT: 1752b0a2fdeeSScott Long mpt_prtc(mpt, " Multi-Channel-Arrays"); 1753b0a2fdeeSScott Long default: 1754b0a2fdeeSScott Long break; 1755b0a2fdeeSScott Long } 1756b0a2fdeeSScott Long } 1757b0a2fdeeSScott Long mpt_prtc(mpt, " )\n"); 1758b0a2fdeeSScott Long if ((mpt->ioc_page2->CapabilitiesFlags 1759b0a2fdeeSScott Long & (MPI_IOCPAGE2_CAP_FLAGS_IS_SUPPORT 1760b0a2fdeeSScott Long | MPI_IOCPAGE2_CAP_FLAGS_IME_SUPPORT 1761b0a2fdeeSScott Long | MPI_IOCPAGE2_CAP_FLAGS_IM_SUPPORT)) != 0) { 1762b0a2fdeeSScott Long mpt_prt(mpt, "%d Active Volume%s(%d Max)\n", 1763b0a2fdeeSScott Long mpt->ioc_page2->NumActiveVolumes, 1764b0a2fdeeSScott Long mpt->ioc_page2->NumActiveVolumes != 1 1765b0a2fdeeSScott Long ? "s " : " ", 1766b0a2fdeeSScott Long mpt->ioc_page2->MaxVolumes); 1767b0a2fdeeSScott Long mpt_prt(mpt, "%d Hidden Drive Member%s(%d Max)\n", 1768b0a2fdeeSScott Long mpt->ioc_page2->NumActivePhysDisks, 1769b0a2fdeeSScott Long mpt->ioc_page2->NumActivePhysDisks != 1 1770b0a2fdeeSScott Long ? "s " : " ", 1771b0a2fdeeSScott Long mpt->ioc_page2->MaxPhysDisks); 1772b0a2fdeeSScott Long } 1773b0a2fdeeSScott Long } 1774b0a2fdeeSScott Long 1775b0a2fdeeSScott Long len = mpt->ioc_page2->MaxVolumes * sizeof(struct mpt_raid_volume); 17761d79ca0eSMatt Jacob mpt->raid_volumes = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 1777b0a2fdeeSScott Long if (mpt->raid_volumes == NULL) { 1778b0a2fdeeSScott Long mpt_prt(mpt, "Could not allocate RAID volume data\n"); 17791d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 17801d79ca0eSMatt Jacob return (ENOMEM); 1781b0a2fdeeSScott Long } 1782b0a2fdeeSScott Long 1783b0a2fdeeSScott Long /* 1784b0a2fdeeSScott Long * Copy critical data out of ioc_page2 so that we can 1785b0a2fdeeSScott Long * safely refresh the page without windows of unreliable 1786b0a2fdeeSScott Long * data. 1787b0a2fdeeSScott Long */ 1788b0a2fdeeSScott Long mpt->raid_max_volumes = mpt->ioc_page2->MaxVolumes; 1789b0a2fdeeSScott Long 17901d79ca0eSMatt Jacob len = sizeof(*mpt->raid_volumes->config_page) + 17911d79ca0eSMatt Jacob (sizeof (RAID_VOL0_PHYS_DISK) * (mpt->ioc_page2->MaxPhysDisks - 1)); 1792b0a2fdeeSScott Long for (i = 0; i < mpt->ioc_page2->MaxVolumes; i++) { 1793b0a2fdeeSScott Long mpt_raid = &mpt->raid_volumes[i]; 17941d79ca0eSMatt Jacob mpt_raid->config_page = 17951d79ca0eSMatt Jacob malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 1796b0a2fdeeSScott Long if (mpt_raid->config_page == NULL) { 1797b0a2fdeeSScott Long mpt_prt(mpt, "Could not allocate RAID page data\n"); 17981d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 17991d79ca0eSMatt Jacob return (ENOMEM); 1800b0a2fdeeSScott Long } 1801b0a2fdeeSScott Long } 1802b0a2fdeeSScott Long mpt->raid_page0_len = len; 1803b0a2fdeeSScott Long 1804b0a2fdeeSScott Long len = mpt->ioc_page2->MaxPhysDisks * sizeof(struct mpt_raid_disk); 18051d79ca0eSMatt Jacob mpt->raid_disks = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 1806b0a2fdeeSScott Long if (mpt->raid_disks == NULL) { 1807b0a2fdeeSScott Long mpt_prt(mpt, "Could not allocate RAID disk data\n"); 18081d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 18091d79ca0eSMatt Jacob return (ENOMEM); 1810b0a2fdeeSScott Long } 1811b0a2fdeeSScott Long mpt->raid_max_disks = mpt->ioc_page2->MaxPhysDisks; 1812b0a2fdeeSScott Long 18131d79ca0eSMatt Jacob /* 18141d79ca0eSMatt Jacob * Load page 3. 18151d79ca0eSMatt Jacob */ 1816b0a2fdeeSScott Long rv = mpt_read_cfg_header(mpt, MPI_CONFIG_PAGETYPE_IOC, 18171d79ca0eSMatt Jacob 3, 0, &hdr, FALSE, 5000); 18181d79ca0eSMatt Jacob if (rv) { 18191d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 1820b0a2fdeeSScott Long return (EIO); 18211d79ca0eSMatt Jacob } 1822b0a2fdeeSScott Long 1823b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC Page 3 Header: %x %x %x %x\n", 1824b0a2fdeeSScott Long hdr.PageVersion, hdr.PageLength, hdr.PageNumber, hdr.PageType); 1825b0a2fdeeSScott Long 1826b0a2fdeeSScott Long len = hdr.PageLength * sizeof(uint32_t); 1827a3699bcaSScott Long mpt->ioc_page3 = malloc(len, M_DEVBUF, M_NOWAIT | M_ZERO); 18281d79ca0eSMatt Jacob if (mpt->ioc_page3 == NULL) { 18291d79ca0eSMatt Jacob mpt_prt(mpt, "unable to allocate memory for IOC page 3\n"); 18301d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 18311d79ca0eSMatt Jacob return (ENOMEM); 1832b0a2fdeeSScott Long } 18331d79ca0eSMatt Jacob memcpy(&mpt->ioc_page3->Header, &hdr, sizeof(hdr)); 18341d79ca0eSMatt Jacob rv = mpt_read_cur_cfg_page(mpt, 0, 18351d79ca0eSMatt Jacob &mpt->ioc_page3->Header, len, FALSE, 5000); 18361d79ca0eSMatt Jacob if (rv) { 18371d79ca0eSMatt Jacob mpt_raid_free_mem(mpt); 18381d79ca0eSMatt Jacob return (EIO); 18391d79ca0eSMatt Jacob } 1840b0a2fdeeSScott Long mpt_raid_wakeup(mpt); 18417104aeefSMatt Jacob return (0); 18427104aeefSMatt Jacob } 18437104aeefSMatt Jacob 18447104aeefSMatt Jacob /* 18457104aeefSMatt Jacob * Enable IOC port 18467104aeefSMatt Jacob */ 18477104aeefSMatt Jacob static int 1848b0a2fdeeSScott Long mpt_send_port_enable(struct mpt_softc *mpt, int port) 18499b631363SMatt Jacob { 18509b631363SMatt Jacob request_t *req; 18519b631363SMatt Jacob MSG_PORT_ENABLE *enable_req; 1852b0a2fdeeSScott Long int error; 18539b631363SMatt Jacob 1854b0a2fdeeSScott Long req = mpt_get_request(mpt, /*sleep_ok*/FALSE); 1855b0a2fdeeSScott Long if (req == NULL) 1856b0a2fdeeSScott Long return (-1); 18579b631363SMatt Jacob 18589b631363SMatt Jacob enable_req = req->req_vbuf; 18595e073106SMatt Jacob memset(enable_req, 0, MPT_RQSL(mpt)); 18609b631363SMatt Jacob 18619b631363SMatt Jacob enable_req->Function = MPI_FUNCTION_PORT_ENABLE; 1862b0a2fdeeSScott Long enable_req->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_CONFIG); 18639b631363SMatt Jacob enable_req->PortNumber = port; 18649b631363SMatt Jacob 18659b631363SMatt Jacob mpt_check_doorbell(mpt); 1866b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "enabling port %d\n", port); 18679b631363SMatt Jacob 1868b0a2fdeeSScott Long mpt_send_cmd(mpt, req); 1869b0a2fdeeSScott Long error = mpt_wait_req(mpt, req, REQ_STATE_DONE, REQ_STATE_DONE, 18705089bd63SMatt Jacob FALSE, (mpt->is_sas || mpt->is_fc)? 30000 : 3000); 1871b0a2fdeeSScott Long if (error != 0) { 1872c87e3f83SMatt Jacob mpt_prt(mpt, "port %d enable timed out\n", port); 18739b631363SMatt Jacob return (-1); 18749b631363SMatt Jacob } 18759b631363SMatt Jacob mpt_free_request(mpt, req); 1876c87e3f83SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "enabled port %d\n", port); 18779b631363SMatt Jacob return (0); 18789b631363SMatt Jacob } 18799b631363SMatt Jacob 18809b631363SMatt Jacob /* 18819b631363SMatt Jacob * Enable/Disable asynchronous event reporting. 18829b631363SMatt Jacob */ 18839b631363SMatt Jacob static int 1884b0a2fdeeSScott Long mpt_send_event_request(struct mpt_softc *mpt, int onoff) 18859b631363SMatt Jacob { 18869b631363SMatt Jacob request_t *req; 18879b631363SMatt Jacob MSG_EVENT_NOTIFY *enable_req; 18889b631363SMatt Jacob 18895e073106SMatt Jacob req = mpt_get_request(mpt, FALSE); 18905e073106SMatt Jacob if (req == NULL) { 18915e073106SMatt Jacob return (ENOMEM); 18925e073106SMatt Jacob } 18939b631363SMatt Jacob enable_req = req->req_vbuf; 18945e073106SMatt Jacob memset(enable_req, 0, sizeof *enable_req); 18959b631363SMatt Jacob 18969b631363SMatt Jacob enable_req->Function = MPI_FUNCTION_EVENT_NOTIFICATION; 1897b0a2fdeeSScott Long enable_req->MsgContext = htole32(req->index | MPT_REPLY_HANDLER_EVENTS); 18989b631363SMatt Jacob enable_req->Switch = onoff; 18999b631363SMatt Jacob 19009b631363SMatt Jacob mpt_check_doorbell(mpt); 19015e073106SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "%sabling async events\n", 19025e073106SMatt Jacob onoff ? "en" : "dis"); 19035e073106SMatt Jacob /* 19045e073106SMatt Jacob * Send the command off, but don't wait for it. 19055e073106SMatt Jacob */ 19069b631363SMatt Jacob mpt_send_cmd(mpt, req); 19079b631363SMatt Jacob return (0); 19089b631363SMatt Jacob } 19099b631363SMatt Jacob 19109b631363SMatt Jacob /* 19119b631363SMatt Jacob * Un-mask the interupts on the chip. 19129b631363SMatt Jacob */ 19139b631363SMatt Jacob void 1914b0a2fdeeSScott Long mpt_enable_ints(struct mpt_softc *mpt) 19159b631363SMatt Jacob { 19169b631363SMatt Jacob /* Unmask every thing except door bell int */ 19179b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_MASK, MPT_INTR_DB_MASK); 19189b631363SMatt Jacob } 19199b631363SMatt Jacob 19209b631363SMatt Jacob /* 19219b631363SMatt Jacob * Mask the interupts on the chip. 19229b631363SMatt Jacob */ 19239b631363SMatt Jacob void 1924b0a2fdeeSScott Long mpt_disable_ints(struct mpt_softc *mpt) 19259b631363SMatt Jacob { 19269b631363SMatt Jacob /* Mask all interrupts */ 19279b631363SMatt Jacob mpt_write(mpt, MPT_OFFSET_INTR_MASK, 19289b631363SMatt Jacob MPT_INTR_REPLY_MASK | MPT_INTR_DB_MASK); 19299b631363SMatt Jacob } 19309b631363SMatt Jacob 1931b0a2fdeeSScott Long static void 1932b0a2fdeeSScott Long mpt_sysctl_attach(struct mpt_softc *mpt) 19339b631363SMatt Jacob { 1934c87e3f83SMatt Jacob #if __FreeBSD_version >= 500000 1935b0a2fdeeSScott Long struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(mpt->dev); 1936b0a2fdeeSScott Long struct sysctl_oid *tree = device_get_sysctl_tree(mpt->dev); 19379b631363SMatt Jacob 1938b0a2fdeeSScott Long SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 1939b0a2fdeeSScott Long "debug", CTLFLAG_RW, &mpt->verbose, 0, 1940b0a2fdeeSScott Long "Debugging/Verbose level"); 1941c87e3f83SMatt Jacob #endif 19429b631363SMatt Jacob } 19439b631363SMatt Jacob 1944b0a2fdeeSScott Long int 1945b0a2fdeeSScott Long mpt_attach(struct mpt_softc *mpt) 1946b0a2fdeeSScott Long { 1947b0a2fdeeSScott Long struct mpt_personality *pers; 1948c87e3f83SMatt Jacob int i; 1949b0a2fdeeSScott Long int error; 1950b0a2fdeeSScott Long 1951c87e3f83SMatt Jacob for (i = 0; i < MPT_MAX_PERSONALITIES; i++) { 1952b0a2fdeeSScott Long pers = mpt_personalities[i]; 1953c87e3f83SMatt Jacob if (pers == NULL) { 1954b0a2fdeeSScott Long continue; 1955c87e3f83SMatt Jacob } 1956b0a2fdeeSScott Long if (pers->probe(mpt) == 0) { 1957b0a2fdeeSScott Long error = pers->attach(mpt); 1958b0a2fdeeSScott Long if (error != 0) { 1959b0a2fdeeSScott Long mpt_detach(mpt); 1960b0a2fdeeSScott Long return (error); 1961b0a2fdeeSScott Long } 1962b0a2fdeeSScott Long mpt->mpt_pers_mask |= (0x1 << pers->id); 1963b0a2fdeeSScott Long pers->use_count++; 1964b0a2fdeeSScott Long } 1965b0a2fdeeSScott Long } 1966444dd2b6SMatt Jacob 1967c87e3f83SMatt Jacob /* 1968c87e3f83SMatt Jacob * Now that we've attached everything, do the enable function 1969c87e3f83SMatt Jacob * for all of the personalities. This allows the personalities 1970c87e3f83SMatt Jacob * to do setups that are appropriate for them prior to enabling 1971c87e3f83SMatt Jacob * any ports. 1972c87e3f83SMatt Jacob */ 1973c87e3f83SMatt Jacob for (i = 0; i < MPT_MAX_PERSONALITIES; i++) { 1974c87e3f83SMatt Jacob pers = mpt_personalities[i]; 1975c87e3f83SMatt Jacob if (pers != NULL && MPT_PERS_ATTACHED(pers, mpt) != 0) { 1976c87e3f83SMatt Jacob error = pers->enable(mpt); 1977c87e3f83SMatt Jacob if (error != 0) { 1978c87e3f83SMatt Jacob mpt_prt(mpt, "personality %s attached but would" 1979c87e3f83SMatt Jacob " not enable (%d)\n", pers->name, error); 1980c87e3f83SMatt Jacob mpt_detach(mpt); 1981c87e3f83SMatt Jacob return (error); 1982c87e3f83SMatt Jacob } 1983c87e3f83SMatt Jacob } 1984c87e3f83SMatt Jacob } 1985b0a2fdeeSScott Long return (0); 1986b0a2fdeeSScott Long } 1987b0a2fdeeSScott Long 1988b0a2fdeeSScott Long int 1989b0a2fdeeSScott Long mpt_shutdown(struct mpt_softc *mpt) 1990b0a2fdeeSScott Long { 1991b0a2fdeeSScott Long struct mpt_personality *pers; 1992b0a2fdeeSScott Long 1993c87e3f83SMatt Jacob MPT_PERS_FOREACH_REVERSE(mpt, pers) { 1994b0a2fdeeSScott Long pers->shutdown(mpt); 1995c87e3f83SMatt Jacob } 1996b0a2fdeeSScott Long return (0); 1997b0a2fdeeSScott Long } 1998b0a2fdeeSScott Long 1999b0a2fdeeSScott Long int 2000b0a2fdeeSScott Long mpt_detach(struct mpt_softc *mpt) 2001b0a2fdeeSScott Long { 2002b0a2fdeeSScott Long struct mpt_personality *pers; 2003b0a2fdeeSScott Long 2004b0a2fdeeSScott Long MPT_PERS_FOREACH_REVERSE(mpt, pers) { 2005b0a2fdeeSScott Long pers->detach(mpt); 2006b0a2fdeeSScott Long mpt->mpt_pers_mask &= ~(0x1 << pers->id); 2007b0a2fdeeSScott Long pers->use_count--; 2008b0a2fdeeSScott Long } 2009b0a2fdeeSScott Long 2010b0a2fdeeSScott Long return (0); 2011b0a2fdeeSScott Long } 2012b0a2fdeeSScott Long 2013b0a2fdeeSScott Long int 2014b0a2fdeeSScott Long mpt_core_load(struct mpt_personality *pers) 2015b0a2fdeeSScott Long { 2016b0a2fdeeSScott Long int i; 2017b0a2fdeeSScott Long 2018b0a2fdeeSScott Long /* 2019b0a2fdeeSScott Long * Setup core handlers and insert the default handler 2020b0a2fdeeSScott Long * into all "empty slots". 2021b0a2fdeeSScott Long */ 2022c87e3f83SMatt Jacob for (i = 0; i < MPT_NUM_REPLY_HANDLERS; i++) { 2023b0a2fdeeSScott Long mpt_reply_handlers[i] = mpt_default_reply_handler; 2024c87e3f83SMatt Jacob } 2025b0a2fdeeSScott Long 2026b0a2fdeeSScott Long mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_EVENTS)] = 2027b0a2fdeeSScott Long mpt_event_reply_handler; 2028b0a2fdeeSScott Long mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_CONFIG)] = 2029b0a2fdeeSScott Long mpt_config_reply_handler; 2030b0a2fdeeSScott Long mpt_reply_handlers[MPT_CBI(MPT_REPLY_HANDLER_HANDSHAKE)] = 2031b0a2fdeeSScott Long mpt_handshake_reply_handler; 2032b0a2fdeeSScott Long return (0); 20339b631363SMatt Jacob } 20349b631363SMatt Jacob 20359b631363SMatt Jacob /* 2036b0a2fdeeSScott Long * Initialize per-instance driver data and perform 2037b0a2fdeeSScott Long * initial controller configuration. 20389b631363SMatt Jacob */ 2039b0a2fdeeSScott Long int 2040b0a2fdeeSScott Long mpt_core_attach(struct mpt_softc *mpt) 2041b0a2fdeeSScott Long { 2042b0a2fdeeSScott Long int val; 2043b0a2fdeeSScott Long int error; 2044b0a2fdeeSScott Long 2045c87e3f83SMatt Jacob 2046b0a2fdeeSScott Long LIST_INIT(&mpt->ack_frames); 2047b0a2fdeeSScott Long 2048b0a2fdeeSScott Long /* Put all request buffers on the free list */ 2049b0a2fdeeSScott Long TAILQ_INIT(&mpt->request_pending_list); 2050b0a2fdeeSScott Long TAILQ_INIT(&mpt->request_free_list); 20515e073106SMatt Jacob TAILQ_INIT(&mpt->request_timeout_list); 2052c87e3f83SMatt Jacob for (val = 0; val < MPT_MAX_REQUESTS(mpt); val++) { 20535e073106SMatt Jacob request_t *req = &mpt->request_pool[val]; 20545e073106SMatt Jacob req->state = REQ_STATE_ALLOCATED; 20555e073106SMatt Jacob mpt_free_request(mpt, req); 2056c87e3f83SMatt Jacob } 2057c87e3f83SMatt Jacob 2058c87e3f83SMatt Jacob for (val = 0; val < MPT_MAX_LUNS; val++) { 2059c87e3f83SMatt Jacob STAILQ_INIT(&mpt->trt[val].atios); 2060c87e3f83SMatt Jacob STAILQ_INIT(&mpt->trt[val].inots); 2061c87e3f83SMatt Jacob } 2062c87e3f83SMatt Jacob STAILQ_INIT(&mpt->trt_wildcard.atios); 2063c87e3f83SMatt Jacob STAILQ_INIT(&mpt->trt_wildcard.inots); 2064c87e3f83SMatt Jacob 2065c87e3f83SMatt Jacob mpt->scsi_tgt_handler_id = MPT_HANDLER_ID_NONE; 2066b0a2fdeeSScott Long 2067b0a2fdeeSScott Long mpt_sysctl_attach(mpt); 2068b0a2fdeeSScott Long 2069b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "doorbell req = %s\n", 2070b0a2fdeeSScott Long mpt_ioc_diag(mpt_read(mpt, MPT_OFFSET_DOORBELL))); 2071b0a2fdeeSScott Long 2072b0a2fdeeSScott Long error = mpt_configure_ioc(mpt); 2073b0a2fdeeSScott Long 2074b0a2fdeeSScott Long return (error); 20759b631363SMatt Jacob } 20769b631363SMatt Jacob 2077c87e3f83SMatt Jacob int 2078c87e3f83SMatt Jacob mpt_core_enable(struct mpt_softc *mpt) 2079c87e3f83SMatt Jacob { 2080c87e3f83SMatt Jacob /* 2081c87e3f83SMatt Jacob * We enter with the IOC enabled, but async events 2082c87e3f83SMatt Jacob * not enabled, ports not enabled and interrupts 2083c87e3f83SMatt Jacob * not enabled. 2084c87e3f83SMatt Jacob */ 2085c87e3f83SMatt Jacob 2086c87e3f83SMatt Jacob /* 2087c87e3f83SMatt Jacob * Enable asynchronous event reporting- all personalities 2088c87e3f83SMatt Jacob * have attached so that they should be able to now field 2089c87e3f83SMatt Jacob * async events. 2090c87e3f83SMatt Jacob */ 2091c87e3f83SMatt Jacob mpt_send_event_request(mpt, 1); 2092c87e3f83SMatt Jacob 2093c87e3f83SMatt Jacob /* 2094c87e3f83SMatt Jacob * Catch any pending interrupts 2095c87e3f83SMatt Jacob * 2096c87e3f83SMatt Jacob * This seems to be crucial- otherwise 2097c87e3f83SMatt Jacob * the portenable below times out. 2098c87e3f83SMatt Jacob */ 2099c87e3f83SMatt Jacob mpt_intr(mpt); 2100c87e3f83SMatt Jacob 2101c87e3f83SMatt Jacob /* 2102c87e3f83SMatt Jacob * Enable Interrupts 2103c87e3f83SMatt Jacob */ 2104c87e3f83SMatt Jacob mpt_enable_ints(mpt); 2105c87e3f83SMatt Jacob 2106c87e3f83SMatt Jacob /* 2107c87e3f83SMatt Jacob * Catch any pending interrupts 2108c87e3f83SMatt Jacob * 2109c87e3f83SMatt Jacob * This seems to be crucial- otherwise 2110c87e3f83SMatt Jacob * the portenable below times out. 2111c87e3f83SMatt Jacob */ 2112c87e3f83SMatt Jacob mpt_intr(mpt); 2113c87e3f83SMatt Jacob 2114c87e3f83SMatt Jacob /* 21155089bd63SMatt Jacob * Enable the port. 2116c87e3f83SMatt Jacob */ 2117c87e3f83SMatt Jacob if (mpt_send_port_enable(mpt, 0) != MPT_OK) { 2118c87e3f83SMatt Jacob mpt_prt(mpt, "failed to enable port 0\n"); 2119c87e3f83SMatt Jacob return (ENXIO); 2120c87e3f83SMatt Jacob } 2121c87e3f83SMatt Jacob return (0); 2122c87e3f83SMatt Jacob } 2123c87e3f83SMatt Jacob 2124b0a2fdeeSScott Long void 2125b0a2fdeeSScott Long mpt_core_shutdown(struct mpt_softc *mpt) 2126b0a2fdeeSScott Long { 2127c87e3f83SMatt Jacob mpt_disable_ints(mpt); 2128b0a2fdeeSScott Long } 2129b0a2fdeeSScott Long 2130b0a2fdeeSScott Long void 2131b0a2fdeeSScott Long mpt_core_detach(struct mpt_softc *mpt) 2132b0a2fdeeSScott Long { 2133c87e3f83SMatt Jacob mpt_disable_ints(mpt); 2134b0a2fdeeSScott Long } 2135b0a2fdeeSScott Long 2136b0a2fdeeSScott Long int 2137b0a2fdeeSScott Long mpt_core_unload(struct mpt_personality *pers) 2138b0a2fdeeSScott Long { 2139b0a2fdeeSScott Long /* Unload is always successfull. */ 2140b0a2fdeeSScott Long return (0); 2141b0a2fdeeSScott Long } 2142b0a2fdeeSScott Long 2143b0a2fdeeSScott Long #define FW_UPLOAD_REQ_SIZE \ 2144b0a2fdeeSScott Long (sizeof(MSG_FW_UPLOAD) - sizeof(SGE_MPI_UNION) \ 2145b0a2fdeeSScott Long + sizeof(FW_UPLOAD_TCSGE) + sizeof(SGE_SIMPLE32)) 2146b0a2fdeeSScott Long 2147b0a2fdeeSScott Long static int 2148b0a2fdeeSScott Long mpt_upload_fw(struct mpt_softc *mpt) 2149b0a2fdeeSScott Long { 2150b0a2fdeeSScott Long uint8_t fw_req_buf[FW_UPLOAD_REQ_SIZE]; 2151b0a2fdeeSScott Long MSG_FW_UPLOAD_REPLY fw_reply; 2152b0a2fdeeSScott Long MSG_FW_UPLOAD *fw_req; 2153b0a2fdeeSScott Long FW_UPLOAD_TCSGE *tsge; 2154b0a2fdeeSScott Long SGE_SIMPLE32 *sge; 2155b0a2fdeeSScott Long uint32_t flags; 2156b0a2fdeeSScott Long int error; 2157b0a2fdeeSScott Long 2158b0a2fdeeSScott Long memset(&fw_req_buf, 0, sizeof(fw_req_buf)); 2159b0a2fdeeSScott Long fw_req = (MSG_FW_UPLOAD *)fw_req_buf; 2160b0a2fdeeSScott Long fw_req->ImageType = MPI_FW_UPLOAD_ITYPE_FW_IOC_MEM; 2161b0a2fdeeSScott Long fw_req->Function = MPI_FUNCTION_FW_UPLOAD; 2162b0a2fdeeSScott Long fw_req->MsgContext = htole32(MPT_REPLY_HANDLER_HANDSHAKE); 2163b0a2fdeeSScott Long tsge = (FW_UPLOAD_TCSGE *)&fw_req->SGL; 2164b0a2fdeeSScott Long tsge->DetailsLength = 12; 2165b0a2fdeeSScott Long tsge->Flags = MPI_SGE_FLAGS_TRANSACTION_ELEMENT; 2166b0a2fdeeSScott Long tsge->ImageSize = htole32(mpt->fw_image_size); 2167b0a2fdeeSScott Long sge = (SGE_SIMPLE32 *)(tsge + 1); 2168b0a2fdeeSScott Long flags = (MPI_SGE_FLAGS_LAST_ELEMENT | MPI_SGE_FLAGS_END_OF_BUFFER 2169b0a2fdeeSScott Long | MPI_SGE_FLAGS_END_OF_LIST | MPI_SGE_FLAGS_SIMPLE_ELEMENT 2170b0a2fdeeSScott Long | MPI_SGE_FLAGS_32_BIT_ADDRESSING | MPI_SGE_FLAGS_IOC_TO_HOST); 2171b0a2fdeeSScott Long flags <<= MPI_SGE_FLAGS_SHIFT; 2172b0a2fdeeSScott Long sge->FlagsLength = htole32(flags | mpt->fw_image_size); 2173b0a2fdeeSScott Long sge->Address = htole32(mpt->fw_phys); 2174b0a2fdeeSScott Long error = mpt_send_handshake_cmd(mpt, sizeof(fw_req_buf), &fw_req_buf); 2175b0a2fdeeSScott Long if (error) 2176b0a2fdeeSScott Long return(error); 2177b0a2fdeeSScott Long error = mpt_recv_handshake_reply(mpt, sizeof(fw_reply), &fw_reply); 2178b0a2fdeeSScott Long return (error); 2179b0a2fdeeSScott Long } 2180b0a2fdeeSScott Long 2181b0a2fdeeSScott Long static void 2182b0a2fdeeSScott Long mpt_diag_outsl(struct mpt_softc *mpt, uint32_t addr, 2183b0a2fdeeSScott Long uint32_t *data, bus_size_t len) 2184b0a2fdeeSScott Long { 2185b0a2fdeeSScott Long uint32_t *data_end; 2186b0a2fdeeSScott Long 2187b0a2fdeeSScott Long data_end = data + (roundup2(len, sizeof(uint32_t)) / 4); 2188444dd2b6SMatt Jacob pci_enable_io(mpt->dev, SYS_RES_IOPORT); 2189b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, addr); 2190b0a2fdeeSScott Long while (data != data_end) { 2191b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, *data); 2192b0a2fdeeSScott Long data++; 2193b0a2fdeeSScott Long } 2194444dd2b6SMatt Jacob pci_disable_io(mpt->dev, SYS_RES_IOPORT); 2195b0a2fdeeSScott Long } 2196b0a2fdeeSScott Long 2197b0a2fdeeSScott Long static int 2198b0a2fdeeSScott Long mpt_download_fw(struct mpt_softc *mpt) 2199b0a2fdeeSScott Long { 2200b0a2fdeeSScott Long MpiFwHeader_t *fw_hdr; 2201b0a2fdeeSScott Long int error; 2202b0a2fdeeSScott Long uint32_t ext_offset; 2203b0a2fdeeSScott Long uint32_t data; 2204b0a2fdeeSScott Long 2205b0a2fdeeSScott Long mpt_prt(mpt, "Downloading Firmware - Image Size %d\n", 2206b0a2fdeeSScott Long mpt->fw_image_size); 2207b0a2fdeeSScott Long 2208b0a2fdeeSScott Long error = mpt_enable_diag_mode(mpt); 2209b0a2fdeeSScott Long if (error != 0) { 2210b0a2fdeeSScott Long mpt_prt(mpt, "Could not enter diagnostic mode!\n"); 2211b0a2fdeeSScott Long return (EIO); 2212b0a2fdeeSScott Long } 2213b0a2fdeeSScott Long 2214b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, 2215b0a2fdeeSScott Long MPI_DIAG_RW_ENABLE|MPI_DIAG_DISABLE_ARM); 2216b0a2fdeeSScott Long 2217b0a2fdeeSScott Long fw_hdr = (MpiFwHeader_t *)mpt->fw_image; 2218b0a2fdeeSScott Long mpt_diag_outsl(mpt, fw_hdr->LoadStartAddress, (uint32_t*)fw_hdr, 2219b0a2fdeeSScott Long fw_hdr->ImageSize); 2220b0a2fdeeSScott Long 2221b0a2fdeeSScott Long ext_offset = fw_hdr->NextImageHeaderOffset; 2222b0a2fdeeSScott Long while (ext_offset != 0) { 2223b0a2fdeeSScott Long MpiExtImageHeader_t *ext; 2224b0a2fdeeSScott Long 2225b0a2fdeeSScott Long ext = (MpiExtImageHeader_t *)((uintptr_t)fw_hdr + ext_offset); 2226b0a2fdeeSScott Long ext_offset = ext->NextImageHeaderOffset; 2227b0a2fdeeSScott Long 2228b0a2fdeeSScott Long mpt_diag_outsl(mpt, ext->LoadStartAddress, (uint32_t*)ext, 2229b0a2fdeeSScott Long ext->ImageSize); 2230b0a2fdeeSScott Long } 2231b0a2fdeeSScott Long 2232444dd2b6SMatt Jacob pci_enable_io(mpt->dev, SYS_RES_IOPORT); 2233b0a2fdeeSScott Long /* Setup the address to jump to on reset. */ 2234b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, fw_hdr->IopResetRegAddr); 2235b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, fw_hdr->IopResetVectorValue); 2236b0a2fdeeSScott Long 2237b0a2fdeeSScott Long /* 2238b0a2fdeeSScott Long * The controller sets the "flash bad" status after attempting 2239b0a2fdeeSScott Long * to auto-boot from flash. Clear the status so that the controller 2240b0a2fdeeSScott Long * will continue the boot process with our newly installed firmware. 2241b0a2fdeeSScott Long */ 2242b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, MPT_DIAG_MEM_CFG_BASE); 2243b0a2fdeeSScott Long data = mpt_pio_read(mpt, MPT_OFFSET_DIAG_DATA) | MPT_DIAG_MEM_CFG_BADFL; 2244b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_ADDR, MPT_DIAG_MEM_CFG_BASE); 2245b0a2fdeeSScott Long mpt_pio_write(mpt, MPT_OFFSET_DIAG_DATA, data); 2246b0a2fdeeSScott Long 2247444dd2b6SMatt Jacob pci_disable_io(mpt->dev, SYS_RES_IOPORT); 2248444dd2b6SMatt Jacob 2249b0a2fdeeSScott Long /* 2250b0a2fdeeSScott Long * Re-enable the processor and clear the boot halt flag. 2251b0a2fdeeSScott Long */ 2252b0a2fdeeSScott Long data = mpt_read(mpt, MPT_OFFSET_DIAGNOSTIC); 2253b0a2fdeeSScott Long data &= ~(MPI_DIAG_PREVENT_IOC_BOOT|MPI_DIAG_DISABLE_ARM); 2254b0a2fdeeSScott Long mpt_write(mpt, MPT_OFFSET_DIAGNOSTIC, data); 2255b0a2fdeeSScott Long 2256b0a2fdeeSScott Long mpt_disable_diag_mode(mpt); 2257b0a2fdeeSScott Long return (0); 2258b0a2fdeeSScott Long } 2259b0a2fdeeSScott Long 2260b0a2fdeeSScott Long /* 2261b0a2fdeeSScott Long * Allocate/Initialize data structures for the controller. Called 2262b0a2fdeeSScott Long * once at instance startup. 2263b0a2fdeeSScott Long */ 2264b0a2fdeeSScott Long static int 2265b0a2fdeeSScott Long mpt_configure_ioc(struct mpt_softc *mpt) 2266b0a2fdeeSScott Long { 2267b0a2fdeeSScott Long MSG_PORT_FACTS_REPLY pfp; 2268b0a2fdeeSScott Long MSG_IOC_FACTS_REPLY facts; 2269b0a2fdeeSScott Long int try; 2270b0a2fdeeSScott Long int needreset; 2271444dd2b6SMatt Jacob uint32_t max_chain_depth; 2272b0a2fdeeSScott Long 2273b0a2fdeeSScott Long needreset = 0; 22749b631363SMatt Jacob for (try = 0; try < MPT_MAX_TRYS; try++) { 2275b0a2fdeeSScott Long 22769b631363SMatt Jacob /* 22779b631363SMatt Jacob * No need to reset if the IOC is already in the READY state. 22789b631363SMatt Jacob * 22799b631363SMatt Jacob * Force reset if initialization failed previously. 22809b631363SMatt Jacob * Note that a hard_reset of the second channel of a '929 22819b631363SMatt Jacob * will stop operation of the first channel. Hopefully, if the 22829b631363SMatt Jacob * first channel is ok, the second will not require a hard 22839b631363SMatt Jacob * reset. 22849b631363SMatt Jacob */ 2285c87e3f83SMatt Jacob if (needreset || MPT_STATE(mpt_rd_db(mpt)) != 22869b631363SMatt Jacob MPT_DB_STATE_READY) { 2287c87e3f83SMatt Jacob if (mpt_reset(mpt, FALSE) != MPT_OK) { 22889b631363SMatt Jacob continue; 22899b631363SMatt Jacob } 2290c87e3f83SMatt Jacob } 2291b0a2fdeeSScott Long needreset = 0; 22929b631363SMatt Jacob 22939b631363SMatt Jacob if (mpt_get_iocfacts(mpt, &facts) != MPT_OK) { 2294b0a2fdeeSScott Long mpt_prt(mpt, "mpt_get_iocfacts failed\n"); 2295b0a2fdeeSScott Long needreset = 1; 22969b631363SMatt Jacob continue; 22977104aeefSMatt Jacob } 22987104aeefSMatt Jacob 2299b0a2fdeeSScott Long mpt->mpt_global_credits = le16toh(facts.GlobalCredits); 2300b0a2fdeeSScott Long mpt->request_frame_size = le16toh(facts.RequestFrameSize); 2301444dd2b6SMatt Jacob mpt->ioc_facts_flags = facts.Flags; 2302b0a2fdeeSScott Long mpt_prt(mpt, "MPI Version=%d.%d.%d.%d\n", 2303b0a2fdeeSScott Long le16toh(facts.MsgVersion) >> 8, 2304b0a2fdeeSScott Long le16toh(facts.MsgVersion) & 0xFF, 2305b0a2fdeeSScott Long le16toh(facts.HeaderVersion) >> 8, 2306b0a2fdeeSScott Long le16toh(facts.HeaderVersion) & 0xFF); 2307444dd2b6SMatt Jacob 2308444dd2b6SMatt Jacob /* 2309444dd2b6SMatt Jacob * Now that we know request frame size, we can calculate 2310444dd2b6SMatt Jacob * the actual (reasonable) segment limit for read/write I/O. 2311444dd2b6SMatt Jacob * 2312444dd2b6SMatt Jacob * This limit is constrained by: 2313444dd2b6SMatt Jacob * 2314444dd2b6SMatt Jacob * + The size of each area we allocate per command (and how 2315444dd2b6SMatt Jacob * many chain segments we can fit into it). 2316444dd2b6SMatt Jacob * + The total number of areas we've set up. 2317444dd2b6SMatt Jacob * + The actual chain depth the card will allow. 2318444dd2b6SMatt Jacob * 2319444dd2b6SMatt Jacob * The first area's segment count is limited by the I/O request 2320444dd2b6SMatt Jacob * at the head of it. We cannot allocate realistically more 2321444dd2b6SMatt Jacob * than MPT_MAX_REQUESTS areas. Therefore, to account for both 2322444dd2b6SMatt Jacob * conditions, we'll just start out with MPT_MAX_REQUESTS-2. 2323444dd2b6SMatt Jacob * 2324444dd2b6SMatt Jacob */ 2325444dd2b6SMatt Jacob max_chain_depth = facts.MaxChainDepth; 2326444dd2b6SMatt Jacob 2327444dd2b6SMatt Jacob /* total number of request areas we (can) allocate */ 2328444dd2b6SMatt Jacob mpt->max_seg_cnt = MPT_MAX_REQUESTS(mpt) - 2; 2329444dd2b6SMatt Jacob 2330444dd2b6SMatt Jacob /* converted to the number of chain areas possible */ 2331444dd2b6SMatt Jacob mpt->max_seg_cnt *= MPT_NRFM(mpt); 2332444dd2b6SMatt Jacob 2333444dd2b6SMatt Jacob /* limited by the number of chain areas the card will support */ 2334444dd2b6SMatt Jacob if (mpt->max_seg_cnt > max_chain_depth) { 2335444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, 2336444dd2b6SMatt Jacob "chain depth limited to %u (from %u)\n", 2337444dd2b6SMatt Jacob max_chain_depth, mpt->max_seg_cnt); 2338444dd2b6SMatt Jacob mpt->max_seg_cnt = max_chain_depth; 2339444dd2b6SMatt Jacob } 2340444dd2b6SMatt Jacob 2341444dd2b6SMatt Jacob /* converted to the number of simple sges in chain segments. */ 2342444dd2b6SMatt Jacob mpt->max_seg_cnt *= (MPT_NSGL(mpt) - 1); 2343444dd2b6SMatt Jacob 2344444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, 2345444dd2b6SMatt Jacob "Maximum Segment Count: %u\n", mpt->max_seg_cnt); 2346b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, 2347b0a2fdeeSScott Long "MsgLength=%u IOCNumber = %d\n", 2348b0a2fdeeSScott Long facts.MsgLength, facts.IOCNumber); 2349b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, 2350444dd2b6SMatt Jacob "IOCFACTS: GlobalCredits=%d BlockSize=%u bytes " 2351444dd2b6SMatt Jacob "Request Frame Size %u bytes Max Chain Depth %u\n", 2352444dd2b6SMatt Jacob mpt->mpt_global_credits, facts.BlockSize, 2353444dd2b6SMatt Jacob mpt->request_frame_size << 2, max_chain_depth); 2354b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, 2355b0a2fdeeSScott Long "IOCFACTS: Num Ports %d, FWImageSize %d, " 2356b0a2fdeeSScott Long "Flags=%#x\n", facts.NumberOfPorts, 2357b0a2fdeeSScott Long le32toh(facts.FWImageSize), facts.Flags); 2358b0a2fdeeSScott Long 2359444dd2b6SMatt Jacob 2360b0a2fdeeSScott Long if ((facts.Flags & MPI_IOCFACTS_FLAGS_FW_DOWNLOAD_BOOT) != 0) { 2361b0a2fdeeSScott Long struct mpt_map_info mi; 2362b0a2fdeeSScott Long int error; 2363b0a2fdeeSScott Long 2364b0a2fdeeSScott Long /* 2365b0a2fdeeSScott Long * In some configurations, the IOC's firmware is 2366b0a2fdeeSScott Long * stored in a shared piece of system NVRAM that 2367b0a2fdeeSScott Long * is only accessable via the BIOS. In this 2368b0a2fdeeSScott Long * case, the firmware keeps a copy of firmware in 2369b0a2fdeeSScott Long * RAM until the OS driver retrieves it. Once 2370b0a2fdeeSScott Long * retrieved, we are responsible for re-downloading 2371b0a2fdeeSScott Long * the firmware after any hard-reset. 2372b0a2fdeeSScott Long */ 2373b0a2fdeeSScott Long mpt->fw_image_size = le32toh(facts.FWImageSize); 2374b0a2fdeeSScott Long error = mpt_dma_tag_create(mpt, mpt->parent_dmat, 2375b0a2fdeeSScott Long /*alignment*/1, /*boundary*/0, 2376b0a2fdeeSScott Long /*lowaddr*/BUS_SPACE_MAXADDR_32BIT, 2377b0a2fdeeSScott Long /*highaddr*/BUS_SPACE_MAXADDR, /*filter*/NULL, 2378b0a2fdeeSScott Long /*filterarg*/NULL, mpt->fw_image_size, 2379b0a2fdeeSScott Long /*nsegments*/1, /*maxsegsz*/mpt->fw_image_size, 2380b0a2fdeeSScott Long /*flags*/0, &mpt->fw_dmat); 2381b0a2fdeeSScott Long if (error != 0) { 2382b0a2fdeeSScott Long mpt_prt(mpt, "cannot create fw dma tag\n"); 2383b0a2fdeeSScott Long return (ENOMEM); 23849b631363SMatt Jacob } 2385b0a2fdeeSScott Long error = bus_dmamem_alloc(mpt->fw_dmat, 2386b0a2fdeeSScott Long (void **)&mpt->fw_image, BUS_DMA_NOWAIT, 2387b0a2fdeeSScott Long &mpt->fw_dmap); 2388b0a2fdeeSScott Long if (error != 0) { 2389b0a2fdeeSScott Long mpt_prt(mpt, "cannot allocate fw mem.\n"); 2390b0a2fdeeSScott Long bus_dma_tag_destroy(mpt->fw_dmat); 2391b0a2fdeeSScott Long return (ENOMEM); 2392b0a2fdeeSScott Long } 2393b0a2fdeeSScott Long mi.mpt = mpt; 2394b0a2fdeeSScott Long mi.error = 0; 2395b0a2fdeeSScott Long bus_dmamap_load(mpt->fw_dmat, mpt->fw_dmap, 2396b0a2fdeeSScott Long mpt->fw_image, mpt->fw_image_size, mpt_map_rquest, 2397b0a2fdeeSScott Long &mi, 0); 2398b0a2fdeeSScott Long mpt->fw_phys = mi.phys; 2399b0a2fdeeSScott Long 2400b0a2fdeeSScott Long error = mpt_upload_fw(mpt); 2401b0a2fdeeSScott Long if (error != 0) { 2402b0a2fdeeSScott Long mpt_prt(mpt, "fw upload failed.\n"); 2403b0a2fdeeSScott Long bus_dmamap_unload(mpt->fw_dmat, mpt->fw_dmap); 2404b0a2fdeeSScott Long bus_dmamem_free(mpt->fw_dmat, mpt->fw_image, 2405b0a2fdeeSScott Long mpt->fw_dmap); 2406b0a2fdeeSScott Long bus_dma_tag_destroy(mpt->fw_dmat); 2407b0a2fdeeSScott Long mpt->fw_image = NULL; 2408b0a2fdeeSScott Long return (EIO); 2409b0a2fdeeSScott Long } 2410b0a2fdeeSScott Long } 24119b631363SMatt Jacob 24127104aeefSMatt Jacob if (mpt_get_portfacts(mpt, &pfp) != MPT_OK) { 2413b0a2fdeeSScott Long mpt_prt(mpt, "mpt_get_portfacts failed\n"); 2414b0a2fdeeSScott Long needreset = 1; 24157104aeefSMatt Jacob continue; 24167104aeefSMatt Jacob } 24177104aeefSMatt Jacob 2418b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, 24197dec90bcSMatt Jacob "PORTFACTS: Type %x PFlags %x IID %d MaxDev %d\n", 24207dec90bcSMatt Jacob pfp.PortType, pfp.ProtocolFlags, pfp.PortSCSIID, 24217dec90bcSMatt Jacob pfp.MaxDevices); 24227104aeefSMatt Jacob 2423b0a2fdeeSScott Long mpt->mpt_port_type = pfp.PortType; 2424b0a2fdeeSScott Long mpt->mpt_proto_flags = pfp.ProtocolFlags; 24257104aeefSMatt Jacob if (pfp.PortType != MPI_PORTFACTS_PORTTYPE_SCSI && 2426444dd2b6SMatt Jacob pfp.PortType != MPI_PORTFACTS_PORTTYPE_SAS && 24277104aeefSMatt Jacob pfp.PortType != MPI_PORTFACTS_PORTTYPE_FC) { 2428b0a2fdeeSScott Long mpt_prt(mpt, "Unsupported Port Type (%x)\n", 24297104aeefSMatt Jacob pfp.PortType); 24307104aeefSMatt Jacob return (ENXIO); 24317104aeefSMatt Jacob } 2432c87e3f83SMatt Jacob mpt->mpt_max_tgtcmds = le16toh(pfp.MaxPostedCmdBuffers); 2433c87e3f83SMatt Jacob 24347104aeefSMatt Jacob if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_FC) { 24357104aeefSMatt Jacob mpt->is_fc = 1; 2436444dd2b6SMatt Jacob mpt->is_sas = 0; 2437444dd2b6SMatt Jacob } else if (pfp.PortType == MPI_PORTFACTS_PORTTYPE_SAS) { 2438444dd2b6SMatt Jacob mpt->is_fc = 0; 2439444dd2b6SMatt Jacob mpt->is_sas = 1; 24407104aeefSMatt Jacob } else { 24417104aeefSMatt Jacob mpt->is_fc = 0; 2442444dd2b6SMatt Jacob mpt->is_sas = 0; 24437104aeefSMatt Jacob } 24447104aeefSMatt Jacob mpt->mpt_ini_id = pfp.PortSCSIID; 2445444dd2b6SMatt Jacob mpt->mpt_max_devices = pfp.MaxDevices; 24467104aeefSMatt Jacob 2447c87e3f83SMatt Jacob /* 24485089bd63SMatt Jacob * Set our expected role with what this port supports. 2449c87e3f83SMatt Jacob */ 2450c87e3f83SMatt Jacob 24515089bd63SMatt Jacob mpt->role = MPT_ROLE_NONE; 2452c87e3f83SMatt Jacob if (pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_INITIATOR) { 24535089bd63SMatt Jacob mpt->role |= MPT_ROLE_INITIATOR; 2454c87e3f83SMatt Jacob } 2455c87e3f83SMatt Jacob if (pfp.ProtocolFlags & MPI_PORTFACTS_PROTOCOL_TARGET) { 24565089bd63SMatt Jacob mpt->role |= MPT_ROLE_TARGET; 2457c87e3f83SMatt Jacob } 24585089bd63SMatt Jacob if (mpt->role == MPT_ROLE_NONE) { 2459c87e3f83SMatt Jacob mpt_prt(mpt, "port does not support either target or " 2460c87e3f83SMatt Jacob "initiator role\n"); 2461c87e3f83SMatt Jacob return (ENXIO); 2462c87e3f83SMatt Jacob } 2463c87e3f83SMatt Jacob 2464c87e3f83SMatt Jacob if (mpt_enable_ioc(mpt, 0) != MPT_OK) { 2465c87e3f83SMatt Jacob mpt_prt(mpt, "unable to initialize IOC\n"); 2466b0a2fdeeSScott Long return (ENXIO); 24677104aeefSMatt Jacob } 24687104aeefSMatt Jacob 2469b0a2fdeeSScott Long /* 2470c87e3f83SMatt Jacob * Read IOC configuration information. 24711d79ca0eSMatt Jacob * 24721d79ca0eSMatt Jacob * We need this to determine whether or not we have certain 24731d79ca0eSMatt Jacob * settings for Integrated Mirroring (e.g.). 2474b0a2fdeeSScott Long */ 2475b0a2fdeeSScott Long mpt_read_config_info_ioc(mpt); 2476b0a2fdeeSScott Long 2477b0a2fdeeSScott Long /* Everything worked */ 2478b0a2fdeeSScott Long break; 2479b0a2fdeeSScott Long } 2480b0a2fdeeSScott Long 2481b0a2fdeeSScott Long if (try >= MPT_MAX_TRYS) { 2482b0a2fdeeSScott Long mpt_prt(mpt, "failed to initialize IOC"); 2483b0a2fdeeSScott Long return (EIO); 2484b0a2fdeeSScott Long } 2485b0a2fdeeSScott Long 2486b0a2fdeeSScott Long return (0); 2487b0a2fdeeSScott Long } 2488b0a2fdeeSScott Long 2489b0a2fdeeSScott Long static int 2490c87e3f83SMatt Jacob mpt_enable_ioc(struct mpt_softc *mpt, int portenable) 2491b0a2fdeeSScott Long { 2492b0a2fdeeSScott Long uint32_t pptr; 2493b0a2fdeeSScott Long int val; 2494b0a2fdeeSScott Long 2495444dd2b6SMatt Jacob if (mpt_send_ioc_init(mpt, MPI_WHOINIT_HOST_DRIVER) != MPT_OK) { 2496b0a2fdeeSScott Long mpt_prt(mpt, "mpt_send_ioc_init failed\n"); 2497b0a2fdeeSScott Long return (EIO); 2498b0a2fdeeSScott Long } 2499b0a2fdeeSScott Long 2500b0a2fdeeSScott Long mpt_lprt(mpt, MPT_PRT_DEBUG, "mpt_send_ioc_init ok\n"); 25019b631363SMatt Jacob 25029b631363SMatt Jacob if (mpt_wait_state(mpt, MPT_DB_STATE_RUNNING) != MPT_OK) { 2503b0a2fdeeSScott Long mpt_prt(mpt, "IOC failed to go to run state\n"); 2504b0a2fdeeSScott Long return (ENXIO); 25057104aeefSMatt Jacob } 2506444dd2b6SMatt Jacob mpt_lprt(mpt, MPT_PRT_DEBUG, "IOC now at RUNSTATE\n"); 25079b631363SMatt Jacob 25089b631363SMatt Jacob /* 25099b631363SMatt Jacob * Give it reply buffers 25109b631363SMatt Jacob * 2511b0a2fdeeSScott Long * Do *not* exceed global credits. 25129b631363SMatt Jacob */ 25139b631363SMatt Jacob for (val = 0, pptr = mpt->reply_phys; 25149b631363SMatt Jacob (pptr + MPT_REPLY_SIZE) < (mpt->reply_phys + PAGE_SIZE); 25159b631363SMatt Jacob pptr += MPT_REPLY_SIZE) { 25169b631363SMatt Jacob mpt_free_reply(mpt, pptr); 25179b631363SMatt Jacob if (++val == mpt->mpt_global_credits - 1) 25189b631363SMatt Jacob break; 25199b631363SMatt Jacob } 25209b631363SMatt Jacob 2521c87e3f83SMatt Jacob 2522c87e3f83SMatt Jacob /* 25235e073106SMatt Jacob * Enable the port if asked. This is only done if we're resetting 25245e073106SMatt Jacob * the IOC after initial startup. 2525c87e3f83SMatt Jacob */ 2526c87e3f83SMatt Jacob if (portenable) { 25277104aeefSMatt Jacob /* 25287104aeefSMatt Jacob * Enable asynchronous event reporting 25297104aeefSMatt Jacob */ 25309b631363SMatt Jacob mpt_send_event_request(mpt, 1); 25319b631363SMatt Jacob 25329b631363SMatt Jacob if (mpt_send_port_enable(mpt, 0) != MPT_OK) { 2533b0a2fdeeSScott Long mpt_prt(mpt, "failed to enable port 0\n"); 2534b0a2fdeeSScott Long return (ENXIO); 25357104aeefSMatt Jacob } 2536c87e3f83SMatt Jacob } 253729ae59edSMatt Jacob return (MPT_OK); 25389b631363SMatt Jacob } 2539