1 /**********************************************************************
2 * Author: Cavium, Inc.
3 *
4 * Contact: support@cavium.com
5 * Please include "LiquidIO" in the subject.
6 *
7 * Copyright (c) 2003-2016 Cavium, Inc.
8 *
9 * This file is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License, Version 2, as
11 * published by the Free Software Foundation.
12 *
13 * This file is distributed in the hope that it will be useful, but
14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
16 * NONINFRINGEMENT. See the GNU General Public License for more details.
17 ***********************************************************************/
18 /*! \file octeon_device.h
19 * \brief Host Driver: This file defines the octeon device structure.
20 */
21
22 #ifndef _OCTEON_DEVICE_H_
23 #define _OCTEON_DEVICE_H_
24
25 #include <linux/interrupt.h>
26 #include <net/devlink.h>
27
28 /** PCI VendorId Device Id */
29 #define OCTEON_CN68XX_PCIID 0x91177d
30 #define OCTEON_CN66XX_PCIID 0x92177d
31 #define OCTEON_CN23XX_PCIID_PF 0x9702177d
32 /** Driver identifies chips by these Ids, created by clubbing together
33 * DeviceId+RevisionId; Where Revision Id is not used to distinguish
34 * between chips, a value of 0 is used for revision id.
35 */
36 #define OCTEON_CN68XX 0x0091
37 #define OCTEON_CN66XX 0x0092
38 #define OCTEON_CN23XX_PF_VID 0x9702
39 #define OCTEON_CN23XX_VF_VID 0x9712
40
41 /**RevisionId for the chips */
42 #define OCTEON_CN23XX_REV_1_0 0x00
43 #define OCTEON_CN23XX_REV_1_1 0x01
44 #define OCTEON_CN23XX_REV_2_0 0x80
45
46 /**SubsystemId for the chips */
47 #define OCTEON_CN2350_10GB_SUBSYS_ID_1 0X3177d
48 #define OCTEON_CN2350_10GB_SUBSYS_ID_2 0X4177d
49 #define OCTEON_CN2360_10GB_SUBSYS_ID 0X5177d
50 #define OCTEON_CN2350_25GB_SUBSYS_ID 0X7177d
51 #define OCTEON_CN2360_25GB_SUBSYS_ID 0X6177d
52
53 /** Endian-swap modes supported by Octeon. */
54 enum octeon_pci_swap_mode {
55 OCTEON_PCI_PASSTHROUGH = 0,
56 OCTEON_PCI_64BIT_SWAP = 1,
57 OCTEON_PCI_32BIT_BYTE_SWAP = 2,
58 OCTEON_PCI_32BIT_LW_SWAP = 3
59 };
60
61 enum lio_fw_state {
62 FW_IS_PRELOADED = 0,
63 FW_NEEDS_TO_BE_LOADED = 1,
64 FW_IS_BEING_LOADED = 2,
65 FW_HAS_BEEN_LOADED = 3,
66 };
67
68 enum {
69 OCTEON_CONFIG_TYPE_DEFAULT = 0,
70 NUM_OCTEON_CONFS,
71 };
72
73 #define OCTEON_INPUT_INTR (1)
74 #define OCTEON_OUTPUT_INTR (2)
75 #define OCTEON_MBOX_INTR (4)
76 #define OCTEON_ALL_INTR 0xff
77
78 /*--------------- PCI BAR1 index registers -------------*/
79
80 /* BAR1 Mask */
81 #define PCI_BAR1_ENABLE_CA 1
82 #define PCI_BAR1_ENDIAN_MODE OCTEON_PCI_64BIT_SWAP
83 #define PCI_BAR1_ENTRY_VALID 1
84 #define PCI_BAR1_MASK ((PCI_BAR1_ENABLE_CA << 3) \
85 | (PCI_BAR1_ENDIAN_MODE << 1) \
86 | PCI_BAR1_ENTRY_VALID)
87
88 /** Octeon Device state.
89 * Each octeon device goes through each of these states
90 * as it is initialized.
91 */
92 #define OCT_DEV_BEGIN_STATE 0x0
93 #define OCT_DEV_PCI_ENABLE_DONE 0x1
94 #define OCT_DEV_PCI_MAP_DONE 0x2
95 #define OCT_DEV_DISPATCH_INIT_DONE 0x3
96 #define OCT_DEV_INSTR_QUEUE_INIT_DONE 0x4
97 #define OCT_DEV_SC_BUFF_POOL_INIT_DONE 0x5
98 #define OCT_DEV_RESP_LIST_INIT_DONE 0x6
99 #define OCT_DEV_DROQ_INIT_DONE 0x7
100 #define OCT_DEV_MBOX_SETUP_DONE 0x8
101 #define OCT_DEV_MSIX_ALLOC_VECTOR_DONE 0x9
102 #define OCT_DEV_INTR_SET_DONE 0xa
103 #define OCT_DEV_IO_QUEUES_DONE 0xb
104 #define OCT_DEV_CONSOLE_INIT_DONE 0xc
105 #define OCT_DEV_HOST_OK 0xd
106 #define OCT_DEV_CORE_OK 0xe
107 #define OCT_DEV_RUNNING 0xf
108 #define OCT_DEV_IN_RESET 0x10
109 #define OCT_DEV_STATE_INVALID 0x11
110
111 #define OCT_DEV_STATES OCT_DEV_STATE_INVALID
112
113 /** Octeon Device interrupts
114 * These interrupt bits are set in int_status filed of
115 * octeon_device structure
116 */
117 #define OCT_DEV_INTR_DMA0_FORCE 0x01
118 #define OCT_DEV_INTR_DMA1_FORCE 0x02
119 #define OCT_DEV_INTR_PKT_DATA 0x04
120
121 #define LIO_RESET_SECS (3)
122
123 /*---------------------------DISPATCH LIST-------------------------------*/
124
125 /** The dispatch list entry.
126 * The driver keeps a record of functions registered for each
127 * response header opcode in this structure. Since the opcode is
128 * hashed to index into the driver's list, more than one opcode
129 * can hash to the same entry, in which case the list field points
130 * to a linked list with the other entries.
131 */
132 struct octeon_dispatch {
133 /** List head for this entry */
134 struct list_head list;
135
136 /** The opcode for which the dispatch function & arg should be used */
137 u16 opcode;
138
139 /** The function to be called for a packet received by the driver */
140 octeon_dispatch_fn_t dispatch_fn;
141
142 /* The application specified argument to be passed to the above
143 * function along with the received packet
144 */
145 void *arg;
146 };
147
148 /** The dispatch list structure. */
149 struct octeon_dispatch_list {
150 /** access to dispatch list must be atomic */
151 spinlock_t lock;
152
153 /** Count of dispatch functions currently registered */
154 u32 count;
155
156 /** The list of dispatch functions */
157 struct octeon_dispatch *dlist;
158 };
159
160 /*----------------------- THE OCTEON DEVICE ---------------------------*/
161
162 #define OCT_MEM_REGIONS 3
163 /** PCI address space mapping information.
164 * Each of the 3 address spaces given by BAR0, BAR2 and BAR4 of
165 * Octeon gets mapped to different physical address spaces in
166 * the kernel.
167 */
168 struct octeon_mmio {
169 /** PCI address to which the BAR is mapped. */
170 u64 start;
171
172 /** Length of this PCI address space. */
173 u32 len;
174
175 /** Length that has been mapped to phys. address space. */
176 u32 mapped_len;
177
178 /** The physical address to which the PCI address space is mapped. */
179 u8 __iomem *hw_addr;
180
181 /** Flag indicating the mapping was successful. */
182 u32 done;
183 };
184
185 #define MAX_OCTEON_MAPS 32
186
187 struct octeon_io_enable {
188 u64 iq;
189 u64 oq;
190 u64 iq64B;
191 };
192
193 struct octeon_reg_list {
194 u32 __iomem *pci_win_wr_addr_hi;
195 u32 __iomem *pci_win_wr_addr_lo;
196 u64 __iomem *pci_win_wr_addr;
197
198 u32 __iomem *pci_win_rd_addr_hi;
199 u32 __iomem *pci_win_rd_addr_lo;
200 u64 __iomem *pci_win_rd_addr;
201
202 u32 __iomem *pci_win_wr_data_hi;
203 u32 __iomem *pci_win_wr_data_lo;
204 u64 __iomem *pci_win_wr_data;
205
206 u32 __iomem *pci_win_rd_data_hi;
207 u32 __iomem *pci_win_rd_data_lo;
208 u64 __iomem *pci_win_rd_data;
209 };
210
211 #define OCTEON_CONSOLE_MAX_READ_BYTES 512
212 typedef int (*octeon_console_print_fn)(struct octeon_device *oct,
213 u32 num, char *pre, char *suf);
214 struct octeon_console {
215 u32 active;
216 u32 waiting;
217 u64 addr;
218 u32 buffer_size;
219 u64 input_base_addr;
220 u64 output_base_addr;
221 octeon_console_print_fn print;
222 char leftover[OCTEON_CONSOLE_MAX_READ_BYTES];
223 };
224
225 struct octeon_board_info {
226 char name[OCT_BOARD_NAME];
227 char serial_number[OCT_SERIAL_LEN];
228 u64 major;
229 u64 minor;
230 };
231
232 struct octeon_fn_list {
233 void (*setup_iq_regs)(struct octeon_device *, u32);
234 void (*setup_oq_regs)(struct octeon_device *, u32);
235
236 irqreturn_t (*process_interrupt_regs)(void *);
237 u64 (*msix_interrupt_handler)(void *);
238
239 int (*setup_mbox)(struct octeon_device *);
240 int (*free_mbox)(struct octeon_device *);
241
242 int (*soft_reset)(struct octeon_device *);
243 int (*setup_device_regs)(struct octeon_device *);
244 void (*bar1_idx_setup)(struct octeon_device *, u64, u32, int);
245 void (*bar1_idx_write)(struct octeon_device *, u32, u32);
246 u32 (*bar1_idx_read)(struct octeon_device *, u32);
247 u32 (*update_iq_read_idx)(struct octeon_instr_queue *);
248
249 void (*enable_oq_pkt_time_intr)(struct octeon_device *, u32);
250 void (*disable_oq_pkt_time_intr)(struct octeon_device *, u32);
251
252 void (*enable_interrupt)(struct octeon_device *, u8);
253 void (*disable_interrupt)(struct octeon_device *, u8);
254
255 int (*enable_io_queues)(struct octeon_device *);
256 void (*disable_io_queues)(struct octeon_device *);
257 };
258
259 /* Must be multiple of 8, changing breaks ABI */
260 #define CVMX_BOOTMEM_NAME_LEN 128
261
262 /* Structure for named memory blocks
263 * Number of descriptors
264 * available can be changed without affecting compatibility,
265 * but name length changes require a bump in the bootmem
266 * descriptor version
267 * Note: This structure must be naturally 64 bit aligned, as a single
268 * memory image will be used by both 32 and 64 bit programs.
269 */
270 struct cvmx_bootmem_named_block_desc {
271 /** Base address of named block */
272 u64 base_addr;
273
274 /** Size actually allocated for named block */
275 u64 size;
276
277 /** name of named block */
278 char name[CVMX_BOOTMEM_NAME_LEN];
279 };
280
281 struct oct_fw_info {
282 u32 max_nic_ports; /** max nic ports for the device */
283 u32 num_gmx_ports; /** num gmx ports */
284 u64 app_cap_flags; /** firmware cap flags */
285
286 /** The core application is running in this mode.
287 * See octeon-drv-opcodes.h for values.
288 */
289 u32 app_mode;
290 char liquidio_firmware_version[32];
291 /* Fields extracted from legacy string 'liquidio_firmware_version' */
292 struct {
293 u8 maj;
294 u8 min;
295 u8 rev;
296 } ver;
297 };
298
299 #define OCT_FW_VER(maj, min, rev) \
300 (((u32)(maj) << 16) | ((u32)(min) << 8) | ((u32)(rev)))
301
302 /* wrappers around work structs */
303 struct cavium_wk {
304 struct delayed_work work;
305 void *ctxptr;
306 u64 ctxul;
307 };
308
309 struct cavium_wq {
310 struct workqueue_struct *wq;
311 struct cavium_wk wk;
312 };
313
314 struct octdev_props {
315 /* Each interface in the Octeon device has a network
316 * device pointer (used for OS specific calls).
317 */
318 int rx_on;
319 int fec;
320 int fec_boot;
321 int napi_enabled;
322 int gmxport;
323 struct net_device *netdev;
324 };
325
326 #define LIO_FLAG_MSIX_ENABLED 0x1
327 #define MSIX_PO_INT 0x1
328 #define MSIX_PI_INT 0x2
329 #define MSIX_MBOX_INT 0x4
330
331 struct octeon_pf_vf_hs_word {
332 #ifdef __LITTLE_ENDIAN_BITFIELD
333 /** PKIND value assigned for the DPI interface */
334 u64 pkind : 8;
335
336 /** OCTEON core clock multiplier */
337 u64 core_tics_per_us : 16;
338
339 /** OCTEON coprocessor clock multiplier */
340 u64 coproc_tics_per_us : 16;
341
342 /** app that currently running on OCTEON */
343 u64 app_mode : 8;
344
345 /** RESERVED */
346 u64 reserved : 16;
347
348 #else
349
350 /** RESERVED */
351 u64 reserved : 16;
352
353 /** app that currently running on OCTEON */
354 u64 app_mode : 8;
355
356 /** OCTEON coprocessor clock multiplier */
357 u64 coproc_tics_per_us : 16;
358
359 /** OCTEON core clock multiplier */
360 u64 core_tics_per_us : 16;
361
362 /** PKIND value assigned for the DPI interface */
363 u64 pkind : 8;
364 #endif
365 };
366
367 struct octeon_sriov_info {
368 /* Number of rings assigned to VF */
369 u32 rings_per_vf;
370
371 /** Max Number of VF devices that can be enabled. This variable can
372 * specified during load time or it will be derived after allocating
373 * PF queues. When max_vfs is derived then each VF will get one queue
374 **/
375 u32 max_vfs;
376
377 /** Number of VF devices enabled using sysfs. */
378 u32 num_vfs_alloced;
379
380 /* Actual rings left for PF device */
381 u32 num_pf_rings;
382
383 /* SRN of PF usable IO queues */
384 u32 pf_srn;
385
386 /* total pf rings */
387 u32 trs;
388
389 u32 sriov_enabled;
390
391 struct lio_trusted_vf trusted_vf;
392
393 /*lookup table that maps DPI ring number to VF pci_dev struct pointer*/
394 struct pci_dev *dpiring_to_vfpcidev_lut[MAX_POSSIBLE_VFS];
395
396 u64 vf_macaddr[MAX_POSSIBLE_VFS];
397
398 u16 vf_vlantci[MAX_POSSIBLE_VFS];
399
400 int vf_linkstate[MAX_POSSIBLE_VFS];
401
402 bool vf_spoofchk[MAX_POSSIBLE_VFS];
403
404 u64 vf_drv_loaded_mask;
405 };
406
407 struct octeon_ioq_vector {
408 struct octeon_device *oct_dev;
409 int iq_index;
410 int droq_index;
411 int vector;
412 struct octeon_mbox *mbox;
413 struct cpumask affinity_mask;
414 u32 ioq_num;
415 };
416
417 struct lio_vf_rep_list {
418 int num_vfs;
419 struct net_device *ndev[CN23XX_MAX_VFS_PER_PF];
420 };
421
422 struct lio_devlink_priv {
423 struct octeon_device *oct;
424 };
425
426 /** The Octeon device.
427 * Each Octeon device has this structure to represent all its
428 * components.
429 */
430 struct octeon_device {
431 /** Lock for PCI window configuration accesses */
432 spinlock_t pci_win_lock;
433
434 /** Lock for memory accesses */
435 spinlock_t mem_access_lock;
436
437 /** PCI device pointer */
438 struct pci_dev *pci_dev;
439
440 /** Chip specific information. */
441 void *chip;
442
443 /** Number of interfaces detected in this octeon device. */
444 u32 ifcount;
445
446 struct octdev_props props[MAX_OCTEON_LINKS];
447
448 /** Octeon Chip type. */
449 u16 chip_id;
450
451 u16 rev_id;
452
453 u32 subsystem_id;
454
455 u16 pf_num;
456
457 u16 vf_num;
458
459 /** This device's id - set by the driver. */
460 u32 octeon_id;
461
462 /** This device's PCIe port used for traffic. */
463 u16 pcie_port;
464
465 u16 flags;
466 #define LIO_FLAG_MSI_ENABLED (u32)(1 << 1)
467
468 /** The state of this device */
469 atomic_t status;
470
471 /** memory mapped io range */
472 struct octeon_mmio mmio[OCT_MEM_REGIONS];
473
474 struct octeon_reg_list reg_list;
475
476 struct octeon_fn_list fn_list;
477
478 struct octeon_board_info boardinfo;
479
480 u32 num_iqs;
481
482 /* The pool containing pre allocated buffers used for soft commands */
483 struct octeon_sc_buffer_pool sc_buf_pool;
484
485 /** The input instruction queues */
486 struct octeon_instr_queue *instr_queue
487 [MAX_POSSIBLE_OCTEON_INSTR_QUEUES];
488
489 /** The doubly-linked list of instruction response */
490 struct octeon_response_list response_list[MAX_RESPONSE_LISTS];
491
492 u32 num_oqs;
493
494 /** The DROQ output queues */
495 struct octeon_droq *droq[MAX_POSSIBLE_OCTEON_OUTPUT_QUEUES];
496
497 struct octeon_io_enable io_qmask;
498
499 /** List of dispatch functions */
500 struct octeon_dispatch_list dispatch;
501
502 u32 int_status;
503
504 u64 droq_intr;
505
506 /** Physical location of the cvmx_bootmem_desc_t in octeon memory */
507 u64 bootmem_desc_addr;
508
509 /** Placeholder memory for named blocks.
510 * Assumes single-threaded access
511 */
512 struct cvmx_bootmem_named_block_desc bootmem_named_block_desc;
513
514 /** Address of consoles descriptor */
515 u64 console_desc_addr;
516
517 /** Number of consoles available. 0 means they are inaccessible */
518 u32 num_consoles;
519
520 /* Console caches */
521 struct octeon_console console[MAX_OCTEON_MAPS];
522
523 /* Console named block info */
524 struct {
525 u64 dram_region_base;
526 int bar1_index;
527 } console_nb_info;
528
529 /* Coprocessor clock rate. */
530 u64 coproc_clock_rate;
531
532 /** The core application is running in this mode. See liquidio_common.h
533 * for values.
534 */
535 u32 app_mode;
536
537 struct oct_fw_info fw_info;
538
539 /** The name given to this device. */
540 char device_name[32];
541
542 /** Application Context */
543 void *app_ctx;
544
545 struct cavium_wq dma_comp_wq;
546
547 /** Lock for dma response list */
548 spinlock_t cmd_resp_wqlock;
549 u32 cmd_resp_state;
550
551 struct cavium_wq check_db_wq[MAX_POSSIBLE_OCTEON_INSTR_QUEUES];
552
553 struct cavium_wk nic_poll_work;
554
555 struct cavium_wk console_poll_work[MAX_OCTEON_MAPS];
556
557 void *priv;
558
559 int num_msix_irqs;
560
561 void *msix_entries;
562
563 /* when requesting IRQs, the names are stored here */
564 void *irq_name_storage;
565
566 struct octeon_sriov_info sriov_info;
567
568 struct octeon_pf_vf_hs_word pfvf_hsword;
569
570 int msix_on;
571
572 /** Mail Box details of each octeon queue. */
573 struct octeon_mbox *mbox[MAX_POSSIBLE_VFS];
574
575 /** IOq information of it's corresponding MSI-X interrupt. */
576 struct octeon_ioq_vector *ioq_vector;
577
578 int rx_pause;
579 int tx_pause;
580
581 struct oct_link_stats link_stats; /*stastics from firmware*/
582
583 /* private flags to control driver-specific features through ethtool */
584 u32 priv_flags;
585
586 void *watchdog_task;
587
588 u32 rx_coalesce_usecs;
589 u32 rx_max_coalesced_frames;
590 u32 tx_max_coalesced_frames;
591
592 bool cores_crashed;
593
594 struct {
595 int bus;
596 int dev;
597 int func;
598 } loc;
599
600 atomic_t *adapter_refcount; /* reference count of adapter */
601
602 atomic_t *adapter_fw_state; /* per-adapter, lio_fw_state */
603
604 bool ptp_enable;
605
606 struct lio_vf_rep_list vf_rep_list;
607 struct devlink *devlink;
608 enum devlink_eswitch_mode eswitch_mode;
609
610 /* for 25G NIC speed change */
611 u8 speed_boot;
612 u8 speed_setting;
613 u8 no_speed_setting;
614
615 u32 vfstats_poll;
616 #define LIO_VFSTATS_POLL 10
617 };
618
619 #define OCT_DRV_ONLINE 1
620 #define OCT_DRV_OFFLINE 2
621 #define OCTEON_CN6XXX(oct) ({ \
622 typeof(oct) _oct = (oct); \
623 ((_oct->chip_id == OCTEON_CN66XX) || \
624 (_oct->chip_id == OCTEON_CN68XX)); })
625 #define OCTEON_CN23XX_PF(oct) ((oct)->chip_id == OCTEON_CN23XX_PF_VID)
626 #define OCTEON_CN23XX_VF(oct) ((oct)->chip_id == OCTEON_CN23XX_VF_VID)
627 #define CHIP_CONF(oct, TYPE) \
628 (((struct octeon_ ## TYPE *)((oct)->chip))->conf)
629
630 #define MAX_IO_PENDING_PKT_COUNT 100
631
632 /*------------------ Function Prototypes ----------------------*/
633
634 /** Initialize device list memory */
635 void octeon_init_device_list(int conf_type);
636
637 /** Free memory for Input and Output queue structures for a octeon device */
638 void octeon_free_device_mem(struct octeon_device *oct);
639
640 /* Look up a free entry in the octeon_device table and allocate resources
641 * for the octeon_device structure for an octeon device. Called at init
642 * time.
643 */
644 struct octeon_device *octeon_allocate_device(u32 pci_id,
645 u32 priv_size);
646
647 /** Register a device's bus location at initialization time.
648 * @param octeon_dev - pointer to the octeon device structure.
649 * @param bus - PCIe bus #
650 * @param dev - PCIe device #
651 * @param func - PCIe function #
652 * @param is_pf - TRUE for PF, FALSE for VF
653 * @return reference count of device's adapter
654 */
655 int octeon_register_device(struct octeon_device *oct,
656 int bus, int dev, int func, int is_pf);
657
658 /** Deregister a device at de-initialization time.
659 * @param octeon_dev - pointer to the octeon device structure.
660 * @return reference count of device's adapter
661 */
662 int octeon_deregister_device(struct octeon_device *oct);
663
664 /** Initialize the driver's dispatch list which is a mix of a hash table
665 * and a linked list. This is done at driver load time.
666 * @param octeon_dev - pointer to the octeon device structure.
667 * @return 0 on success, else -ve error value
668 */
669 int octeon_init_dispatch_list(struct octeon_device *octeon_dev);
670
671 /** Delete the driver's dispatch list and all registered entries.
672 * This is done at driver unload time.
673 * @param octeon_dev - pointer to the octeon device structure.
674 */
675 void octeon_delete_dispatch_list(struct octeon_device *octeon_dev);
676
677 /** Initialize the core device fields with the info returned by the FW.
678 * @param recv_info - Receive info structure
679 * @param buf - Receive buffer
680 */
681 int octeon_core_drv_init(struct octeon_recv_info *recv_info, void *buf);
682
683 /** Gets the dispatch function registered to receive packets with a
684 * given opcode/subcode.
685 * @param octeon_dev - the octeon device pointer.
686 * @param opcode - the opcode for which the dispatch function
687 * is to checked.
688 * @param subcode - the subcode for which the dispatch function
689 * is to checked.
690 *
691 * @return Success: octeon_dispatch_fn_t (dispatch function pointer)
692 * @return Failure: NULL
693 *
694 * Looks up the dispatch list to get the dispatch function for a
695 * given opcode.
696 */
697 octeon_dispatch_fn_t
698 octeon_get_dispatch(struct octeon_device *octeon_dev, u16 opcode,
699 u16 subcode);
700
701 /** Get the octeon device pointer.
702 * @param octeon_id - The id for which the octeon device pointer is required.
703 * @return Success: Octeon device pointer.
704 * @return Failure: NULL.
705 */
706 struct octeon_device *lio_get_device(u32 octeon_id);
707
708 /** Get the octeon id assigned to the octeon device passed as argument.
709 * This function is exported to other modules.
710 * @param dev - octeon device pointer passed as a void *.
711 * @return octeon device id
712 */
713 int lio_get_device_id(void *dev);
714
OCTEON_MAJOR_REV(struct octeon_device * oct)715 static inline u16 OCTEON_MAJOR_REV(struct octeon_device *oct)
716 {
717 u16 rev = (oct->rev_id & 0xC) >> 2;
718
719 return (rev == 0) ? 1 : rev;
720 }
721
OCTEON_MINOR_REV(struct octeon_device * oct)722 static inline u16 OCTEON_MINOR_REV(struct octeon_device *oct)
723 {
724 return oct->rev_id & 0x3;
725 }
726
727 /** Read windowed register.
728 * @param oct - pointer to the Octeon device.
729 * @param addr - Address of the register to read.
730 *
731 * This routine is called to read from the indirectly accessed
732 * Octeon registers that are visible through a PCI BAR0 mapped window
733 * register.
734 * @return - 64 bit value read from the register.
735 */
736
737 u64 lio_pci_readq(struct octeon_device *oct, u64 addr);
738
739 /** Write windowed register.
740 * @param oct - pointer to the Octeon device.
741 * @param val - Value to write
742 * @param addr - Address of the register to write
743 *
744 * This routine is called to write to the indirectly accessed
745 * Octeon registers that are visible through a PCI BAR0 mapped window
746 * register.
747 * @return Nothing.
748 */
749 void lio_pci_writeq(struct octeon_device *oct, u64 val, u64 addr);
750
751 /* Routines for reading and writing CSRs */
752 #define octeon_write_csr(oct_dev, reg_off, value) \
753 writel(value, (oct_dev)->mmio[0].hw_addr + (reg_off))
754
755 #define octeon_write_csr64(oct_dev, reg_off, val64) \
756 writeq(val64, (oct_dev)->mmio[0].hw_addr + (reg_off))
757
758 #define octeon_read_csr(oct_dev, reg_off) \
759 readl((oct_dev)->mmio[0].hw_addr + (reg_off))
760
761 #define octeon_read_csr64(oct_dev, reg_off) \
762 readq((oct_dev)->mmio[0].hw_addr + (reg_off))
763
764 /**
765 * Checks if memory access is okay
766 *
767 * @param oct which octeon to send to
768 * @return Zero on success, negative on failure.
769 */
770 int octeon_mem_access_ok(struct octeon_device *oct);
771
772 /**
773 * Waits for DDR initialization.
774 *
775 * @param oct which octeon to send to
776 * @param timeout_in_ms pointer to how long to wait until DDR is initialized
777 * in ms.
778 * If contents are 0, it waits until contents are non-zero
779 * before starting to check.
780 * @return Zero on success, negative on failure.
781 */
782 int octeon_wait_for_ddr_init(struct octeon_device *oct,
783 u32 *timeout_in_ms);
784
785 /**
786 * Wait for u-boot to boot and be waiting for a command.
787 *
788 * @param wait_time_hundredths
789 * Maximum time to wait
790 *
791 * @return Zero on success, negative on failure.
792 */
793 int octeon_wait_for_bootloader(struct octeon_device *oct,
794 u32 wait_time_hundredths);
795
796 /**
797 * Initialize console access
798 *
799 * @param oct which octeon initialize
800 * @return Zero on success, negative on failure.
801 */
802 int octeon_init_consoles(struct octeon_device *oct);
803
804 /**
805 * Adds access to a console to the device.
806 *
807 * @param oct: which octeon to add to
808 * @param console_num: which console
809 * @param dbg_enb: ptr to debug enablement string, one of:
810 * * NULL for no debug output (i.e. disabled)
811 * * empty string enables debug output (via default method)
812 * * specific string to enable debug console output
813 *
814 * @return Zero on success, negative on failure.
815 */
816 int octeon_add_console(struct octeon_device *oct, u32 console_num,
817 char *dbg_enb);
818
819 /** write or read from a console */
820 int octeon_console_write(struct octeon_device *oct, u32 console_num,
821 char *buffer, u32 write_request_size, u32 flags);
822 int octeon_console_write_avail(struct octeon_device *oct, u32 console_num);
823
824 int octeon_console_read_avail(struct octeon_device *oct, u32 console_num);
825
826 /** Removes all attached consoles. */
827 void octeon_remove_consoles(struct octeon_device *oct);
828
829 /**
830 * Send a string to u-boot on console 0 as a command.
831 *
832 * @param oct which octeon to send to
833 * @param cmd_str String to send
834 * @param wait_hundredths Time to wait for u-boot to accept the command.
835 *
836 * @return Zero on success, negative on failure.
837 */
838 int octeon_console_send_cmd(struct octeon_device *oct, char *cmd_str,
839 u32 wait_hundredths);
840
841 /** Parses, validates, and downloads firmware, then boots associated cores.
842 * @param oct which octeon to download firmware to
843 * @param data - The complete firmware file image
844 * @param size - The size of the data
845 *
846 * @return 0 if success.
847 * -EINVAL if file is incompatible or badly formatted.
848 * -ENODEV if no handler was found for the application type or an
849 * invalid octeon id was passed.
850 */
851 int octeon_download_firmware(struct octeon_device *oct, const u8 *data,
852 size_t size);
853
854 char *lio_get_state_string(atomic_t *state_ptr);
855
856 /** Sets up instruction queues for the device
857 * @param oct which octeon to setup
858 *
859 * @return 0 if success. 1 if fails
860 */
861 int octeon_setup_instr_queues(struct octeon_device *oct);
862
863 /** Sets up output queues for the device
864 * @param oct which octeon to setup
865 *
866 * @return 0 if success. 1 if fails
867 */
868 int octeon_setup_output_queues(struct octeon_device *oct);
869
870 int octeon_get_tx_qsize(struct octeon_device *oct, u32 q_no);
871
872 int octeon_get_rx_qsize(struct octeon_device *oct, u32 q_no);
873
874 /** Turns off the input and output queues for the device
875 * @param oct which octeon to disable
876 */
877 int octeon_set_io_queues_off(struct octeon_device *oct);
878
879 /** Turns on or off the given output queue for the device
880 * @param oct which octeon to change
881 * @param q_no which queue
882 * @param enable 1 to enable, 0 to disable
883 */
884 void octeon_set_droq_pkt_op(struct octeon_device *oct, u32 q_no, u32 enable);
885
886 /** Retrieve the config for the device
887 * @param oct which octeon
888 * @param card_type type of card
889 *
890 * @returns pointer to configuration
891 */
892 void *oct_get_config_info(struct octeon_device *oct, u16 card_type);
893
894 /** Gets the octeon device configuration
895 * @return - pointer to the octeon configuration struture
896 */
897 struct octeon_config *octeon_get_conf(struct octeon_device *oct);
898
899 void octeon_free_ioq_vector(struct octeon_device *oct);
900 int octeon_allocate_ioq_vector(struct octeon_device *oct, u32 num_ioqs);
901 void lio_enable_irq(struct octeon_droq *droq, struct octeon_instr_queue *iq);
902
903 /* LiquidIO driver pivate flags */
904 enum {
905 OCT_PRIV_FLAG_TX_BYTES = 0, /* Tx interrupts by pending byte count */
906 };
907
908 #define OCT_PRIV_FLAG_DEFAULT 0x0
909
lio_get_priv_flag(struct octeon_device * octdev,u32 flag)910 static inline u32 lio_get_priv_flag(struct octeon_device *octdev, u32 flag)
911 {
912 return !!(octdev->priv_flags & (0x1 << flag));
913 }
914
lio_set_priv_flag(struct octeon_device * octdev,u32 flag,u32 val)915 static inline void lio_set_priv_flag(struct octeon_device *octdev,
916 u32 flag, u32 val)
917 {
918 if (val)
919 octdev->priv_flags |= (0x1 << flag);
920 else
921 octdev->priv_flags &= ~(0x1 << flag);
922 }
923 #endif
924