drivers/staging/fieldbus/anybuss/host.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * HMS Anybus-S Host Driver
   4  *
   5  * Copyright (C) 2018 Arcx Inc
   6  */
   7
   8 /*
   9  * Architecture Overview
  10  * =====================
  11  * This driver (running on the CPU/SoC) and the Anybus-S card communicate
  12  * by reading and writing data to/from the Anybus-S Dual-Port RAM (dpram).
  13  * This is memory connected to both the SoC and Anybus-S card, which both sides
  14  * can access freely and concurrently.
  15  *
  16  * Synchronization happens by means of two registers located in the dpram:
  17  * IND_AB: written exclusively by the Anybus card; and
  18  * IND_AP: written exclusively by this driver.
  19  *
  20  * Communication happens using one of the following mechanisms:
  21  * 1. reserve, read/write, release dpram memory areas:
  22  *      using an IND_AB/IND_AP protocol, the driver is able to reserve certain
  23  *      memory areas. no dpram memory can be read or written except if reserved.
  24  *      (with a few limited exceptions)
  25  * 2. send and receive data structures via a shared mailbox:
  26  *      using an IND_AB/IND_AP protocol, the driver and Anybus card are able to
  27  *      exchange commands and responses using a shared mailbox.
  28  * 3. receive software interrupts:
  29  *      using an IND_AB/IND_AP protocol, the Anybus card is able to notify the
  30  *      driver of certain events such as: bus online/offline, data available.
  31  *      note that software interrupt event bits are located in a memory area
  32  *      which must be reserved before it can be accessed.
  33  *
  34  * The manual[1] is silent on whether these mechanisms can happen concurrently,
  35  * or how they should be synchronized. However, section 13 (Driver Example)
  36  * provides the following suggestion for developing a driver:
  37  * a) an interrupt handler which updates global variables;
  38  * b) a continuously-running task handling area requests (1 above)
  39  * c) a continuously-running task handling mailbox requests (2 above)
  40  * The example conspicuously leaves out software interrupts (3 above), which
  41  * is the thorniest issue to get right (see below).
  42  *
  43  * The naive, straightforward way to implement this would be:
  44  * - create an isr which updates shared variables;
  45  * - create a work_struct which handles software interrupts on a queue;
  46  * - create a function which does reserve/update/unlock in a loop;
  47  * - create a function which does mailbox send/receive in a loop;
  48  * - call the above functions from the driver's read/write/ioctl;
  49  * - synchronize using mutexes/spinlocks:
  50  *      + only one area request at a time
  51  *      + only one mailbox request at a time
  52  *      + protect AB_IND, AB_IND against data hazards (e.g. read-after-write)
  53  *
  54  * Unfortunately, the presence of the software interrupt causes subtle yet
  55  * considerable synchronization issues; especially problematic is the
  56  * requirement to reserve/release the area which contains the status bits.
  57  *
  58  * The driver architecture presented here sidesteps these synchronization issues
  59  * by accessing the dpram from a single kernel thread only. User-space throws
  60  * "tasks" (i.e. 1, 2 above) into a task queue, waits for their completion,
  61  * and the kernel thread runs them to completion.
  62  *
  63  * Each task has a task_function, which is called/run by the queue thread.
  64  * That function communicates with the Anybus card, and returns either
  65  * 0 (OK), a negative error code (error), or -EINPROGRESS (waiting).
  66  * On OK or error, the queue thread completes and dequeues the task,
  67  * which also releases the user space thread which may still be waiting for it.
  68  * On -EINPROGRESS (waiting), the queue thread will leave the task on the queue,
  69  * and revisit (call again) whenever an interrupt event comes in.
  70  *
  71  * Each task has a state machine, which is run by calling its task_function.
  72  * It ensures that the task will go through its various stages over time,
  73  * returning -EINPROGRESS if it wants to wait for an event to happen.
  74  *
  75  * Note that according to the manual's driver example, the following operations
  76  * may run independent of each other:
  77  * - area reserve/read/write/release    (point 1 above)
  78  * - mailbox operations                 (point 2 above)
  79  * - switching power on/off
  80  *
  81  * To allow them to run independently, each operation class gets its own queue.
  82  *
  83  * Userspace processes A, B, C, D post tasks to the appropriate queue,
  84  * and wait for task completion:
  85  *
  86  *      process A       B       C       D
  87  *              |       |       |       |
  88  *              v       v       v       v
  89  *      |<----- ========================================
  90  *      |               |          |            |
  91  *      |               v          v            v-------<-------+
  92  *      |       +--------------------------------------+        |
  93  *      |       | power q     | mbox q    | area q     |        |
  94  *      |       |------------|------------|------------|        |
  95  *      |       | task       | task       | task       |        |
  96  *      |       | task       | task       | task       |        |
  97  *      |       | task wait  | task wait  | task wait  |        |
  98  *      |       +--------------------------------------+        |
  99  *      |               ^          ^            ^               |
 100  *      |               |          |            |               ^
 101  *      |       +--------------------------------------+        |
 102  *      |       |            queue thread              |        |
 103  *      |       |--------------------------------------|        |
 104  *      |       | single-threaded:                     |        |
 105  *      |       | loop:                                |        |
 106  *      v       |   for each queue:                    |        |
 107  *      |       |     run task state machine           |        |
 108  *      |       |     if task waiting:                 |        |
 109  *      |       |       leave on queue                 |        |
 110  *      |       |     if task done:                    |        |
 111  *      |       |       complete task, remove from q   |        |
 112  *      |       |   if software irq event bits set:    |        |
 113  *      |       |     notify userspace                 |        |
 114  *      |       |     post clear event bits task------>|>-------+
 115  *      |       |   wait for IND_AB changed event OR   |
 116  *      |       |            task added event     OR   |
 117  *      |       |            timeout                   |
 118  *      |       | end loop                             |
 119  *      |       +--------------------------------------+
 120  *      |       +               wake up                +
 121  *      |       +--------------------------------------+
 122  *      |               ^                       ^
 123  *      |               |                       |
 124  *      +-------->-------                       |
 125  *                                              |
 126  *              +--------------------------------------+
 127  *              |       interrupt service routine      |
 128  *              |--------------------------------------|
 129  *              | wake up queue thread on IND_AB change|
 130  *              +--------------------------------------+
 131  *
 132  * Note that the Anybus interrupt is dual-purpose:
 133  * - after a reset, triggered when the card becomes ready;
 134  * - during normal operation, triggered when AB_IND changes.
 135  * This is why the interrupt service routine doesn't just wake up the
 136  * queue thread, but also completes the card_boot completion.
 137  *
 138  * [1] https://www.anybus.com/docs/librariesprovider7/default-document-library/
 139  *      manuals-design-guides/hms-hmsi-27-275.pdf
 140  */
 141
 142 #include <linux/kernel.h>
 143 #include <linux/module.h>
 144 #include <linux/init.h>
 145 #include <linux/slab.h>
 146 #include <linux/interrupt.h>
 147 #include <linux/atomic.h>
 148 #include <linux/kthread.h>
 149 #include <linux/kfifo.h>
 150 #include <linux/spinlock.h>
 151 #include <linux/uaccess.h>
 152 #include <linux/regmap.h>
 153 #include <linux/of.h>
 154 #include <linux/random.h>
 155 #include <linux/kref.h>
 156 #include <linux/of_address.h>
 157
 158 /* move to <linux/anybuss-*.h> when taking this out of staging */
 159 #include "anybuss-client.h"
 160 #include "anybuss-controller.h"
 161
 162 #define DPRAM_SIZE              0x800
 163 #define MAX_MBOX_MSG_SZ         0x0FF
 164 #define TIMEOUT                 (HZ * 2)
 165 #define MAX_DATA_AREA_SZ        0x200
 166 #define MAX_FBCTRL_AREA_SZ      0x1BE
 167
 168 #define REG_BOOTLOADER_V        0x7C0
 169 #define REG_API_V               0x7C2
 170 #define REG_FIELDBUS_V          0x7C4
 171 #define REG_SERIAL_NO           0x7C6
 172 #define REG_FIELDBUS_TYPE       0x7CC
 173 #define REG_MODULE_SW_V         0x7CE
 174 #define REG_IND_AB              0x7FF
 175 #define REG_IND_AP              0x7FE
 176 #define REG_EVENT_CAUSE         0x7ED
 177 #define MBOX_IN_AREA            0x400
 178 #define MBOX_OUT_AREA           0x520
 179 #define DATA_IN_AREA            0x000
 180 #define DATA_OUT_AREA           0x200
 181 #define FBCTRL_AREA             0x640
 182
 183 #define EVENT_CAUSE_DC          0x01
 184 #define EVENT_CAUSE_FBOF        0x02
 185 #define EVENT_CAUSE_FBON        0x04
 186
 187 #define IND_AB_UPDATED          0x08
 188 #define IND_AX_MIN              0x80
 189 #define IND_AX_MOUT             0x40
 190 #define IND_AX_IN               0x04
 191 #define IND_AX_OUT              0x02
 192 #define IND_AX_FBCTRL           0x01
 193 #define IND_AP_LOCK             0x08
 194 #define IND_AP_ACTION           0x10
 195 #define IND_AX_EVNT             0x20
 196 #define IND_AP_ABITS            (IND_AX_IN | IND_AX_OUT | \
 197                                         IND_AX_FBCTRL | \
 198                                         IND_AP_ACTION | IND_AP_LOCK)
 199
 200 #define INFO_TYPE_FB            0x0002
 201 #define INFO_TYPE_APP           0x0001
 202 #define INFO_COMMAND            0x4000
 203
 204 #define OP_MODE_FBFC            0x0002
 205 #define OP_MODE_FBS             0x0004
 206 #define OP_MODE_CD              0x0200
 207
 208 #define CMD_START_INIT          0x0001
 209 #define CMD_ANYBUS_INIT         0x0002
 210 #define CMD_END_INIT            0x0003
 211
 212 /*
 213  * ---------------------------------------------------------------
 214  * Anybus mailbox messages - definitions
 215  * ---------------------------------------------------------------
 216  * note that we're depending on the layout of these structures being
 217  * exactly as advertised.
 218  */
 219
 220 struct anybus_mbox_hdr {
 221         __be16 id;
 222         __be16 info;
 223         __be16 cmd_num;
 224         __be16 data_size;
 225         __be16 frame_count;
 226         __be16 frame_num;
 227         __be16 offset_high;
 228         __be16 offset_low;
 229         __be16 extended[8];
 230 };
 231
 232 struct msg_anybus_init {
 233         __be16 input_io_len;
 234         __be16 input_dpram_len;
 235         __be16 input_total_len;
 236         __be16 output_io_len;
 237         __be16 output_dpram_len;
 238         __be16 output_total_len;
 239         __be16 op_mode;
 240         __be16 notif_config;
 241         __be16 wd_val;
 242 };
 243
 244 /* ------------- ref counted tasks ------------- */
 245
 246 struct ab_task;
 247 typedef int (*ab_task_fn_t)(struct anybuss_host *cd,
 248                                         struct ab_task *t);
 249 typedef void (*ab_done_fn_t)(struct anybuss_host *cd);
 250
 251 struct area_priv {
 252         bool is_write;
 253         u16 flags;
 254         u16 addr;
 255         size_t count;
 256         u8 buf[MAX_DATA_AREA_SZ];
 257 };
 258
 259 struct mbox_priv {
 260         struct anybus_mbox_hdr hdr;
 261         size_t msg_out_sz;
 262         size_t msg_in_sz;
 263         u8 msg[MAX_MBOX_MSG_SZ];
 264 };
 265
 266 struct ab_task {
 267         struct kmem_cache       *cache;
 268         struct kref             refcount;
 269         ab_task_fn_t            task_fn;
 270         ab_done_fn_t            done_fn;
 271         int                     result;
 272         struct completion       done;
 273         unsigned long           start_jiffies;
 274         union {
 275                 struct area_priv area_pd;
 276                 struct mbox_priv mbox_pd;
 277         };
 278 };
 279
 280 static struct ab_task *ab_task_create_get(struct kmem_cache *cache,
 281                                           ab_task_fn_t task_fn)
 282 {
 283         struct ab_task *t;
 284
 285         t = kmem_cache_alloc(cache, GFP_KERNEL);
 286         if (!t)
 287                 return NULL;
 288         t->cache = cache;
 289         kref_init(&t->refcount);
 290         t->task_fn = task_fn;
 291         t->done_fn = NULL;
 292         t->result = 0;
 293         init_completion(&t->done);
 294         return t;
 295 }
 296
 297 static void __ab_task_destroy(struct kref *refcount)
 298 {
 299         struct ab_task *t = container_of(refcount, struct ab_task, refcount);
 300         struct kmem_cache *cache = t->cache;
 301
 302         kmem_cache_free(cache, t);
 303 }
 304
 305 static void ab_task_put(struct ab_task *t)
 306 {
 307         kref_put(&t->refcount, __ab_task_destroy);
 308 }
 309
 310 static struct ab_task *__ab_task_get(struct ab_task *t)
 311 {
 312         kref_get(&t->refcount);
 313         return t;
 314 }
 315
 316 static void __ab_task_finish(struct ab_task *t, struct anybuss_host *cd)
 317 {
 318         if (t->done_fn)
 319                 t->done_fn(cd);
 320         complete(&t->done);
 321 }
 322
 323 static void
 324 ab_task_dequeue_finish_put(struct kfifo *q, struct anybuss_host *cd)
 325 {
 326         int ret;
 327         struct ab_task *t;
 328
 329         ret = kfifo_out(q, &t, sizeof(t));
 330         WARN_ON(!ret);
 331         __ab_task_finish(t, cd);
 332         ab_task_put(t);
 333 }
 334
 335 static int
 336 ab_task_enqueue(struct ab_task *t, struct kfifo *q, spinlock_t *slock,
 337                 wait_queue_head_t *wq)
 338 {
 339         int ret;
 340
 341         t->start_jiffies = jiffies;
 342         __ab_task_get(t);
 343         ret = kfifo_in_spinlocked(q, &t, sizeof(t), slock);
 344         if (!ret) {
 345                 ab_task_put(t);
 346                 return -ENOMEM;
 347         }
 348         wake_up(wq);
 349         return 0;
 350 }
 351
 352 static int
 353 ab_task_enqueue_wait(struct ab_task *t, struct kfifo *q, spinlock_t *slock,
 354                      wait_queue_head_t *wq)
 355 {
 356         int ret;
 357
 358         ret = ab_task_enqueue(t, q, slock, wq);
 359         if (ret)
 360                 return ret;
 361         ret = wait_for_completion_interruptible(&t->done);
 362         if (ret)
 363                 return ret;
 364         return t->result;
 365 }
 366
 367 /* ------------------------ anybus hardware ------------------------ */
 368
 369 struct anybuss_host {
 370         struct device *dev;
 371         struct anybuss_client *client;
 372         void (*reset)(struct device *dev, bool assert);
 373         struct regmap *regmap;
 374         int irq;
 375         int host_idx;
 376         struct task_struct *qthread;
 377         wait_queue_head_t wq;
 378         struct completion card_boot;
 379         atomic_t ind_ab;
 380         spinlock_t qlock; /* protects IN side of powerq, mboxq, areaq */
 381         struct kmem_cache *qcache;
 382         struct kfifo qs[3];
 383         struct kfifo *powerq;
 384         struct kfifo *mboxq;
 385         struct kfifo *areaq;
 386         bool power_on;
 387         bool softint_pending;
 388 };
 389
 390 static void reset_assert(struct anybuss_host *cd)
 391 {
 392         cd->reset(cd->dev, true);
 393 }
 394
 395 static void reset_deassert(struct anybuss_host *cd)
 396 {
 397         cd->reset(cd->dev, false);
 398 }
 399
 400 static int test_dpram(struct regmap *regmap)
 401 {
 402         int i;
 403         unsigned int val;
 404
 405         for (i = 0; i < DPRAM_SIZE; i++)
 406                 regmap_write(regmap, i, (u8)i);
 407         for (i = 0; i < DPRAM_SIZE; i++) {
 408                 regmap_read(regmap, i, &val);
 409                 if ((u8)val != (u8)i)
 410                         return -EIO;
 411         }
 412         return 0;
 413 }
 414
 415 static int read_ind_ab(struct regmap *regmap)
 416 {
 417         unsigned long timeout = jiffies + HZ / 2;
 418         unsigned int a, b, i = 0;
 419
 420         while (time_before_eq(jiffies, timeout)) {
 421                 regmap_read(regmap, REG_IND_AB, &a);
 422                 regmap_read(regmap, REG_IND_AB, &b);
 423                 if (likely(a == b))
 424                         return (int)a;
 425                 if (i < 10) {
 426                         cpu_relax();
 427                         i++;
 428                 } else {
 429                         usleep_range(500, 1000);
 430                 }
 431         }
 432         WARN(1, "IND_AB register not stable");
 433         return -ETIMEDOUT;
 434 }
 435
 436 static int write_ind_ap(struct regmap *regmap, unsigned int ind_ap)
 437 {
 438         unsigned long timeout = jiffies + HZ / 2;
 439         unsigned int v, i = 0;
 440
 441         while (time_before_eq(jiffies, timeout)) {
 442                 regmap_write(regmap, REG_IND_AP, ind_ap);
 443                 regmap_read(regmap, REG_IND_AP, &v);
 444                 if (likely(ind_ap == v))
 445                         return 0;
 446                 if (i < 10) {
 447                         cpu_relax();
 448                         i++;
 449                 } else {
 450                         usleep_range(500, 1000);
 451                 }
 452         }
 453         WARN(1, "IND_AP register not stable");
 454         return -ETIMEDOUT;
 455 }
 456
 457 static irqreturn_t irq_handler(int irq, void *data)
 458 {
 459         struct anybuss_host *cd = data;
 460         int ind_ab;
 461
 462         /*
 463          * irq handler needs exclusive access to the IND_AB register,
 464          * because the act of reading the register acks the interrupt.
 465          *
 466          * store the register value in cd->ind_ab (an atomic_t), so that the
 467          * queue thread is able to read it without causing an interrupt ack
 468          * side-effect (and without spuriously acking an interrupt).
 469          */
 470         ind_ab = read_ind_ab(cd->regmap);
 471         if (ind_ab < 0)
 472                 return IRQ_NONE;
 473         atomic_set(&cd->ind_ab, ind_ab);
 474         complete(&cd->card_boot);
 475         wake_up(&cd->wq);
 476         return IRQ_HANDLED;
 477 }
 478
 479 /* ------------------------ power on/off tasks --------------------- */
 480
 481 static int task_fn_power_off(struct anybuss_host *cd,
 482                              struct ab_task *t)
 483 {
 484         struct anybuss_client *client = cd->client;
 485
 486         if (!cd->power_on)
 487                 return 0;
 488         disable_irq(cd->irq);
 489         reset_assert(cd);
 490         atomic_set(&cd->ind_ab, IND_AB_UPDATED);
 491         if (client->on_online_changed)
 492                 client->on_online_changed(client, false);
 493         cd->power_on = false;
 494         return 0;
 495 }
 496
 497 static int task_fn_power_on_2(struct anybuss_host *cd,
 498                               struct ab_task *t)
 499 {
 500         if (completion_done(&cd->card_boot)) {
 501                 cd->power_on = true;
 502                 return 0;
 503         }
 504         if (time_after(jiffies, t->start_jiffies + TIMEOUT)) {
 505                 disable_irq(cd->irq);
 506                 reset_assert(cd);
 507                 dev_err(cd->dev, "power on timed out");
 508                 return -ETIMEDOUT;
 509         }
 510         return -EINPROGRESS;
 511 }
 512
 513 static int task_fn_power_on(struct anybuss_host *cd,
 514                             struct ab_task *t)
 515 {
 516         unsigned int dummy;
 517
 518         if (cd->power_on)
 519                 return 0;
 520         /*
 521          * anybus docs: prevent false 'init done' interrupt by
 522          * doing a dummy read of IND_AB register while in reset.
 523          */
 524         regmap_read(cd->regmap, REG_IND_AB, &dummy);
 525         reinit_completion(&cd->card_boot);
 526         enable_irq(cd->irq);
 527         reset_deassert(cd);
 528         t->task_fn = task_fn_power_on_2;
 529         return -EINPROGRESS;
 530 }
 531
 532 int anybuss_set_power(struct anybuss_client *client, bool power_on)
 533 {
 534         struct anybuss_host *cd = client->host;
 535         struct ab_task *t;
 536         int err;
 537
 538         t = ab_task_create_get(cd->qcache, power_on ?
 539                                 task_fn_power_on : task_fn_power_off);
 540         if (!t)
 541                 return -ENOMEM;
 542         err = ab_task_enqueue_wait(t, cd->powerq, &cd->qlock, &cd->wq);
 543         ab_task_put(t);
 544         return err;
 545 }
 546 EXPORT_SYMBOL_GPL(anybuss_set_power);
 547
 548 /* ---------------------------- area tasks ------------------------ */
 549
 550 static int task_fn_area_3(struct anybuss_host *cd, struct ab_task *t)
 551 {
 552         struct area_priv *pd = &t->area_pd;
 553
 554         if (!cd->power_on)
 555                 return -EIO;
 556         if (atomic_read(&cd->ind_ab) & pd->flags) {
 557                 /* area not released yet */
 558                 if (time_after(jiffies, t->start_jiffies + TIMEOUT))
 559                         return -ETIMEDOUT;
 560                 return -EINPROGRESS;
 561         }
 562         return 0;
 563 }
 564
 565 static int task_fn_area_2(struct anybuss_host *cd, struct ab_task *t)
 566 {
 567         struct area_priv *pd = &t->area_pd;
 568         unsigned int ind_ap;
 569         int ret;
 570
 571         if (!cd->power_on)
 572                 return -EIO;
 573         regmap_read(cd->regmap, REG_IND_AP, &ind_ap);
 574         if (!(atomic_read(&cd->ind_ab) & pd->flags)) {
 575                 /* we don't own the area yet */
 576                 if (time_after(jiffies, t->start_jiffies + TIMEOUT)) {
 577                         dev_warn(cd->dev, "timeout waiting for area");
 578                         dump_stack();
 579                         return -ETIMEDOUT;
 580                 }
 581                 return -EINPROGRESS;
 582         }
 583         /* we own the area, do what we're here to do */
 584         if (pd->is_write)
 585                 regmap_bulk_write(cd->regmap, pd->addr, pd->buf,
 586                                   pd->count);
 587         else
 588                 regmap_bulk_read(cd->regmap, pd->addr, pd->buf,
 589                                  pd->count);
 590         /* ask to release the area, must use unlocked release */
 591         ind_ap &= ~IND_AP_ABITS;
 592         ind_ap |= pd->flags;
 593         ret = write_ind_ap(cd->regmap, ind_ap);
 594         if (ret)
 595                 return ret;
 596         t->task_fn = task_fn_area_3;
 597         return -EINPROGRESS;
 598 }
 599
 600 static int task_fn_area(struct anybuss_host *cd, struct ab_task *t)
 601 {
 602         struct area_priv *pd = &t->area_pd;
 603         unsigned int ind_ap;
 604         int ret;
 605
 606         if (!cd->power_on)
 607                 return -EIO;
 608         regmap_read(cd->regmap, REG_IND_AP, &ind_ap);
 609         /* ask to take the area */
 610         ind_ap &= ~IND_AP_ABITS;
 611         ind_ap |= pd->flags | IND_AP_ACTION | IND_AP_LOCK;
 612         ret = write_ind_ap(cd->regmap, ind_ap);
 613         if (ret)
 614                 return ret;
 615         t->task_fn = task_fn_area_2;
 616         return -EINPROGRESS;
 617 }
 618
 619 static struct ab_task *
 620 create_area_reader(struct kmem_cache *qcache, u16 flags, u16 addr,
 621                    size_t count)
 622 {
 623         struct ab_task *t;
 624         struct area_priv *ap;
 625
 626         t = ab_task_create_get(qcache, task_fn_area);
 627         if (!t)
 628                 return NULL;
 629         ap = &t->area_pd;
 630         ap->flags = flags;
 631         ap->addr = addr;
 632         ap->is_write = false;
 633         ap->count = count;
 634         return t;
 635 }
 636
 637 static struct ab_task *
 638 create_area_writer(struct kmem_cache *qcache, u16 flags, u16 addr,
 639                    const void *buf, size_t count)
 640 {
 641         struct ab_task *t;
 642         struct area_priv *ap;
 643
 644         t = ab_task_create_get(qcache, task_fn_area);
 645         if (!t)
 646                 return NULL;
 647         ap = &t->area_pd;
 648         ap->flags = flags;
 649         ap->addr = addr;
 650         ap->is_write = true;
 651         ap->count = count;
 652         memcpy(ap->buf, buf, count);
 653         return t;
 654 }
 655
 656 static struct ab_task *
 657 create_area_user_writer(struct kmem_cache *qcache, u16 flags, u16 addr,
 658                         const void __user *buf, size_t count)
 659 {
 660         struct ab_task *t;
 661         struct area_priv *ap;
 662
 663         t = ab_task_create_get(qcache, task_fn_area);
 664         if (!t)
 665                 return ERR_PTR(-ENOMEM);
 666         ap = &t->area_pd;
 667         ap->flags = flags;
 668         ap->addr = addr;
 669         ap->is_write = true;
 670         ap->count = count;
 671         if (copy_from_user(ap->buf, buf, count)) {
 672                 ab_task_put(t);
 673                 return ERR_PTR(-EFAULT);
 674         }
 675         return t;
 676 }
 677
 678 static bool area_range_ok(u16 addr, size_t count, u16 area_start,
 679                           size_t area_sz)
 680 {
 681         u16 area_end_ex = area_start + area_sz;
 682         u16 addr_end_ex;
 683
 684         if (addr < area_start)
 685                 return false;
 686         if (addr >= area_end_ex)
 687                 return false;
 688         addr_end_ex = addr + count;
 689         if (addr_end_ex > area_end_ex)
 690                 return false;
 691         return true;
 692 }
 693
 694 /* -------------------------- mailbox tasks ----------------------- */
 695
 696 static int task_fn_mbox_2(struct anybuss_host *cd, struct ab_task *t)
 697 {
 698         struct mbox_priv *pd = &t->mbox_pd;
 699         unsigned int ind_ap;
 700
 701         if (!cd->power_on)
 702                 return -EIO;
 703         regmap_read(cd->regmap, REG_IND_AP, &ind_ap);
 704         if (((atomic_read(&cd->ind_ab) ^ ind_ap) & IND_AX_MOUT) == 0) {
 705                 /* output message not here */
 706                 if (time_after(jiffies, t->start_jiffies + TIMEOUT))
 707                         return -ETIMEDOUT;
 708                 return -EINPROGRESS;
 709         }
 710         /* grab the returned header and msg */
 711         regmap_bulk_read(cd->regmap, MBOX_OUT_AREA, &pd->hdr,
 712                          sizeof(pd->hdr));
 713         regmap_bulk_read(cd->regmap, MBOX_OUT_AREA + sizeof(pd->hdr),
 714                          pd->msg, pd->msg_in_sz);
 715         /* tell anybus we've consumed the message */
 716         ind_ap ^= IND_AX_MOUT;
 717         return write_ind_ap(cd->regmap, ind_ap);
 718 }
 719
 720 static int task_fn_mbox(struct anybuss_host *cd, struct ab_task *t)
 721 {
 722         struct mbox_priv *pd = &t->mbox_pd;
 723         unsigned int ind_ap;
 724         int ret;
 725
 726         if (!cd->power_on)
 727                 return -EIO;
 728         regmap_read(cd->regmap, REG_IND_AP, &ind_ap);
 729         if ((atomic_read(&cd->ind_ab) ^ ind_ap) & IND_AX_MIN) {
 730                 /* mbox input area busy */
 731                 if (time_after(jiffies, t->start_jiffies + TIMEOUT))
 732                         return -ETIMEDOUT;
 733                 return -EINPROGRESS;
 734         }
 735         /* write the header and msg to input area */
 736         regmap_bulk_write(cd->regmap, MBOX_IN_AREA, &pd->hdr,
 737                           sizeof(pd->hdr));
 738         regmap_bulk_write(cd->regmap, MBOX_IN_AREA + sizeof(pd->hdr),
 739                           pd->msg, pd->msg_out_sz);
 740         /* tell anybus we gave it a message */
 741         ind_ap ^= IND_AX_MIN;
 742         ret = write_ind_ap(cd->regmap, ind_ap);
 743         if (ret)
 744                 return ret;
 745         t->start_jiffies = jiffies;
 746         t->task_fn = task_fn_mbox_2;
 747         return -EINPROGRESS;
 748 }
 749
 750 static void log_invalid_other(struct device *dev,
 751                               struct anybus_mbox_hdr *hdr)
 752 {
 753         size_t ext_offs = ARRAY_SIZE(hdr->extended) - 1;
 754         u16 code = be16_to_cpu(hdr->extended[ext_offs]);
 755
 756         dev_err(dev, "   Invalid other: [0x%02X]", code);
 757 }
 758
 759 static const char * const EMSGS[] = {
 760         "Invalid Message ID",
 761         "Invalid Message Type",
 762         "Invalid Command",
 763         "Invalid Data Size",
 764         "Message Header Malformed (offset 008h)",
 765         "Message Header Malformed (offset 00Ah)",
 766         "Message Header Malformed (offset 00Ch - 00Dh)",
 767         "Invalid Address",
 768         "Invalid Response",
 769         "Flash Config Error",
 770 };
 771
 772 static int mbox_cmd_err(struct device *dev, struct mbox_priv *mpriv)
 773 {
 774         int i;
 775         u8 ecode;
 776         struct anybus_mbox_hdr *hdr = &mpriv->hdr;
 777         u16 info = be16_to_cpu(hdr->info);
 778         u8 *phdr = (u8 *)hdr;
 779         u8 *pmsg = mpriv->msg;
 780
 781         if (!(info & 0x8000))
 782                 return 0;
 783         ecode = (info >> 8) & 0x0F;
 784         dev_err(dev, "mailbox command failed:");
 785         if (ecode == 0x0F)
 786                 log_invalid_other(dev, hdr);
 787         else if (ecode < ARRAY_SIZE(EMSGS))
 788                 dev_err(dev, "   Error code: %s (0x%02X)",
 789                         EMSGS[ecode], ecode);
 790         else
 791                 dev_err(dev, "   Error code: 0x%02X\n", ecode);
 792         dev_err(dev, "Failed command:");
 793         dev_err(dev, "Message Header:");
 794         for (i = 0; i < sizeof(mpriv->hdr); i += 2)
 795                 dev_err(dev, "%02X%02X", phdr[i], phdr[i + 1]);
 796         dev_err(dev, "Message Data:");
 797         for (i = 0; i < mpriv->msg_in_sz; i += 2)
 798                 dev_err(dev, "%02X%02X", pmsg[i], pmsg[i + 1]);
 799         dev_err(dev, "Stack dump:");
 800         dump_stack();
 801         return -EIO;
 802 }
 803
 804 static int _anybus_mbox_cmd(struct anybuss_host *cd,
 805                             u16 cmd_num, bool is_fb_cmd,
 806                                 const void *msg_out, size_t msg_out_sz,
 807                                 void *msg_in, size_t msg_in_sz,
 808                                 const void *ext, size_t ext_sz)
 809 {
 810         struct ab_task *t;
 811         struct mbox_priv *pd;
 812         struct anybus_mbox_hdr *h;
 813         size_t msg_sz = max(msg_in_sz, msg_out_sz);
 814         u16 info;
 815         int err;
 816
 817         if (msg_sz > MAX_MBOX_MSG_SZ)
 818                 return -EINVAL;
 819         if (ext && ext_sz > sizeof(h->extended))
 820                 return -EINVAL;
 821         t = ab_task_create_get(cd->qcache, task_fn_mbox);
 822         if (!t)
 823                 return -ENOMEM;
 824         pd = &t->mbox_pd;
 825         h = &pd->hdr;
 826         info = is_fb_cmd ? INFO_TYPE_FB : INFO_TYPE_APP;
 827         /*
 828          * prevent uninitialized memory in the header from being sent
 829          * across the anybus
 830          */
 831         memset(h, 0, sizeof(*h));
 832         h->info = cpu_to_be16(info | INFO_COMMAND);
 833         h->cmd_num = cpu_to_be16(cmd_num);
 834         h->data_size = cpu_to_be16(msg_out_sz);
 835         h->frame_count = cpu_to_be16(1);
 836         h->frame_num = cpu_to_be16(1);
 837         h->offset_high = cpu_to_be16(0);
 838         h->offset_low = cpu_to_be16(0);
 839         if (ext)
 840                 memcpy(h->extended, ext, ext_sz);
 841         memcpy(pd->msg, msg_out, msg_out_sz);
 842         pd->msg_out_sz = msg_out_sz;
 843         pd->msg_in_sz = msg_in_sz;
 844         err = ab_task_enqueue_wait(t, cd->powerq, &cd->qlock, &cd->wq);
 845         if (err)
 846                 goto out;
 847         /*
 848          * mailbox mechanism worked ok, but maybe the mbox response
 849          * contains an error ?
 850          */
 851         err = mbox_cmd_err(cd->dev, pd);
 852         if (err)
 853                 goto out;
 854         memcpy(msg_in, pd->msg, msg_in_sz);
 855 out:
 856         ab_task_put(t);
 857         return err;
 858 }
 859
 860 /* ------------------------ anybus queues ------------------------ */
 861
 862 static void process_q(struct anybuss_host *cd, struct kfifo *q)
 863 {
 864         struct ab_task *t;
 865         int ret;
 866
 867         ret = kfifo_out_peek(q, &t, sizeof(t));
 868         if (!ret)
 869                 return;
 870         t->result = t->task_fn(cd, t);
 871         if (t->result != -EINPROGRESS)
 872                 ab_task_dequeue_finish_put(q, cd);
 873 }
 874
 875 static bool qs_have_work(struct kfifo *qs, size_t num)
 876 {
 877         size_t i;
 878         struct ab_task *t;
 879         int ret;
 880
 881         for (i = 0; i < num; i++, qs++) {
 882                 ret = kfifo_out_peek(qs, &t, sizeof(t));
 883                 if (ret && (t->result != -EINPROGRESS))
 884                         return true;
 885         }
 886         return false;
 887 }
 888
 889 static void process_qs(struct anybuss_host *cd)
 890 {
 891         size_t i;
 892         struct kfifo *qs = cd->qs;
 893         size_t nqs = ARRAY_SIZE(cd->qs);
 894
 895         for (i = 0; i < nqs; i++, qs++)
 896                 process_q(cd, qs);
 897 }
 898
 899 static void softint_ack(struct anybuss_host *cd)
 900 {
 901         unsigned int ind_ap;
 902
 903         cd->softint_pending = false;
 904         if (!cd->power_on)
 905                 return;
 906         regmap_read(cd->regmap, REG_IND_AP, &ind_ap);
 907         ind_ap &= ~IND_AX_EVNT;
 908         ind_ap |= atomic_read(&cd->ind_ab) & IND_AX_EVNT;
 909         write_ind_ap(cd->regmap, ind_ap);
 910 }
 911
 912 static void process_softint(struct anybuss_host *cd)
 913 {
 914         struct anybuss_client *client = cd->client;
 915         static const u8 zero;
 916         int ret;
 917         unsigned int ind_ap, ev;
 918         struct ab_task *t;
 919
 920         if (!cd->power_on)
 921                 return;
 922         if (cd->softint_pending)
 923                 return;
 924         regmap_read(cd->regmap, REG_IND_AP, &ind_ap);
 925         if (!((atomic_read(&cd->ind_ab) ^ ind_ap) & IND_AX_EVNT))
 926                 return;
 927         /* process software interrupt */
 928         regmap_read(cd->regmap, REG_EVENT_CAUSE, &ev);
 929         if (ev & EVENT_CAUSE_FBON) {
 930                 if (client->on_online_changed)
 931                         client->on_online_changed(client, true);
 932                 dev_dbg(cd->dev, "Fieldbus ON");
 933         }
 934         if (ev & EVENT_CAUSE_FBOF) {
 935                 if (client->on_online_changed)
 936                         client->on_online_changed(client, false);
 937                 dev_dbg(cd->dev, "Fieldbus OFF");
 938         }
 939         if (ev & EVENT_CAUSE_DC) {
 940                 if (client->on_area_updated)
 941                         client->on_area_updated(client);
 942                 dev_dbg(cd->dev, "Fieldbus data changed");
 943         }
 944         /*
 945          * reset the event cause bits.
 946          * this must be done while owning the fbctrl area, so we'll
 947          * enqueue a task to do that.
 948          */
 949         t = create_area_writer(cd->qcache, IND_AX_FBCTRL,
 950                                REG_EVENT_CAUSE, &zero, sizeof(zero));
 951         if (!t) {
 952                 ret = -ENOMEM;
 953                 goto out;
 954         }
 955         t->done_fn = softint_ack;
 956         ret = ab_task_enqueue(t, cd->powerq, &cd->qlock, &cd->wq);
 957         ab_task_put(t);
 958         cd->softint_pending = true;
 959 out:
 960         WARN_ON(ret);
 961         if (ret)
 962                 softint_ack(cd);
 963 }
 964
 965 static int qthread_fn(void *data)
 966 {
 967         struct anybuss_host *cd = data;
 968         struct kfifo *qs = cd->qs;
 969         size_t nqs = ARRAY_SIZE(cd->qs);
 970         unsigned int ind_ab;
 971
 972         /*
 973          * this kernel thread has exclusive access to the anybus's memory.
 974          * only exception: the IND_AB register, which is accessed exclusively
 975          * by the interrupt service routine (ISR). This thread must not touch
 976          * the IND_AB register, but it does require access to its value.
 977          *
 978          * the interrupt service routine stores the register's value in
 979          * cd->ind_ab (an atomic_t), where we may safely access it, with the
 980          * understanding that it can be modified by the ISR at any time.
 981          */
 982
 983         while (!kthread_should_stop()) {
 984                 /*
 985                  * make a local copy of IND_AB, so we can go around the loop
 986                  * again in case it changed while processing queues and softint.
 987                  */
 988                 ind_ab = atomic_read(&cd->ind_ab);
 989                 process_qs(cd);
 990                 process_softint(cd);
 991                 wait_event_timeout(cd->wq,
 992                                    (atomic_read(&cd->ind_ab) != ind_ab) ||
 993                                 qs_have_work(qs, nqs) ||
 994                                 kthread_should_stop(),
 995                         HZ);
 996                 /*
 997                  * time out so even 'stuck' tasks will run eventually,
 998                  * and can time out.
 999                  */
1000         }
1001
1002         return 0;
1003 }
1004
1005 /* ------------------------ anybus exports ------------------------ */
1006
1007 int anybuss_start_init(struct anybuss_client *client,
1008                        const struct anybuss_memcfg *cfg)
1009 {
1010         int ret;
1011         u16 op_mode;
1012         struct anybuss_host *cd = client->host;
1013         struct msg_anybus_init msg = {
1014                 .input_io_len = cpu_to_be16(cfg->input_io),
1015                 .input_dpram_len = cpu_to_be16(cfg->input_dpram),
1016                 .input_total_len = cpu_to_be16(cfg->input_total),
1017                 .output_io_len = cpu_to_be16(cfg->output_io),
1018                 .output_dpram_len = cpu_to_be16(cfg->output_dpram),
1019                 .output_total_len = cpu_to_be16(cfg->output_total),
1020                 .notif_config = cpu_to_be16(0x000F),
1021                 .wd_val = cpu_to_be16(0),
1022         };
1023
1024         switch (cfg->offl_mode) {
1025         case FIELDBUS_DEV_OFFL_MODE_CLEAR:
1026                 op_mode = 0;
1027                 break;
1028         case FIELDBUS_DEV_OFFL_MODE_FREEZE:
1029                 op_mode = OP_MODE_FBFC;
1030                 break;
1031         case FIELDBUS_DEV_OFFL_MODE_SET:
1032                 op_mode = OP_MODE_FBS;
1033                 break;
1034         default:
1035                 return -EINVAL;
1036         }
1037         msg.op_mode = cpu_to_be16(op_mode | OP_MODE_CD);
1038         ret = _anybus_mbox_cmd(cd, CMD_START_INIT, false, NULL, 0,
1039                                NULL, 0, NULL, 0);
1040         if (ret)
1041                 return ret;
1042         return _anybus_mbox_cmd(cd, CMD_ANYBUS_INIT, false,
1043                         &msg, sizeof(msg), NULL, 0, NULL, 0);
1044 }
1045 EXPORT_SYMBOL_GPL(anybuss_start_init);
1046
1047 int anybuss_finish_init(struct anybuss_client *client)
1048 {
1049         struct anybuss_host *cd = client->host;
1050
1051         return _anybus_mbox_cmd(cd, CMD_END_INIT, false, NULL, 0,
1052                                         NULL, 0, NULL, 0);
1053 }
1054 EXPORT_SYMBOL_GPL(anybuss_finish_init);
1055
1056 int anybuss_read_fbctrl(struct anybuss_client *client, u16 addr,
1057                         void *buf, size_t count)
1058 {
1059         struct anybuss_host *cd = client->host;
1060         struct ab_task *t;
1061         int ret;
1062
1063         if (count == 0)
1064                 return 0;
1065         if (!area_range_ok(addr, count, FBCTRL_AREA,
1066                            MAX_FBCTRL_AREA_SZ))
1067                 return -EFAULT;
1068         t = create_area_reader(cd->qcache, IND_AX_FBCTRL, addr, count);
1069         if (!t)
1070                 return -ENOMEM;
1071         ret = ab_task_enqueue_wait(t, cd->powerq, &cd->qlock, &cd->wq);
1072         if (ret)
1073                 goto out;
1074         memcpy(buf, t->area_pd.buf, count);
1075 out:
1076         ab_task_put(t);
1077         return ret;
1078 }
1079 EXPORT_SYMBOL_GPL(anybuss_read_fbctrl);
1080
1081 int anybuss_write_input(struct anybuss_client *client,
1082                         const char __user *buf, size_t size,
1083                                 loff_t *offset)
1084 {
1085         ssize_t len = min_t(loff_t, MAX_DATA_AREA_SZ - *offset, size);
1086         struct anybuss_host *cd = client->host;
1087         struct ab_task *t;
1088         int ret;
1089
1090         if (len <= 0)
1091                 return 0;
1092         t = create_area_user_writer(cd->qcache, IND_AX_IN,
1093                                     DATA_IN_AREA + *offset, buf, len);
1094         if (IS_ERR(t))
1095                 return PTR_ERR(t);
1096         ret = ab_task_enqueue_wait(t, cd->powerq, &cd->qlock, &cd->wq);
1097         ab_task_put(t);
1098         if (ret)
1099                 return ret;
1100         /* success */
1101         *offset += len;
1102         return len;
1103 }
1104 EXPORT_SYMBOL_GPL(anybuss_write_input);
1105
1106 int anybuss_read_output(struct anybuss_client *client,
1107                         char __user *buf, size_t size,
1108                                 loff_t *offset)
1109 {
1110         ssize_t len = min_t(loff_t, MAX_DATA_AREA_SZ - *offset, size);
1111         struct anybuss_host *cd = client->host;
1112         struct ab_task *t;
1113         int ret;
1114
1115         if (len <= 0)
1116                 return 0;
1117         t = create_area_reader(cd->qcache, IND_AX_OUT,
1118                                DATA_OUT_AREA + *offset, len);
1119         if (!t)
1120                 return -ENOMEM;
1121         ret = ab_task_enqueue_wait(t, cd->powerq, &cd->qlock, &cd->wq);
1122         if (ret)
1123                 goto out;
1124         if (copy_to_user(buf, t->area_pd.buf, len))
1125                 ret = -EFAULT;
1126 out:
1127         ab_task_put(t);
1128         if (ret)
1129                 return ret;
1130         /* success */
1131         *offset += len;
1132         return len;
1133 }
1134 EXPORT_SYMBOL_GPL(anybuss_read_output);
1135
1136 int anybuss_send_msg(struct anybuss_client *client, u16 cmd_num,
1137                      const void *buf, size_t count)
1138 {
1139         struct anybuss_host *cd = client->host;
1140
1141         return _anybus_mbox_cmd(cd, cmd_num, true, buf, count, NULL, 0,
1142                                         NULL, 0);
1143 }
1144 EXPORT_SYMBOL_GPL(anybuss_send_msg);
1145
1146 int anybuss_send_ext(struct anybuss_client *client, u16 cmd_num,
1147                      const void *buf, size_t count)
1148 {
1149         struct anybuss_host *cd = client->host;
1150
1151         return _anybus_mbox_cmd(cd, cmd_num, true, NULL, 0, NULL, 0,
1152                                         buf, count);
1153 }
1154 EXPORT_SYMBOL_GPL(anybuss_send_ext);
1155
1156 int anybuss_recv_msg(struct anybuss_client *client, u16 cmd_num,
1157                      void *buf, size_t count)
1158 {
1159         struct anybuss_host *cd = client->host;
1160
1161         return _anybus_mbox_cmd(cd, cmd_num, true, NULL, 0, buf, count,
1162                                         NULL, 0);
1163 }
1164 EXPORT_SYMBOL_GPL(anybuss_recv_msg);
1165
1166 /* ------------------------ bus functions ------------------------ */
1167
1168 static int anybus_bus_match(struct device *dev,
1169                             struct device_driver *drv)
1170 {
1171         struct anybuss_client_driver *adrv =
1172                 to_anybuss_client_driver(drv);
1173         struct anybuss_client *adev =
1174                 to_anybuss_client(dev);
1175
1176         return adrv->anybus_id == be16_to_cpu(adev->anybus_id);
1177 }
1178
1179 static int anybus_bus_probe(struct device *dev)
1180 {
1181         struct anybuss_client_driver *adrv =
1182                 to_anybuss_client_driver(dev->driver);
1183         struct anybuss_client *adev =
1184                 to_anybuss_client(dev);
1185
1186         if (!adrv->probe)
1187                 return -ENODEV;
1188         return adrv->probe(adev);
1189 }
1190
1191 static int anybus_bus_remove(struct device *dev)
1192 {
1193         struct anybuss_client_driver *adrv =
1194                 to_anybuss_client_driver(dev->driver);
1195
1196         if (adrv->remove)
1197                 return adrv->remove(to_anybuss_client(dev));
1198         return 0;
1199 }
1200
1201 static struct bus_type anybus_bus = {
1202         .name           = "anybuss",
1203         .match          = anybus_bus_match,
1204         .probe          = anybus_bus_probe,
1205         .remove         = anybus_bus_remove,
1206 };
1207
1208 int anybuss_client_driver_register(struct anybuss_client_driver *drv)
1209 {
1210         drv->driver.bus = &anybus_bus;
1211         return driver_register(&drv->driver);
1212 }
1213 EXPORT_SYMBOL_GPL(anybuss_client_driver_register);
1214
1215 void anybuss_client_driver_unregister(struct anybuss_client_driver *drv)
1216 {
1217         return driver_unregister(&drv->driver);
1218 }
1219 EXPORT_SYMBOL_GPL(anybuss_client_driver_unregister);
1220
1221 static void client_device_release(struct device *dev)
1222 {
1223         kfree(to_anybuss_client(dev));
1224 }
1225
1226 static int taskq_alloc(struct device *dev, struct kfifo *q)
1227 {
1228         void *buf;
1229         size_t size = 64 * sizeof(struct ab_task *);
1230
1231         buf = devm_kzalloc(dev, size, GFP_KERNEL);
1232         if (!buf)
1233                 return -EIO;
1234         return kfifo_init(q, buf, size);
1235 }
1236
1237 static int anybus_of_get_host_idx(struct device_node *np)
1238 {
1239         const __be32 *host_idx;
1240
1241         host_idx = of_get_address(np, 0, NULL, NULL);
1242         if (!host_idx)
1243                 return -ENOENT;
1244         return __be32_to_cpu(*host_idx);
1245 }
1246
1247 static struct device_node *
1248 anybus_of_find_child_device(struct device *dev, int host_idx)
1249 {
1250         struct device_node *node;
1251
1252         if (!dev || !dev->of_node)
1253                 return NULL;
1254         for_each_child_of_node(dev->of_node, node) {
1255                 if (anybus_of_get_host_idx(node) == host_idx)
1256                         return node;
1257         }
1258         return NULL;
1259 }
1260
1261 struct anybuss_host * __must_check
1262 anybuss_host_common_probe(struct device *dev,
1263                           const struct anybuss_ops *ops)
1264 {
1265         int ret, i;
1266         u8 val[4];
1267         __be16 fieldbus_type;
1268         struct anybuss_host *cd;
1269
1270         cd = devm_kzalloc(dev, sizeof(*cd), GFP_KERNEL);
1271         if (!cd)
1272                 return ERR_PTR(-ENOMEM);
1273         cd->dev = dev;
1274         cd->host_idx = ops->host_idx;
1275         init_completion(&cd->card_boot);
1276         init_waitqueue_head(&cd->wq);
1277         for (i = 0; i < ARRAY_SIZE(cd->qs); i++) {
1278                 ret = taskq_alloc(dev, &cd->qs[i]);
1279                 if (ret)
1280                         return ERR_PTR(ret);
1281         }
1282         if (WARN_ON(ARRAY_SIZE(cd->qs) < 3))
1283                 return ERR_PTR(-EINVAL);
1284         cd->powerq = &cd->qs[0];
1285         cd->mboxq = &cd->qs[1];
1286         cd->areaq = &cd->qs[2];
1287         cd->reset = ops->reset;
1288         if (!cd->reset)
1289                 return ERR_PTR(-EINVAL);
1290         cd->regmap = ops->regmap;
1291         if (!cd->regmap)
1292                 return ERR_PTR(-EINVAL);
1293         spin_lock_init(&cd->qlock);
1294         cd->qcache = kmem_cache_create(dev_name(dev),
1295                                        sizeof(struct ab_task), 0, 0, NULL);
1296         if (!cd->qcache)
1297                 return ERR_PTR(-ENOMEM);
1298         cd->irq = ops->irq;
1299         if (cd->irq <= 0) {
1300                 ret = -EINVAL;
1301                 goto err_qcache;
1302         }
1303         /*
1304          * use a dpram test to check if a card is present, this is only
1305          * possible while in reset.
1306          */
1307         reset_assert(cd);
1308         if (test_dpram(cd->regmap)) {
1309                 dev_err(dev, "no Anybus-S card in slot");
1310                 ret = -ENODEV;
1311                 goto err_qcache;
1312         }
1313         ret = devm_request_threaded_irq(dev, cd->irq, NULL, irq_handler,
1314                                         IRQF_ONESHOT, dev_name(dev), cd);
1315         if (ret) {
1316                 dev_err(dev, "could not request irq");
1317                 goto err_qcache;
1318         }
1319         /*
1320          * startup sequence:
1321          *   perform dummy IND_AB read to prevent false 'init done' irq
1322          *     (already done by test_dpram() above)
1323          *   release reset
1324          *   wait for first interrupt
1325          *   interrupt came in: ready to go !
1326          */
1327         reset_deassert(cd);
1328         if (!wait_for_completion_timeout(&cd->card_boot, TIMEOUT)) {
1329                 ret = -ETIMEDOUT;
1330                 goto err_reset;
1331         }
1332         /*
1333          * according to the anybus docs, we're allowed to read these
1334          * without handshaking / reserving the area
1335          */
1336         dev_info(dev, "Anybus-S card detected");
1337         regmap_bulk_read(cd->regmap, REG_BOOTLOADER_V, val, 2);
1338         dev_info(dev, "Bootloader version: %02X%02X",
1339                  val[0], val[1]);
1340         regmap_bulk_read(cd->regmap, REG_API_V, val, 2);
1341         dev_info(dev, "API version: %02X%02X", val[0], val[1]);
1342         regmap_bulk_read(cd->regmap, REG_FIELDBUS_V, val, 2);
1343         dev_info(dev, "Fieldbus version: %02X%02X", val[0], val[1]);
1344         regmap_bulk_read(cd->regmap, REG_SERIAL_NO, val, 4);
1345         dev_info(dev, "Serial number: %02X%02X%02X%02X",
1346                  val[0], val[1], val[2], val[3]);
1347         add_device_randomness(&val, 4);
1348         regmap_bulk_read(cd->regmap, REG_FIELDBUS_TYPE, &fieldbus_type,
1349                          sizeof(fieldbus_type));
1350         dev_info(dev, "Fieldbus type: %04X", be16_to_cpu(fieldbus_type));
1351         regmap_bulk_read(cd->regmap, REG_MODULE_SW_V, val, 2);
1352         dev_info(dev, "Module SW version: %02X%02X",
1353                  val[0], val[1]);
1354         /* put card back reset until a client driver releases it */
1355         disable_irq(cd->irq);
1356         reset_assert(cd);
1357         atomic_set(&cd->ind_ab, IND_AB_UPDATED);
1358         /* fire up the queue thread */
1359         cd->qthread = kthread_run(qthread_fn, cd, dev_name(dev));
1360         if (IS_ERR(cd->qthread)) {
1361                 dev_err(dev, "could not create kthread");
1362                 ret = PTR_ERR(cd->qthread);
1363                 goto err_reset;
1364         }
1365         /*
1366          * now advertise that we've detected a client device (card).
1367          * the bus infrastructure will match it to a client driver.
1368          */
1369         cd->client = kzalloc(sizeof(*cd->client), GFP_KERNEL);
1370         if (!cd->client) {
1371                 ret = -ENOMEM;
1372                 goto err_kthread;
1373         }
1374         cd->client->anybus_id = fieldbus_type;
1375         cd->client->host = cd;
1376         cd->client->dev.bus = &anybus_bus;
1377         cd->client->dev.parent = dev;
1378         cd->client->dev.release = client_device_release;
1379         cd->client->dev.of_node =
1380                 anybus_of_find_child_device(dev, cd->host_idx);
1381         dev_set_name(&cd->client->dev, "anybuss.card%d", cd->host_idx);
1382         ret = device_register(&cd->client->dev);
1383         if (ret)
1384                 goto err_device;
1385         return cd;
1386 err_device:
1387         device_unregister(&cd->client->dev);
1388 err_kthread:
1389         kthread_stop(cd->qthread);
1390 err_reset:
1391         reset_assert(cd);
1392 err_qcache:
1393         kmem_cache_destroy(cd->qcache);
1394         return ERR_PTR(ret);
1395 }
1396 EXPORT_SYMBOL_GPL(anybuss_host_common_probe);
1397
1398 void anybuss_host_common_remove(struct anybuss_host *host)
1399 {
1400         struct anybuss_host *cd = host;
1401
1402         device_unregister(&cd->client->dev);
1403         kthread_stop(cd->qthread);
1404         reset_assert(cd);
1405         kmem_cache_destroy(cd->qcache);
1406 }
1407 EXPORT_SYMBOL_GPL(anybuss_host_common_remove);
1408
1409 static void host_release(struct device *dev, void *res)
1410 {
1411         struct anybuss_host **dr = res;
1412
1413         anybuss_host_common_remove(*dr);
1414 }
1415
1416 struct anybuss_host * __must_check
1417 devm_anybuss_host_common_probe(struct device *dev,
1418                                const struct anybuss_ops *ops)
1419 {
1420         struct anybuss_host **dr;
1421         struct anybuss_host *host;
1422
1423         dr = devres_alloc(host_release, sizeof(struct anybuss_host *),
1424                           GFP_KERNEL);
1425         if (!dr)
1426                 return ERR_PTR(-ENOMEM);
1427
1428         host = anybuss_host_common_probe(dev, ops);
1429         if (IS_ERR(host)) {
1430                 devres_free(dr);
1431                 return host;
1432         }
1433         *dr = host;
1434         devres_add(dev, dr);
1435         return host;
1436 }
1437 EXPORT_SYMBOL_GPL(devm_anybuss_host_common_probe);
1438
1439 static int __init anybus_init(void)
1440 {
1441         int ret;
1442
1443         ret = bus_register(&anybus_bus);
1444         if (ret)
1445                 pr_err("could not register Anybus-S bus: %d\n", ret);
1446         return ret;
1447 }
1448 module_init(anybus_init);
1449
1450 static void __exit anybus_exit(void)
1451 {
1452         bus_unregister(&anybus_bus);
1453 }
1454 module_exit(anybus_exit);
1455
1456 MODULE_DESCRIPTION("HMS Anybus-S Host Driver");
1457 MODULE_AUTHOR("Sven Van Asbroeck <[email protected]>");
1458 MODULE_LICENSE("GPL v2");