sys/dev/disk/mps/mpsvar.h

   1 /*-
   2  * Copyright (c) 2009 Yahoo! Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/dev/mps/mpsvar.h,v 1.5 2010/12/10 21:45:10 ken Exp $
  27  */
  28
  29 #ifndef _MPSVAR_H
  30 #define _MPSVAR_H
  31
  32 #define MPS_DB_MAX_WAIT         2500
  33
  34 #define MPS_REQ_FRAMES          1024
  35 #define MPS_EVT_REPLY_FRAMES    32
  36 #define MPS_REPLY_FRAMES        MPS_REQ_FRAMES
  37 #define MPS_CHAIN_FRAMES        1024
  38 #define MPS_SENSE_LEN           SSD_FULL_SIZE
  39 #define MPS_MSI_COUNT           1
  40 #define MPS_SGE64_SIZE          12
  41 #define MPS_SGE32_SIZE          8
  42 #define MPS_SGC_SIZE            8
  43
  44 #define MPS_PERIODIC_DELAY      1       /* 1 second heartbeat/watchdog check */
  45
  46 struct mps_softc;
  47 struct mps_command;
  48 struct mpssas_softc;
  49 struct mpssas_target;
  50
  51 MALLOC_DECLARE(M_MPT2);
  52
  53 typedef void mps_evt_callback_t(struct mps_softc *, uintptr_t,
  54     MPI2_EVENT_NOTIFICATION_REPLY *reply);
  55 typedef void mps_command_callback_t(struct mps_softc *, struct mps_command *cm);
  56
  57 struct mps_chain {
  58         TAILQ_ENTRY(mps_chain)          chain_link;
  59         MPI2_SGE_IO_UNION               *chain;
  60         uint32_t                        chain_busaddr;
  61 };
  62
  63 /*
  64  * This needs to be at least 2 to support SMP passthrough.
  65  */
  66 #define MPS_IOVEC_COUNT 2
  67
  68 struct mps_command {
  69         TAILQ_ENTRY(mps_command)        cm_link;
  70         struct mps_softc                *cm_sc;
  71         void                            *cm_data;
  72         u_int                           cm_length;
  73         struct uio                      cm_uio;
  74         struct iovec                    cm_iovec[MPS_IOVEC_COUNT];
  75         u_int                           cm_max_segs;
  76         u_int                           cm_sglsize;
  77         MPI2_SGE_IO_UNION               *cm_sge;
  78         uint8_t                         *cm_req;
  79         uint8_t                         *cm_reply;
  80         uint32_t                        cm_reply_data;
  81         mps_command_callback_t          *cm_complete;
  82         void                            *cm_complete_data;
  83         struct mpssas_target            *cm_targ;
  84         MPI2_REQUEST_DESCRIPTOR_UNION   cm_desc;
  85         u_int                           cm_flags;
  86 #define MPS_CM_FLAGS_POLLED             (1 << 0)
  87 #define MPS_CM_FLAGS_COMPLETE           (1 << 1)
  88 #define MPS_CM_FLAGS_SGE_SIMPLE         (1 << 2)
  89 #define MPS_CM_FLAGS_DATAOUT            (1 << 3)
  90 #define MPS_CM_FLAGS_DATAIN             (1 << 4)
  91 #define MPS_CM_FLAGS_WAKEUP             (1 << 5)
  92 #define MPS_CM_FLAGS_ACTIVE             (1 << 6)
  93 #define MPS_CM_FLAGS_USE_UIO            (1 << 7)
  94 #define MPS_CM_FLAGS_SMP_PASS           (1 << 8)
  95         u_int                           cm_state;
  96 #define MPS_CM_STATE_FREE               0
  97 #define MPS_CM_STATE_BUSY               1
  98 #define MPS_CM_STATE_TIMEDOUT           2
  99         bus_dmamap_t                    cm_dmamap;
 100         struct scsi_sense_data          *cm_sense;
 101         TAILQ_HEAD(, mps_chain)         cm_chain_list;
 102         uint32_t                        cm_req_busaddr;
 103         uint32_t                        cm_sense_busaddr;
 104         struct callout                  cm_callout;
 105 };
 106
 107 struct mps_event_handle {
 108         TAILQ_ENTRY(mps_event_handle)   eh_list;
 109         mps_evt_callback_t              *callback;
 110         void                            *data;
 111         uint8_t                         mask[16];
 112 };
 113
 114 struct mps_softc {
 115         device_t                        mps_dev;
 116         struct cdev                     *mps_cdev;
 117         u_int                           mps_flags;
 118 #define MPS_FLAGS_INTX          (1 << 0)
 119 #define MPS_FLAGS_MSI           (1 << 1)
 120 #define MPS_FLAGS_BUSY          (1 << 2)
 121 #define MPS_FLAGS_SHUTDOWN      (1 << 3)
 122         u_int                           mps_debug;
 123         u_int                           allow_multiple_tm_cmds;
 124         int                             tm_cmds_active;
 125         struct sysctl_ctx_list          sysctl_ctx;
 126         struct sysctl_oid               *sysctl_tree;
 127         struct mps_command              *commands;
 128         struct mps_chain                *chains;
 129         struct callout                  periodic;
 130
 131         struct mpssas_softc             *sassc;
 132
 133         TAILQ_HEAD(, mps_command)       req_list;
 134         TAILQ_HEAD(, mps_chain)         chain_list;
 135         TAILQ_HEAD(, mps_command)       tm_list;
 136         int                             replypostindex;
 137         int                             replyfreeindex;
 138
 139         struct resource                 *mps_regs_resource;
 140         bus_space_handle_t              mps_bhandle;
 141         bus_space_tag_t                 mps_btag;
 142         int                             mps_regs_rid;
 143
 144         bus_dma_tag_t                   mps_parent_dmat;
 145         bus_dma_tag_t                   buffer_dmat;
 146
 147         MPI2_IOC_FACTS_REPLY            *facts;
 148         MPI2_PORT_FACTS_REPLY           *pfacts;
 149         int                             num_reqs;
 150         int                             num_replies;
 151         int                             fqdepth;        /* Free queue */
 152         int                             pqdepth;        /* Post queue */
 153
 154         uint8_t                         event_mask[16];
 155         TAILQ_HEAD(, mps_event_handle)  event_list;
 156         struct mps_event_handle         *mps_log_eh;
 157
 158         struct lock                     mps_lock;
 159         struct intr_config_hook         mps_ich;
 160         struct resource                 *mps_irq[MPS_MSI_COUNT];
 161         void                            *mps_intrhand[MPS_MSI_COUNT];
 162         int                             mps_irq_rid[MPS_MSI_COUNT];
 163
 164         uint8_t                         *req_frames;
 165         bus_addr_t                      req_busaddr;
 166         bus_dma_tag_t                   req_dmat;
 167         bus_dmamap_t                    req_map;
 168
 169         uint8_t                         *reply_frames;
 170         bus_addr_t                      reply_busaddr;
 171         bus_dma_tag_t                   reply_dmat;
 172         bus_dmamap_t                    reply_map;
 173
 174         struct scsi_sense_data          *sense_frames;
 175         bus_addr_t                      sense_busaddr;
 176         bus_dma_tag_t                   sense_dmat;
 177         bus_dmamap_t                    sense_map;
 178
 179         uint8_t                         *chain_frames;
 180         bus_addr_t                      chain_busaddr;
 181         bus_dma_tag_t                   chain_dmat;
 182         bus_dmamap_t                    chain_map;
 183
 184         MPI2_REPLY_DESCRIPTORS_UNION    *post_queue;
 185         bus_addr_t                      post_busaddr;
 186         uint32_t                        *free_queue;
 187         bus_addr_t                      free_busaddr;
 188         bus_dma_tag_t                   queues_dmat;
 189         bus_dmamap_t                    queues_map;
 190 };
 191
 192 struct mps_config_params {
 193         MPI2_CONFIG_EXT_PAGE_HEADER_UNION       hdr;
 194         u_int           action;
 195         u_int           page_address;   /* Attributes, not a phys address */
 196         u_int           status;
 197         void            *buffer;
 198         u_int           length;
 199         int             timeout;
 200         void            (*callback)(struct mps_softc *, struct mps_config_params *);
 201         void            *cbdata;
 202 };
 203
 204 static __inline uint32_t
 205 mps_regread(struct mps_softc *sc, uint32_t offset)
 206 {
 207         return (bus_space_read_4(sc->mps_btag, sc->mps_bhandle, offset));
 208 }
 209
 210 static __inline void
 211 mps_regwrite(struct mps_softc *sc, uint32_t offset, uint32_t val)
 212 {
 213         bus_space_write_4(sc->mps_btag, sc->mps_bhandle, offset, val);
 214 }
 215
 216 static __inline void
 217 mps_free_reply(struct mps_softc *sc, uint32_t busaddr)
 218 {
 219
 220         if (++sc->replyfreeindex >= sc->fqdepth)
 221                 sc->replyfreeindex = 0;
 222         sc->free_queue[sc->replyfreeindex] = busaddr;
 223         mps_regwrite(sc, MPI2_REPLY_FREE_HOST_INDEX_OFFSET, sc->replyfreeindex);
 224 }
 225
 226 static __inline struct mps_chain *
 227 mps_alloc_chain(struct mps_softc *sc)
 228 {
 229         struct mps_chain *chain;
 230
 231         if ((chain = TAILQ_FIRST(&sc->chain_list)) != NULL)
 232                 TAILQ_REMOVE(&sc->chain_list, chain, chain_link);
 233         return (chain);
 234 }
 235
 236 static __inline void
 237 mps_free_chain(struct mps_softc *sc, struct mps_chain *chain)
 238 {
 239 #if 0
 240         bzero(chain->chain, 128);
 241 #endif
 242         TAILQ_INSERT_TAIL(&sc->chain_list, chain, chain_link);
 243 }
 244
 245 static __inline void
 246 mps_free_command(struct mps_softc *sc, struct mps_command *cm)
 247 {
 248         struct mps_chain *chain, *chain_temp;
 249
 250         if (cm->cm_reply != NULL) {
 251                 mps_free_reply(sc, cm->cm_reply_data);
 252                 cm->cm_reply = NULL;
 253         }
 254         cm->cm_flags = 0;
 255         cm->cm_complete = NULL;
 256         cm->cm_complete_data = NULL;
 257         cm->cm_targ = 0;
 258         cm->cm_max_segs = 0;
 259         cm->cm_state = MPS_CM_STATE_FREE;
 260         TAILQ_FOREACH_MUTABLE(chain, &cm->cm_chain_list, chain_link, chain_temp) {
 261                 TAILQ_REMOVE(&cm->cm_chain_list, chain, chain_link);
 262                 mps_free_chain(sc, chain);
 263         }
 264         TAILQ_INSERT_TAIL(&sc->req_list, cm, cm_link);
 265 }
 266
 267 static __inline struct mps_command *
 268 mps_alloc_command(struct mps_softc *sc)
 269 {
 270         struct mps_command *cm;
 271
 272         cm = TAILQ_FIRST(&sc->req_list);
 273         if (cm == NULL)
 274                 return (NULL);
 275
 276         TAILQ_REMOVE(&sc->req_list, cm, cm_link);
 277         KASSERT(cm->cm_state == MPS_CM_STATE_FREE, ("mps: Allocating busy command\n"));
 278         cm->cm_state = MPS_CM_STATE_BUSY;
 279         return (cm);
 280 }
 281
 282 static __inline void
 283 mps_lock(struct mps_softc *sc)
 284 {
 285         lockmgr(&sc->mps_lock, LK_EXCLUSIVE);
 286 }
 287
 288 static __inline void
 289 mps_unlock(struct mps_softc *sc)
 290 {
 291         lockmgr(&sc->mps_lock, LK_RELEASE);
 292 }
 293
 294 #define MPS_INFO        (1 << 0)
 295 #define MPS_TRACE       (1 << 1)
 296 #define MPS_FAULT       (1 << 2)
 297 #define MPS_EVENT       (1 << 3)
 298 #define MPS_LOG         (1 << 4)
 299
 300 #define mps_printf(sc, args...)                         \
 301         device_printf((sc)->mps_dev, ##args)
 302
 303 #define mps_dprint(sc, level, msg, args...)             \
 304 do {                                                    \
 305         if (sc->mps_debug & level)                      \
 306                 device_printf(sc->mps_dev, msg, ##args);        \
 307 } while (0)
 308
 309 #define mps_dprint_field(sc, level, msg, args...)               \
 310 do {                                                            \
 311         if (sc->mps_debug & level)                              \
 312                 kprintf("\t" msg, ##args);                      \
 313 } while (0)
 314
 315 #define MPS_PRINTFIELD_START(sc, tag...)        \
 316         mps_dprint((sc), MPS_INFO, ##tag);      \
 317         mps_dprint_field((sc), MPS_INFO, ":\n")
 318 #define MPS_PRINTFIELD_END(sc, tag)             \
 319         mps_dprint((sc), MPS_INFO, tag "\n")
 320 #define MPS_PRINTFIELD(sc, facts, attr, fmt)    \
 321         mps_dprint_field((sc), MPS_INFO, #attr ": " #fmt "\n", (facts)->attr)
 322
 323 #define MPS_EVENTFIELD_START(sc, tag...)        \
 324         mps_dprint((sc), MPS_EVENT, ##tag);     \
 325         mps_dprint_field((sc), MPS_EVENT, ":\n")
 326 #define MPS_EVENTFIELD(sc, facts, attr, fmt)    \
 327         mps_dprint_field((sc), MPS_EVENT, #attr ": " #fmt "\n", (facts)->attr)
 328
 329 static __inline void
 330 mps_from_u64(uint64_t data, U64 *mps)
 331 {
 332         (mps)->High = (uint32_t)((data) >> 32);
 333         (mps)->Low = (uint32_t)((data) & 0xffffffff);
 334 }
 335
 336 static __inline uint64_t
 337 mps_to_u64(U64 *data)
 338 {
 339
 340         return (((uint64_t)data->High << 32) | data->Low);
 341 }
 342
 343 static __inline void
 344 mps_mask_intr(struct mps_softc *sc)
 345 {
 346         uint32_t mask;
 347
 348         mask = mps_regread(sc, MPI2_HOST_INTERRUPT_MASK_OFFSET);
 349         mask |= MPI2_HIM_REPLY_INT_MASK;
 350         mps_regwrite(sc, MPI2_HOST_INTERRUPT_MASK_OFFSET, mask);
 351 }
 352
 353 static __inline void
 354 mps_unmask_intr(struct mps_softc *sc)
 355 {
 356         uint32_t mask;
 357
 358         mask = mps_regread(sc, MPI2_HOST_INTERRUPT_MASK_OFFSET);
 359         mask &= ~MPI2_HIM_REPLY_INT_MASK;
 360         mps_regwrite(sc, MPI2_HOST_INTERRUPT_MASK_OFFSET, mask);
 361 }
 362
 363 int mps_pci_setup_interrupts(struct mps_softc *);
 364 int mps_attach(struct mps_softc *sc);
 365 int mps_free(struct mps_softc *sc);
 366 void mps_intr(void *);
 367 void mps_intr_msi(void *);
 368 void mps_intr_locked(void *);
 369 int mps_register_events(struct mps_softc *, uint8_t *, mps_evt_callback_t *,
 370     void *, struct mps_event_handle **);
 371 int mps_update_events(struct mps_softc *, struct mps_event_handle *, uint8_t *);
 372 int mps_deregister_events(struct mps_softc *, struct mps_event_handle *);
 373 int mps_request_polled(struct mps_softc *sc, struct mps_command *cm);
 374 void mps_enqueue_request(struct mps_softc *, struct mps_command *);
 375 int mps_push_sge(struct mps_command *, void *, size_t, int);
 376 int mps_add_dmaseg(struct mps_command *, vm_paddr_t, size_t, u_int, int);
 377 int mps_attach_sas(struct mps_softc *sc);
 378 int mps_detach_sas(struct mps_softc *sc);
 379 int mps_map_command(struct mps_softc *sc, struct mps_command *cm);
 380 int mps_read_config_page(struct mps_softc *, struct mps_config_params *);
 381 int mps_write_config_page(struct mps_softc *, struct mps_config_params *);
 382 void mps_memaddr_cb(void *, bus_dma_segment_t *, int , int );
 383 void mpi_init_sge(struct mps_command *cm, void *req, void *sge);
 384 int mps_attach_user(struct mps_softc *);
 385 void mps_detach_user(struct mps_softc *);
 386
 387 SYSCTL_DECL(_hw_mps);
 388
 389 #endif