linux/drivers/counter/104-quad-8.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Counter driver for the ACCES 104-QUAD-8
   4 * Copyright (C) 2016 William Breathitt Gray
   5 *
   6 * This driver supports the ACCES 104-QUAD-8 and ACCES 104-QUAD-4.
   7 */
   8#include <linux/bitops.h>
   9#include <linux/counter.h>
  10#include <linux/device.h>
  11#include <linux/errno.h>
  12#include <linux/io.h>
  13#include <linux/ioport.h>
  14#include <linux/isa.h>
  15#include <linux/kernel.h>
  16#include <linux/module.h>
  17#include <linux/moduleparam.h>
  18#include <linux/types.h>
  19
  20#define QUAD8_EXTENT 32
  21
  22static unsigned int base[max_num_isa_dev(QUAD8_EXTENT)];
  23static unsigned int num_quad8;
  24module_param_hw_array(base, uint, ioport, &num_quad8, 0);
  25MODULE_PARM_DESC(base, "ACCES 104-QUAD-8 base addresses");
  26
  27#define QUAD8_NUM_COUNTERS 8
  28
  29/**
  30 * struct quad8 - device private data structure
  31 * @counter:            instance of the counter_device
  32 * @fck_prescaler:      array of filter clock prescaler configurations
  33 * @preset:             array of preset values
  34 * @count_mode:         array of count mode configurations
  35 * @quadrature_mode:    array of quadrature mode configurations
  36 * @quadrature_scale:   array of quadrature mode scale configurations
  37 * @ab_enable:          array of A and B inputs enable configurations
  38 * @preset_enable:      array of set_to_preset_on_index attribute configurations
  39 * @synchronous_mode:   array of index function synchronous mode configurations
  40 * @index_polarity:     array of index function polarity configurations
  41 * @cable_fault_enable: differential encoder cable status enable configurations
  42 * @base:               base port address of the device
  43 */
  44struct quad8 {
  45        struct mutex lock;
  46        struct counter_device counter;
  47        unsigned int fck_prescaler[QUAD8_NUM_COUNTERS];
  48        unsigned int preset[QUAD8_NUM_COUNTERS];
  49        unsigned int count_mode[QUAD8_NUM_COUNTERS];
  50        unsigned int quadrature_mode[QUAD8_NUM_COUNTERS];
  51        unsigned int quadrature_scale[QUAD8_NUM_COUNTERS];
  52        unsigned int ab_enable[QUAD8_NUM_COUNTERS];
  53        unsigned int preset_enable[QUAD8_NUM_COUNTERS];
  54        unsigned int synchronous_mode[QUAD8_NUM_COUNTERS];
  55        unsigned int index_polarity[QUAD8_NUM_COUNTERS];
  56        unsigned int cable_fault_enable;
  57        unsigned int base;
  58};
  59
  60#define QUAD8_REG_CHAN_OP 0x11
  61#define QUAD8_REG_INDEX_INPUT_LEVELS 0x16
  62#define QUAD8_DIFF_ENCODER_CABLE_STATUS 0x17
  63/* Borrow Toggle flip-flop */
  64#define QUAD8_FLAG_BT BIT(0)
  65/* Carry Toggle flip-flop */
  66#define QUAD8_FLAG_CT BIT(1)
  67/* Error flag */
  68#define QUAD8_FLAG_E BIT(4)
  69/* Up/Down flag */
  70#define QUAD8_FLAG_UD BIT(5)
  71/* Reset and Load Signal Decoders */
  72#define QUAD8_CTR_RLD 0x00
  73/* Counter Mode Register */
  74#define QUAD8_CTR_CMR 0x20
  75/* Input / Output Control Register */
  76#define QUAD8_CTR_IOR 0x40
  77/* Index Control Register */
  78#define QUAD8_CTR_IDR 0x60
  79/* Reset Byte Pointer (three byte data pointer) */
  80#define QUAD8_RLD_RESET_BP 0x01
  81/* Reset Counter */
  82#define QUAD8_RLD_RESET_CNTR 0x02
  83/* Reset Borrow Toggle, Carry Toggle, Compare Toggle, and Sign flags */
  84#define QUAD8_RLD_RESET_FLAGS 0x04
  85/* Reset Error flag */
  86#define QUAD8_RLD_RESET_E 0x06
  87/* Preset Register to Counter */
  88#define QUAD8_RLD_PRESET_CNTR 0x08
  89/* Transfer Counter to Output Latch */
  90#define QUAD8_RLD_CNTR_OUT 0x10
  91/* Transfer Preset Register LSB to FCK Prescaler */
  92#define QUAD8_RLD_PRESET_PSC 0x18
  93#define QUAD8_CHAN_OP_ENABLE_COUNTERS 0x00
  94#define QUAD8_CHAN_OP_RESET_COUNTERS 0x01
  95#define QUAD8_CMR_QUADRATURE_X1 0x08
  96#define QUAD8_CMR_QUADRATURE_X2 0x10
  97#define QUAD8_CMR_QUADRATURE_X4 0x18
  98
  99static int quad8_signal_read(struct counter_device *counter,
 100        struct counter_signal *signal, enum counter_signal_value *val)
 101{
 102        const struct quad8 *const priv = counter->priv;
 103        unsigned int state;
 104
 105        /* Only Index signal levels can be read */
 106        if (signal->id < 16)
 107                return -EINVAL;
 108
 109        state = inb(priv->base + QUAD8_REG_INDEX_INPUT_LEVELS)
 110                & BIT(signal->id - 16);
 111
 112        *val = (state) ? COUNTER_SIGNAL_HIGH : COUNTER_SIGNAL_LOW;
 113
 114        return 0;
 115}
 116
 117static int quad8_count_read(struct counter_device *counter,
 118        struct counter_count *count, unsigned long *val)
 119{
 120        struct quad8 *const priv = counter->priv;
 121        const int base_offset = priv->base + 2 * count->id;
 122        unsigned int flags;
 123        unsigned int borrow;
 124        unsigned int carry;
 125        int i;
 126
 127        flags = inb(base_offset + 1);
 128        borrow = flags & QUAD8_FLAG_BT;
 129        carry = !!(flags & QUAD8_FLAG_CT);
 130
 131        /* Borrow XOR Carry effectively doubles count range */
 132        *val = (unsigned long)(borrow ^ carry) << 24;
 133
 134        mutex_lock(&priv->lock);
 135
 136        /* Reset Byte Pointer; transfer Counter to Output Latch */
 137        outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP | QUAD8_RLD_CNTR_OUT,
 138             base_offset + 1);
 139
 140        for (i = 0; i < 3; i++)
 141                *val |= (unsigned long)inb(base_offset) << (8 * i);
 142
 143        mutex_unlock(&priv->lock);
 144
 145        return 0;
 146}
 147
 148static int quad8_count_write(struct counter_device *counter,
 149        struct counter_count *count, unsigned long val)
 150{
 151        struct quad8 *const priv = counter->priv;
 152        const int base_offset = priv->base + 2 * count->id;
 153        int i;
 154
 155        /* Only 24-bit values are supported */
 156        if (val > 0xFFFFFF)
 157                return -EINVAL;
 158
 159        mutex_lock(&priv->lock);
 160
 161        /* Reset Byte Pointer */
 162        outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP, base_offset + 1);
 163
 164        /* Counter can only be set via Preset Register */
 165        for (i = 0; i < 3; i++)
 166                outb(val >> (8 * i), base_offset);
 167
 168        /* Transfer Preset Register to Counter */
 169        outb(QUAD8_CTR_RLD | QUAD8_RLD_PRESET_CNTR, base_offset + 1);
 170
 171        /* Reset Byte Pointer */
 172        outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP, base_offset + 1);
 173
 174        /* Set Preset Register back to original value */
 175        val = priv->preset[count->id];
 176        for (i = 0; i < 3; i++)
 177                outb(val >> (8 * i), base_offset);
 178
 179        /* Reset Borrow, Carry, Compare, and Sign flags */
 180        outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_FLAGS, base_offset + 1);
 181        /* Reset Error flag */
 182        outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_E, base_offset + 1);
 183
 184        mutex_unlock(&priv->lock);
 185
 186        return 0;
 187}
 188
 189enum quad8_count_function {
 190        QUAD8_COUNT_FUNCTION_PULSE_DIRECTION = 0,
 191        QUAD8_COUNT_FUNCTION_QUADRATURE_X1,
 192        QUAD8_COUNT_FUNCTION_QUADRATURE_X2,
 193        QUAD8_COUNT_FUNCTION_QUADRATURE_X4
 194};
 195
 196static const enum counter_count_function quad8_count_functions_list[] = {
 197        [QUAD8_COUNT_FUNCTION_PULSE_DIRECTION] = COUNTER_COUNT_FUNCTION_PULSE_DIRECTION,
 198        [QUAD8_COUNT_FUNCTION_QUADRATURE_X1] = COUNTER_COUNT_FUNCTION_QUADRATURE_X1_A,
 199        [QUAD8_COUNT_FUNCTION_QUADRATURE_X2] = COUNTER_COUNT_FUNCTION_QUADRATURE_X2_A,
 200        [QUAD8_COUNT_FUNCTION_QUADRATURE_X4] = COUNTER_COUNT_FUNCTION_QUADRATURE_X4
 201};
 202
 203static int quad8_function_get(struct counter_device *counter,
 204        struct counter_count *count, size_t *function)
 205{
 206        struct quad8 *const priv = counter->priv;
 207        const int id = count->id;
 208
 209        mutex_lock(&priv->lock);
 210
 211        if (priv->quadrature_mode[id])
 212                switch (priv->quadrature_scale[id]) {
 213                case 0:
 214                        *function = QUAD8_COUNT_FUNCTION_QUADRATURE_X1;
 215                        break;
 216                case 1:
 217                        *function = QUAD8_COUNT_FUNCTION_QUADRATURE_X2;
 218                        break;
 219                case 2:
 220                        *function = QUAD8_COUNT_FUNCTION_QUADRATURE_X4;
 221                        break;
 222                }
 223        else
 224                *function = QUAD8_COUNT_FUNCTION_PULSE_DIRECTION;
 225
 226        mutex_unlock(&priv->lock);
 227
 228        return 0;
 229}
 230
 231static int quad8_function_set(struct counter_device *counter,
 232        struct counter_count *count, size_t function)
 233{
 234        struct quad8 *const priv = counter->priv;
 235        const int id = count->id;
 236        unsigned int *const quadrature_mode = priv->quadrature_mode + id;
 237        unsigned int *const scale = priv->quadrature_scale + id;
 238        unsigned int *const synchronous_mode = priv->synchronous_mode + id;
 239        const int base_offset = priv->base + 2 * id + 1;
 240        unsigned int mode_cfg;
 241        unsigned int idr_cfg;
 242
 243        mutex_lock(&priv->lock);
 244
 245        mode_cfg = priv->count_mode[id] << 1;
 246        idr_cfg = priv->index_polarity[id] << 1;
 247
 248        if (function == QUAD8_COUNT_FUNCTION_PULSE_DIRECTION) {
 249                *quadrature_mode = 0;
 250
 251                /* Quadrature scaling only available in quadrature mode */
 252                *scale = 0;
 253
 254                /* Synchronous function not supported in non-quadrature mode */
 255                if (*synchronous_mode) {
 256                        *synchronous_mode = 0;
 257                        /* Disable synchronous function mode */
 258                        outb(QUAD8_CTR_IDR | idr_cfg, base_offset);
 259                }
 260        } else {
 261                *quadrature_mode = 1;
 262
 263                switch (function) {
 264                case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
 265                        *scale = 0;
 266                        mode_cfg |= QUAD8_CMR_QUADRATURE_X1;
 267                        break;
 268                case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
 269                        *scale = 1;
 270                        mode_cfg |= QUAD8_CMR_QUADRATURE_X2;
 271                        break;
 272                case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
 273                        *scale = 2;
 274                        mode_cfg |= QUAD8_CMR_QUADRATURE_X4;
 275                        break;
 276                }
 277        }
 278
 279        /* Load mode configuration to Counter Mode Register */
 280        outb(QUAD8_CTR_CMR | mode_cfg, base_offset);
 281
 282        mutex_unlock(&priv->lock);
 283
 284        return 0;
 285}
 286
 287static void quad8_direction_get(struct counter_device *counter,
 288        struct counter_count *count, enum counter_count_direction *direction)
 289{
 290        const struct quad8 *const priv = counter->priv;
 291        unsigned int ud_flag;
 292        const unsigned int flag_addr = priv->base + 2 * count->id + 1;
 293
 294        /* U/D flag: nonzero = up, zero = down */
 295        ud_flag = inb(flag_addr) & QUAD8_FLAG_UD;
 296
 297        *direction = (ud_flag) ? COUNTER_COUNT_DIRECTION_FORWARD :
 298                COUNTER_COUNT_DIRECTION_BACKWARD;
 299}
 300
 301enum quad8_synapse_action {
 302        QUAD8_SYNAPSE_ACTION_NONE = 0,
 303        QUAD8_SYNAPSE_ACTION_RISING_EDGE,
 304        QUAD8_SYNAPSE_ACTION_FALLING_EDGE,
 305        QUAD8_SYNAPSE_ACTION_BOTH_EDGES
 306};
 307
 308static const enum counter_synapse_action quad8_index_actions_list[] = {
 309        [QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
 310        [QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE
 311};
 312
 313static const enum counter_synapse_action quad8_synapse_actions_list[] = {
 314        [QUAD8_SYNAPSE_ACTION_NONE] = COUNTER_SYNAPSE_ACTION_NONE,
 315        [QUAD8_SYNAPSE_ACTION_RISING_EDGE] = COUNTER_SYNAPSE_ACTION_RISING_EDGE,
 316        [QUAD8_SYNAPSE_ACTION_FALLING_EDGE] = COUNTER_SYNAPSE_ACTION_FALLING_EDGE,
 317        [QUAD8_SYNAPSE_ACTION_BOTH_EDGES] = COUNTER_SYNAPSE_ACTION_BOTH_EDGES
 318};
 319
 320static int quad8_action_get(struct counter_device *counter,
 321        struct counter_count *count, struct counter_synapse *synapse,
 322        size_t *action)
 323{
 324        struct quad8 *const priv = counter->priv;
 325        int err;
 326        size_t function = 0;
 327        const size_t signal_a_id = count->synapses[0].signal->id;
 328        enum counter_count_direction direction;
 329
 330        /* Handle Index signals */
 331        if (synapse->signal->id >= 16) {
 332                if (priv->preset_enable[count->id])
 333                        *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
 334                else
 335                        *action = QUAD8_SYNAPSE_ACTION_NONE;
 336
 337                return 0;
 338        }
 339
 340        err = quad8_function_get(counter, count, &function);
 341        if (err)
 342                return err;
 343
 344        /* Default action mode */
 345        *action = QUAD8_SYNAPSE_ACTION_NONE;
 346
 347        /* Determine action mode based on current count function mode */
 348        switch (function) {
 349        case QUAD8_COUNT_FUNCTION_PULSE_DIRECTION:
 350                if (synapse->signal->id == signal_a_id)
 351                        *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
 352                break;
 353        case QUAD8_COUNT_FUNCTION_QUADRATURE_X1:
 354                if (synapse->signal->id == signal_a_id) {
 355                        quad8_direction_get(counter, count, &direction);
 356
 357                        if (direction == COUNTER_COUNT_DIRECTION_FORWARD)
 358                                *action = QUAD8_SYNAPSE_ACTION_RISING_EDGE;
 359                        else
 360                                *action = QUAD8_SYNAPSE_ACTION_FALLING_EDGE;
 361                }
 362                break;
 363        case QUAD8_COUNT_FUNCTION_QUADRATURE_X2:
 364                if (synapse->signal->id == signal_a_id)
 365                        *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
 366                break;
 367        case QUAD8_COUNT_FUNCTION_QUADRATURE_X4:
 368                *action = QUAD8_SYNAPSE_ACTION_BOTH_EDGES;
 369                break;
 370        }
 371
 372        return 0;
 373}
 374
 375static const struct counter_ops quad8_ops = {
 376        .signal_read = quad8_signal_read,
 377        .count_read = quad8_count_read,
 378        .count_write = quad8_count_write,
 379        .function_get = quad8_function_get,
 380        .function_set = quad8_function_set,
 381        .action_get = quad8_action_get
 382};
 383
 384static const char *const quad8_index_polarity_modes[] = {
 385        "negative",
 386        "positive"
 387};
 388
 389static int quad8_index_polarity_get(struct counter_device *counter,
 390        struct counter_signal *signal, size_t *index_polarity)
 391{
 392        const struct quad8 *const priv = counter->priv;
 393        const size_t channel_id = signal->id - 16;
 394
 395        *index_polarity = priv->index_polarity[channel_id];
 396
 397        return 0;
 398}
 399
 400static int quad8_index_polarity_set(struct counter_device *counter,
 401        struct counter_signal *signal, size_t index_polarity)
 402{
 403        struct quad8 *const priv = counter->priv;
 404        const size_t channel_id = signal->id - 16;
 405        const int base_offset = priv->base + 2 * channel_id + 1;
 406        unsigned int idr_cfg = index_polarity << 1;
 407
 408        mutex_lock(&priv->lock);
 409
 410        idr_cfg |= priv->synchronous_mode[channel_id];
 411
 412        priv->index_polarity[channel_id] = index_polarity;
 413
 414        /* Load Index Control configuration to Index Control Register */
 415        outb(QUAD8_CTR_IDR | idr_cfg, base_offset);
 416
 417        mutex_unlock(&priv->lock);
 418
 419        return 0;
 420}
 421
 422static struct counter_signal_enum_ext quad8_index_pol_enum = {
 423        .items = quad8_index_polarity_modes,
 424        .num_items = ARRAY_SIZE(quad8_index_polarity_modes),
 425        .get = quad8_index_polarity_get,
 426        .set = quad8_index_polarity_set
 427};
 428
 429static const char *const quad8_synchronous_modes[] = {
 430        "non-synchronous",
 431        "synchronous"
 432};
 433
 434static int quad8_synchronous_mode_get(struct counter_device *counter,
 435        struct counter_signal *signal, size_t *synchronous_mode)
 436{
 437        const struct quad8 *const priv = counter->priv;
 438        const size_t channel_id = signal->id - 16;
 439
 440        *synchronous_mode = priv->synchronous_mode[channel_id];
 441
 442        return 0;
 443}
 444
 445static int quad8_synchronous_mode_set(struct counter_device *counter,
 446        struct counter_signal *signal, size_t synchronous_mode)
 447{
 448        struct quad8 *const priv = counter->priv;
 449        const size_t channel_id = signal->id - 16;
 450        const int base_offset = priv->base + 2 * channel_id + 1;
 451        unsigned int idr_cfg = synchronous_mode;
 452
 453        mutex_lock(&priv->lock);
 454
 455        idr_cfg |= priv->index_polarity[channel_id] << 1;
 456
 457        /* Index function must be non-synchronous in non-quadrature mode */
 458        if (synchronous_mode && !priv->quadrature_mode[channel_id]) {
 459                mutex_unlock(&priv->lock);
 460                return -EINVAL;
 461        }
 462
 463        priv->synchronous_mode[channel_id] = synchronous_mode;
 464
 465        /* Load Index Control configuration to Index Control Register */
 466        outb(QUAD8_CTR_IDR | idr_cfg, base_offset);
 467
 468        mutex_unlock(&priv->lock);
 469
 470        return 0;
 471}
 472
 473static struct counter_signal_enum_ext quad8_syn_mode_enum = {
 474        .items = quad8_synchronous_modes,
 475        .num_items = ARRAY_SIZE(quad8_synchronous_modes),
 476        .get = quad8_synchronous_mode_get,
 477        .set = quad8_synchronous_mode_set
 478};
 479
 480static ssize_t quad8_count_floor_read(struct counter_device *counter,
 481        struct counter_count *count, void *private, char *buf)
 482{
 483        /* Only a floor of 0 is supported */
 484        return sprintf(buf, "0\n");
 485}
 486
 487static int quad8_count_mode_get(struct counter_device *counter,
 488        struct counter_count *count, size_t *cnt_mode)
 489{
 490        const struct quad8 *const priv = counter->priv;
 491
 492        /* Map 104-QUAD-8 count mode to Generic Counter count mode */
 493        switch (priv->count_mode[count->id]) {
 494        case 0:
 495                *cnt_mode = COUNTER_COUNT_MODE_NORMAL;
 496                break;
 497        case 1:
 498                *cnt_mode = COUNTER_COUNT_MODE_RANGE_LIMIT;
 499                break;
 500        case 2:
 501                *cnt_mode = COUNTER_COUNT_MODE_NON_RECYCLE;
 502                break;
 503        case 3:
 504                *cnt_mode = COUNTER_COUNT_MODE_MODULO_N;
 505                break;
 506        }
 507
 508        return 0;
 509}
 510
 511static int quad8_count_mode_set(struct counter_device *counter,
 512        struct counter_count *count, size_t cnt_mode)
 513{
 514        struct quad8 *const priv = counter->priv;
 515        unsigned int mode_cfg;
 516        const int base_offset = priv->base + 2 * count->id + 1;
 517
 518        /* Map Generic Counter count mode to 104-QUAD-8 count mode */
 519        switch (cnt_mode) {
 520        case COUNTER_COUNT_MODE_NORMAL:
 521                cnt_mode = 0;
 522                break;
 523        case COUNTER_COUNT_MODE_RANGE_LIMIT:
 524                cnt_mode = 1;
 525                break;
 526        case COUNTER_COUNT_MODE_NON_RECYCLE:
 527                cnt_mode = 2;
 528                break;
 529        case COUNTER_COUNT_MODE_MODULO_N:
 530                cnt_mode = 3;
 531                break;
 532        }
 533
 534        mutex_lock(&priv->lock);
 535
 536        priv->count_mode[count->id] = cnt_mode;
 537
 538        /* Set count mode configuration value */
 539        mode_cfg = cnt_mode << 1;
 540
 541        /* Add quadrature mode configuration */
 542        if (priv->quadrature_mode[count->id])
 543                mode_cfg |= (priv->quadrature_scale[count->id] + 1) << 3;
 544
 545        /* Load mode configuration to Counter Mode Register */
 546        outb(QUAD8_CTR_CMR | mode_cfg, base_offset);
 547
 548        mutex_unlock(&priv->lock);
 549
 550        return 0;
 551}
 552
 553static struct counter_count_enum_ext quad8_cnt_mode_enum = {
 554        .items = counter_count_mode_str,
 555        .num_items = ARRAY_SIZE(counter_count_mode_str),
 556        .get = quad8_count_mode_get,
 557        .set = quad8_count_mode_set
 558};
 559
 560static ssize_t quad8_count_direction_read(struct counter_device *counter,
 561        struct counter_count *count, void *priv, char *buf)
 562{
 563        enum counter_count_direction dir;
 564
 565        quad8_direction_get(counter, count, &dir);
 566
 567        return sprintf(buf, "%s\n", counter_count_direction_str[dir]);
 568}
 569
 570static ssize_t quad8_count_enable_read(struct counter_device *counter,
 571        struct counter_count *count, void *private, char *buf)
 572{
 573        const struct quad8 *const priv = counter->priv;
 574
 575        return sprintf(buf, "%u\n", priv->ab_enable[count->id]);
 576}
 577
 578static ssize_t quad8_count_enable_write(struct counter_device *counter,
 579        struct counter_count *count, void *private, const char *buf, size_t len)
 580{
 581        struct quad8 *const priv = counter->priv;
 582        const int base_offset = priv->base + 2 * count->id;
 583        int err;
 584        bool ab_enable;
 585        unsigned int ior_cfg;
 586
 587        err = kstrtobool(buf, &ab_enable);
 588        if (err)
 589                return err;
 590
 591        mutex_lock(&priv->lock);
 592
 593        priv->ab_enable[count->id] = ab_enable;
 594
 595        ior_cfg = ab_enable | priv->preset_enable[count->id] << 1;
 596
 597        /* Load I/O control configuration */
 598        outb(QUAD8_CTR_IOR | ior_cfg, base_offset + 1);
 599
 600        mutex_unlock(&priv->lock);
 601
 602        return len;
 603}
 604
 605static const char *const quad8_noise_error_states[] = {
 606        "No excessive noise is present at the count inputs",
 607        "Excessive noise is present at the count inputs"
 608};
 609
 610static int quad8_error_noise_get(struct counter_device *counter,
 611        struct counter_count *count, size_t *noise_error)
 612{
 613        const struct quad8 *const priv = counter->priv;
 614        const int base_offset = priv->base + 2 * count->id + 1;
 615
 616        *noise_error = !!(inb(base_offset) & QUAD8_FLAG_E);
 617
 618        return 0;
 619}
 620
 621static struct counter_count_enum_ext quad8_error_noise_enum = {
 622        .items = quad8_noise_error_states,
 623        .num_items = ARRAY_SIZE(quad8_noise_error_states),
 624        .get = quad8_error_noise_get
 625};
 626
 627static ssize_t quad8_count_preset_read(struct counter_device *counter,
 628        struct counter_count *count, void *private, char *buf)
 629{
 630        const struct quad8 *const priv = counter->priv;
 631
 632        return sprintf(buf, "%u\n", priv->preset[count->id]);
 633}
 634
 635static void quad8_preset_register_set(struct quad8 *const priv, const int id,
 636                                      const unsigned int preset)
 637{
 638        const unsigned int base_offset = priv->base + 2 * id;
 639        int i;
 640
 641        priv->preset[id] = preset;
 642
 643        /* Reset Byte Pointer */
 644        outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP, base_offset + 1);
 645
 646        /* Set Preset Register */
 647        for (i = 0; i < 3; i++)
 648                outb(preset >> (8 * i), base_offset);
 649}
 650
 651static ssize_t quad8_count_preset_write(struct counter_device *counter,
 652        struct counter_count *count, void *private, const char *buf, size_t len)
 653{
 654        struct quad8 *const priv = counter->priv;
 655        unsigned int preset;
 656        int ret;
 657
 658        ret = kstrtouint(buf, 0, &preset);
 659        if (ret)
 660                return ret;
 661
 662        /* Only 24-bit values are supported */
 663        if (preset > 0xFFFFFF)
 664                return -EINVAL;
 665
 666        mutex_lock(&priv->lock);
 667
 668        quad8_preset_register_set(priv, count->id, preset);
 669
 670        mutex_unlock(&priv->lock);
 671
 672        return len;
 673}
 674
 675static ssize_t quad8_count_ceiling_read(struct counter_device *counter,
 676        struct counter_count *count, void *private, char *buf)
 677{
 678        struct quad8 *const priv = counter->priv;
 679
 680        mutex_lock(&priv->lock);
 681
 682        /* Range Limit and Modulo-N count modes use preset value as ceiling */
 683        switch (priv->count_mode[count->id]) {
 684        case 1:
 685        case 3:
 686                mutex_unlock(&priv->lock);
 687                return sprintf(buf, "%u\n", priv->preset[count->id]);
 688        }
 689
 690        mutex_unlock(&priv->lock);
 691
 692        /* By default 0x1FFFFFF (25 bits unsigned) is maximum count */
 693        return sprintf(buf, "33554431\n");
 694}
 695
 696static ssize_t quad8_count_ceiling_write(struct counter_device *counter,
 697        struct counter_count *count, void *private, const char *buf, size_t len)
 698{
 699        struct quad8 *const priv = counter->priv;
 700        unsigned int ceiling;
 701        int ret;
 702
 703        ret = kstrtouint(buf, 0, &ceiling);
 704        if (ret)
 705                return ret;
 706
 707        /* Only 24-bit values are supported */
 708        if (ceiling > 0xFFFFFF)
 709                return -EINVAL;
 710
 711        mutex_lock(&priv->lock);
 712
 713        /* Range Limit and Modulo-N count modes use preset value as ceiling */
 714        switch (priv->count_mode[count->id]) {
 715        case 1:
 716        case 3:
 717                quad8_preset_register_set(priv, count->id, ceiling);
 718                mutex_unlock(&priv->lock);
 719                return len;
 720        }
 721
 722        mutex_unlock(&priv->lock);
 723
 724        return -EINVAL;
 725}
 726
 727static ssize_t quad8_count_preset_enable_read(struct counter_device *counter,
 728        struct counter_count *count, void *private, char *buf)
 729{
 730        const struct quad8 *const priv = counter->priv;
 731
 732        return sprintf(buf, "%u\n", !priv->preset_enable[count->id]);
 733}
 734
 735static ssize_t quad8_count_preset_enable_write(struct counter_device *counter,
 736        struct counter_count *count, void *private, const char *buf, size_t len)
 737{
 738        struct quad8 *const priv = counter->priv;
 739        const int base_offset = priv->base + 2 * count->id + 1;
 740        bool preset_enable;
 741        int ret;
 742        unsigned int ior_cfg;
 743
 744        ret = kstrtobool(buf, &preset_enable);
 745        if (ret)
 746                return ret;
 747
 748        /* Preset enable is active low in Input/Output Control register */
 749        preset_enable = !preset_enable;
 750
 751        mutex_lock(&priv->lock);
 752
 753        priv->preset_enable[count->id] = preset_enable;
 754
 755        ior_cfg = priv->ab_enable[count->id] | (unsigned int)preset_enable << 1;
 756
 757        /* Load I/O control configuration to Input / Output Control Register */
 758        outb(QUAD8_CTR_IOR | ior_cfg, base_offset);
 759
 760        mutex_unlock(&priv->lock);
 761
 762        return len;
 763}
 764
 765static ssize_t quad8_signal_cable_fault_read(struct counter_device *counter,
 766                                             struct counter_signal *signal,
 767                                             void *private, char *buf)
 768{
 769        struct quad8 *const priv = counter->priv;
 770        const size_t channel_id = signal->id / 2;
 771        bool disabled;
 772        unsigned int status;
 773        unsigned int fault;
 774
 775        mutex_lock(&priv->lock);
 776
 777        disabled = !(priv->cable_fault_enable & BIT(channel_id));
 778
 779        if (disabled) {
 780                mutex_unlock(&priv->lock);
 781                return -EINVAL;
 782        }
 783
 784        /* Logic 0 = cable fault */
 785        status = inb(priv->base + QUAD8_DIFF_ENCODER_CABLE_STATUS);
 786
 787        mutex_unlock(&priv->lock);
 788
 789        /* Mask respective channel and invert logic */
 790        fault = !(status & BIT(channel_id));
 791
 792        return sprintf(buf, "%u\n", fault);
 793}
 794
 795static ssize_t quad8_signal_cable_fault_enable_read(
 796        struct counter_device *counter, struct counter_signal *signal,
 797        void *private, char *buf)
 798{
 799        const struct quad8 *const priv = counter->priv;
 800        const size_t channel_id = signal->id / 2;
 801        const unsigned int enb = !!(priv->cable_fault_enable & BIT(channel_id));
 802
 803        return sprintf(buf, "%u\n", enb);
 804}
 805
 806static ssize_t quad8_signal_cable_fault_enable_write(
 807        struct counter_device *counter, struct counter_signal *signal,
 808        void *private, const char *buf, size_t len)
 809{
 810        struct quad8 *const priv = counter->priv;
 811        const size_t channel_id = signal->id / 2;
 812        bool enable;
 813        int ret;
 814        unsigned int cable_fault_enable;
 815
 816        ret = kstrtobool(buf, &enable);
 817        if (ret)
 818                return ret;
 819
 820        mutex_lock(&priv->lock);
 821
 822        if (enable)
 823                priv->cable_fault_enable |= BIT(channel_id);
 824        else
 825                priv->cable_fault_enable &= ~BIT(channel_id);
 826
 827        /* Enable is active low in Differential Encoder Cable Status register */
 828        cable_fault_enable = ~priv->cable_fault_enable;
 829
 830        outb(cable_fault_enable, priv->base + QUAD8_DIFF_ENCODER_CABLE_STATUS);
 831
 832        mutex_unlock(&priv->lock);
 833
 834        return len;
 835}
 836
 837static ssize_t quad8_signal_fck_prescaler_read(struct counter_device *counter,
 838        struct counter_signal *signal, void *private, char *buf)
 839{
 840        const struct quad8 *const priv = counter->priv;
 841        const size_t channel_id = signal->id / 2;
 842
 843        return sprintf(buf, "%u\n", priv->fck_prescaler[channel_id]);
 844}
 845
 846static ssize_t quad8_signal_fck_prescaler_write(struct counter_device *counter,
 847        struct counter_signal *signal, void *private, const char *buf,
 848        size_t len)
 849{
 850        struct quad8 *const priv = counter->priv;
 851        const size_t channel_id = signal->id / 2;
 852        const int base_offset = priv->base + 2 * channel_id;
 853        u8 prescaler;
 854        int ret;
 855
 856        ret = kstrtou8(buf, 0, &prescaler);
 857        if (ret)
 858                return ret;
 859
 860        mutex_lock(&priv->lock);
 861
 862        priv->fck_prescaler[channel_id] = prescaler;
 863
 864        /* Reset Byte Pointer */
 865        outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP, base_offset + 1);
 866
 867        /* Set filter clock factor */
 868        outb(prescaler, base_offset);
 869        outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP | QUAD8_RLD_PRESET_PSC,
 870             base_offset + 1);
 871
 872        mutex_unlock(&priv->lock);
 873
 874        return len;
 875}
 876
 877static const struct counter_signal_ext quad8_signal_ext[] = {
 878        {
 879                .name = "cable_fault",
 880                .read = quad8_signal_cable_fault_read
 881        },
 882        {
 883                .name = "cable_fault_enable",
 884                .read = quad8_signal_cable_fault_enable_read,
 885                .write = quad8_signal_cable_fault_enable_write
 886        },
 887        {
 888                .name = "filter_clock_prescaler",
 889                .read = quad8_signal_fck_prescaler_read,
 890                .write = quad8_signal_fck_prescaler_write
 891        }
 892};
 893
 894static const struct counter_signal_ext quad8_index_ext[] = {
 895        COUNTER_SIGNAL_ENUM("index_polarity", &quad8_index_pol_enum),
 896        COUNTER_SIGNAL_ENUM_AVAILABLE("index_polarity", &quad8_index_pol_enum),
 897        COUNTER_SIGNAL_ENUM("synchronous_mode", &quad8_syn_mode_enum),
 898        COUNTER_SIGNAL_ENUM_AVAILABLE("synchronous_mode", &quad8_syn_mode_enum)
 899};
 900
 901#define QUAD8_QUAD_SIGNAL(_id, _name) {         \
 902        .id = (_id),                            \
 903        .name = (_name),                        \
 904        .ext = quad8_signal_ext,                \
 905        .num_ext = ARRAY_SIZE(quad8_signal_ext) \
 906}
 907
 908#define QUAD8_INDEX_SIGNAL(_id, _name) {        \
 909        .id = (_id),                            \
 910        .name = (_name),                        \
 911        .ext = quad8_index_ext,                 \
 912        .num_ext = ARRAY_SIZE(quad8_index_ext)  \
 913}
 914
 915static struct counter_signal quad8_signals[] = {
 916        QUAD8_QUAD_SIGNAL(0, "Channel 1 Quadrature A"),
 917        QUAD8_QUAD_SIGNAL(1, "Channel 1 Quadrature B"),
 918        QUAD8_QUAD_SIGNAL(2, "Channel 2 Quadrature A"),
 919        QUAD8_QUAD_SIGNAL(3, "Channel 2 Quadrature B"),
 920        QUAD8_QUAD_SIGNAL(4, "Channel 3 Quadrature A"),
 921        QUAD8_QUAD_SIGNAL(5, "Channel 3 Quadrature B"),
 922        QUAD8_QUAD_SIGNAL(6, "Channel 4 Quadrature A"),
 923        QUAD8_QUAD_SIGNAL(7, "Channel 4 Quadrature B"),
 924        QUAD8_QUAD_SIGNAL(8, "Channel 5 Quadrature A"),
 925        QUAD8_QUAD_SIGNAL(9, "Channel 5 Quadrature B"),
 926        QUAD8_QUAD_SIGNAL(10, "Channel 6 Quadrature A"),
 927        QUAD8_QUAD_SIGNAL(11, "Channel 6 Quadrature B"),
 928        QUAD8_QUAD_SIGNAL(12, "Channel 7 Quadrature A"),
 929        QUAD8_QUAD_SIGNAL(13, "Channel 7 Quadrature B"),
 930        QUAD8_QUAD_SIGNAL(14, "Channel 8 Quadrature A"),
 931        QUAD8_QUAD_SIGNAL(15, "Channel 8 Quadrature B"),
 932        QUAD8_INDEX_SIGNAL(16, "Channel 1 Index"),
 933        QUAD8_INDEX_SIGNAL(17, "Channel 2 Index"),
 934        QUAD8_INDEX_SIGNAL(18, "Channel 3 Index"),
 935        QUAD8_INDEX_SIGNAL(19, "Channel 4 Index"),
 936        QUAD8_INDEX_SIGNAL(20, "Channel 5 Index"),
 937        QUAD8_INDEX_SIGNAL(21, "Channel 6 Index"),
 938        QUAD8_INDEX_SIGNAL(22, "Channel 7 Index"),
 939        QUAD8_INDEX_SIGNAL(23, "Channel 8 Index")
 940};
 941
 942#define QUAD8_COUNT_SYNAPSES(_id) {                                     \
 943        {                                                               \
 944                .actions_list = quad8_synapse_actions_list,             \
 945                .num_actions = ARRAY_SIZE(quad8_synapse_actions_list),  \
 946                .signal = quad8_signals + 2 * (_id)                     \
 947        },                                                              \
 948        {                                                               \
 949                .actions_list = quad8_synapse_actions_list,             \
 950                .num_actions = ARRAY_SIZE(quad8_synapse_actions_list),  \
 951                .signal = quad8_signals + 2 * (_id) + 1                 \
 952        },                                                              \
 953        {                                                               \
 954                .actions_list = quad8_index_actions_list,               \
 955                .num_actions = ARRAY_SIZE(quad8_index_actions_list),    \
 956                .signal = quad8_signals + 2 * (_id) + 16                \
 957        }                                                               \
 958}
 959
 960static struct counter_synapse quad8_count_synapses[][3] = {
 961        QUAD8_COUNT_SYNAPSES(0), QUAD8_COUNT_SYNAPSES(1),
 962        QUAD8_COUNT_SYNAPSES(2), QUAD8_COUNT_SYNAPSES(3),
 963        QUAD8_COUNT_SYNAPSES(4), QUAD8_COUNT_SYNAPSES(5),
 964        QUAD8_COUNT_SYNAPSES(6), QUAD8_COUNT_SYNAPSES(7)
 965};
 966
 967static const struct counter_count_ext quad8_count_ext[] = {
 968        {
 969                .name = "ceiling",
 970                .read = quad8_count_ceiling_read,
 971                .write = quad8_count_ceiling_write
 972        },
 973        {
 974                .name = "floor",
 975                .read = quad8_count_floor_read
 976        },
 977        COUNTER_COUNT_ENUM("count_mode", &quad8_cnt_mode_enum),
 978        COUNTER_COUNT_ENUM_AVAILABLE("count_mode", &quad8_cnt_mode_enum),
 979        {
 980                .name = "direction",
 981                .read = quad8_count_direction_read
 982        },
 983        {
 984                .name = "enable",
 985                .read = quad8_count_enable_read,
 986                .write = quad8_count_enable_write
 987        },
 988        COUNTER_COUNT_ENUM("error_noise", &quad8_error_noise_enum),
 989        COUNTER_COUNT_ENUM_AVAILABLE("error_noise", &quad8_error_noise_enum),
 990        {
 991                .name = "preset",
 992                .read = quad8_count_preset_read,
 993                .write = quad8_count_preset_write
 994        },
 995        {
 996                .name = "preset_enable",
 997                .read = quad8_count_preset_enable_read,
 998                .write = quad8_count_preset_enable_write
 999        }
1000};
1001
1002#define QUAD8_COUNT(_id, _cntname) {                                    \
1003        .id = (_id),                                                    \
1004        .name = (_cntname),                                             \
1005        .functions_list = quad8_count_functions_list,                   \
1006        .num_functions = ARRAY_SIZE(quad8_count_functions_list),        \
1007        .synapses = quad8_count_synapses[(_id)],                        \
1008        .num_synapses = 2,                                              \
1009        .ext = quad8_count_ext,                                         \
1010        .num_ext = ARRAY_SIZE(quad8_count_ext)                          \
1011}
1012
1013static struct counter_count quad8_counts[] = {
1014        QUAD8_COUNT(0, "Channel 1 Count"),
1015        QUAD8_COUNT(1, "Channel 2 Count"),
1016        QUAD8_COUNT(2, "Channel 3 Count"),
1017        QUAD8_COUNT(3, "Channel 4 Count"),
1018        QUAD8_COUNT(4, "Channel 5 Count"),
1019        QUAD8_COUNT(5, "Channel 6 Count"),
1020        QUAD8_COUNT(6, "Channel 7 Count"),
1021        QUAD8_COUNT(7, "Channel 8 Count")
1022};
1023
1024static int quad8_probe(struct device *dev, unsigned int id)
1025{
1026        struct quad8 *priv;
1027        int i, j;
1028        unsigned int base_offset;
1029
1030        if (!devm_request_region(dev, base[id], QUAD8_EXTENT, dev_name(dev))) {
1031                dev_err(dev, "Unable to lock port addresses (0x%X-0x%X)\n",
1032                        base[id], base[id] + QUAD8_EXTENT);
1033                return -EBUSY;
1034        }
1035
1036        priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
1037        if (!priv)
1038                return -ENOMEM;
1039
1040        /* Initialize Counter device and driver data */
1041        priv->counter.name = dev_name(dev);
1042        priv->counter.parent = dev;
1043        priv->counter.ops = &quad8_ops;
1044        priv->counter.counts = quad8_counts;
1045        priv->counter.num_counts = ARRAY_SIZE(quad8_counts);
1046        priv->counter.signals = quad8_signals;
1047        priv->counter.num_signals = ARRAY_SIZE(quad8_signals);
1048        priv->counter.priv = priv;
1049        priv->base = base[id];
1050
1051        /* Initialize mutex */
1052        mutex_init(&priv->lock);
1053
1054        /* Reset all counters and disable interrupt function */
1055        outb(QUAD8_CHAN_OP_RESET_COUNTERS, base[id] + QUAD8_REG_CHAN_OP);
1056        /* Set initial configuration for all counters */
1057        for (i = 0; i < QUAD8_NUM_COUNTERS; i++) {
1058                base_offset = base[id] + 2 * i;
1059                /* Reset Byte Pointer */
1060                outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP, base_offset + 1);
1061                /* Reset filter clock factor */
1062                outb(0, base_offset);
1063                outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP | QUAD8_RLD_PRESET_PSC,
1064                     base_offset + 1);
1065                /* Reset Byte Pointer */
1066                outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_BP, base_offset + 1);
1067                /* Reset Preset Register */
1068                for (j = 0; j < 3; j++)
1069                        outb(0x00, base_offset);
1070                /* Reset Borrow, Carry, Compare, and Sign flags */
1071                outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_FLAGS, base_offset + 1);
1072                /* Reset Error flag */
1073                outb(QUAD8_CTR_RLD | QUAD8_RLD_RESET_E, base_offset + 1);
1074                /* Binary encoding; Normal count; non-quadrature mode */
1075                outb(QUAD8_CTR_CMR, base_offset + 1);
1076                /* Disable A and B inputs; preset on index; FLG1 as Carry */
1077                outb(QUAD8_CTR_IOR, base_offset + 1);
1078                /* Disable index function; negative index polarity */
1079                outb(QUAD8_CTR_IDR, base_offset + 1);
1080        }
1081        /* Disable Differential Encoder Cable Status for all channels */
1082        outb(0xFF, base[id] + QUAD8_DIFF_ENCODER_CABLE_STATUS);
1083        /* Enable all counters */
1084        outb(QUAD8_CHAN_OP_ENABLE_COUNTERS, base[id] + QUAD8_REG_CHAN_OP);
1085
1086        return devm_counter_register(dev, &priv->counter);
1087}
1088
1089static struct isa_driver quad8_driver = {
1090        .probe = quad8_probe,
1091        .driver = {
1092                .name = "104-quad-8"
1093        }
1094};
1095
1096module_isa_driver(quad8_driver, num_quad8);
1097
1098MODULE_AUTHOR("William Breathitt Gray <vilhelm.gray@gmail.com>");
1099MODULE_DESCRIPTION("ACCES 104-QUAD-8 driver");
1100MODULE_LICENSE("GPL v2");
1101