summaryrefslogtreecommitdiff
path: root/include/linux/soc/mediatek/mtk_wed.h
blob: a476648858a66beccd3e604ba97c41044088c460 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
#ifndef __MTK_WED_H
#define __MTK_WED_H

#include <linux/kernel.h>
#include <linux/rcupdate.h>
#include <linux/regmap.h>
#include <linux/pci.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>

#define MTK_WED_TX_QUEUES		2
#define MTK_WED_RX_QUEUES		2
#define MTK_WED_RX_PAGE_QUEUES		3

#define WED_WO_STA_REC			0x6

struct mtk_wed_hw;
struct mtk_wdma_desc;

enum mtk_wed_wo_cmd {
	MTK_WED_WO_CMD_WED_CFG,
	MTK_WED_WO_CMD_WED_RX_STAT,
	MTK_WED_WO_CMD_RRO_SER,
	MTK_WED_WO_CMD_DBG_INFO,
	MTK_WED_WO_CMD_DEV_INFO,
	MTK_WED_WO_CMD_BSS_INFO,
	MTK_WED_WO_CMD_STA_REC,
	MTK_WED_WO_CMD_DEV_INFO_DUMP,
	MTK_WED_WO_CMD_BSS_INFO_DUMP,
	MTK_WED_WO_CMD_STA_REC_DUMP,
	MTK_WED_WO_CMD_BA_INFO_DUMP,
	MTK_WED_WO_CMD_FBCMD_Q_DUMP,
	MTK_WED_WO_CMD_FW_LOG_CTRL,
	MTK_WED_WO_CMD_LOG_FLUSH,
	MTK_WED_WO_CMD_CHANGE_STATE,
	MTK_WED_WO_CMD_CPU_STATS_ENABLE,
	MTK_WED_WO_CMD_CPU_STATS_DUMP,
	MTK_WED_WO_CMD_EXCEPTION_INIT,
	MTK_WED_WO_CMD_PROF_CTRL,
	MTK_WED_WO_CMD_STA_BA_DUMP,
	MTK_WED_WO_CMD_BA_CTRL_DUMP,
	MTK_WED_WO_CMD_RXCNT_CTRL,
	MTK_WED_WO_CMD_RXCNT_INFO,
	MTK_WED_WO_CMD_SET_CAP,
	MTK_WED_WO_CMD_CCIF_RING_DUMP,
	MTK_WED_WO_CMD_WED_END
};

struct mtk_wed_bm_desc {
	__le32 buf0;
	__le32 token;
} __packed __aligned(4);

enum mtk_wed_bus_tye {
	MTK_WED_BUS_PCIE,
	MTK_WED_BUS_AXI,
};

#define MTK_WED_RING_CONFIGURED		BIT(0)
struct mtk_wed_ring {
	struct mtk_wdma_desc *desc;
	dma_addr_t desc_phys;
	u32 desc_size;
	int size;
	u32 flags;

	u32 reg_base;
	void __iomem *wpdma;
};

struct mtk_wed_wo_rx_stats {
	__le16 wlan_idx;
	__le16 tid;
	__le32 rx_pkt_cnt;
	__le32 rx_byte_cnt;
	__le32 rx_err_cnt;
	__le32 rx_drop_cnt;
};

struct mtk_wed_buf {
	void *p;
	dma_addr_t phy_addr;
};

struct mtk_wed_device {
#ifdef CONFIG_NET_MEDIATEK_SOC_WED
	const struct mtk_wed_ops *ops;
	struct device *dev;
	struct mtk_wed_hw *hw;
	bool init_done, running;
	int wdma_idx;
	int irq;
	u8 version;

	/* used by wlan driver */
	u32 rev_id;

	struct mtk_wed_ring tx_ring[MTK_WED_TX_QUEUES];
	struct mtk_wed_ring rx_ring[MTK_WED_RX_QUEUES];
	struct mtk_wed_ring txfree_ring;
	struct mtk_wed_ring tx_wdma[MTK_WED_TX_QUEUES];
	struct mtk_wed_ring rx_wdma[MTK_WED_RX_QUEUES];
	struct mtk_wed_ring rx_rro_ring[MTK_WED_RX_QUEUES];
	struct mtk_wed_ring rx_page_ring[MTK_WED_RX_PAGE_QUEUES];
	struct mtk_wed_ring ind_cmd_ring;

	struct {
		int size;
		struct mtk_wed_buf *pages;
		struct mtk_wdma_desc *desc;
		dma_addr_t desc_phys;
	} tx_buf_ring;

	struct {
		int size;
		struct mtk_wed_bm_desc *desc;
		dma_addr_t desc_phys;
	} rx_buf_ring;

	struct {
		struct mtk_wed_ring ring;
		dma_addr_t miod_phys;
		dma_addr_t fdbk_phys;
	} rro;

