sys/dev/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$
  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 struct mps_command {
  64         TAILQ_ENTRY(mps_command)        cm_link;
  65         struct mps_softc                *cm_sc;
  66         void                            *cm_data;
  67         u_int                           cm_length;
  68         u_int                           cm_sglsize;
  69         MPI2_SGE_IO_UNION               *cm_sge;
  70         uint8_t                         *cm_req;
  71         uint8_t                         *cm_reply;
  72         uint32_t                        cm_reply_data;
  73         mps_command_callback_t          *cm_complete;
  74         void                            *cm_complete_data;
  75         struct mpssas_target            *cm_targ;
  76         MPI2_REQUEST_DESCRIPTOR_UNION   cm_desc;
  77         u_int                           cm_flags;
  78 #define MPS_CM_FLAGS_POLLED             (1 << 0)
  79 #define MPS_CM_FLAGS_COMPLETE           (1 << 1)
  80 #define MPS_CM_FLAGS_SGE_SIMPLE         (1 << 2)
  81 #define MPS_CM_FLAGS_DATAOUT            (1 << 3)
  82 #define MPS_CM_FLAGS_DATAIN             (1 << 4)
  83 #define MPS_CM_FLAGS_WAKEUP             (1 << 5)
  84         u_int                           cm_state;
  85 #define MPS_CM_STATE_FREE               0
  86 #define MPS_CM_STATE_BUSY               1
  87 #define MPS_CM_STATE_TIMEDOUT           2
  88         bus_dmamap_t                    cm_dmamap;
  89         struct scsi_sense_data          *cm_sense;
  90         TAILQ_HEAD(, mps_chain)         cm_chain_list;
  91         uint32_t                        cm_req_busaddr;
  92         uint32_t                        cm_sense_busaddr;
  93         struct callout                  cm_callout;
  94 };
  95
  96 struct mps_event_handle {
  97         TAILQ_ENTRY(mps_event_handle)   eh_list;
  98         mps_evt_callback_t              *callback;
  99         void                            *data;
 100         uint8_t                         mask[16];
 101 };
 102
 103 struct mps_softc {
 104         device_t                        mps_dev;
 105         struct cdev                     *mps_cdev;
 106         u_int                           mps_flags;
 107 #define MPS_FLAGS_INTX          (1 << 0)
 108 #define MPS_FLAGS_MSI           (1 << 1)
 109 #define MPS_FLAGS_BUSY          (1 << 2)
 110 #define MPS_FLAGS_SHUTDOWN      (1 << 3)
 111         u_int                           mps_debug;
 112         struct sysctl_ctx_list          sysctl_ctx;
 113         struct sysctl_oid               *sysctl_tree;
 114         struct mps_command              *commands;
 115         struct mps_chain                *chains;
 116         struct callout                  periodic;
 117
 118         struct mpssas_softc             *sassc;
 119
 120         TAILQ_HEAD(, mps_command)       req_list;
 121         TAILQ_HEAD(, mps_chain)         chain_list;
 122         int                             replypostindex;
 123         int                             replyfreeindex;
 124         int                             replycurindex;
 125
 126         struct resource                 *mps_regs_resource;
 127         bus_space_handle_t              mps_bhandle;
 128         bus_space_tag_t                 mps_btag;
 129         int                             mps_regs_rid;
 130
 131         bus_dma_tag_t                   mps_parent_dmat;
 132         bus_dma_tag_t                   buffer_dmat;
 133
 134         MPI2_IOC_FACTS_REPLY            *facts;
 135         MPI2_PORT_FACTS_REPLY           *pfacts;
 136         int                             num_reqs;
 137         int                             num_replies;
 138         int                             fqdepth;        /* Free queue */
 139         int                             pqdepth;        /* Post queue */
 140
 141         uint8_t                         event_mask[16];
 142         TAILQ_HEAD(, mps_event_handle)  event_list;
 143         struct mps_event_handle         *mps_log_eh;
 144
 145         struct mtx                      mps_mtx;
 146         struct intr_config_hook         mps_ich;
 147         struct resource                 *mps_irq[MPS_MSI_COUNT];
 148         void                            *mps_intrhand[MPS_MSI_COUNT];
 149         int                             mps_irq_rid[MPS_MSI_COUNT];
 150
 151         uint8_t                         *req_frames;
 152         bus_addr_t                      req_busaddr;
 153         bus_dma_tag_t                   req_dmat;
 154         bus_dmamap_t                    req_map;
 155
 156         uint8_t                         *reply_frames;
 157         bus_addr_t                      reply_busaddr;
 158         bus_dma_tag_t                   reply_dmat;
 159         bus_dmamap_t                    reply_map;
 160
 161         struct scsi_sense_data          *sense_frames;
 162         bus_addr_t                      sense_busaddr;
 163         bus_dma_tag_t                   sense_dmat;
 164         bus_dmamap_t                    sense_map;
 165
 166         uint8_t                         *chain_frames;
 167         bus_addr_t                      chain_busaddr;
 168         bus_dma_tag_t                   chain_dmat;
 169         bus_dmamap_t                    chain_map;
 170
 171         MPI2_REPLY_DESCRIPTORS_UNION    *post_queue;
 172         bus_addr_t                      post_busaddr;
 173         uint32_t                        *free_queue;
 174         bus_addr_t                      free_busaddr;
 175         bus_dma_tag_t                   queues_dmat;
 176         bus_dmamap_t                    queues_map;
 177 };
 178
 179 struct mps_config_params {
 180         MPI2_CONFIG_EXT_PAGE_HEADER_UNION       hdr;
 181         u_int           action;
 182         u_int           page_address;   /* Attributes, not a phys address */
 183         u_int           status;
 184         void            *buffer;
 185         u_int           length;
 186         int             timeout;
 187         void            (*callback)(struct mps_softc *, struct mps_config_params *);
 188         void            *cbdata;
 189 };
 190
 191 static __inline uint32_t
 192 mps_regread(struct mps_softc *sc, uint32_t offset)
 193 {
 194         return (bus_space_read_4(sc->mps_btag, sc->mps_bhandle, offset));
 195 }
 196
 197 static __inline void
 198 mps_regwrite(struct mps_softc *sc, uint32_t offset, uint32_t val)
 199 {
 200         bus_space_write_4(sc->mps_btag, sc->mps_bhandle, offset, val);
 201 }
 202
 203 static __inline void
 204 mps_free_reply(struct mps_softc *sc, uint32_t busaddr)
 205 {
 206
 207         if (++sc->replyfreeindex >= sc->fqdepth)
 208                 sc->replyfreeindex = 0;
 209         sc->free_queue[sc->replyfreeindex] = busaddr;
 210         mps_regwrite(sc, MPI2_REPLY_FREE_HOST_INDEX_OFFSET, sc->replyfreeindex);
 211 }
 212
 213 static __inline struct mps_chain *
 214 mps_alloc_chain(struct mps_softc *sc)
 215 {
 216         struct mps_chain *chain;
 217
 218         if ((chain = TAILQ_FIRST(&sc->chain_list)) != NULL)
 219                 TAILQ_REMOVE(&sc->chain_list, chain, chain_link);
 220         return (chain);
 221 }
 222
 223 static __inline void
 224 mps_free_chain(struct mps_softc *sc, struct mps_chain *chain)
 225 {
 226 #if 0
 227         bzero(chain->chain, 128);
 228 #endif
 229         TAILQ_INSERT_TAIL(&sc->chain_list, chain, chain_link);
 230 }
 231
 232 static __inline void
 233 mps_free_command(struct mps_softc *sc, struct mps_command *cm)
 234 {
 235         struct mps_chain *chain, *chain_temp;
 236
 237         if (cm->cm_reply != NULL)
 238                 mps_free_reply(sc, cm->cm_reply_data);
 239         cm->cm_flags = 0;
 240         cm->cm_complete = NULL;
 241         cm->cm_complete_data = NULL;
 242         cm->cm_targ = 0;
 243         cm->cm_state = MPS_CM_STATE_FREE;
 244         TAILQ_FOREACH_SAFE(chain, &cm->cm_chain_list, chain_link, chain_temp) {
 245                 TAILQ_REMOVE(&cm->cm_chain_list, chain, chain_link);
 246                 mps_free_chain(sc, chain);
 247         }
 248         TAILQ_INSERT_TAIL(&sc->req_list, cm, cm_link);
 249 }
 250
 251 static __inline struct mps_command *
 252 mps_alloc_command(struct mps_softc *sc)
 253 {
 254         struct mps_command *cm;
 255
 256         cm = TAILQ_FIRST(&sc->req_list);
 257         if (cm == NULL)
 258                 return (NULL);
 259
 260         TAILQ_REMOVE(&sc->req_list, cm, cm_link);
 261         KASSERT(cm->cm_state == MPS_CM_STATE_FREE, ("mps: Allocating busy command\n"));
 262         cm->cm_state = MPS_CM_STATE_BUSY;
 263         return (cm);
 264 }
 265
 266 static __inline void
 267 mps_lock(struct mps_softc *sc)
 268 {
 269         mtx_lock(&sc->mps_mtx);
 270 }
 271
 272 static __inline void
 273 mps_unlock(struct mps_softc *sc)
 274 {
 275         mtx_unlock(&sc->mps_mtx);
 276 }
 277
 278 #define MPS_INFO        (1 << 0)
 279 #define MPS_TRACE       (1 << 1)
 280 #define MPS_FAULT       (1 << 2)
 281 #define MPS_EVENT       (1 << 3)
 282 #define MPS_LOG         (1 << 4)
 283
 284 #define mps_printf(sc, args...)                         \
 285         device_printf((sc)->mps_dev, ##args)
 286
 287 #define mps_dprint(sc, level, msg, args...)             \
 288 do {                                                    \
 289         if (sc->mps_debug & level)                      \
 290                 device_printf(sc->mps_dev, msg, ##args);        \
 291 } while (0)
 292
 293 #define mps_dprint_field(sc, level, msg, args...)               \
 294 do {                                                            \
 295         if (sc->mps_debug & level)                              \
 296                 printf("\t" msg, ##args);                       \
 297 } while (0)
 298
 299 #define MPS_PRINTFIELD_START(sc, tag...)        \
 300         mps_dprint((sc), MPS_INFO, ##tag);      \
 301         mps_dprint_field((sc), MPS_INFO, ":\n")
 302 #define MPS_PRINTFIELD_END(sc, tag)             \
 303         mps_dprint((sc), MPS_INFO, tag "\n")
 304 #define MPS_PRINTFIELD(sc, facts, attr, fmt)    \
 305         mps_dprint_field((sc), MPS_INFO, #attr ": " #fmt "\n", (facts)->attr)
 306
 307 #define MPS_EVENTFIELD_START(sc, tag...)        \
 308         mps_dprint((sc), MPS_EVENT, ##tag);     \
 309         mps_dprint_field((sc), MPS_EVENT, ":\n")
 310 #define MPS_EVENTFIELD(sc, facts, attr, fmt)    \
 311         mps_dprint_field((sc), MPS_EVENT, #attr ": " #fmt "\n", (facts)->attr)
 312
 313 static __inline void
 314 mps_from_u64(uint64_t data, U64 *mps)
 315 {
 316         (mps)->High = (uint32_t)((data) >> 32);
 317         (mps)->Low = (uint32_t)((data) & 0xffffffff);
 318 }
 319
 320 static __inline uint64_t
 321 mps_to_u64(U64 *data)
 322 {
 323
 324         return (((uint64_t)data->High << 32) | data->Low);
 325 }
 326
 327 static __inline void
 328 mps_mask_intr(struct mps_softc *sc)
 329 {
 330         uint32_t mask;
 331
 332         mask = mps_regread(sc, MPI2_HOST_INTERRUPT_MASK_OFFSET);
 333         mask |= MPI2_HIM_REPLY_INT_MASK;
 334         mps_regwrite(sc, MPI2_HOST_INTERRUPT_MASK_OFFSET, mask);
 335 }
 336
 337 static __inline void
 338 mps_unmask_intr(struct mps_softc *sc)
 339 {
 340         uint32_t mask;
 341
 342         mask = mps_regread(sc, MPI2_HOST_INTERRUPT_MASK_OFFSET);
 343         mask &= ~MPI2_HIM_REPLY_INT_MASK;
 344         mps_regwrite(sc, MPI2_HOST_INTERRUPT_MASK_OFFSET, mask);
 345 }
 346
 347 int mps_pci_setup_interrupts(struct mps_softc *);
 348 int mps_attach(struct mps_softc *sc);
 349 int mps_free(struct mps_softc *sc);
 350 void mps_intr(void *);
 351 void mps_intr_msi(void *);
 352 void mps_intr_locked(void *);
 353 int mps_register_events(struct mps_softc *, uint8_t *, mps_evt_callback_t *,
 354     void *, struct mps_event_handle **);
 355 int mps_update_events(struct mps_softc *, struct mps_event_handle *, uint8_t *);
 356 int mps_deregister_events(struct mps_softc *, struct mps_event_handle *);
 357 int mps_request_polled(struct mps_softc *sc, struct mps_command *cm);
 358 int mps_attach_sas(struct mps_softc *sc);
 359 int mps_detach_sas(struct mps_softc *sc);
 360 int mps_map_command(struct mps_softc *sc, struct mps_command *cm);
 361 int mps_read_config_page(struct mps_softc *, struct mps_config_params *);
 362 int mps_write_config_page(struct mps_softc *, struct mps_config_params *);
 363 void mps_memaddr_cb(void *, bus_dma_segment_t *, int , int );
 364 int mps_attach_user(struct mps_softc *);
 365 void mps_detach_user(struct mps_softc *);
 366
 367 SYSCTL_DECL(_hw_mps);
 368
 369 #endif
 370