xref: /linux/include/linux/pds/pds_core_if.h (revision 0ea5c948cb64bab5bc7a5516774eb8536f05aa0d)
1 /* SPDX-License-Identifier: (GPL-2.0 OR Linux-OpenIB) OR BSD-2-Clause */
2 /* Copyright(c) 2023 Advanced Micro Devices, Inc. */
3 
4 #ifndef _PDS_CORE_IF_H_
5 #define _PDS_CORE_IF_H_
6 
7 #define PCI_VENDOR_ID_PENSANDO			0x1dd8
8 #define PCI_DEVICE_ID_PENSANDO_CORE_PF		0x100c
9 #define PCI_DEVICE_ID_VIRTIO_NET_TRANS		0x1000
10 #define PCI_DEVICE_ID_PENSANDO_IONIC_ETH_VF	0x1003
11 #define PCI_DEVICE_ID_PENSANDO_VDPA_VF		0x100b
12 #define PDS_CORE_BARS_MAX			4
13 #define PDS_CORE_PCI_BAR_DBELL			1
14 
15 /* Bar0 */
16 #define PDS_CORE_DEV_INFO_SIGNATURE		0x44455649 /* 'DEVI' */
17 #define PDS_CORE_BAR0_SIZE			0x8000
18 #define PDS_CORE_BAR0_DEV_INFO_REGS_OFFSET	0x0000
19 #define PDS_CORE_BAR0_DEV_CMD_REGS_OFFSET	0x0800
20 #define PDS_CORE_BAR0_DEV_CMD_DATA_REGS_OFFSET	0x0c00
21 #define PDS_CORE_BAR0_INTR_STATUS_OFFSET	0x1000
22 #define PDS_CORE_BAR0_INTR_CTRL_OFFSET		0x2000
23 #define PDS_CORE_DEV_CMD_DONE			0x00000001
24 
25 #define PDS_CORE_DEVCMD_TIMEOUT			5
26 
27 #define PDS_CORE_CLIENT_ID			0
28 #define PDS_CORE_ASIC_TYPE_CAPRI		0
29 
30 /*
31  * enum pds_core_cmd_opcode - Device commands
32  */
33 enum pds_core_cmd_opcode {
34 	/* Core init */
35 	PDS_CORE_CMD_NOP		= 0,
36 	PDS_CORE_CMD_IDENTIFY		= 1,
37 	PDS_CORE_CMD_RESET		= 2,
38 	PDS_CORE_CMD_INIT		= 3,
39 
40 	PDS_CORE_CMD_FW_DOWNLOAD	= 4,
41 	PDS_CORE_CMD_FW_CONTROL		= 5,
42 
43 	/* SR/IOV commands */
44 	PDS_CORE_CMD_VF_GETATTR		= 60,
45 	PDS_CORE_CMD_VF_SETATTR		= 61,
46 	PDS_CORE_CMD_VF_CTRL		= 62,
47 
48 	/* Add commands before this line */
49 	PDS_CORE_CMD_MAX,
50 	PDS_CORE_CMD_COUNT
51 };
52 
53 /*
54  * enum pds_core_status_code - Device command return codes
55  */
56 enum pds_core_status_code {
57 	PDS_RC_SUCCESS	= 0,	/* Success */
58 	PDS_RC_EVERSION	= 1,	/* Incorrect version for request */
59 	PDS_RC_EOPCODE	= 2,	/* Invalid cmd opcode */
60 	PDS_RC_EIO	= 3,	/* I/O error */
61 	PDS_RC_EPERM	= 4,	/* Permission denied */
62 	PDS_RC_EQID	= 5,	/* Bad qid */
63 	PDS_RC_EQTYPE	= 6,	/* Bad qtype */
64 	PDS_RC_ENOENT	= 7,	/* No such element */
65 	PDS_RC_EINTR	= 8,	/* operation interrupted */
66 	PDS_RC_EAGAIN	= 9,	/* Try again */
67 	PDS_RC_ENOMEM	= 10,	/* Out of memory */
68 	PDS_RC_EFAULT	= 11,	/* Bad address */
69 	PDS_RC_EBUSY	= 12,	/* Device or resource busy */
70 	PDS_RC_EEXIST	= 13,	/* object already exists */
71 	PDS_RC_EINVAL	= 14,	/* Invalid argument */
72 	PDS_RC_ENOSPC	= 15,	/* No space left or alloc failure */
73 	PDS_RC_ERANGE	= 16,	/* Parameter out of range */
74 	PDS_RC_BAD_ADDR	= 17,	/* Descriptor contains a bad ptr */
75 	PDS_RC_DEV_CMD	= 18,	/* Device cmd attempted on AdminQ */
76 	PDS_RC_ENOSUPP	= 19,	/* Operation not supported */
77 	PDS_RC_ERROR	= 29,	/* Generic error */
78 	PDS_RC_ERDMA	= 30,	/* Generic RDMA error */
79 	PDS_RC_EVFID	= 31,	/* VF ID does not exist */
80 	PDS_RC_BAD_FW	= 32,	/* FW file is invalid or corrupted */
81 	PDS_RC_ECLIENT	= 33,   /* No such client id */
82 	PDS_RC_BAD_PCI	= 255,  /* Broken PCI when reading status */
83 };
84 
85 /**
86  * struct pds_core_drv_identity - Driver identity information
87  * @drv_type:         Driver type (enum pds_core_driver_type)
88  * @os_dist:          OS distribution, numeric format
89  * @os_dist_str:      OS distribution, string format
90  * @kernel_ver:       Kernel version, numeric format
91  * @kernel_ver_str:   Kernel version, string format
92  * @driver_ver_str:   Driver version, string format
93  */
94 struct pds_core_drv_identity {
95 	__le32 drv_type;
96 	__le32 os_dist;
97 	char   os_dist_str[128];
98 	__le32 kernel_ver;
99 	char   kernel_ver_str[32];
100 	char   driver_ver_str[32];
101 };
102 
103 #define PDS_DEV_TYPE_MAX	16
104 /**
105  * struct pds_core_dev_identity - Device identity information
106  * @version:	      Version of device identify
107  * @type:	      Identify type (0 for now)
108  * @state:	      Device state
109  * @rsvd:	      Word boundary padding
110  * @nlifs:	      Number of LIFs provisioned
111  * @nintrs:	      Number of interrupts provisioned
112  * @ndbpgs_per_lif:   Number of doorbell pages per LIF
113  * @intr_coal_mult:   Interrupt coalescing multiplication factor
114  *		      Scale user-supplied interrupt coalescing
115  *		      value in usecs to device units using:
116  *		      device units = usecs * mult / div
117  * @intr_coal_div:    Interrupt coalescing division factor
118  *		      Scale user-supplied interrupt coalescing
119  *		      value in usecs to device units using:
120  *		      device units = usecs * mult / div
121  * @vif_types:        How many of each VIF device type is supported
122  */
123 struct pds_core_dev_identity {
124 	u8     version;
125 	u8     type;
126 	u8     state;
127 	u8     rsvd;
128 	__le32 nlifs;
129 	__le32 nintrs;
130 	__le32 ndbpgs_per_lif;
131 	__le32 intr_coal_mult;
132 	__le32 intr_coal_div;
133 	__le16 vif_types[PDS_DEV_TYPE_MAX];
134 };
135 
136 #define PDS_CORE_IDENTITY_VERSION_1	1
137 
138 /**
139  * struct pds_core_dev_identify_cmd - Driver/device identify command
140  * @opcode:	Opcode PDS_CORE_CMD_IDENTIFY
141  * @ver:	Highest version of identify supported by driver
142  *
143  * Expects to find driver identification info (struct pds_core_drv_identity)
144  * in cmd_regs->data.  Driver should keep the devcmd interface locked
145  * while preparing the driver info.
146  */
147 struct pds_core_dev_identify_cmd {
148 	u8 opcode;
149 	u8 ver;
150 };
151 
152 /**
153  * struct pds_core_dev_identify_comp - Device identify command completion
154  * @status:	Status of the command (enum pds_core_status_code)
155  * @ver:	Version of identify returned by device
156  *
157  * Device identification info (struct pds_core_dev_identity) can be found
158  * in cmd_regs->data.  Driver should keep the devcmd interface locked
159  * while reading the results.
160  */
161 struct pds_core_dev_identify_comp {
162 	u8 status;
163 	u8 ver;
164 };
165 
166 /**
167  * struct pds_core_dev_reset_cmd - Device reset command
168  * @opcode:	Opcode PDS_CORE_CMD_RESET
169  *
170  * Resets and clears all LIFs, VDevs, and VIFs on the device.
171  */
172 struct pds_core_dev_reset_cmd {
173 	u8 opcode;
174 };
175 
176 /**
177  * struct pds_core_dev_reset_comp - Reset command completion
178  * @status:	Status of the command (enum pds_core_status_code)
179  */
180 struct pds_core_dev_reset_comp {
181 	u8 status;
182 };
183 
184 /*
185  * struct pds_core_dev_init_data - Pointers and info needed for the Core
186  * initialization PDS_CORE_CMD_INIT command.  The in and out structs are
187  * overlays on the pds_core_dev_cmd_regs.data space for passing data down
188  * to the firmware on init, and then returning initialization results.
189  */
190 struct pds_core_dev_init_data_in {
191 	__le64 adminq_q_base;
192 	__le64 adminq_cq_base;
193 	__le64 notifyq_cq_base;
194 	__le32 flags;
195 	__le16 intr_index;
196 	u8     adminq_ring_size;
197 	u8     notifyq_ring_size;
198 };
199 
200 struct pds_core_dev_init_data_out {
201 	__le32 core_hw_index;
202 	__le32 adminq_hw_index;
203 	__le32 notifyq_hw_index;
204 	u8     adminq_hw_type;
205 	u8     notifyq_hw_type;
206 };
207 
208 /**
209  * struct pds_core_dev_init_cmd - Core device initialize
210  * @opcode:          opcode PDS_CORE_CMD_INIT
211  *
212  * Initializes the core device and sets up the AdminQ and NotifyQ.
213  * Expects to find initialization data (struct pds_core_dev_init_data_in)
214  * in cmd_regs->data.  Driver should keep the devcmd interface locked
215  * while preparing the driver info.
216  */
217 struct pds_core_dev_init_cmd {
218 	u8     opcode;
219 };
220 
221 /**
222  * struct pds_core_dev_init_comp - Core init completion
223  * @status:     Status of the command (enum pds_core_status_code)
224  *
225  * Initialization result data (struct pds_core_dev_init_data_in)
226  * is found in cmd_regs->data.
227  */
228 struct pds_core_dev_init_comp {
229 	u8     status;
230 };
231 
232 /**
233  * struct pds_core_fw_download_cmd - Firmware download command
234  * @opcode:     opcode
235  * @rsvd:	Word boundary padding
236  * @addr:       DMA address of the firmware buffer
237  * @offset:     offset of the firmware buffer within the full image
238  * @length:     number of valid bytes in the firmware buffer
239  */
240 struct pds_core_fw_download_cmd {
241 	u8     opcode;
242 	u8     rsvd[3];
243 	__le32 offset;
244 	__le64 addr;
245 	__le32 length;
246 };
247 
248 /**
249  * struct pds_core_fw_download_comp - Firmware download completion
250  * @status:     Status of the command (enum pds_core_status_code)
251  */
252 struct pds_core_fw_download_comp {
253 	u8     status;
254 };
255 
256 /**
257  * enum pds_core_fw_control_oper - FW control operations
258  * @PDS_CORE_FW_INSTALL_ASYNC:     Install firmware asynchronously
259  * @PDS_CORE_FW_INSTALL_STATUS:    Firmware installation status
260  * @PDS_CORE_FW_ACTIVATE_ASYNC:    Activate firmware asynchronously
261  * @PDS_CORE_FW_ACTIVATE_STATUS:   Firmware activate status
262  * @PDS_CORE_FW_UPDATE_CLEANUP:    Cleanup any firmware update leftovers
263  * @PDS_CORE_FW_GET_BOOT:          Return current active firmware slot
264  * @PDS_CORE_FW_SET_BOOT:          Set active firmware slot for next boot
265  * @PDS_CORE_FW_GET_LIST:          Return list of installed firmware images
266  */
267 enum pds_core_fw_control_oper {
268 	PDS_CORE_FW_INSTALL_ASYNC          = 0,
269 	PDS_CORE_FW_INSTALL_STATUS         = 1,
270 	PDS_CORE_FW_ACTIVATE_ASYNC         = 2,
271 	PDS_CORE_FW_ACTIVATE_STATUS        = 3,
272 	PDS_CORE_FW_UPDATE_CLEANUP         = 4,
273 	PDS_CORE_FW_GET_BOOT               = 5,
274 	PDS_CORE_FW_SET_BOOT               = 6,
275 	PDS_CORE_FW_GET_LIST               = 7,
276 };
277 
278 enum pds_core_fw_slot {
279 	PDS_CORE_FW_SLOT_INVALID    = 0,
280 	PDS_CORE_FW_SLOT_A	    = 1,
281 	PDS_CORE_FW_SLOT_B          = 2,
282 	PDS_CORE_FW_SLOT_GOLD       = 3,
283 };
284 
285 /**
286  * struct pds_core_fw_control_cmd - Firmware control command
287  * @opcode:    opcode
288  * @rsvd:      Word boundary padding
289  * @oper:      firmware control operation (enum pds_core_fw_control_oper)
290  * @slot:      slot to operate on (enum pds_core_fw_slot)
291  */
292 struct pds_core_fw_control_cmd {
293 	u8  opcode;
294 	u8  rsvd[3];
295 	u8  oper;
296 	u8  slot;
297 };
298 
299 /**
300  * struct pds_core_fw_control_comp - Firmware control copletion
301  * @status:	Status of the command (enum pds_core_status_code)
302  * @rsvd:	Word alignment space
303  * @slot:	Slot number (enum pds_core_fw_slot)
304  * @rsvd1:	Struct padding
305  * @color:	Color bit
306  */
307 struct pds_core_fw_control_comp {
308 	u8     status;
309 	u8     rsvd[3];
310 	u8     slot;
311 	u8     rsvd1[10];
312 	u8     color;
313 };
314 
315 struct pds_core_fw_name_info {
316 #define PDS_CORE_FWSLOT_BUFLEN		8
317 #define PDS_CORE_FWVERS_BUFLEN		32
318 	char   slotname[PDS_CORE_FWSLOT_BUFLEN];
319 	char   fw_version[PDS_CORE_FWVERS_BUFLEN];
320 };
321 
322 struct pds_core_fw_list_info {
323 #define PDS_CORE_FWVERS_LIST_LEN	16
324 	u8 num_fw_slots;
325 	struct pds_core_fw_name_info fw_names[PDS_CORE_FWVERS_LIST_LEN];
326 } __packed;
327 
328 enum pds_core_vf_attr {
329 	PDS_CORE_VF_ATTR_SPOOFCHK	= 1,
330 	PDS_CORE_VF_ATTR_TRUST		= 2,
331 	PDS_CORE_VF_ATTR_MAC		= 3,
332 	PDS_CORE_VF_ATTR_LINKSTATE	= 4,
333 	PDS_CORE_VF_ATTR_VLAN		= 5,
334 	PDS_CORE_VF_ATTR_RATE		= 6,
335 	PDS_CORE_VF_ATTR_STATSADDR	= 7,
336 };
337 
338 /**
339  * enum pds_core_vf_link_status - Virtual Function link status
340  * @PDS_CORE_VF_LINK_STATUS_AUTO:   Use link state of the uplink
341  * @PDS_CORE_VF_LINK_STATUS_UP:     Link always up
342  * @PDS_CORE_VF_LINK_STATUS_DOWN:   Link always down
343  */
344 enum pds_core_vf_link_status {
345 	PDS_CORE_VF_LINK_STATUS_AUTO = 0,
346 	PDS_CORE_VF_LINK_STATUS_UP   = 1,
347 	PDS_CORE_VF_LINK_STATUS_DOWN = 2,
348 };
349 
350 /**
351  * struct pds_core_vf_setattr_cmd - Set VF attributes on the NIC
352  * @opcode:     Opcode
353  * @attr:       Attribute type (enum pds_core_vf_attr)
354  * @vf_index:   VF index
355  * @macaddr:	mac address
356  * @vlanid:	vlan ID
357  * @maxrate:	max Tx rate in Mbps
358  * @spoofchk:	enable address spoof checking
359  * @trust:	enable VF trust
360  * @linkstate:	set link up or down
361  * @stats:	stats addr struct
362  * @stats.pa:	set DMA address for VF stats
363  * @stats.len:	length of VF stats space
364  * @pad:	force union to specific size
365  */
366 struct pds_core_vf_setattr_cmd {
367 	u8     opcode;
368 	u8     attr;
369 	__le16 vf_index;
370 	union {
371 		u8     macaddr[6];
372 		__le16 vlanid;
373 		__le32 maxrate;
374 		u8     spoofchk;
375 		u8     trust;
376 		u8     linkstate;
377 		struct {
378 			__le64 pa;
379 			__le32 len;
380 		} stats;
381 		u8     pad[60];
382 	} __packed;
383 };
384 
385 struct pds_core_vf_setattr_comp {
386 	u8     status;
387 	u8     attr;
388 	__le16 vf_index;
389 	__le16 comp_index;
390 	u8     rsvd[9];
391 	u8     color;
392 };
393 
394 /**
395  * struct pds_core_vf_getattr_cmd - Get VF attributes from the NIC
396  * @opcode:     Opcode
397  * @attr:       Attribute type (enum pds_core_vf_attr)
398  * @vf_index:   VF index
399  */
400 struct pds_core_vf_getattr_cmd {
401 	u8     opcode;
402 	u8     attr;
403 	__le16 vf_index;
404 };
405 
406 struct pds_core_vf_getattr_comp {
407 	u8     status;
408 	u8     attr;
409 	__le16 vf_index;
410 	union {
411 		u8     macaddr[6];
412 		__le16 vlanid;
413 		__le32 maxrate;
414 		u8     spoofchk;
415 		u8     trust;
416 		u8     linkstate;
417 		__le64 stats_pa;
418 		u8     pad[11];
419 	} __packed;
420 	u8     color;
421 };
422 
423 enum pds_core_vf_ctrl_opcode {
424 	PDS_CORE_VF_CTRL_START_ALL	= 0,
425 	PDS_CORE_VF_CTRL_START		= 1,
426 };
427 
428 /**
429  * struct pds_core_vf_ctrl_cmd - VF control command
430  * @opcode:         Opcode for the command
431  * @ctrl_opcode:    VF control operation type
432  * @vf_index:       VF Index. It is unused if op START_ALL is used.
433  */
434 
435 struct pds_core_vf_ctrl_cmd {
436 	u8	opcode;
437 	u8	ctrl_opcode;
438 	__le16	vf_index;
439 };
440 
441 /**
442  * struct pds_core_vf_ctrl_comp - VF_CTRL command completion.
443  * @status:     Status of the command (enum pds_core_status_code)
444  */
445 struct pds_core_vf_ctrl_comp {
446 	u8	status;
447 };
448 
449 /*
450  * union pds_core_dev_cmd - Overlay of core device command structures
451  */
452 union pds_core_dev_cmd {
453 	u8     opcode;
454 	u32    words[16];
455 
456 	struct pds_core_dev_identify_cmd identify;
457 	struct pds_core_dev_init_cmd     init;
458 	struct pds_core_dev_reset_cmd    reset;
459 	struct pds_core_fw_download_cmd  fw_download;
460 	struct pds_core_fw_control_cmd   fw_control;
461 
462 	struct pds_core_vf_setattr_cmd   vf_setattr;
463 	struct pds_core_vf_getattr_cmd   vf_getattr;
464 	struct pds_core_vf_ctrl_cmd      vf_ctrl;
465 };
466 
467 /*
468  * union pds_core_dev_comp - Overlay of core device completion structures
469  */
470 union pds_core_dev_comp {
471 	u8                                status;
472 	u8                                bytes[16];
473 
474 	struct pds_core_dev_identify_comp identify;
475 	struct pds_core_dev_reset_comp    reset;
476 	struct pds_core_dev_init_comp     init;
477 	struct pds_core_fw_download_comp  fw_download;
478 	struct pds_core_fw_control_comp   fw_control;
479 
480 	struct pds_core_vf_setattr_comp   vf_setattr;
481 	struct pds_core_vf_getattr_comp   vf_getattr;
482 	struct pds_core_vf_ctrl_comp      vf_ctrl;
483 };
484 
485 /**
486  * struct pds_core_dev_hwstamp_regs - Hardware current timestamp registers
487  * @tick_low:        Low 32 bits of hardware timestamp
488  * @tick_high:       High 32 bits of hardware timestamp
489  */
490 struct pds_core_dev_hwstamp_regs {
491 	u32    tick_low;
492 	u32    tick_high;
493 };
494 
495 /**
496  * struct pds_core_dev_info_regs - Device info register format (read-only)
497  * @signature:       Signature value of 0x44455649 ('DEVI')
498  * @version:         Current version of info
499  * @asic_type:       Asic type
500  * @asic_rev:        Asic revision
501  * @fw_status:       Firmware status
502  *			bit 0   - 1 = fw running
503  *			bit 4-7 - 4 bit generation number, changes on fw restart
504  * @fw_heartbeat:    Firmware heartbeat counter
505  * @serial_num:      Serial number
506  * @fw_version:      Firmware version
507  * @oprom_regs:      oprom_regs to store oprom debug enable/disable and bmp
508  * @rsvd_pad1024:    Struct padding
509  * @hwstamp:         Hardware current timestamp registers
510  * @rsvd_pad2048:    Struct padding
511  */
512 struct pds_core_dev_info_regs {
513 #define PDS_CORE_DEVINFO_FWVERS_BUFLEN 32
514 #define PDS_CORE_DEVINFO_SERIAL_BUFLEN 32
515 	u32    signature;
516 	u8     version;
517 	u8     asic_type;
518 	u8     asic_rev;
519 #define PDS_CORE_FW_STS_F_STOPPED	0x00
520 #define PDS_CORE_FW_STS_F_RUNNING	0x01
521 #define PDS_CORE_FW_STS_F_GENERATION	0xF0
522 	u8     fw_status;
523 	__le32 fw_heartbeat;
524 	char   fw_version[PDS_CORE_DEVINFO_FWVERS_BUFLEN];
525 	char   serial_num[PDS_CORE_DEVINFO_SERIAL_BUFLEN];
526 	u8     oprom_regs[32];     /* reserved */
527 	u8     rsvd_pad1024[916];
528 	struct pds_core_dev_hwstamp_regs hwstamp;   /* on 1k boundary */
529 	u8     rsvd_pad2048[1016];
530 } __packed;
531 
532 /**
533  * struct pds_core_dev_cmd_regs - Device command register format (read-write)
534  * @doorbell:	Device Cmd Doorbell, write-only
535  *              Write a 1 to signal device to process cmd
536  * @done:	Command completed indicator, poll for completion
537  *              bit 0 == 1 when command is complete
538  * @cmd:	Opcode-specific command bytes
539  * @comp:	Opcode-specific response bytes
540  * @rsvd:	Struct padding
541  * @data:	Opcode-specific side-data
542  */
543 struct pds_core_dev_cmd_regs {
544 	u32                     doorbell;
545 	u32                     done;
546 	union pds_core_dev_cmd  cmd;
547 	union pds_core_dev_comp comp;
548 	u8                      rsvd[48];
549 	u32                     data[478];
550 } __packed;
551 
552 /**
553  * struct pds_core_dev_regs - Device register format for bar 0 page 0
554  * @info:            Device info registers
555  * @devcmd:          Device command registers
556  */
557 struct pds_core_dev_regs {
558 	struct pds_core_dev_info_regs info;
559 	struct pds_core_dev_cmd_regs  devcmd;
560 } __packed;
561 
562 #ifndef __CHECKER__
563 static_assert(sizeof(struct pds_core_drv_identity) <= 1912);
564 static_assert(sizeof(struct pds_core_dev_identity) <= 1912);
565 static_assert(sizeof(union pds_core_dev_cmd) == 64);
566 static_assert(sizeof(union pds_core_dev_comp) == 16);
567 static_assert(sizeof(struct pds_core_dev_info_regs) == 2048);
568 static_assert(sizeof(struct pds_core_dev_cmd_regs) == 2048);
569 static_assert(sizeof(struct pds_core_dev_regs) == 4096);
570 #endif /* __CHECKER__ */
571 
572 #endif /* _PDS_CORE_IF_H_ */
573