1 // SPDX-License-Identifier: GPL-2.0+
3 * comedi/drivers/ni_routes.c
4 * Route information for NI boards.
6 * COMEDI - Linux Control and Measurement Device Interface
7 * Copyright (C) 2016 Spencer E. Olson <olsonse@umich.edu>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
20 #include <linux/module.h>
21 #include <linux/slab.h>
22 #include <linux/bsearch.h>
23 #include <linux/sort.h>
25 #include "../comedi.h"
27 #include "ni_routes.h"
28 #include "ni_routing/ni_route_values.h"
29 #include "ni_routing/ni_device_routes.h"
32 * This is defined in ni_routing/ni_route_values.h:
33 * #define B(x) ((x) - NI_NAMES_BASE)
37 * These are defined in ni_routing/ni_route_values.h to identify clearly
38 * elements of the table that were set. In other words, entries that are zero
39 * are invalid. To get the value to use for the register, one must mask out the
42 * #define V(x) ((x) | 0x80)
44 * #define UNMARK(x) ((x) & (~(0x80)))
48 /* Helper for accessing data. */
49 #define RVi(table, src, dest) ((table)[(dest) * NI_NUM_NAMES + (src)])
52 * Find the route values for a device family.
54 static const u8 *ni_find_route_values(const char *device_family)
59 for (i = 0; ni_all_route_values[i]; ++i) {
60 if (memcmp(ni_all_route_values[i]->family, device_family,
61 strnlen(device_family, 30)) == 0) {
62 rv = &ni_all_route_values[i]->register_values[0][0];
70 * Find the valid routes for a board.
72 static const struct ni_device_routes *
73 ni_find_valid_routes(const char *board_name)
75 const struct ni_device_routes *dr = NULL;
78 for (i = 0; ni_device_routes_list[i]; ++i) {
79 if (memcmp(ni_device_routes_list[i]->device, board_name,
80 strnlen(board_name, 30)) == 0) {
81 dr = ni_device_routes_list[i];
89 * Find the proper route_values and ni_device_routes tables for this particular
90 * device. Possibly try an alternate board name if device routes not found
91 * for the actual board name.
93 * Return: -ENODATA if either was not found; 0 if both were found.
95 static int ni_find_device_routes(const char *device_family,
96 const char *board_name,
97 const char *alt_board_name,
98 struct ni_route_tables *tables)
100 const struct ni_device_routes *dr;
103 /* First, find the register_values table for this device family */
104 rv = ni_find_route_values(device_family);
106 /* Second, find the set of routes valid for this device. */
107 dr = ni_find_valid_routes(board_name);
108 if (!dr && alt_board_name)
109 dr = ni_find_valid_routes(alt_board_name);
111 tables->route_values = rv;
112 tables->valid_routes = dr;
121 * ni_assign_device_routes() - Assign the proper lookup table for NI signal
122 * routing to the specified NI device.
123 * @device_family: Device family name (determines route values).
124 * @board_name: Board name (determines set of routes).
125 * @alt_board_name: Optional alternate board name to try on failure.
126 * @tables: Pointer to assigned routing information.
128 * Finds the route values for the device family and the set of valid routes
129 * for the board. If valid routes could not be found for the actual board
130 * name and an alternate board name has been specified, try that one.
132 * On failure, the assigned routing information may be partially filled
133 * (for example, with the route values but not the set of valid routes).
135 * Return: -ENODATA if assignment was not successful; 0 if successful.
137 int ni_assign_device_routes(const char *device_family,
138 const char *board_name,
139 const char *alt_board_name,
140 struct ni_route_tables *tables)
142 memset(tables, 0, sizeof(struct ni_route_tables));
143 return ni_find_device_routes(device_family, board_name, alt_board_name,
146 EXPORT_SYMBOL_GPL(ni_assign_device_routes);
149 * ni_count_valid_routes() - Count the number of valid routes.
150 * @tables: Routing tables for which to count all valid routes.
152 unsigned int ni_count_valid_routes(const struct ni_route_tables *tables)
157 for (i = 0; i < tables->valid_routes->n_route_sets; ++i) {
158 const struct ni_route_set *R = &tables->valid_routes->routes[i];
161 for (j = 0; j < R->n_src; ++j) {
162 const int src = R->src[j];
163 const int dest = R->dest;
164 const u8 *rv = tables->route_values;
166 if (RVi(rv, B(src), B(dest)))
167 /* direct routing is valid */
169 else if (channel_is_rtsi(dest) &&
170 (RVi(rv, B(src), B(NI_RGOUT0)) ||
171 RVi(rv, B(src), B(NI_RTSI_BRD(0))) ||
172 RVi(rv, B(src), B(NI_RTSI_BRD(1))) ||
173 RVi(rv, B(src), B(NI_RTSI_BRD(2))) ||
174 RVi(rv, B(src), B(NI_RTSI_BRD(3))))) {
181 EXPORT_SYMBOL_GPL(ni_count_valid_routes);
184 * ni_get_valid_routes() - Implements INSN_DEVICE_CONFIG_GET_ROUTES.
185 * @tables: pointer to relevant set of routing tables.
186 * @n_pairs: Number of pairs for which memory is allocated by the user. If
187 * the user specifies '0', only the number of available pairs is
189 * @pair_data: Pointer to memory allocated to return pairs back to user. Each
190 * even, odd indexed member of this array will hold source,
191 * destination of a route pair respectively.
193 * Return: the number of valid routes if n_pairs == 0; otherwise, the number of
194 * valid routes copied.
196 unsigned int ni_get_valid_routes(const struct ni_route_tables *tables,
197 unsigned int n_pairs,
198 unsigned int *pair_data)
200 unsigned int n_valid = ni_count_valid_routes(tables);
203 if (n_pairs == 0 || n_valid == 0)
211 for (i = 0; i < tables->valid_routes->n_route_sets; ++i) {
212 const struct ni_route_set *R = &tables->valid_routes->routes[i];
215 for (j = 0; j < R->n_src; ++j) {
216 const int src = R->src[j];
217 const int dest = R->dest;
219 const u8 *rv = tables->route_values;
221 if (RVi(rv, B(src), B(dest)))
222 /* direct routing is valid */
224 else if (channel_is_rtsi(dest) &&
225 (RVi(rv, B(src), B(NI_RGOUT0)) ||
226 RVi(rv, B(src), B(NI_RTSI_BRD(0))) ||
227 RVi(rv, B(src), B(NI_RTSI_BRD(1))) ||
228 RVi(rv, B(src), B(NI_RTSI_BRD(2))) ||
229 RVi(rv, B(src), B(NI_RTSI_BRD(3))))) {
230 /* indirect routing also valid */
235 pair_data[2 * n_valid] = src;
236 pair_data[2 * n_valid + 1] = dest;
240 if (n_valid >= n_pairs)
246 EXPORT_SYMBOL_GPL(ni_get_valid_routes);
249 * List of NI global signal names that, as destinations, are only routeable
250 * indirectly through the *_arg elements of the comedi_cmd structure.
252 static const int NI_CMD_DESTS[] = {
263 * ni_is_cmd_dest() - Determine whether the given destination is only
264 * configurable via a comedi_cmd struct.
265 * @dest: Destination to test.
267 bool ni_is_cmd_dest(int dest)
271 for (i = 0; i < ARRAY_SIZE(NI_CMD_DESTS); ++i)
272 if (NI_CMD_DESTS[i] == dest)
276 EXPORT_SYMBOL_GPL(ni_is_cmd_dest);
278 /* **** BEGIN Routes sort routines **** */
279 static int _ni_sort_destcmp(const void *va, const void *vb)
281 const struct ni_route_set *a = va;
282 const struct ni_route_set *b = vb;
284 if (a->dest < b->dest)
286 else if (a->dest > b->dest)
291 static int _ni_sort_srccmp(const void *vsrc0, const void *vsrc1)
293 const int *src0 = vsrc0;
294 const int *src1 = vsrc1;
298 else if (*src0 > *src1)
304 * ni_sort_device_routes() - Sort the list of valid device signal routes in
305 * preparation for use.
306 * @valid_routes: pointer to ni_device_routes struct to sort.
308 void ni_sort_device_routes(struct ni_device_routes *valid_routes)
312 /* 1. Count and set the number of ni_route_set objects. */
313 valid_routes->n_route_sets = 0;
314 while (valid_routes->routes[valid_routes->n_route_sets].dest != 0)
315 ++valid_routes->n_route_sets;
317 /* 2. sort all ni_route_set objects by destination. */
318 sort(valid_routes->routes, valid_routes->n_route_sets,
319 sizeof(struct ni_route_set), _ni_sort_destcmp, NULL);
321 /* 3. Loop through each route_set for sorting. */
322 for (n = 0; n < valid_routes->n_route_sets; ++n) {
323 struct ni_route_set *rs = &valid_routes->routes[n];
325 /* 3a. Count and set the number of sources. */
327 while (rs->src[rs->n_src])
330 /* 3a. Sort sources. */
331 sort(valid_routes->routes[n].src, valid_routes->routes[n].n_src,
332 sizeof(int), _ni_sort_srccmp, NULL);
335 EXPORT_SYMBOL_GPL(ni_sort_device_routes);
337 /* sort all valid device signal routes in prep for use */
338 static void ni_sort_all_device_routes(void)
342 for (i = 0; ni_device_routes_list[i]; ++i)
343 ni_sort_device_routes(ni_device_routes_list[i]);
346 /* **** BEGIN Routes search routines **** */
347 static int _ni_bsearch_destcmp(const void *vkey, const void *velt)
349 const int *key = vkey;
350 const struct ni_route_set *elt = velt;
352 if (*key < elt->dest)
354 else if (*key > elt->dest)
359 static int _ni_bsearch_srccmp(const void *vkey, const void *velt)
361 const int *key = vkey;
362 const int *elt = velt;
366 else if (*key > *elt)
372 * ni_find_route_set() - Finds the proper route set with the specified
374 * @destination: Destination of which to search for the route set.
375 * @valid_routes: Pointer to device routes within which to search.
377 * Return: NULL if no route_set is found with the specified @destination;
378 * otherwise, a pointer to the route_set if found.
380 const struct ni_route_set *
381 ni_find_route_set(const int destination,
382 const struct ni_device_routes *valid_routes)
384 return bsearch(&destination, valid_routes->routes,
385 valid_routes->n_route_sets, sizeof(struct ni_route_set),
386 _ni_bsearch_destcmp);
388 EXPORT_SYMBOL_GPL(ni_find_route_set);
391 * ni_route_set_has_source() - Determines whether the given source is in
392 * included given route_set.
394 * Return: true if found; false otherwise.
396 bool ni_route_set_has_source(const struct ni_route_set *routes,
399 if (!bsearch(&source, routes->src, routes->n_src, sizeof(int),
404 EXPORT_SYMBOL_GPL(ni_route_set_has_source);
407 * ni_lookup_route_register() - Look up a register value for a particular route
408 * without checking whether the route is valid for
409 * the particular device.
410 * @src: global-identifier for route source
411 * @dest: global-identifier for route destination
412 * @tables: pointer to relevant set of routing tables.
414 * Return: -EINVAL if the specified route is not valid for this device family.
416 s8 ni_lookup_route_register(int src, int dest,
417 const struct ni_route_tables *tables)
422 * Be sure to use the B() macro to subtract off the NI_NAMES_BASE before
423 * indexing into the route_values array.
427 if (src < 0 || src >= NI_NUM_NAMES || dest < 0 || dest >= NI_NUM_NAMES)
429 regval = RVi(tables->route_values, src, dest);
432 /* mask out the valid-value marking bit */
433 return UNMARK(regval);
435 EXPORT_SYMBOL_GPL(ni_lookup_route_register);
438 * ni_route_to_register() - Validates and converts the specified signal route
439 * (src-->dest) to the value used at the appropriate
441 * @src: global-identifier for route source
442 * @dest: global-identifier for route destination
443 * @tables: pointer to relevant set of routing tables.
445 * Generally speaking, most routes require the first six bits and a few require
446 * 7 bits. Special handling is given for the return value when the route is to
447 * be handled by the RTSI sub-device. In this case, the returned register may
448 * not be sufficient to define the entire route path, but rather may only
449 * indicate the intermediate route. For example, if the route must go through
450 * the RGOUT0 pin, the (src->RGOUT0) register value will be returned.
451 * Similarly, if the route must go through the NI_RTSI_BRD lines, the BIT(6)
454 * if route does not need RTSI_BRD lines:
455 * bits 0:7 : register value
456 * for a route that must go through RGOUT0 pin, this will be equal
457 * to the (src->RGOUT0) register value.
458 * else: * route is (src->RTSI_BRD(x), RTSI_BRD(x)->TRIGGER_LINE(i)) *
463 * Return: register value to be used for source at destination with special
464 * cases given above; Otherwise, -1 if the specified route is not valid for
465 * this particular device.
467 s8 ni_route_to_register(const int src, const int dest,
468 const struct ni_route_tables *tables)
470 const struct ni_route_set *routes =
471 ni_find_route_set(dest, tables->valid_routes);
475 /* first check to see if source is listed with bunch of destinations. */
478 /* 2nd, check to see if destination is in list of source's targets. */
479 if (!ni_route_set_has_source(routes, src))
482 * finally, check to see if we know how to route...
483 * Be sure to use the B() macro to subtract off the NI_NAMES_BASE before
484 * indexing into the route_values array.
486 rv = tables->route_values;
487 regval = RVi(rv, B(src), B(dest));
490 * if we did not validate the route, we'll see if we can route through
493 if (!regval && channel_is_rtsi(dest)) {
494 regval = RVi(rv, B(src), B(NI_RGOUT0));
495 if (!regval && (RVi(rv, B(src), B(NI_RTSI_BRD(0))) ||
496 RVi(rv, B(src), B(NI_RTSI_BRD(1))) ||
497 RVi(rv, B(src), B(NI_RTSI_BRD(2))) ||
498 RVi(rv, B(src), B(NI_RTSI_BRD(3)))))
504 /* mask out the valid-value marking bit */
505 return UNMARK(regval);
507 EXPORT_SYMBOL_GPL(ni_route_to_register);
510 * ni_find_route_source() - Finds the signal source corresponding to a signal
511 * route (src-->dest) of the specified routing register
512 * value and the specified route destination on the
515 * Note that this function does _not_ validate the source based on device
518 * Return: The NI signal value (e.g. NI_PFI(0) or PXI_Clk10) if found.
519 * If the source was not found (i.e. the register value is not
520 * valid for any routes to the destination), -EINVAL is returned.
522 int ni_find_route_source(const u8 src_sel_reg_value, int dest,
523 const struct ni_route_tables *tables)
527 if (!tables->route_values)
530 dest = B(dest); /* subtract NI names offset */
531 /* ensure we are not going to under/over run the route value table */
532 if (dest < 0 || dest >= NI_NUM_NAMES)
534 for (src = 0; src < NI_NUM_NAMES; ++src)
535 if (RVi(tables->route_values, src, dest) ==
536 V(src_sel_reg_value))
537 return src + NI_NAMES_BASE;
540 EXPORT_SYMBOL_GPL(ni_find_route_source);
542 /* **** END Routes search routines **** */
544 /* **** BEGIN simple module entry/exit functions **** */
545 static int __init ni_routes_module_init(void)
547 ni_sort_all_device_routes();
551 static void __exit ni_routes_module_exit(void)
555 module_init(ni_routes_module_init);
556 module_exit(ni_routes_module_exit);
558 MODULE_AUTHOR("Comedi https://www.comedi.org");
559 MODULE_DESCRIPTION("Comedi helper for routing signals-->terminals for NI");
560 MODULE_LICENSE("GPL");
561 /* **** END simple module entry/exit functions **** */