	struct {
		int size;
		struct mtk_wed_buf *pages;
		struct mtk_wed_bm_desc *desc;
		dma_addr_t desc_phys;
	} hw_rro;

	/* filled by driver: */
	struct {
		union {
			struct platform_device *platform_dev;
			struct pci_dev *pci_dev;
		};
		enum mtk_wed_bus_tye bus_type;
		void __iomem *base;
		u32 phy_base;
		u32 id;

		u32 wpdma_phys;
		u32 wpdma_int;
		u32 wpdma_mask;
		u32 wpdma_tx;
		u32 wpdma_txfree;
		u32 wpdma_rx_glo;
		u32 wpdma_rx;
		u32 wpdma_rx_rro[MTK_WED_RX_QUEUES];
		u32 wpdma_rx_pg;

		bool wcid_512;
		bool hw_rro;
		bool msi;

		u16 token_start;
		unsigned int nbuf;
		unsigned int rx_nbuf;
		unsigned int rx_npkt;
		unsigned int rx_size;
		unsigned int amsdu_max_len;

		u8 tx_tbit[MTK_WED_TX_QUEUES];
		u8 rx_tbit[MTK_WED_RX_QUEUES];
		u8 rro_rx_tbit[MTK_WED_RX_QUEUES];
		u8 rx_pg_tbit[MTK_WED_RX_PAGE_QUEUES];
		u8 txfree_tbit;
		u8 amsdu_max_subframes;

		struct {
			u8 se_group_nums;
			u16 win_size;
			u16 particular_sid;
			u32 ack_sn_addr;
			dma_addr_t particular_se_phys;
			dma_addr_t addr_elem_phys[1024];
		} ind_cmd;

		u32 (*init_buf)(void *ptr, dma_addr_t phys, int token_id);
		int (*offload_enable)(struct mtk_wed_device *wed);
		void (*offload_disable)(struct mtk_wed_device *wed);
		u32 (*init_rx_buf)(struct mtk_wed_device *wed, int size);
		void (*release_rx_buf)(struct mtk_wed_device *wed);
		void (*update_wo_rx_stats)(struct mtk_wed_device *wed,
					   struct mtk_wed_wo_rx_stats *stats);
		int (*reset)(struct mtk_wed_device *wed);
		void (*reset_complete)(struct mtk_wed_device *wed);
	} wlan;
#endif
};

struct mtk_wed_ops {
	int (*attach)(struct mtk_wed_device *dev);
	int (*tx_ring_setup)(struct mtk_wed_device *dev, int ring,
			     void __iomem *regs, bool reset);
	int (*rx_ring_setup)(struct mtk_wed_device *dev, int ring,
			     void __iomem *regs, bool reset);
	int (*txfree_ring_setup)(struct mtk_wed_device *dev,
				 void __iomem *regs);
	int (*msg_update)(struct mtk_wed_device *dev, int cmd_id,
			  void *data, int len);
	void (*detach)(struct mtk_wed_device *dev);
	void (*ppe_check)(struct mtk_wed_device *dev, struct sk_buff *skb,
			  u32 reason, u32 hash);

	void (*stop)(struct mtk_wed_device *dev);
	void (*start)(struct mtk_wed_device *dev, u32 irq_mask);
	void (*reset_dma)(struct mtk_wed_device *dev);

	u32 (*reg_read)(struct mtk_wed_device *dev, u32 reg);
	void (*reg_write)(struct mtk_wed_device *dev, u32 reg, u32 val);

	u32 (*irq_get)(struct mtk_wed_device *dev, u32 mask);
	void (*irq_set_mask)(struct mtk_wed_device *dev, u32 mask);
	int (*setup_tc)(struct mtk_wed_device *wed, struct net_device *dev,
			enum tc_setup_type type, void *type_data);
	void (*start_hw_rro)(struct mtk_wed_device *dev, u32 irq_mask,
			     bool reset);
	void (*rro_rx_ring_setup)(struct mtk_wed_device *dev, int ring,
				  void __iomem *regs);
	void (*msdu_pg_rx_ring_setup)(struct mtk_wed_device *dev, int ring,
				      void __iomem *regs);
	int (*ind_rx_ring_setup)(struct mtk_wed_device *dev,
				 void __iomem *regs);
};

extern const struct mtk_wed_ops __rcu *mtk_soc_wed_ops;

static inline int
mtk_wed_device_attach(struct mtk_wed_device *dev)
{
	int ret = -ENODEV;

#ifdef CONFIG_NET_MEDIATEK_SOC_WED
	rcu_read_lock();
	dev->ops = rcu_dereference(mtk_soc_wed_ops);
	if (dev->ops)
		ret = dev->ops->attach(dev);
	else
		rcu_read_unlock();

	if (ret)
		dev->ops = NULL;
#endif

	return ret;
}

static inline bool mtk_wed_get_rx_capa(struct mtk_wed_device *dev)
{
#ifdef CONFIG_NET_MEDIATEK_SOC_WED
	if (dev->version == 3)
		return dev->wlan.hw_rro;

	return dev->version != 1;
#else
	return false;
#endif
}

