[Infiniband] Move event-queue process from driver to Infiniband core
[people/mdeck/gpxe.git] / src / drivers / infiniband / hermon.h
1 #ifndef _HERMON_H
2 #define _HERMON_H
3
4 /** @file
5  *
6  * Mellanox Hermon Infiniband HCA driver
7  *
8  */
9
10 #include <stdint.h>
11 #include <gpxe/uaccess.h>
12 #include "mlx_bitops.h"
13 #include "MT25408_PRM.h"
14
15 /*
16  * Hardware constants
17  *
18  */
19
20 /* Ports in existence */
21 #define HERMON_NUM_PORTS                2
22 #define HERMON_PORT_BASE                1
23
24 /* PCI BARs */
25 #define HERMON_PCI_CONFIG_BAR           PCI_BASE_ADDRESS_0
26 #define HERMON_PCI_CONFIG_BAR_SIZE      0x100000
27 #define HERMON_PCI_UAR_BAR              PCI_BASE_ADDRESS_2
28
29 /* Work queue entry and completion queue entry opcodes */
30 #define HERMON_OPCODE_SEND              0x0a
31 #define HERMON_OPCODE_RECV_ERROR        0xfe
32 #define HERMON_OPCODE_SEND_ERROR        0xff
33
34 /* HCA command register opcodes */
35 #define HERMON_HCR_QUERY_DEV_CAP        0x0003
36 #define HERMON_HCR_QUERY_FW             0x0004
37 #define HERMON_HCR_INIT_HCA             0x0007
38 #define HERMON_HCR_CLOSE_HCA            0x0008
39 #define HERMON_HCR_INIT_PORT            0x0009
40 #define HERMON_HCR_CLOSE_PORT           0x000a
41 #define HERMON_HCR_SW2HW_MPT            0x000d
42 #define HERMON_HCR_WRITE_MTT            0x0011
43 #define HERMON_HCR_MAP_EQ               0x0012
44 #define HERMON_HCR_SW2HW_EQ             0x0013
45 #define HERMON_HCR_HW2SW_EQ             0x0014
46 #define HERMON_HCR_QUERY_EQ             0x0015
47 #define HERMON_HCR_SW2HW_CQ             0x0016
48 #define HERMON_HCR_HW2SW_CQ             0x0017
49 #define HERMON_HCR_RST2INIT_QP          0x0019
50 #define HERMON_HCR_INIT2RTR_QP          0x001a
51 #define HERMON_HCR_RTR2RTS_QP           0x001b
52 #define HERMON_HCR_RTS2RTS_QP           0x001c
53 #define HERMON_HCR_2RST_QP              0x0021
54 #define HERMON_HCR_MAD_IFC              0x0024
55 #define HERMON_HCR_READ_MCG             0x0025
56 #define HERMON_HCR_WRITE_MCG            0x0026
57 #define HERMON_HCR_MGID_HASH            0x0027
58 #define HERMON_HCR_RUN_FW               0x0ff6
59 #define HERMON_HCR_DISABLE_LAM          0x0ff7
60 #define HERMON_HCR_ENABLE_LAM           0x0ff8
61 #define HERMON_HCR_UNMAP_ICM            0x0ff9
62 #define HERMON_HCR_MAP_ICM              0x0ffa
63 #define HERMON_HCR_UNMAP_ICM_AUX        0x0ffb
64 #define HERMON_HCR_MAP_ICM_AUX          0x0ffc
65 #define HERMON_HCR_SET_ICM_SIZE         0x0ffd
66 #define HERMON_HCR_UNMAP_FA             0x0ffe
67 #define HERMON_HCR_MAP_FA               0x0fff
68
69 /* Service types */
70 #define HERMON_ST_UD                    0x03
71
72 /* MTUs */
73 #define HERMON_MTU_2048                 0x04
74
75 #define HERMON_INVALID_LKEY             0x00000100UL
76
77 #define HERMON_PAGE_SIZE                4096
78
79 #define HERMON_DB_POST_SND_OFFSET       0x14
80 #define HERMON_DB_EQ_OFFSET(_eqn)       \
81         ( 0x800 + HERMON_PAGE_SIZE * ( (_eqn) / 4 ) + 0x08 * ( (_eqn) % 4 ) )
82
83 #define HERMON_QP_OPT_PARAM_QKEY        0x00000020UL
84
85 #define HERMON_MAP_EQ                   ( 0UL << 31 )
86 #define HERMON_UNMAP_EQ                 ( 1UL << 31 )
87
88 #define HERMON_EV_PORT_STATE_CHANGE     0x09
89
90 /*
91  * Datatypes that seem to be missing from the autogenerated documentation
92  *
93  */
94 struct hermonprm_mgm_hash_st {
95         pseudo_bit_t reserved0[0x00020];
96 /* -------------- */
97         pseudo_bit_t hash[0x00010];
98         pseudo_bit_t reserved1[0x00010];
99 } __attribute__ (( packed ));
100
101 struct hermonprm_mcg_entry_st {
102         struct hermonprm_mcg_hdr_st hdr;
103         struct hermonprm_mcg_qp_dw_st qp[8];
104 } __attribute__ (( packed ));
105
106 struct hermonprm_cq_db_record_st {
107         pseudo_bit_t update_ci[0x00018];
108         pseudo_bit_t reserved0[0x00008];
109 /* -------------- */
110         pseudo_bit_t arm_ci[0x00018];
111         pseudo_bit_t cmd[0x00003];
112         pseudo_bit_t reserved1[0x00001];
113         pseudo_bit_t cmd_sn[0x00002];
114         pseudo_bit_t reserved2[0x00002];
115 } __attribute__ (( packed ));
116
117 struct hermonprm_send_db_register_st {
118         pseudo_bit_t reserved[0x00008];
119         pseudo_bit_t qn[0x00018];
120 } __attribute__ (( packed ));
121
122 struct hermonprm_event_db_register_st {
123         pseudo_bit_t ci[0x00018];
124         pseudo_bit_t reserver[0x00007];
125         pseudo_bit_t a[0x00001];
126 } __attribute__ (( packed ));
127
128 struct hermonprm_scalar_parameter_st {
129         pseudo_bit_t value_hi[0x00020];
130 /* -------------- */
131         pseudo_bit_t value[0x00020];
132 } __attribute__ (( packed ));
133
134 struct hermonprm_event_mask_st {
135         pseudo_bit_t reserved0[0x00020];
136 /* -------------- */
137         pseudo_bit_t completion[0x00001];
138         pseudo_bit_t reserved1[0x0008];
139         pseudo_bit_t port_state_change[0x00001];
140         pseudo_bit_t reserved2[0x00016];
141 } __attribute__ (( packed ));
142
143 struct hermonprm_port_state_change_event_st {
144         pseudo_bit_t reserved[0x00020];
145         struct hermonprm_port_state_change_st data;
146 } __attribute__ (( packed ));
147
148 /*
149  * Wrapper structures for hardware datatypes
150  *
151  */
152
153 struct MLX_DECLARE_STRUCT ( hermonprm_completion_queue_context );
154 struct MLX_DECLARE_STRUCT ( hermonprm_completion_queue_entry );
155 struct MLX_DECLARE_STRUCT ( hermonprm_completion_with_error );
156 struct MLX_DECLARE_STRUCT ( hermonprm_cq_db_record );
157 struct MLX_DECLARE_STRUCT ( hermonprm_eqc );
158 struct MLX_DECLARE_STRUCT ( hermonprm_event_db_register );
159 struct MLX_DECLARE_STRUCT ( hermonprm_event_mask );
160 struct MLX_DECLARE_STRUCT ( hermonprm_event_queue_entry );
161 struct MLX_DECLARE_STRUCT ( hermonprm_hca_command_register );
162 struct MLX_DECLARE_STRUCT ( hermonprm_init_hca );
163 struct MLX_DECLARE_STRUCT ( hermonprm_init_port );
164 struct MLX_DECLARE_STRUCT ( hermonprm_mad_ifc );
165 struct MLX_DECLARE_STRUCT ( hermonprm_mcg_entry );
166 struct MLX_DECLARE_STRUCT ( hermonprm_mgm_hash );
167 struct MLX_DECLARE_STRUCT ( hermonprm_mpt );
168 struct MLX_DECLARE_STRUCT ( hermonprm_mtt );
169 struct MLX_DECLARE_STRUCT ( hermonprm_port_state_change_event );
170 struct MLX_DECLARE_STRUCT ( hermonprm_qp_db_record );
171 struct MLX_DECLARE_STRUCT ( hermonprm_qp_ee_state_transitions );
172 struct MLX_DECLARE_STRUCT ( hermonprm_query_dev_cap );
173 struct MLX_DECLARE_STRUCT ( hermonprm_query_fw );
174 struct MLX_DECLARE_STRUCT ( hermonprm_queue_pair_ee_context_entry );
175 struct MLX_DECLARE_STRUCT ( hermonprm_scalar_parameter );
176 struct MLX_DECLARE_STRUCT ( hermonprm_send_db_register );
177 struct MLX_DECLARE_STRUCT ( hermonprm_ud_address_vector );
178 struct MLX_DECLARE_STRUCT ( hermonprm_virtual_physical_mapping );
179 struct MLX_DECLARE_STRUCT ( hermonprm_wqe_segment_ctrl_send );
180 struct MLX_DECLARE_STRUCT ( hermonprm_wqe_segment_data_ptr );
181 struct MLX_DECLARE_STRUCT ( hermonprm_wqe_segment_ud );
182
183 /*
184  * Composite hardware datatypes
185  *
186  */
187
188 struct hermonprm_write_mtt {
189         struct hermonprm_scalar_parameter mtt_base_addr;
190         struct hermonprm_scalar_parameter reserved;
191         struct hermonprm_mtt mtt;
192 } __attribute__ (( packed ));
193
194 #define HERMON_MAX_GATHER 1
195
196 struct hermonprm_ud_send_wqe {
197         struct hermonprm_wqe_segment_ctrl_send ctrl;
198         struct hermonprm_wqe_segment_ud ud;
199         struct hermonprm_wqe_segment_data_ptr data[HERMON_MAX_GATHER];
200 } __attribute__ (( packed ));
201
202 #define HERMON_MAX_SCATTER 1
203
204 struct hermonprm_recv_wqe {
205         struct hermonprm_wqe_segment_data_ptr data[HERMON_MAX_SCATTER];
206 } __attribute__ (( packed ));
207
208 union hermonprm_completion_entry {
209         struct hermonprm_completion_queue_entry normal;
210         struct hermonprm_completion_with_error error;
211 } __attribute__ (( packed ));
212
213 union hermonprm_event_entry {
214         struct hermonprm_event_queue_entry generic;
215         struct hermonprm_port_state_change_event port_state_change;
216 } __attribute__ (( packed ));
217
218 union hermonprm_doorbell_register {
219         struct hermonprm_send_db_register send;
220         struct hermonprm_event_db_register event;
221         uint32_t dword[1];
222 } __attribute__ (( packed ));
223
224 union hermonprm_mad {
225         struct hermonprm_mad_ifc ifc;
226         union ib_mad mad;
227 } __attribute__ (( packed ));
228
229 /*
230  * gPXE-specific definitions
231  *
232  */
233
234 /** Hermon device capabilitiess */
235 struct hermon_dev_cap {
236         /** CMPT entry size */
237         size_t cmpt_entry_size;
238         /** Number of reserved QPs */
239         unsigned int reserved_qps;
240         /** QP context entry size */
241         size_t qpc_entry_size;
242         /** Alternate path context entry size */
243         size_t altc_entry_size;
244         /** Auxiliary context entry size */
245         size_t auxc_entry_size;
246         /** Number of reserved SRQs */
247         unsigned int reserved_srqs;
248         /** SRQ context entry size */
249         size_t srqc_entry_size;
250         /** Number of reserved CQs */
251         unsigned int reserved_cqs;
252         /** CQ context entry size */
253         size_t cqc_entry_size;
254         /** Number of reserved EQs */
255         unsigned int reserved_eqs;
256         /** EQ context entry size */
257         size_t eqc_entry_size;
258         /** Number of reserved MTTs */
259         unsigned int reserved_mtts;
260         /** MTT entry size */
261         size_t mtt_entry_size;
262         /** Number of reserved MRWs */
263         unsigned int reserved_mrws;
264         /** DMPT entry size */
265         size_t dmpt_entry_size;
266         /** Number of reserved UARs */
267         unsigned int reserved_uars;
268 };
269
270 /** Number of cMPT entries of each type */
271 #define HERMON_CMPT_MAX_ENTRIES ( 1 << 24 )
272
273 /** Hermon ICM memory map entry */
274 struct hermon_icm_map {
275         /** Offset (virtual address within ICM) */
276         uint64_t offset;
277         /** Length */
278         size_t len;
279 };
280
281 /** Discontiguous regions within Hermon ICM */
282 enum hermon_icm_map_regions {
283         HERMON_ICM_QP_CMPT = 0,
284         HERMON_ICM_SRQ_CMPT,
285         HERMON_ICM_CQ_CMPT,
286         HERMON_ICM_EQ_CMPT,
287         HERMON_ICM_OTHER,
288         HERMON_ICM_NUM_REGIONS
289 };
290
291 /** UAR page for doorbell accesses
292  *
293  * Pages 0-127 are reserved for event queue doorbells only, so we use
294  * page 128.
295  */
296 #define HERMON_UAR_NON_EQ_PAGE  128
297
298 /** Maximum number of allocatable MTT entries
299  *
300  * This is a policy decision, not a device limit.
301  */
302 #define HERMON_MAX_MTTS         64
303
304 /** A Hermon MTT descriptor */
305 struct hermon_mtt {
306         /** MTT offset */
307         unsigned int mtt_offset;
308         /** Number of pages */
309         unsigned int num_pages;
310         /** MTT base address */
311         unsigned int mtt_base_addr;
312         /** Offset within page */
313         unsigned int page_offset;
314 };
315
316 /** Alignment of Hermon send work queue entries */
317 #define HERMON_SEND_WQE_ALIGN 128
318
319 /** A Hermon send work queue entry */
320 union hermon_send_wqe {
321         struct hermonprm_ud_send_wqe ud;
322         uint8_t force_align[HERMON_SEND_WQE_ALIGN];
323 } __attribute__ (( packed ));
324
325 /** A Hermon send work queue */
326 struct hermon_send_work_queue {
327         /** Number of work queue entries, including headroom
328          *
329          * Hermon requires us to leave unused space within the send
330          * WQ, so we create a send WQ with more entries than are
331          * requested in the create_qp() call.
332          */
333         unsigned int num_wqes;
334         /** Work queue entries */
335         union hermon_send_wqe *wqe;
336         /** Size of work queue */
337         size_t wqe_size;
338         /** Doorbell register */
339         void *doorbell;
340 };
341
342 /** Alignment of Hermon receive work queue entries */
343 #define HERMON_RECV_WQE_ALIGN 16
344
345 /** A Hermon receive work queue entry */
346 union hermon_recv_wqe {
347         struct hermonprm_recv_wqe recv;
348         uint8_t force_align[HERMON_RECV_WQE_ALIGN];
349 } __attribute__ (( packed ));
350
351 /** A Hermon receive work queue */
352 struct hermon_recv_work_queue {
353         /** Work queue entries */
354         union hermon_recv_wqe *wqe;
355         /** Size of work queue */
356         size_t wqe_size;
357         /** Doorbell */
358         struct hermonprm_qp_db_record doorbell __attribute__ (( aligned (4) ));
359 };
360
361 /** Maximum number of allocatable queue pairs
362  *
363  * This is a policy decision, not a device limit.
364  */
365 #define HERMON_MAX_QPS          8
366
367 /** Base queue pair number */
368 #define HERMON_QPN_BASE 0x550000
369
370 /** A Hermon queue pair */
371 struct hermon_queue_pair {
372         /** Work queue buffer */
373         void *wqe;
374         /** Size of work queue buffer */
375         size_t wqe_size;
376         /** MTT descriptor */
377         struct hermon_mtt mtt;
378         /** Send work queue */
379         struct hermon_send_work_queue send;
380         /** Receive work queue */
381         struct hermon_recv_work_queue recv;
382 };
383
384 /** Maximum number of allocatable completion queues
385  *
386  * This is a policy decision, not a device limit.
387  */
388 #define HERMON_MAX_CQS          8
389
390 /** A Hermon completion queue */
391 struct hermon_completion_queue {
392         /** Completion queue entries */
393         union hermonprm_completion_entry *cqe;
394         /** Size of completion queue */
395         size_t cqe_size;
396         /** MTT descriptor */
397         struct hermon_mtt mtt;
398         /** Doorbell */
399         struct hermonprm_cq_db_record doorbell __attribute__ (( aligned (8) ));
400 };
401
402 /** Maximum number of allocatable event queues
403  *
404  * This is a policy decision, not a device limit.
405  */
406 #define HERMON_MAX_EQS          8
407
408 /** A Hermon event queue */
409 struct hermon_event_queue {
410         /** Event queue entries */
411         union hermonprm_event_entry *eqe;
412         /** Size of event queue */
413         size_t eqe_size;
414         /** MTT descriptor */
415         struct hermon_mtt mtt;
416         /** Event queue number */
417         unsigned long eqn;
418         /** Next event queue entry index */
419         unsigned long next_idx;
420         /** Doorbell register */
421         void *doorbell;
422 };
423
424 /** Number of event queue entries
425  *
426  * This is a policy decision.
427  */
428 #define HERMON_NUM_EQES         4
429
430 /** A Hermon resource bitmask */
431 typedef uint32_t hermon_bitmask_t;
432
433 /** Size of a hermon resource bitmask */
434 #define HERMON_BITMASK_SIZE(max_entries)                                     \
435         ( ( (max_entries) + ( 8 * sizeof ( hermon_bitmask_t ) ) - 1 ) /      \
436           ( 8 * sizeof ( hermon_bitmask_t ) ) )
437
438 /** A Hermon device */
439 struct hermon {
440         /** PCI configuration registers */
441         void *config;
442         /** PCI user Access Region */
443         void *uar;
444
445         /** Command toggle */
446         unsigned int toggle;
447         /** Command input mailbox */
448         void *mailbox_in;
449         /** Command output mailbox */
450         void *mailbox_out;
451
452         /** Firmware area in external memory */
453         userptr_t firmware_area;
454         /** ICM map */
455         struct hermon_icm_map icm_map[HERMON_ICM_NUM_REGIONS];
456         /** ICM area */
457         userptr_t icm;
458
459         /** Reserved LKey
460          *
461          * Used to get unrestricted memory access.
462          */
463         unsigned long reserved_lkey;
464
465         /** Event queue */
466         struct hermon_event_queue eq;
467
468         /** Completion queue in-use bitmask */
469         hermon_bitmask_t cq_inuse[ HERMON_BITMASK_SIZE ( HERMON_MAX_CQS ) ];
470         /** Queue pair in-use bitmask */
471         hermon_bitmask_t qp_inuse[ HERMON_BITMASK_SIZE ( HERMON_MAX_QPS ) ];
472         /** MTT entry in-use bitmask */
473         hermon_bitmask_t mtt_inuse[ HERMON_BITMASK_SIZE ( HERMON_MAX_MTTS ) ];
474
475         /** Device capabilities */
476         struct hermon_dev_cap cap;
477
478         /** Infiniband devices */
479         struct ib_device *ibdev[HERMON_NUM_PORTS];
480 };
481
482 /** Global protection domain */
483 #define HERMON_GLOBAL_PD                0x123456
484
485 /** Memory key prefix */
486 #define HERMON_MKEY_PREFIX              0x77000000UL
487
488 /*
489  * HCA commands
490  *
491  */
492
493 #define HERMON_HCR_BASE                 0x80680
494 #define HERMON_HCR_REG(x)               ( HERMON_HCR_BASE + 4 * (x) )
495 #define HERMON_HCR_MAX_WAIT_MS          2000
496 #define HERMON_MBOX_ALIGN               4096
497 #define HERMON_MBOX_SIZE                512
498
499 /* HCA command is split into
500  *
501  * bits  11:0   Opcode
502  * bit     12   Input uses mailbox
503  * bit     13   Output uses mailbox
504  * bits 22:14   Input parameter length (in dwords)
505  * bits 31:23   Output parameter length (in dwords)
506  *
507  * Encoding the information in this way allows us to cut out several
508  * parameters to the hermon_command() call.
509  */
510 #define HERMON_HCR_IN_MBOX              0x00001000UL
511 #define HERMON_HCR_OUT_MBOX             0x00002000UL
512 #define HERMON_HCR_OPCODE( _command )   ( (_command) & 0xfff )
513 #define HERMON_HCR_IN_LEN( _command )   ( ( (_command) >> 12 ) & 0x7fc )
514 #define HERMON_HCR_OUT_LEN( _command )  ( ( (_command) >> 21 ) & 0x7fc )
515
516 /** Build HCR command from component parts */
517 #define HERMON_HCR_INOUT_CMD( _opcode, _in_mbox, _in_len,                    \
518                              _out_mbox, _out_len )                           \
519         ( (_opcode) |                                                        \
520           ( (_in_mbox) ? HERMON_HCR_IN_MBOX : 0 ) |                          \
521           ( ( (_in_len) / 4 ) << 14 ) |                                      \
522           ( (_out_mbox) ? HERMON_HCR_OUT_MBOX : 0 ) |                        \
523           ( ( (_out_len) / 4 ) << 23 ) )
524
525 #define HERMON_HCR_IN_CMD( _opcode, _in_mbox, _in_len )                      \
526         HERMON_HCR_INOUT_CMD ( _opcode, _in_mbox, _in_len, 0, 0 )
527
528 #define HERMON_HCR_OUT_CMD( _opcode, _out_mbox, _out_len )                   \
529         HERMON_HCR_INOUT_CMD ( _opcode, 0, 0, _out_mbox, _out_len )
530
531 #define HERMON_HCR_VOID_CMD( _opcode )                                       \
532         HERMON_HCR_INOUT_CMD ( _opcode, 0, 0, 0, 0 )
533
534 #endif /* _HERMON_H */