Commit | Line | Data |
---|---|---|
a1bd3bae AH |
1 | /* |
2 | * This file is provided under a dual BSD/GPLv2 license. When using or | |
3 | * redistributing this file, you may do so under either license. | |
4 | * | |
5 | * GPL LICENSE SUMMARY | |
6 | * | |
7 | * Copyright (C) 2015 EMC Corporation. All Rights Reserved. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of version 2 of the GNU General Public License as | |
11 | * published by the Free Software Foundation. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 | * General Public License for more details. | |
17 | * | |
18 | * BSD LICENSE | |
19 | * | |
20 | * Copyright (C) 2015 EMC Corporation. All Rights Reserved. | |
21 | * | |
22 | * Redistribution and use in source and binary forms, with or without | |
23 | * modification, are permitted provided that the following conditions | |
24 | * are met: | |
25 | * | |
26 | * * Redistributions of source code must retain the above copyright | |
27 | * notice, this list of conditions and the following disclaimer. | |
28 | * * Redistributions in binary form must reproduce the above copy | |
29 | * notice, this list of conditions and the following disclaimer in | |
30 | * the documentation and/or other materials provided with the | |
31 | * distribution. | |
32 | * * Neither the name of Intel Corporation nor the names of its | |
33 | * contributors may be used to endorse or promote products derived | |
34 | * from this software without specific prior written permission. | |
35 | * | |
36 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
37 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
38 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
39 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
40 | * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
41 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
42 | * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
43 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
44 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
45 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
46 | * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
47 | * | |
48 | * PCIe NTB Linux driver | |
49 | * | |
50 | * Contact Information: | |
51 | * Allen Hubbe <Allen.Hubbe@emc.com> | |
52 | */ | |
53 | ||
54 | #ifndef _NTB_H_ | |
55 | #define _NTB_H_ | |
56 | ||
57 | #include <linux/completion.h> | |
58 | #include <linux/device.h> | |
59 | ||
60 | struct ntb_client; | |
61 | struct ntb_dev; | |
62 | struct pci_dev; | |
63 | ||
64 | /** | |
65 | * enum ntb_topo - NTB connection topology | |
66 | * @NTB_TOPO_NONE: Topology is unknown or invalid. | |
67 | * @NTB_TOPO_PRI: On primary side of local ntb. | |
68 | * @NTB_TOPO_SEC: On secondary side of remote ntb. | |
69 | * @NTB_TOPO_B2B_USD: On primary side of local ntb upstream of remote ntb. | |
70 | * @NTB_TOPO_B2B_DSD: On primary side of local ntb downstream of remote ntb. | |
71 | */ | |
72 | enum ntb_topo { | |
73 | NTB_TOPO_NONE = -1, | |
74 | NTB_TOPO_PRI, | |
75 | NTB_TOPO_SEC, | |
76 | NTB_TOPO_B2B_USD, | |
77 | NTB_TOPO_B2B_DSD, | |
78 | }; | |
79 | ||
80 | static inline int ntb_topo_is_b2b(enum ntb_topo topo) | |
81 | { | |
82 | switch ((int)topo) { | |
83 | case NTB_TOPO_B2B_USD: | |
84 | case NTB_TOPO_B2B_DSD: | |
85 | return 1; | |
86 | } | |
87 | return 0; | |
88 | } | |
89 | ||
90 | static inline char *ntb_topo_string(enum ntb_topo topo) | |
91 | { | |
92 | switch (topo) { | |
93 | case NTB_TOPO_NONE: return "NTB_TOPO_NONE"; | |
94 | case NTB_TOPO_PRI: return "NTB_TOPO_PRI"; | |
95 | case NTB_TOPO_SEC: return "NTB_TOPO_SEC"; | |
96 | case NTB_TOPO_B2B_USD: return "NTB_TOPO_B2B_USD"; | |
97 | case NTB_TOPO_B2B_DSD: return "NTB_TOPO_B2B_DSD"; | |
98 | } | |
99 | return "NTB_TOPO_INVALID"; | |
100 | } | |
101 | ||
102 | /** | |
103 | * enum ntb_speed - NTB link training speed | |
104 | * @NTB_SPEED_AUTO: Request the max supported speed. | |
105 | * @NTB_SPEED_NONE: Link is not trained to any speed. | |
106 | * @NTB_SPEED_GEN1: Link is trained to gen1 speed. | |
107 | * @NTB_SPEED_GEN2: Link is trained to gen2 speed. | |
108 | * @NTB_SPEED_GEN3: Link is trained to gen3 speed. | |
109 | */ | |
110 | enum ntb_speed { | |
111 | NTB_SPEED_AUTO = -1, | |
112 | NTB_SPEED_NONE = 0, | |
113 | NTB_SPEED_GEN1 = 1, | |
114 | NTB_SPEED_GEN2 = 2, | |
115 | NTB_SPEED_GEN3 = 3, | |
116 | }; | |
117 | ||
118 | /** | |
119 | * enum ntb_width - NTB link training width | |
120 | * @NTB_WIDTH_AUTO: Request the max supported width. | |
121 | * @NTB_WIDTH_NONE: Link is not trained to any width. | |
122 | * @NTB_WIDTH_1: Link is trained to 1 lane width. | |
123 | * @NTB_WIDTH_2: Link is trained to 2 lane width. | |
124 | * @NTB_WIDTH_4: Link is trained to 4 lane width. | |
125 | * @NTB_WIDTH_8: Link is trained to 8 lane width. | |
126 | * @NTB_WIDTH_12: Link is trained to 12 lane width. | |
127 | * @NTB_WIDTH_16: Link is trained to 16 lane width. | |
128 | * @NTB_WIDTH_32: Link is trained to 32 lane width. | |
129 | */ | |
130 | enum ntb_width { | |
131 | NTB_WIDTH_AUTO = -1, | |
132 | NTB_WIDTH_NONE = 0, | |
133 | NTB_WIDTH_1 = 1, | |
134 | NTB_WIDTH_2 = 2, | |
135 | NTB_WIDTH_4 = 4, | |
136 | NTB_WIDTH_8 = 8, | |
137 | NTB_WIDTH_12 = 12, | |
138 | NTB_WIDTH_16 = 16, | |
139 | NTB_WIDTH_32 = 32, | |
140 | }; | |
141 | ||
142 | /** | |
143 | * struct ntb_client_ops - ntb client operations | |
144 | * @probe: Notify client of a new device. | |
145 | * @remove: Notify client to remove a device. | |
146 | */ | |
147 | struct ntb_client_ops { | |
148 | int (*probe)(struct ntb_client *client, struct ntb_dev *ntb); | |
149 | void (*remove)(struct ntb_client *client, struct ntb_dev *ntb); | |
150 | }; | |
151 | ||
152 | static inline int ntb_client_ops_is_valid(const struct ntb_client_ops *ops) | |
153 | { | |
154 | /* commented callbacks are not required: */ | |
155 | return | |
156 | ops->probe && | |
157 | ops->remove && | |
158 | 1; | |
159 | } | |
160 | ||
161 | /** | |
162 | * struct ntb_ctx_ops - ntb driver context operations | |
163 | * @link_event: See ntb_link_event(). | |
164 | * @db_event: See ntb_db_event(). | |
165 | */ | |
166 | struct ntb_ctx_ops { | |
167 | void (*link_event)(void *ctx); | |
168 | void (*db_event)(void *ctx, int db_vector); | |
169 | }; | |
170 | ||
171 | static inline int ntb_ctx_ops_is_valid(const struct ntb_ctx_ops *ops) | |
172 | { | |
173 | /* commented callbacks are not required: */ | |
174 | return | |
175 | /* ops->link_event && */ | |
176 | /* ops->db_event && */ | |
177 | 1; | |
178 | } | |
179 | ||
180 | /** | |
181 | * struct ntb_ctx_ops - ntb device operations | |
182 | * @mw_count: See ntb_mw_count(). | |
183 | * @mw_get_range: See ntb_mw_get_range(). | |
184 | * @mw_set_trans: See ntb_mw_set_trans(). | |
185 | * @mw_clear_trans: See ntb_mw_clear_trans(). | |
186 | * @link_is_up: See ntb_link_is_up(). | |
187 | * @link_enable: See ntb_link_enable(). | |
188 | * @link_disable: See ntb_link_disable(). | |
189 | * @db_is_unsafe: See ntb_db_is_unsafe(). | |
190 | * @db_valid_mask: See ntb_db_valid_mask(). | |
191 | * @db_vector_count: See ntb_db_vector_count(). | |
192 | * @db_vector_mask: See ntb_db_vector_mask(). | |
193 | * @db_read: See ntb_db_read(). | |
194 | * @db_set: See ntb_db_set(). | |
195 | * @db_clear: See ntb_db_clear(). | |
196 | * @db_read_mask: See ntb_db_read_mask(). | |
197 | * @db_set_mask: See ntb_db_set_mask(). | |
198 | * @db_clear_mask: See ntb_db_clear_mask(). | |
199 | * @peer_db_addr: See ntb_peer_db_addr(). | |
200 | * @peer_db_read: See ntb_peer_db_read(). | |
201 | * @peer_db_set: See ntb_peer_db_set(). | |
202 | * @peer_db_clear: See ntb_peer_db_clear(). | |
203 | * @peer_db_read_mask: See ntb_peer_db_read_mask(). | |
204 | * @peer_db_set_mask: See ntb_peer_db_set_mask(). | |
205 | * @peer_db_clear_mask: See ntb_peer_db_clear_mask(). | |
206 | * @spad_is_unsafe: See ntb_spad_is_unsafe(). | |
207 | * @spad_count: See ntb_spad_count(). | |
208 | * @spad_read: See ntb_spad_read(). | |
209 | * @spad_write: See ntb_spad_write(). | |
210 | * @peer_spad_addr: See ntb_peer_spad_addr(). | |
211 | * @peer_spad_read: See ntb_peer_spad_read(). | |
212 | * @peer_spad_write: See ntb_peer_spad_write(). | |
213 | */ | |
214 | struct ntb_dev_ops { | |
215 | int (*mw_count)(struct ntb_dev *ntb); | |
216 | int (*mw_get_range)(struct ntb_dev *ntb, int idx, | |
217 | phys_addr_t *base, resource_size_t *size, | |
218 | resource_size_t *align, resource_size_t *align_size); | |
219 | int (*mw_set_trans)(struct ntb_dev *ntb, int idx, | |
220 | dma_addr_t addr, resource_size_t size); | |
221 | int (*mw_clear_trans)(struct ntb_dev *ntb, int idx); | |
222 | ||
223 | int (*link_is_up)(struct ntb_dev *ntb, | |
224 | enum ntb_speed *speed, enum ntb_width *width); | |
225 | int (*link_enable)(struct ntb_dev *ntb, | |
226 | enum ntb_speed max_speed, enum ntb_width max_width); | |
227 | int (*link_disable)(struct ntb_dev *ntb); | |
228 | ||
229 | int (*db_is_unsafe)(struct ntb_dev *ntb); | |
230 | u64 (*db_valid_mask)(struct ntb_dev *ntb); | |
231 | int (*db_vector_count)(struct ntb_dev *ntb); | |
232 | u64 (*db_vector_mask)(struct ntb_dev *ntb, int db_vector); | |
233 | ||
234 | u64 (*db_read)(struct ntb_dev *ntb); | |
235 | int (*db_set)(struct ntb_dev *ntb, u64 db_bits); | |
236 | int (*db_clear)(struct ntb_dev *ntb, u64 db_bits); | |
237 | ||
238 | u64 (*db_read_mask)(struct ntb_dev *ntb); | |
239 | int (*db_set_mask)(struct ntb_dev *ntb, u64 db_bits); | |
240 | int (*db_clear_mask)(struct ntb_dev *ntb, u64 db_bits); | |
241 | ||
242 | int (*peer_db_addr)(struct ntb_dev *ntb, | |
243 | phys_addr_t *db_addr, resource_size_t *db_size); | |
244 | u64 (*peer_db_read)(struct ntb_dev *ntb); | |
245 | int (*peer_db_set)(struct ntb_dev *ntb, u64 db_bits); | |
246 | int (*peer_db_clear)(struct ntb_dev *ntb, u64 db_bits); | |
247 | ||
248 | u64 (*peer_db_read_mask)(struct ntb_dev *ntb); | |
249 | int (*peer_db_set_mask)(struct ntb_dev *ntb, u64 db_bits); | |
250 | int (*peer_db_clear_mask)(struct ntb_dev *ntb, u64 db_bits); | |
251 | ||
252 | int (*spad_is_unsafe)(struct ntb_dev *ntb); | |
253 | int (*spad_count)(struct ntb_dev *ntb); | |
254 | ||
255 | u32 (*spad_read)(struct ntb_dev *ntb, int idx); | |
256 | int (*spad_write)(struct ntb_dev *ntb, int idx, u32 val); | |
257 | ||
258 | int (*peer_spad_addr)(struct ntb_dev *ntb, int idx, | |
259 | phys_addr_t *spad_addr); | |
260 | u32 (*peer_spad_read)(struct ntb_dev *ntb, int idx); | |
261 | int (*peer_spad_write)(struct ntb_dev *ntb, int idx, u32 val); | |
262 | }; | |
263 | ||
264 | static inline int ntb_dev_ops_is_valid(const struct ntb_dev_ops *ops) | |
265 | { | |
266 | /* commented callbacks are not required: */ | |
267 | return | |
268 | ops->mw_count && | |
269 | ops->mw_get_range && | |
270 | ops->mw_set_trans && | |
271 | /* ops->mw_clear_trans && */ | |
272 | ops->link_is_up && | |
273 | ops->link_enable && | |
274 | ops->link_disable && | |
275 | /* ops->db_is_unsafe && */ | |
276 | ops->db_valid_mask && | |
277 | ||
278 | /* both set, or both unset */ | |
279 | (!ops->db_vector_count == !ops->db_vector_mask) && | |
280 | ||
281 | ops->db_read && | |
282 | /* ops->db_set && */ | |
283 | ops->db_clear && | |
284 | /* ops->db_read_mask && */ | |
285 | ops->db_set_mask && | |
286 | ops->db_clear_mask && | |
afc54992 | 287 | /* ops->peer_db_addr && */ |
a1bd3bae AH |
288 | /* ops->peer_db_read && */ |
289 | ops->peer_db_set && | |
290 | /* ops->peer_db_clear && */ | |
291 | /* ops->peer_db_read_mask && */ | |
292 | /* ops->peer_db_set_mask && */ | |
293 | /* ops->peer_db_clear_mask && */ | |
294 | /* ops->spad_is_unsafe && */ | |
295 | ops->spad_count && | |
296 | ops->spad_read && | |
297 | ops->spad_write && | |
afc54992 | 298 | /* ops->peer_spad_addr && */ |
a1bd3bae AH |
299 | /* ops->peer_spad_read && */ |
300 | ops->peer_spad_write && | |
301 | 1; | |
302 | } | |
303 | ||
304 | /** | |
305 | * struct ntb_client - client interested in ntb devices | |
306 | * @drv: Linux driver object. | |
307 | * @ops: See &ntb_client_ops. | |
308 | */ | |
309 | struct ntb_client { | |
310 | struct device_driver drv; | |
311 | const struct ntb_client_ops ops; | |
312 | }; | |
313 | ||
314 | #define drv_ntb_client(__drv) container_of((__drv), struct ntb_client, drv) | |
315 | ||
316 | /** | |
317 | * struct ntb_device - ntb device | |
318 | * @dev: Linux device object. | |
319 | * @pdev: Pci device entry of the ntb. | |
320 | * @topo: Detected topology of the ntb. | |
321 | * @ops: See &ntb_dev_ops. | |
322 | * @ctx: See &ntb_ctx_ops. | |
323 | * @ctx_ops: See &ntb_ctx_ops. | |
324 | */ | |
325 | struct ntb_dev { | |
326 | struct device dev; | |
327 | struct pci_dev *pdev; | |
328 | enum ntb_topo topo; | |
329 | const struct ntb_dev_ops *ops; | |
330 | void *ctx; | |
331 | const struct ntb_ctx_ops *ctx_ops; | |
332 | ||
333 | /* private: */ | |
334 | ||
335 | /* synchronize setting, clearing, and calling ctx_ops */ | |
336 | spinlock_t ctx_lock; | |
337 | /* block unregister until device is fully released */ | |
338 | struct completion released; | |
339 | }; | |
340 | ||
341 | #define dev_ntb(__dev) container_of((__dev), struct ntb_dev, dev) | |
342 | ||
343 | /** | |
344 | * ntb_register_client() - register a client for interest in ntb devices | |
345 | * @client: Client context. | |
346 | * | |
347 | * The client will be added to the list of clients interested in ntb devices. | |
348 | * The client will be notified of any ntb devices that are not already | |
349 | * associated with a client, or if ntb devices are registered later. | |
350 | * | |
351 | * Return: Zero if the client is registered, otherwise an error number. | |
352 | */ | |
353 | #define ntb_register_client(client) \ | |
354 | __ntb_register_client((client), THIS_MODULE, KBUILD_MODNAME) | |
355 | ||
356 | int __ntb_register_client(struct ntb_client *client, struct module *mod, | |
357 | const char *mod_name); | |
358 | ||
359 | /** | |
360 | * ntb_unregister_client() - unregister a client for interest in ntb devices | |
361 | * @client: Client context. | |
362 | * | |
363 | * The client will be removed from the list of clients interested in ntb | |
364 | * devices. If any ntb devices are associated with the client, the client will | |
365 | * be notified to remove those devices. | |
366 | */ | |
367 | void ntb_unregister_client(struct ntb_client *client); | |
368 | ||
369 | #define module_ntb_client(__ntb_client) \ | |
370 | module_driver(__ntb_client, ntb_register_client, \ | |
371 | ntb_unregister_client) | |
372 | ||
373 | /** | |
374 | * ntb_register_device() - register a ntb device | |
375 | * @ntb: NTB device context. | |
376 | * | |
377 | * The device will be added to the list of ntb devices. If any clients are | |
378 | * interested in ntb devices, each client will be notified of the ntb device, | |
379 | * until at most one client accepts the device. | |
380 | * | |
381 | * Return: Zero if the device is registered, otherwise an error number. | |
382 | */ | |
383 | int ntb_register_device(struct ntb_dev *ntb); | |
384 | ||
385 | /** | |
386 | * ntb_register_device() - unregister a ntb device | |
387 | * @ntb: NTB device context. | |
388 | * | |
389 | * The device will be removed from the list of ntb devices. If the ntb device | |
390 | * is associated with a client, the client will be notified to remove the | |
391 | * device. | |
392 | */ | |
393 | void ntb_unregister_device(struct ntb_dev *ntb); | |
394 | ||
395 | /** | |
396 | * ntb_set_ctx() - associate a driver context with an ntb device | |
397 | * @ntb: NTB device context. | |
398 | * @ctx: Driver context. | |
399 | * @ctx_ops: Driver context operations. | |
400 | * | |
401 | * Associate a driver context and operations with a ntb device. The context is | |
402 | * provided by the client driver, and the driver may associate a different | |
403 | * context with each ntb device. | |
404 | * | |
405 | * Return: Zero if the context is associated, otherwise an error number. | |
406 | */ | |
407 | int ntb_set_ctx(struct ntb_dev *ntb, void *ctx, | |
408 | const struct ntb_ctx_ops *ctx_ops); | |
409 | ||
410 | /** | |
411 | * ntb_clear_ctx() - disassociate any driver context from an ntb device | |
412 | * @ntb: NTB device context. | |
413 | * | |
414 | * Clear any association that may exist between a driver context and the ntb | |
415 | * device. | |
416 | */ | |
417 | void ntb_clear_ctx(struct ntb_dev *ntb); | |
418 | ||
419 | /** | |
420 | * ntb_link_event() - notify driver context of a change in link status | |
421 | * @ntb: NTB device context. | |
422 | * | |
423 | * Notify the driver context that the link status may have changed. The driver | |
424 | * should call ntb_link_is_up() to get the current status. | |
425 | */ | |
426 | void ntb_link_event(struct ntb_dev *ntb); | |
427 | ||
428 | /** | |
429 | * ntb_db_event() - notify driver context of a doorbell event | |
430 | * @ntb: NTB device context. | |
431 | * @vector: Interrupt vector number. | |
432 | * | |
433 | * Notify the driver context of a doorbell event. If hardware supports | |
434 | * multiple interrupt vectors for doorbells, the vector number indicates which | |
435 | * vector received the interrupt. The vector number is relative to the first | |
436 | * vector used for doorbells, starting at zero, and must be less than | |
437 | ** ntb_db_vector_count(). The driver may call ntb_db_read() to check which | |
438 | * doorbell bits need service, and ntb_db_vector_mask() to determine which of | |
439 | * those bits are associated with the vector number. | |
440 | */ | |
441 | void ntb_db_event(struct ntb_dev *ntb, int vector); | |
442 | ||
443 | /** | |
444 | * ntb_mw_count() - get the number of memory windows | |
445 | * @ntb: NTB device context. | |
446 | * | |
447 | * Hardware and topology may support a different number of memory windows. | |
448 | * | |
449 | * Return: the number of memory windows. | |
450 | */ | |
451 | static inline int ntb_mw_count(struct ntb_dev *ntb) | |
452 | { | |
453 | return ntb->ops->mw_count(ntb); | |
454 | } | |
455 | ||
456 | /** | |
457 | * ntb_mw_get_range() - get the range of a memory window | |
458 | * @ntb: NTB device context. | |
459 | * @idx: Memory window number. | |
460 | * @base: OUT - the base address for mapping the memory window | |
461 | * @size: OUT - the size for mapping the memory window | |
462 | * @align: OUT - the base alignment for translating the memory window | |
463 | * @align_size: OUT - the size alignment for translating the memory window | |
464 | * | |
465 | * Get the range of a memory window. NULL may be given for any output | |
466 | * parameter if the value is not needed. The base and size may be used for | |
467 | * mapping the memory window, to access the peer memory. The alignment and | |
468 | * size may be used for translating the memory window, for the peer to access | |
469 | * memory on the local system. | |
470 | * | |
471 | * Return: Zero on success, otherwise an error number. | |
472 | */ | |
473 | static inline int ntb_mw_get_range(struct ntb_dev *ntb, int idx, | |
474 | phys_addr_t *base, resource_size_t *size, | |
475 | resource_size_t *align, resource_size_t *align_size) | |
476 | { | |
477 | return ntb->ops->mw_get_range(ntb, idx, base, size, | |
478 | align, align_size); | |
479 | } | |
480 | ||
481 | /** | |
482 | * ntb_mw_set_trans() - set the translation of a memory window | |
483 | * @ntb: NTB device context. | |
484 | * @idx: Memory window number. | |
485 | * @addr: The dma address local memory to expose to the peer. | |
486 | * @size: The size of the local memory to expose to the peer. | |
487 | * | |
488 | * Set the translation of a memory window. The peer may access local memory | |
489 | * through the window starting at the address, up to the size. The address | |
490 | * must be aligned to the alignment specified by ntb_mw_get_range(). The size | |
491 | * must be aligned to the size alignment specified by ntb_mw_get_range(). | |
492 | * | |
493 | * Return: Zero on success, otherwise an error number. | |
494 | */ | |
495 | static inline int ntb_mw_set_trans(struct ntb_dev *ntb, int idx, | |
496 | dma_addr_t addr, resource_size_t size) | |
497 | { | |
498 | return ntb->ops->mw_set_trans(ntb, idx, addr, size); | |
499 | } | |
500 | ||
501 | /** | |
502 | * ntb_mw_clear_trans() - clear the translation of a memory window | |
503 | * @ntb: NTB device context. | |
504 | * @idx: Memory window number. | |
505 | * | |
506 | * Clear the translation of a memory window. The peer may no longer access | |
507 | * local memory through the window. | |
508 | * | |
509 | * Return: Zero on success, otherwise an error number. | |
510 | */ | |
511 | static inline int ntb_mw_clear_trans(struct ntb_dev *ntb, int idx) | |
512 | { | |
513 | if (!ntb->ops->mw_clear_trans) | |
514 | return ntb->ops->mw_set_trans(ntb, idx, 0, 0); | |
515 | ||
516 | return ntb->ops->mw_clear_trans(ntb, idx); | |
517 | } | |
518 | ||
519 | /** | |
520 | * ntb_link_is_up() - get the current ntb link state | |
521 | * @ntb: NTB device context. | |
522 | * @speed: OUT - The link speed expressed as PCIe generation number. | |
523 | * @width: OUT - The link width expressed as the number of PCIe lanes. | |
524 | * | |
a7c23237 AH |
525 | * Get the current state of the ntb link. It is recommended to query the link |
526 | * state once after every link event. It is safe to query the link state in | |
527 | * the context of the link event callback. | |
a1bd3bae AH |
528 | * |
529 | * Return: One if the link is up, zero if the link is down, otherwise a | |
530 | * negative value indicating the error number. | |
531 | */ | |
532 | static inline int ntb_link_is_up(struct ntb_dev *ntb, | |
533 | enum ntb_speed *speed, enum ntb_width *width) | |
534 | { | |
535 | return ntb->ops->link_is_up(ntb, speed, width); | |
536 | } | |
537 | ||
538 | /** | |
539 | * ntb_link_enable() - enable the link on the secondary side of the ntb | |
540 | * @ntb: NTB device context. | |
541 | * @max_speed: The maximum link speed expressed as PCIe generation number. | |
542 | * @max_width: The maximum link width expressed as the number of PCIe lanes. | |
543 | * | |
544 | * Enable the link on the secondary side of the ntb. This can only be done | |
545 | * from the primary side of the ntb in primary or b2b topology. The ntb device | |
546 | * should train the link to its maximum speed and width, or the requested speed | |
547 | * and width, whichever is smaller, if supported. | |
548 | * | |
549 | * Return: Zero on success, otherwise an error number. | |
550 | */ | |
551 | static inline int ntb_link_enable(struct ntb_dev *ntb, | |
552 | enum ntb_speed max_speed, | |
553 | enum ntb_width max_width) | |
554 | { | |
555 | return ntb->ops->link_enable(ntb, max_speed, max_width); | |
556 | } | |
557 | ||
558 | /** | |
559 | * ntb_link_disable() - disable the link on the secondary side of the ntb | |
560 | * @ntb: NTB device context. | |
561 | * | |
562 | * Disable the link on the secondary side of the ntb. This can only be | |
563 | * done from the primary side of the ntb in primary or b2b topology. The ntb | |
564 | * device should disable the link. Returning from this call must indicate that | |
565 | * a barrier has passed, though with no more writes may pass in either | |
566 | * direction across the link, except if this call returns an error number. | |
567 | * | |
568 | * Return: Zero on success, otherwise an error number. | |
569 | */ | |
570 | static inline int ntb_link_disable(struct ntb_dev *ntb) | |
571 | { | |
572 | return ntb->ops->link_disable(ntb); | |
573 | } | |
574 | ||
575 | /** | |
576 | * ntb_db_is_unsafe() - check if it is safe to use hardware doorbell | |
577 | * @ntb: NTB device context. | |
578 | * | |
579 | * It is possible for some ntb hardware to be affected by errata. Hardware | |
580 | * drivers can advise clients to avoid using doorbells. Clients may ignore | |
581 | * this advice, though caution is recommended. | |
582 | * | |
583 | * Return: Zero if it is safe to use doorbells, or One if it is not safe. | |
584 | */ | |
585 | static inline int ntb_db_is_unsafe(struct ntb_dev *ntb) | |
586 | { | |
587 | if (!ntb->ops->db_is_unsafe) | |
588 | return 0; | |
589 | ||
590 | return ntb->ops->db_is_unsafe(ntb); | |
591 | } | |
592 | ||
593 | /** | |
594 | * ntb_db_valid_mask() - get a mask of doorbell bits supported by the ntb | |
595 | * @ntb: NTB device context. | |
596 | * | |
597 | * Hardware may support different number or arrangement of doorbell bits. | |
598 | * | |
599 | * Return: A mask of doorbell bits supported by the ntb. | |
600 | */ | |
601 | static inline u64 ntb_db_valid_mask(struct ntb_dev *ntb) | |
602 | { | |
603 | return ntb->ops->db_valid_mask(ntb); | |
604 | } | |
605 | ||
606 | /** | |
607 | * ntb_db_vector_count() - get the number of doorbell interrupt vectors | |
608 | * @ntb: NTB device context. | |
609 | * | |
610 | * Hardware may support different number of interrupt vectors. | |
611 | * | |
612 | * Return: The number of doorbell interrupt vectors. | |
613 | */ | |
614 | static inline int ntb_db_vector_count(struct ntb_dev *ntb) | |
615 | { | |
616 | if (!ntb->ops->db_vector_count) | |
617 | return 1; | |
618 | ||
619 | return ntb->ops->db_vector_count(ntb); | |
620 | } | |
621 | ||
622 | /** | |
623 | * ntb_db_vector_mask() - get a mask of doorbell bits serviced by a vector | |
624 | * @ntb: NTB device context. | |
625 | * @vector: Doorbell vector number. | |
626 | * | |
627 | * Each interrupt vector may have a different number or arrangement of bits. | |
628 | * | |
629 | * Return: A mask of doorbell bits serviced by a vector. | |
630 | */ | |
631 | static inline u64 ntb_db_vector_mask(struct ntb_dev *ntb, int vector) | |
632 | { | |
633 | if (!ntb->ops->db_vector_mask) | |
634 | return ntb_db_valid_mask(ntb); | |
635 | ||
636 | return ntb->ops->db_vector_mask(ntb, vector); | |
637 | } | |
638 | ||
639 | /** | |
640 | * ntb_db_read() - read the local doorbell register | |
641 | * @ntb: NTB device context. | |
642 | * | |
643 | * Read the local doorbell register, and return the bits that are set. | |
644 | * | |
645 | * Return: The bits currently set in the local doorbell register. | |
646 | */ | |
647 | static inline u64 ntb_db_read(struct ntb_dev *ntb) | |
648 | { | |
649 | return ntb->ops->db_read(ntb); | |
650 | } | |
651 | ||
652 | /** | |
653 | * ntb_db_set() - set bits in the local doorbell register | |
654 | * @ntb: NTB device context. | |
655 | * @db_bits: Doorbell bits to set. | |
656 | * | |
657 | * Set bits in the local doorbell register, which may generate a local doorbell | |
658 | * interrupt. Bits that were already set must remain set. | |
659 | * | |
660 | * This is unusual, and hardware may not support it. | |
661 | * | |
662 | * Return: Zero on success, otherwise an error number. | |
663 | */ | |
664 | static inline int ntb_db_set(struct ntb_dev *ntb, u64 db_bits) | |
665 | { | |
666 | if (!ntb->ops->db_set) | |
667 | return -EINVAL; | |
668 | ||
669 | return ntb->ops->db_set(ntb, db_bits); | |
670 | } | |
671 | ||
672 | /** | |
673 | * ntb_db_clear() - clear bits in the local doorbell register | |
674 | * @ntb: NTB device context. | |
675 | * @db_bits: Doorbell bits to clear. | |
676 | * | |
677 | * Clear bits in the local doorbell register, arming the bits for the next | |
678 | * doorbell. | |
679 | * | |
680 | * Return: Zero on success, otherwise an error number. | |
681 | */ | |
682 | static inline int ntb_db_clear(struct ntb_dev *ntb, u64 db_bits) | |
683 | { | |
684 | return ntb->ops->db_clear(ntb, db_bits); | |
685 | } | |
686 | ||
687 | /** | |
688 | * ntb_db_read_mask() - read the local doorbell mask | |
689 | * @ntb: NTB device context. | |
690 | * | |
691 | * Read the local doorbell mask register, and return the bits that are set. | |
692 | * | |
693 | * This is unusual, though hardware is likely to support it. | |
694 | * | |
695 | * Return: The bits currently set in the local doorbell mask register. | |
696 | */ | |
697 | static inline u64 ntb_db_read_mask(struct ntb_dev *ntb) | |
698 | { | |
699 | if (!ntb->ops->db_read_mask) | |
700 | return 0; | |
701 | ||
702 | return ntb->ops->db_read_mask(ntb); | |
703 | } | |
704 | ||
705 | /** | |
706 | * ntb_db_set_mask() - set bits in the local doorbell mask | |
707 | * @ntb: NTB device context. | |
708 | * @db_bits: Doorbell mask bits to set. | |
709 | * | |
710 | * Set bits in the local doorbell mask register, preventing doorbell interrupts | |
711 | * from being generated for those doorbell bits. Bits that were already set | |
712 | * must remain set. | |
713 | * | |
714 | * Return: Zero on success, otherwise an error number. | |
715 | */ | |
716 | static inline int ntb_db_set_mask(struct ntb_dev *ntb, u64 db_bits) | |
717 | { | |
718 | return ntb->ops->db_set_mask(ntb, db_bits); | |
719 | } | |
720 | ||
721 | /** | |
722 | * ntb_db_clear_mask() - clear bits in the local doorbell mask | |
723 | * @ntb: NTB device context. | |
724 | * @db_bits: Doorbell bits to clear. | |
725 | * | |
726 | * Clear bits in the local doorbell mask register, allowing doorbell interrupts | |
727 | * from being generated for those doorbell bits. If a doorbell bit is already | |
728 | * set at the time the mask is cleared, and the corresponding mask bit is | |
729 | * changed from set to clear, then the ntb driver must ensure that | |
730 | * ntb_db_event() is called. If the hardware does not generate the interrupt | |
731 | * on clearing the mask bit, then the driver must call ntb_db_event() anyway. | |
732 | * | |
733 | * Return: Zero on success, otherwise an error number. | |
734 | */ | |
735 | static inline int ntb_db_clear_mask(struct ntb_dev *ntb, u64 db_bits) | |
736 | { | |
737 | return ntb->ops->db_clear_mask(ntb, db_bits); | |
738 | } | |
739 | ||
740 | /** | |
741 | * ntb_peer_db_addr() - address and size of the peer doorbell register | |
742 | * @ntb: NTB device context. | |
743 | * @db_addr: OUT - The address of the peer doorbell register. | |
744 | * @db_size: OUT - The number of bytes to write the peer doorbell register. | |
745 | * | |
746 | * Return the address of the peer doorbell register. This may be used, for | |
747 | * example, by drivers that offload memory copy operations to a dma engine. | |
748 | * The drivers may wish to ring the peer doorbell at the completion of memory | |
749 | * copy operations. For efficiency, and to simplify ordering of operations | |
750 | * between the dma memory copies and the ringing doorbell, the driver may | |
751 | * append one additional dma memory copy with the doorbell register as the | |
752 | * destination, after the memory copy operations. | |
753 | * | |
754 | * Return: Zero on success, otherwise an error number. | |
755 | */ | |
756 | static inline int ntb_peer_db_addr(struct ntb_dev *ntb, | |
757 | phys_addr_t *db_addr, | |
758 | resource_size_t *db_size) | |
759 | { | |
afc54992 AH |
760 | if (!ntb->ops->peer_db_addr) |
761 | return -EINVAL; | |
762 | ||
a1bd3bae AH |
763 | return ntb->ops->peer_db_addr(ntb, db_addr, db_size); |
764 | } | |
765 | ||
766 | /** | |
767 | * ntb_peer_db_read() - read the peer doorbell register | |
768 | * @ntb: NTB device context. | |
769 | * | |
770 | * Read the peer doorbell register, and return the bits that are set. | |
771 | * | |
772 | * This is unusual, and hardware may not support it. | |
773 | * | |
774 | * Return: The bits currently set in the peer doorbell register. | |
775 | */ | |
776 | static inline u64 ntb_peer_db_read(struct ntb_dev *ntb) | |
777 | { | |
778 | if (!ntb->ops->peer_db_read) | |
779 | return 0; | |
780 | ||
781 | return ntb->ops->peer_db_read(ntb); | |
782 | } | |
783 | ||
784 | /** | |
785 | * ntb_peer_db_set() - set bits in the peer doorbell register | |
786 | * @ntb: NTB device context. | |
787 | * @db_bits: Doorbell bits to set. | |
788 | * | |
789 | * Set bits in the peer doorbell register, which may generate a peer doorbell | |
790 | * interrupt. Bits that were already set must remain set. | |
791 | * | |
792 | * Return: Zero on success, otherwise an error number. | |
793 | */ | |
794 | static inline int ntb_peer_db_set(struct ntb_dev *ntb, u64 db_bits) | |
795 | { | |
796 | return ntb->ops->peer_db_set(ntb, db_bits); | |
797 | } | |
798 | ||
799 | /** | |
86663c91 | 800 | * ntb_peer_db_clear() - clear bits in the peer doorbell register |
a1bd3bae AH |
801 | * @ntb: NTB device context. |
802 | * @db_bits: Doorbell bits to clear. | |
803 | * | |
804 | * Clear bits in the peer doorbell register, arming the bits for the next | |
805 | * doorbell. | |
806 | * | |
807 | * This is unusual, and hardware may not support it. | |
808 | * | |
809 | * Return: Zero on success, otherwise an error number. | |
810 | */ | |
811 | static inline int ntb_peer_db_clear(struct ntb_dev *ntb, u64 db_bits) | |
812 | { | |
813 | if (!ntb->ops->db_clear) | |
814 | return -EINVAL; | |
815 | ||
816 | return ntb->ops->peer_db_clear(ntb, db_bits); | |
817 | } | |
818 | ||
819 | /** | |
820 | * ntb_peer_db_read_mask() - read the peer doorbell mask | |
821 | * @ntb: NTB device context. | |
822 | * | |
823 | * Read the peer doorbell mask register, and return the bits that are set. | |
824 | * | |
825 | * This is unusual, and hardware may not support it. | |
826 | * | |
827 | * Return: The bits currently set in the peer doorbell mask register. | |
828 | */ | |
829 | static inline u64 ntb_peer_db_read_mask(struct ntb_dev *ntb) | |
830 | { | |
831 | if (!ntb->ops->db_read_mask) | |
832 | return 0; | |
833 | ||
834 | return ntb->ops->peer_db_read_mask(ntb); | |
835 | } | |
836 | ||
837 | /** | |
838 | * ntb_peer_db_set_mask() - set bits in the peer doorbell mask | |
839 | * @ntb: NTB device context. | |
840 | * @db_bits: Doorbell mask bits to set. | |
841 | * | |
842 | * Set bits in the peer doorbell mask register, preventing doorbell interrupts | |
843 | * from being generated for those doorbell bits. Bits that were already set | |
844 | * must remain set. | |
845 | * | |
846 | * This is unusual, and hardware may not support it. | |
847 | * | |
848 | * Return: Zero on success, otherwise an error number. | |
849 | */ | |
850 | static inline int ntb_peer_db_set_mask(struct ntb_dev *ntb, u64 db_bits) | |
851 | { | |
852 | if (!ntb->ops->db_set_mask) | |
853 | return -EINVAL; | |
854 | ||
855 | return ntb->ops->peer_db_set_mask(ntb, db_bits); | |
856 | } | |
857 | ||
858 | /** | |
859 | * ntb_peer_db_clear_mask() - clear bits in the peer doorbell mask | |
860 | * @ntb: NTB device context. | |
861 | * @db_bits: Doorbell bits to clear. | |
862 | * | |
863 | * Clear bits in the peer doorbell mask register, allowing doorbell interrupts | |
864 | * from being generated for those doorbell bits. If the hardware does not | |
865 | * generate the interrupt on clearing the mask bit, then the driver should not | |
866 | * implement this function! | |
867 | * | |
868 | * This is unusual, and hardware may not support it. | |
869 | * | |
870 | * Return: Zero on success, otherwise an error number. | |
871 | */ | |
872 | static inline int ntb_peer_db_clear_mask(struct ntb_dev *ntb, u64 db_bits) | |
873 | { | |
874 | if (!ntb->ops->db_clear_mask) | |
875 | return -EINVAL; | |
876 | ||
877 | return ntb->ops->peer_db_clear_mask(ntb, db_bits); | |
878 | } | |
879 | ||
880 | /** | |
881 | * ntb_spad_is_unsafe() - check if it is safe to use the hardware scratchpads | |
882 | * @ntb: NTB device context. | |
883 | * | |
884 | * It is possible for some ntb hardware to be affected by errata. Hardware | |
885 | * drivers can advise clients to avoid using scratchpads. Clients may ignore | |
886 | * this advice, though caution is recommended. | |
887 | * | |
888 | * Return: Zero if it is safe to use scratchpads, or One if it is not safe. | |
889 | */ | |
890 | static inline int ntb_spad_is_unsafe(struct ntb_dev *ntb) | |
891 | { | |
892 | if (!ntb->ops->spad_is_unsafe) | |
893 | return 0; | |
894 | ||
895 | return ntb->ops->spad_is_unsafe(ntb); | |
896 | } | |
897 | ||
898 | /** | |
899 | * ntb_mw_count() - get the number of scratchpads | |
900 | * @ntb: NTB device context. | |
901 | * | |
902 | * Hardware and topology may support a different number of scratchpads. | |
903 | * | |
904 | * Return: the number of scratchpads. | |
905 | */ | |
906 | static inline int ntb_spad_count(struct ntb_dev *ntb) | |
907 | { | |
908 | return ntb->ops->spad_count(ntb); | |
909 | } | |
910 | ||
911 | /** | |
912 | * ntb_spad_read() - read the local scratchpad register | |
913 | * @ntb: NTB device context. | |
914 | * @idx: Scratchpad index. | |
915 | * | |
916 | * Read the local scratchpad register, and return the value. | |
917 | * | |
918 | * Return: The value of the local scratchpad register. | |
919 | */ | |
920 | static inline u32 ntb_spad_read(struct ntb_dev *ntb, int idx) | |
921 | { | |
922 | return ntb->ops->spad_read(ntb, idx); | |
923 | } | |
924 | ||
925 | /** | |
926 | * ntb_spad_write() - write the local scratchpad register | |
927 | * @ntb: NTB device context. | |
928 | * @idx: Scratchpad index. | |
929 | * @val: Scratchpad value. | |
930 | * | |
931 | * Write the value to the local scratchpad register. | |
932 | * | |
933 | * Return: Zero on success, otherwise an error number. | |
934 | */ | |
935 | static inline int ntb_spad_write(struct ntb_dev *ntb, int idx, u32 val) | |
936 | { | |
937 | return ntb->ops->spad_write(ntb, idx, val); | |
938 | } | |
939 | ||
940 | /** | |
941 | * ntb_peer_spad_addr() - address of the peer scratchpad register | |
942 | * @ntb: NTB device context. | |
943 | * @idx: Scratchpad index. | |
944 | * @spad_addr: OUT - The address of the peer scratchpad register. | |
945 | * | |
946 | * Return the address of the peer doorbell register. This may be used, for | |
947 | * example, by drivers that offload memory copy operations to a dma engine. | |
948 | * | |
949 | * Return: Zero on success, otherwise an error number. | |
950 | */ | |
951 | static inline int ntb_peer_spad_addr(struct ntb_dev *ntb, int idx, | |
952 | phys_addr_t *spad_addr) | |
953 | { | |
afc54992 AH |
954 | if (!ntb->ops->peer_spad_addr) |
955 | return -EINVAL; | |
956 | ||
a1bd3bae AH |
957 | return ntb->ops->peer_spad_addr(ntb, idx, spad_addr); |
958 | } | |
959 | ||
960 | /** | |
961 | * ntb_peer_spad_read() - read the peer scratchpad register | |
962 | * @ntb: NTB device context. | |
963 | * @idx: Scratchpad index. | |
964 | * | |
965 | * Read the peer scratchpad register, and return the value. | |
966 | * | |
967 | * Return: The value of the local scratchpad register. | |
968 | */ | |
969 | static inline u32 ntb_peer_spad_read(struct ntb_dev *ntb, int idx) | |
970 | { | |
971 | return ntb->ops->peer_spad_read(ntb, idx); | |
972 | } | |
973 | ||
974 | /** | |
975 | * ntb_peer_spad_write() - write the peer scratchpad register | |
976 | * @ntb: NTB device context. | |
977 | * @idx: Scratchpad index. | |
978 | * @val: Scratchpad value. | |
979 | * | |
980 | * Write the value to the peer scratchpad register. | |
981 | * | |
982 | * Return: Zero on success, otherwise an error number. | |
983 | */ | |
984 | static inline int ntb_peer_spad_write(struct ntb_dev *ntb, int idx, u32 val) | |
985 | { | |
986 | return ntb->ops->peer_spad_write(ntb, idx, val); | |
987 | } | |
988 | ||
989 | #endif |