static inline bool mtk_wed_is_amsdu_supported(struct mtk_wed_device *dev)
{
#ifdef CONFIG_NET_MEDIATEK_SOC_WED
	return dev->version == 3;
#else
	return false;
#endif
}

#ifdef CONFIG_NET_MEDIATEK_SOC_WED
#define mtk_wed_device_active(_dev) !!(_dev)->ops
#define mtk_wed_device_detach(_dev) (_dev)->ops->detach(_dev)
#define mtk_wed_device_start(_dev, _mask) (_dev)->ops->start(_dev, _mask)
#define mtk_wed_device_tx_ring_setup(_dev, _ring, _regs, _reset) \
	(_dev)->ops->tx_ring_setup(_dev, _ring, _regs, _reset)
#define mtk_wed_device_txfree_ring_setup(_dev, _regs) \
	(_dev)->ops->txfree_ring_setup(_dev, _regs)
#define mtk_wed_device_reg_read(_dev, _reg) \
	(_dev)->ops->reg_read(_dev, _reg)
#define mtk_wed_device_reg_write(_dev, _reg, _val) \
	(_dev)->ops->reg_write(_dev, _reg, _val)
#define mtk_wed_device_irq_get(_dev, _mask) \
	(_dev)->ops->irq_get(_dev, _mask)
#define mtk_wed_device_irq_set_mask(_dev, _mask) \
	(_dev)->ops->irq_set_mask(_dev, _mask)
#define mtk_wed_device_rx_ring_setup(_dev, _ring, _regs, _reset) \
	(_dev)->ops->rx_ring_setup(_dev, _ring, _regs, _reset)
#define mtk_wed_device_ppe_check(_dev, _skb, _reason, _hash) \
	(_dev)->ops->ppe_check(_dev, _skb, _reason, _hash)
#define mtk_wed_device_update_msg(_dev, _id, _msg, _len) \
	(_dev)->ops->msg_update(_dev, _id, _msg, _len)
#define mtk_wed_device_stop(_dev) (_dev)->ops->stop(_dev)
#define mtk_wed_device_dma_reset(_dev) (_dev)->ops->reset_dma(_dev)
#define mtk_wed_device_setup_tc(_dev, _netdev, _type, _type_data) \
	(_dev)->ops->setup_tc(_dev, _netdev, _type, _type_data)
#define mtk_wed_device_start_hw_rro(_dev, _mask, _reset) \
	(_dev)->ops->start_hw_rro(_dev, _mask, _reset)
#define mtk_wed_device_rro_rx_ring_setup(_dev, _ring, _regs) \
	(_dev)->ops->rro_rx_ring_setup(_dev, _ring, _regs)
#define mtk_wed_device_msdu_pg_rx_ring_setup(_dev, _ring, _regs) \
	(_dev)->ops->msdu_pg_rx_ring_setup(_dev, _ring, _regs)
#define mtk_wed_device_ind_rx_ring_setup(_dev, _regs) \
	(_dev)->ops->ind_rx_ring_setup(_dev, _regs)

#else
static inline bool mtk_wed_device_active(struct mtk_wed_device *dev)
{
	return false;
}
#define mtk_wed_device_detach(_dev) do {} while (0)
#define mtk_wed_device_start(_dev, _mask) do {} while (0)
#define mtk_wed_device_tx_ring_setup(_dev, _ring, _regs, _reset) -ENODEV
#define mtk_wed_device_txfree_ring_setup(_dev, _ring, _regs) -ENODEV
#define mtk_wed_device_reg_read(_dev, _reg) 0
#define mtk_wed_device_reg_write(_dev, _reg, _val) do {} while (0)
#define mtk_wed_device_irq_get(_dev, _mask) 0
#define mtk_wed_device_irq_set_mask(_dev, _mask) do {} while (0)
#define mtk_wed_device_rx_ring_setup(_dev, _ring, _regs, _reset) -ENODEV
#define mtk_wed_device_ppe_check(_dev, _skb, _reason, _hash)  do {} while (0)
#define mtk_wed_device_update_msg(_dev, _id, _msg, _len) -ENODEV
#define mtk_wed_device_stop(_dev) do {} while (0)
#define mtk_wed_device_dma_reset(_dev) do {} while (0)
#define mtk_wed_device_setup_tc(_dev, _netdev, _type, _type_data) -EOPNOTSUPP
#define mtk_wed_device_start_hw_rro(_dev, _mask, _reset) do {} while (0)
#define mtk_wed_device_rro_rx_ring_setup(_dev, _ring, _regs) -ENODEV
#define mtk_wed_device_msdu_pg_rx_ring_setup(_dev, _ring, _regs) -ENODEV
#define mtk_wed_device_ind_rx_ring_setup(_dev, _regs) -ENODEV
#endif

#endif