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