8964e798494fa2e369e77b3a7d9128e2ccb52510
[dpdk.git] / drivers / raw / ifpga / base / opae_hw_api.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2018 Intel Corporation
3  */
4
5 #include "opae_hw_api.h"
6 #include "opae_debug.h"
7 #include "ifpga_api.h"
8
9 /* OPAE Bridge Functions */
10
11 /**
12  * opae_bridge_alloc - alloc opae_bridge data structure
13  * @name: bridge name.
14  * @ops: ops of this bridge.
15  * @data: private data of this bridge.
16  *
17  * Return opae_bridge on success, otherwise NULL.
18  */
19 struct opae_bridge *
20 opae_bridge_alloc(const char *name, struct opae_bridge_ops *ops, void *data)
21 {
22         struct opae_bridge *br = opae_zmalloc(sizeof(*br));
23
24         if (!br)
25                 return NULL;
26
27         br->name = name;
28         br->ops = ops;
29         br->data = data;
30
31         opae_log("%s %p\n", __func__, br);
32
33         return br;
34 }
35
36 /**
37  * opae_bridge_reset -  reset opae_bridge
38  * @br: bridge to be reset.
39  *
40  * Return: 0 on success, otherwise error code.
41  */
42 int opae_bridge_reset(struct opae_bridge *br)
43 {
44         if (!br)
45                 return -EINVAL;
46
47         if (br->ops && br->ops->reset)
48                 return br->ops->reset(br);
49
50         opae_log("%s no ops\n", __func__);
51
52         return -ENOENT;
53 }
54
55 /* Accelerator Functions */
56
57 /**
58  * opae_accelerator_alloc - alloc opae_accelerator data structure
59  * @name: accelerator name.
60  * @ops: ops of this accelerator.
61  * @data: private data of this accelerator.
62  *
63  * Return: opae_accelerator on success, otherwise NULL.
64  */
65 struct opae_accelerator *
66 opae_accelerator_alloc(const char *name, struct opae_accelerator_ops *ops,
67                        void *data)
68 {
69         struct opae_accelerator *acc = opae_zmalloc(sizeof(*acc));
70
71         if (!acc)
72                 return NULL;
73
74         acc->name = name;
75         acc->ops = ops;
76         acc->data = data;
77
78         opae_log("%s %p\n", __func__, acc);
79
80         return acc;
81 }
82
83 /**
84  * opae_acc_reg_read - read accelerator's register from its reg region.
85  * @acc: accelerator to read.
86  * @region_idx: reg region index.
87  * @offset: reg offset.
88  * @byte: read operation width, e.g 4 byte = 32bit read.
89  * @data: data to store the value read from the register.
90  *
91  * Return: 0 on success, otherwise error code.
92  */
93 int opae_acc_reg_read(struct opae_accelerator *acc, unsigned int region_idx,
94                       u64 offset, unsigned int byte, void *data)
95 {
96         if (!acc || !data)
97                 return -EINVAL;
98
99         if (acc->ops && acc->ops->read)
100                 return acc->ops->read(acc, region_idx, offset, byte, data);
101
102         return -ENOENT;
103 }
104
105 /**
106  * opae_acc_reg_write - write to accelerator's register from its reg region.
107  * @acc: accelerator to write.
108  * @region_idx: reg region index.
109  * @offset: reg offset.
110  * @byte: write operation width, e.g 4 byte = 32bit write.
111  * @data: data stored the value to write to the register.
112  *
113  * Return: 0 on success, otherwise error code.
114  */
115 int opae_acc_reg_write(struct opae_accelerator *acc, unsigned int region_idx,
116                        u64 offset, unsigned int byte, void *data)
117 {
118         if (!acc || !data)
119                 return -EINVAL;
120
121         if (acc->ops && acc->ops->write)
122                 return acc->ops->write(acc, region_idx, offset, byte, data);
123
124         return -ENOENT;
125 }
126
127 /**
128  * opae_acc_get_info - get information of an accelerator.
129  * @acc: targeted accelerator
130  * @info: accelerator info data structure to be filled.
131  *
132  * Return: 0 on success, otherwise error code.
133  */
134 int opae_acc_get_info(struct opae_accelerator *acc, struct opae_acc_info *info)
135 {
136         if (!acc || !info)
137                 return -EINVAL;
138
139         if (acc->ops && acc->ops->get_info)
140                 return acc->ops->get_info(acc, info);
141
142         return -ENOENT;
143 }
144
145 /**
146  * opae_acc_get_region_info - get information of an accelerator register region.
147  * @acc: targeted accelerator
148  * @info: accelerator region info data structure to be filled.
149  *
150  * Return: 0 on success, otherwise error code.
151  */
152 int opae_acc_get_region_info(struct opae_accelerator *acc,
153                              struct opae_acc_region_info *info)
154 {
155         if (!acc || !info)
156                 return -EINVAL;
157
158         if (acc->ops && acc->ops->get_region_info)
159                 return acc->ops->get_region_info(acc, info);
160
161         return -ENOENT;
162 }
163
164 /**
165  * opae_acc_set_irq -  set an accelerator's irq.
166  * @acc: targeted accelerator
167  * @start: start vector number
168  * @count: count of vectors to be set from the start vector
169  * @evtfds: event fds to be notified when corresponding irqs happens
170  *
171  * Return: 0 on success, otherwise error code.
172  */
173 int opae_acc_set_irq(struct opae_accelerator *acc,
174                      u32 start, u32 count, s32 evtfds[])
175 {
176         if (!acc || !acc->data)
177                 return -EINVAL;
178
179         if (start + count <= start)
180                 return -EINVAL;
181
182         if (acc->ops && acc->ops->set_irq)
183                 return acc->ops->set_irq(acc, start, count, evtfds);
184
185         return -ENOENT;
186 }
187
188 /**
189  * opae_acc_get_uuid -  get accelerator's UUID.
190  * @acc: targeted accelerator
191  * @uuid: a pointer to UUID
192  *
193  * Return: 0 on success, otherwise error code.
194  */
195 int opae_acc_get_uuid(struct opae_accelerator *acc,
196                       struct uuid *uuid)
197 {
198         if (!acc || !uuid)
199                 return -EINVAL;
200
201         if (acc->ops && acc->ops->get_uuid)
202                 return acc->ops->get_uuid(acc, uuid);
203
204         return -ENOENT;
205 }
206
207 /* Manager Functions */
208
209 /**
210  * opae_manager_alloc - alloc opae_manager data structure
211  * @name: manager name.
212  * @ops: ops of this manager.
213  * @network_ops: ops of network management.
214  * @data: private data of this manager.
215  *
216  * Return: opae_manager on success, otherwise NULL.
217  */
218 struct opae_manager *
219 opae_manager_alloc(const char *name, struct opae_manager_ops *ops,
220                 struct opae_manager_networking_ops *network_ops, void *data)
221 {
222         struct opae_manager *mgr = opae_zmalloc(sizeof(*mgr));
223
224         if (!mgr)
225                 return NULL;
226
227         mgr->name = name;
228         mgr->ops = ops;
229         mgr->network_ops = network_ops;
230         mgr->data = data;
231
232         opae_log("%s %p\n", __func__, mgr);
233
234         return mgr;
235 }
236
237 /**
238  * opae_manager_flash - flash a reconfiguration image via opae_manager
239  * @mgr: opae_manager for flash.
240  * @id: id of target region (accelerator).
241  * @buf: image data buffer.
242  * @size: buffer size.
243  * @status: status to store flash result.
244  *
245  * Return: 0 on success, otherwise error code.
246  */
247 int opae_manager_flash(struct opae_manager *mgr, int id, const char *buf,
248                 u32 size, u64 *status)
249 {
250         if (!mgr)
251                 return -EINVAL;
252
253         if (mgr && mgr->ops && mgr->ops->flash)
254                 return mgr->ops->flash(mgr, id, buf, size, status);
255
256         return -ENOENT;
257 }
258
259 /* Adapter Functions */
260
261 /**
262  * opae_adapter_data_alloc - alloc opae_adapter_data data structure
263  * @type: opae_adapter_type.
264  *
265  * Return: opae_adapter_data on success, otherwise NULL.
266  */
267 void *opae_adapter_data_alloc(enum opae_adapter_type type)
268 {
269         struct opae_adapter_data *data;
270         int size;
271
272         switch (type) {
273         case OPAE_FPGA_PCI:
274                 size = sizeof(struct opae_adapter_data_pci);
275                 break;
276         case OPAE_FPGA_NET:
277                 size = sizeof(struct opae_adapter_data_net);
278                 break;
279         default:
280                 size = sizeof(struct opae_adapter_data);
281                 break;
282         }
283
284         data = opae_zmalloc(size);
285         if (!data)
286                 return NULL;
287
288         data->type = type;
289
290         return data;
291 }
292
293 static struct opae_adapter_ops *match_ops(struct opae_adapter *adapter)
294 {
295         struct opae_adapter_data *data;
296
297         if (!adapter || !adapter->data)
298                 return NULL;
299
300         data = adapter->data;
301
302         if (data->type == OPAE_FPGA_PCI)
303                 return &ifpga_adapter_ops;
304
305         return NULL;
306 }
307
308 /**
309  * opae_adapter_init - init opae_adapter data structure
310  * @adapter: pointer of opae_adapter data structure
311  * @name: adapter name.
312  * @data: private data of this adapter.
313  *
314  * Return: 0 on success.
315  */
316 int opae_adapter_init(struct opae_adapter *adapter,
317                 const char *name, void *data)
318 {
319         if (!adapter)
320                 return -ENOMEM;
321
322         TAILQ_INIT(&adapter->acc_list);
323         adapter->data = data;
324         adapter->name = name;
325         adapter->ops = match_ops(adapter);
326
327         return 0;
328 }
329
330 /**
331  * opae_adapter_enumerate - enumerate this adapter
332  * @adapter: adapter to enumerate.
333  *
334  * Return: 0 on success, otherwise error code.
335  */
336 int opae_adapter_enumerate(struct opae_adapter *adapter)
337 {
338         int ret = -ENOENT;
339
340         if (!adapter)
341                 return -EINVAL;
342
343         if (adapter->ops && adapter->ops->enumerate)
344                 ret = adapter->ops->enumerate(adapter);
345
346         if (!ret)
347                 opae_adapter_dump(adapter, 0);
348
349         return ret;
350 }
351
352 /**
353  * opae_adapter_destroy - destroy this adapter
354  * @adapter: adapter to destroy.
355  *
356  * destroy things allocated during adapter enumeration.
357  */
358 void opae_adapter_destroy(struct opae_adapter *adapter)
359 {
360         if (adapter && adapter->ops && adapter->ops->destroy)
361                 adapter->ops->destroy(adapter);
362 }
363
364 /**
365  * opae_adapter_get_acc - find and return accelerator with matched id
366  * @adapter: adapter to find the accelerator.
367  * @acc_id: id (index) of the accelerator.
368  *
369  * destroy things allocated during adapter enumeration.
370  */
371 struct opae_accelerator *
372 opae_adapter_get_acc(struct opae_adapter *adapter, int acc_id)
373 {
374         struct opae_accelerator *acc = NULL;
375
376         if (!adapter)
377                 return NULL;
378
379         opae_adapter_for_each_acc(adapter, acc)
380                 if (acc->index == acc_id)
381                         return acc;
382
383         return NULL;
384 }
385
386 /**
387  * opae_manager_read_mac_rom - read the content of the MAC ROM
388  * @mgr: opae_manager for MAC ROM
389  * @port: the port number of retimer
390  * @addr: buffer of the MAC address
391  *
392  * Return: return the bytes of read successfully
393  */
394 int opae_manager_read_mac_rom(struct opae_manager *mgr, int port,
395                 struct opae_ether_addr *addr)
396 {
397         if (!mgr || !mgr->network_ops)
398                 return -EINVAL;
399
400         if (mgr->network_ops->read_mac_rom)
401                 return mgr->network_ops->read_mac_rom(mgr,
402                                 port * sizeof(struct opae_ether_addr),
403                                 addr, sizeof(struct opae_ether_addr));
404
405         return -ENOENT;
406 }
407
408 /**
409  * opae_manager_write_mac_rom - write data into MAC ROM
410  * @mgr: opae_manager for MAC ROM
411  * @port: the port number of the retimer
412  * @addr: data of the MAC address
413  *
414  * Return: return written bytes
415  */
416 int opae_manager_write_mac_rom(struct opae_manager *mgr, int port,
417                 struct opae_ether_addr *addr)
418 {
419         if (!mgr || !mgr->network_ops)
420                 return -EINVAL;
421
422         if (mgr->network_ops && mgr->network_ops->write_mac_rom)
423                 return mgr->network_ops->write_mac_rom(mgr,
424                                 port * sizeof(struct opae_ether_addr),
425                                 addr, sizeof(struct opae_ether_addr));
426
427         return -ENOENT;
428 }
429
430 /**
431  * opae_manager_get_eth_group_nums - get eth group numbers
432  * @mgr: opae_manager for eth group
433  *
434  * Return: the numbers of eth group
435  */
436 int opae_manager_get_eth_group_nums(struct opae_manager *mgr)
437 {
438         if (!mgr || !mgr->network_ops)
439                 return -EINVAL;
440
441         if (mgr->network_ops->get_retimer_info)
442                 return mgr->network_ops->get_eth_group_nums(mgr);
443
444         return -ENOENT;
445 }
446
447 /**
448  * opae_manager_get_eth_group_info - get eth group info
449  * @mgr: opae_manager for eth group
450  * @group_id: id for eth group
451  * @info: info return to caller
452  *
453  * Return: 0 on success, otherwise error code
454  */
455 int opae_manager_get_eth_group_info(struct opae_manager *mgr,
456                u8 group_id, struct opae_eth_group_info *info)
457 {
458         if (!mgr || !mgr->network_ops)
459                 return -EINVAL;
460
461         if (mgr->network_ops->get_retimer_info)
462                 return mgr->network_ops->get_eth_group_info(mgr,
463                         group_id, info);
464
465         return -ENOENT;
466 }
467
468 /**
469  * opae_manager_get_eth_group_region_info
470  * @mgr: opae_manager for flash.
471  * @info: the memory region info for eth group
472  *
473  * Return: 0 on success, otherwise error code.
474  */
475 int opae_manager_get_eth_group_region_info(struct opae_manager *mgr,
476                 u8 group_id, struct opae_eth_group_region_info *info)
477 {
478         if (!mgr)
479                 return -EINVAL;
480
481         if (group_id >= MAX_ETH_GROUP_DEVICES)
482                 return -EINVAL;
483
484         info->group_id = group_id;
485
486         if (mgr && mgr->ops && mgr->ops->get_eth_group_region_info)
487                 return mgr->ops->get_eth_group_region_info(mgr, info);
488
489         return -ENOENT;
490 }
491
492 /**
493  * opae_manager_eth_group_read_reg - read ETH group register
494  * @mgr: opae_manager for ETH Group
495  * @group_id: ETH group id
496  * @type: eth type
497  * @index: port index in eth group device
498  * @addr: register address of ETH Group
499  * @data: read buffer
500  *
501  * Return: 0 on success, otherwise error code
502  */
503 int opae_manager_eth_group_read_reg(struct opae_manager *mgr, u8 group_id,
504                 u8 type, u8 index, u16 addr, u32 *data)
505 {
506         if (!mgr || !mgr->network_ops)
507                 return -EINVAL;
508
509         if (mgr->network_ops->eth_group_reg_read)
510                 return mgr->network_ops->eth_group_reg_read(mgr, group_id,
511                                 type, index, addr, data);
512
513         return -ENOENT;
514 }
515
516 /**
517  * opae_manager_eth_group_write_reg - write ETH group register
518  * @mgr: opae_manager for ETH Group
519  * @group_id: ETH group id
520  * @type: eth type
521  * @index: port index in eth group device
522  * @addr: register address of ETH Group
523  * @data: data will write to register
524  *
525  * Return: 0 on success, otherwise error code
526  */
527 int opae_manager_eth_group_write_reg(struct opae_manager *mgr, u8 group_id,
528                 u8 type, u8 index, u16 addr, u32 data)
529 {
530         if (!mgr || !mgr->network_ops)
531                 return -EINVAL;
532
533         if (mgr->network_ops->eth_group_reg_write)
534                 return mgr->network_ops->eth_group_reg_write(mgr, group_id,
535                                 type, index, addr, data);
536
537         return -ENOENT;
538 }
539
540 /**
541  * opae_manager_get_retimer_info - get retimer info like PKVL chip
542  * @mgr: opae_manager for retimer
543  * @info: info return to caller
544  *
545  * Return: 0 on success, otherwise error code
546  */
547 int opae_manager_get_retimer_info(struct opae_manager *mgr,
548                struct opae_retimer_info *info)
549 {
550         if (!mgr || !mgr->network_ops)
551                 return -EINVAL;
552
553         if (mgr->network_ops->get_retimer_info)
554                 return mgr->network_ops->get_retimer_info(mgr, info);
555
556         return -ENOENT;
557 }
558
559 /**
560  * opae_manager_get_retimer_status - get retimer status
561  * @mgr: opae_manager of retimer
562  * @status: status of retimer
563  *
564  * Return: 0 on success, otherwise error code
565  */
566 int opae_manager_get_retimer_status(struct opae_manager *mgr,
567                 struct opae_retimer_status *status)
568 {
569         if (!mgr || !mgr->network_ops)
570                 return -EINVAL;
571
572         if (mgr->network_ops->get_retimer_status)
573                 return mgr->network_ops->get_retimer_status(mgr,
574                                 status);
575
576         return -ENOENT;
577 }