drivers/staging/comedi/drivers/ni_routes.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /* vim: set ts=8 sw=8 noet tw=80 nowrap: */
   3 /*
   4  *  comedi/drivers/ni_routes.h
   5  *  Route information for NI boards.
   6  *
   7  *  COMEDI - Linux Control and Measurement Device Interface
   8  *  Copyright (C) 2016 Spencer E. Olson <olsonse@umich.edu>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  */
  20
  21 #ifndef _COMEDI_DRIVERS_NI_ROUTES_H
  22 #define _COMEDI_DRIVERS_NI_ROUTES_H
  23
  24 #include <linux/types.h>
  25 #include <linux/errno.h>
  26
  27 #ifndef NI_ROUTE_VALUE_EXTERNAL_CONVERSION
  28 #include <linux/bitops.h>
  29 #endif
  30
  31 #include "../comedi.h"
  32
  33 /**
  34  * struct ni_route_set - Set of destinations with a common source.
  35  * @dest: Destination of all sources in this route set.
  36  * @n_src: Number of sources for this route set.
  37  * @src: List of sources that all map to the same destination.
  38  */
  39 struct ni_route_set {
  40         int dest;
  41         int n_src;
  42         int *src;
  43 };
  44
  45 /**
  46  * struct ni_device_routes - List of all src->dest sets for a particular device.
  47  * @device: Name of board/device (e.g. pxi-6733).
  48  * @n_route_sets: Number of route sets that are valid for this device.
  49  * @routes: List of route sets that are valid for this device.
  50  */
  51 struct ni_device_routes {
  52         const char *device;
  53         int n_route_sets;
  54         struct ni_route_set *routes;
  55 };
  56
  57 /**
  58  * struct ni_route_tables - Register values and valid routes for a device.
  59  * @valid_routes: Pointer to a all valid route sets for a single device.
  60  * @route_values: Pointer to register values for all routes for the family to
  61  *                which the device belongs.
  62  *
  63  * Link to the valid src->dest routes and the register values used to assign
  64  * such routes for that particular device.
  65  */
  66 struct ni_route_tables {
  67         const struct ni_device_routes *valid_routes;
  68         const u8 *route_values;
  69 };
  70
  71 /*
  72  * ni_assign_device_routes() - Assign the proper lookup table for NI signal
  73  *                             routing to the specified NI device.
  74  *
  75  * Return: -ENODATA if assignment was not successful; 0 if successful.
  76  */
  77 int ni_assign_device_routes(const char *device_family,
  78                             const char *board_name,
  79                             const char *alt_board_name,
  80                             struct ni_route_tables *tables);
  81
  82 /*
  83  * ni_find_route_set() - Finds the proper route set with the specified
  84  *                       destination.
  85  * @destination: Destination of which to search for the route set.
  86  * @valid_routes: Pointer to device routes within which to search.
  87  *
  88  * Return: NULL if no route_set is found with the specified @destination;
  89  *      otherwise, a pointer to the route_set if found.
  90  */
  91 const struct ni_route_set *
  92 ni_find_route_set(const int destination,
  93                   const struct ni_device_routes *valid_routes);
  94
  95 /*
  96  * ni_route_set_has_source() - Determines whether the given source is in
  97  *                             included given route_set.
  98  *
  99  * Return: true if found; false otherwise.
 100  */
 101 bool ni_route_set_has_source(const struct ni_route_set *routes, const int src);
 102
 103 /*
 104  * ni_route_to_register() - Validates and converts the specified signal route
 105  *                          (src-->dest) to the value used at the appropriate
 106  *                          register.
 107  * @src:        global-identifier for route source
 108  * @dest:       global-identifier for route destination
 109  * @tables:     pointer to relevant set of routing tables.
 110  *
 111  * Generally speaking, most routes require the first six bits and a few require
 112  * 7 bits.  Special handling is given for the return value when the route is to
 113  * be handled by the RTSI sub-device.  In this case, the returned register may
 114  * not be sufficient to define the entire route path, but rather may only
 115  * indicate the intermediate route.  For example, if the route must go through
 116  * the RGOUT0 pin, the (src->RGOUT0) register value will be returned.
 117  * Similarly, if the route must go through the NI_RTSI_BRD lines, the BIT(6)
 118  * will be set:
 119  *
 120  * if route does not need RTSI_BRD lines:
 121  *   bits 0:7 : register value
 122  *              for a route that must go through RGOUT0 pin, this will be equal
 123  *              to the (src->RGOUT0) register value.
 124  * else: * route is (src->RTSI_BRD(x), RTSI_BRD(x)->TRIGGER_LINE(i)) *
 125  *   bits 0:5 : zero
 126  *   bits 6   : set to 1
 127  *   bits 7:7 : zero
 128  *
 129  * Return: register value to be used for source at destination with special
 130  *      cases given above; Otherwise, -1 if the specified route is not valid for
 131  *      this particular device.
 132  */
 133 s8 ni_route_to_register(const int src, const int dest,
 134                         const struct ni_route_tables *tables);
 135
 136 static inline bool ni_rtsi_route_requires_mux(s8 value)
 137 {
 138         return value & BIT(6);
 139 }
 140
 141 /*
 142  * ni_lookup_route_register() - Look up a register value for a particular route
 143  *                              without checking whether the route is valid for
 144  *                              the particular device.
 145  * @src:        global-identifier for route source
 146  * @dest:       global-identifier for route destination
 147  * @tables:     pointer to relevant set of routing tables.
 148  *
 149  * Return: -EINVAL if the specified route is not valid for this device family.
 150  */
 151 s8 ni_lookup_route_register(int src, int dest,
 152                             const struct ni_route_tables *tables);
 153
 154 /**
 155  * route_is_valid() - Determines whether the specified signal route (src-->dest)
 156  *                    is valid for the given NI comedi_device.
 157  * @src:        global-identifier for route source
 158  * @dest:       global-identifier for route destination
 159  * @tables:     pointer to relevant set of routing tables.
 160  *
 161  * Return: True if the route is valid, otherwise false.
 162  */
 163 static inline bool route_is_valid(const int src, const int dest,
 164                                   const struct ni_route_tables *tables)
 165 {
 166         return ni_route_to_register(src, dest, tables) >= 0;
 167 }
 168
 169 /*
 170  * ni_is_cmd_dest() - Determine whether the given destination is only
 171  *                    configurable via a comedi_cmd struct.
 172  * @dest: Destination to test.
 173  */
 174 bool ni_is_cmd_dest(int dest);
 175
 176 static inline bool channel_is_pfi(int channel)
 177 {
 178         return NI_PFI(0) <= channel && channel <= NI_PFI(-1);
 179 }
 180
 181 static inline bool channel_is_rtsi(int channel)
 182 {
 183         return TRIGGER_LINE(0) <= channel && channel <= TRIGGER_LINE(-1);
 184 }
 185
 186 static inline bool channel_is_ctr(int channel)
 187 {
 188         return channel >= NI_COUNTER_NAMES_BASE &&
 189                channel <= NI_COUNTER_NAMES_MAX;
 190 }
 191
 192 /*
 193  * ni_count_valid_routes() - Count the number of valid routes.
 194  * @tables: Routing tables for which to count all valid routes.
 195  */
 196 unsigned int ni_count_valid_routes(const struct ni_route_tables *tables);
 197
 198 /*
 199  * ni_get_valid_routes() - Implements INSN_DEVICE_CONFIG_GET_ROUTES.
 200  * @tables:     pointer to relevant set of routing tables.
 201  * @n_pairs:    Number of pairs for which memory is allocated by the user.  If
 202  *              the user specifies '0', only the number of available pairs is
 203  *              returned.
 204  * @pair_data:  Pointer to memory allocated to return pairs back to user.  Each
 205  *              even, odd indexed member of this array will hold source,
 206  *              destination of a route pair respectively.
 207  *
 208  * Return: the number of valid routes if n_pairs == 0; otherwise, the number of
 209  *      valid routes copied.
 210  */
 211 unsigned int ni_get_valid_routes(const struct ni_route_tables *tables,
 212                                  unsigned int n_pairs,
 213                                  unsigned int *pair_data);
 214
 215 /*
 216  * ni_sort_device_routes() - Sort the list of valid device signal routes in
 217  *                           preparation for use.
 218  * @valid_routes:       pointer to ni_device_routes struct to sort.
 219  */
 220 void ni_sort_device_routes(struct ni_device_routes *valid_routes);
 221
 222 /*
 223  * ni_find_route_source() - Finds the signal source corresponding to a signal
 224  *                          route (src-->dest) of the specified routing register
 225  *                          value and the specified route destination on the
 226  *                          specified device.
 227  *
 228  * Note that this function does _not_ validate the source based on device
 229  * routes.
 230  *
 231  * Return: The NI signal value (e.g. NI_PFI(0) or PXI_Clk10) if found.
 232  *      If the source was not found (i.e. the register value is not
 233  *      valid for any routes to the destination), -EINVAL is returned.
 234  */
 235 int ni_find_route_source(const u8 src_sel_reg_value, const int dest,
 236                          const struct ni_route_tables *tables);
 237
 238 /**
 239  * route_register_is_valid() - Determines whether the register value for the
 240  *                             specified route destination on the specified
 241  *                             device is valid.
 242  */
 243 static inline bool route_register_is_valid(const u8 src_sel_reg_value,
 244                                            const int dest,
 245                                            const struct ni_route_tables *tables)
 246 {
 247         return ni_find_route_source(src_sel_reg_value, dest, tables) >= 0;
 248 }
 249
 250 /**
 251  * ni_get_reg_value_roffs() - Determines the proper register value for a
 252  *                            particular valid NI signal/terminal route.
 253  * @src:        Either a direct register value or one of NI_* signal names.
 254  * @dest:       global-identifier for route destination
 255  * @tables:     pointer to relevant set of routing tables.
 256  * @direct_reg_offset:
 257  *              Compatibility compensation argument.  This argument allows us to
 258  *              arbitrarily apply an offset to src if src is a direct register
 259  *              value reference.  This is necessary to be compatible with
 260  *              definitions of register values as previously exported directly
 261  *              to user space.
 262  *
 263  * Return: the register value (>0) to be used at the destination if the src is
 264  *      valid for the given destination; -1 otherwise.
 265  */
 266 static inline s8 ni_get_reg_value_roffs(int src, const int dest,
 267                                         const struct ni_route_tables *tables,
 268                                         const int direct_reg_offset)
 269 {
 270         if (src < NI_NAMES_BASE) {
 271                 src += direct_reg_offset;
 272                 /*
 273                  * In this case, the src is expected to actually be a register
 274                  * value.
 275                  */
 276                 if (route_register_is_valid(src, dest, tables))
 277                         return src;
 278                 return -1;
 279         }
 280
 281         /*
 282          * Otherwise, the src is expected to be one of the abstracted NI
 283          * signal/terminal names.
 284          */
 285         return ni_route_to_register(src, dest, tables);
 286 }
 287
 288 static inline int ni_get_reg_value(const int src, const int dest,
 289                                    const struct ni_route_tables *tables)
 290 {
 291         return ni_get_reg_value_roffs(src, dest, tables, 0);
 292 }
 293
 294 /**
 295  * ni_check_trigger_arg_roffs() - Checks the trigger argument (*_arg) of an NI
 296  *                                device to ensure that the *_arg value
 297  *                                corresponds to _either_ a valid register value
 298  *                                to define a trigger source, _or_ a valid NI
 299  *                                signal/terminal name that has a valid route to
 300  *                                the destination on the particular device.
 301  * @src:        Either a direct register value or one of NI_* signal names.
 302  * @dest:       global-identifier for route destination
 303  * @tables:     pointer to relevant set of routing tables.
 304  * @direct_reg_offset:
 305  *              Compatibility compensation argument.  This argument allows us to
 306  *              arbitrarily apply an offset to src if src is a direct register
 307  *              value reference.  This is necessary to be compatible with
 308  *              definitions of register values as previously exported directly
 309  *              to user space.
 310  *
 311  * Return: 0 if the src (either register value or NI signal/terminal name) is
 312  *      valid for the destination; -EINVAL otherwise.
 313  */
 314 static inline
 315 int ni_check_trigger_arg_roffs(int src, const int dest,
 316                                const struct ni_route_tables *tables,
 317                                const int direct_reg_offset)
 318 {
 319         if (ni_get_reg_value_roffs(src, dest, tables, direct_reg_offset) < 0)
 320                 return -EINVAL;
 321         return 0;
 322 }
 323
 324 static inline int ni_check_trigger_arg(const int src, const int dest,
 325                                        const struct ni_route_tables *tables)
 326 {
 327         return ni_check_trigger_arg_roffs(src, dest, tables, 0);
 328 }
 329
 330 #endif /* _COMEDI_DRIVERS_NI_ROUTES_H */