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