linux-imx

// SPDX-License-Identifier: GPL-2.0-only

/*

 * fireworks_transaction.c - a part of driver for Fireworks based devices

 *

 * Copyright (c) 2013-2014 Takashi Sakamoto

 */

​

/*

 * Fireworks have its own transaction. The transaction can be delivered by AV/C

 * Vendor Specific command frame or usual asynchronous transaction. At least,

 * Windows driver and firmware version 5.5 or later don't use AV/C command.

 *

 * Transaction substance:

 *  At first, 6 data exist. Following to the data, parameters for each command

 *  exist. All of the parameters are 32 bit aligned to big endian.

 *   data[0]:   Length of transaction substance

 *   data[1]:   Transaction version

 *   data[2]:   Sequence number. This is incremented by the device

 *   data[3]:   Transaction category

 *   data[4]:   Transaction command

 *   data[5]:   Return value in response.

 *   data[6-]:  Parameters

 *

 * Transaction address:

 *  command:    0xecc000000000

 *  response:   0xecc080000000 (default)

 *

 * I note that the address for response can be changed by command. But this

 * module uses the default address.

 */

#include "./fireworks.h"

​

#define MEMORY_SPACE_EFW_COMMAND    0xecc000000000ULL

#define MEMORY_SPACE_EFW_RESPONSE   0xecc080000000ULL

​

#define ERROR_RETRIES 3

#define ERROR_DELAY_MS 5

#define EFC_TIMEOUT_MS 125

​

static DEFINE_SPINLOCK(instances_lock);

static struct snd_efw *instances[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;

​

static DEFINE_SPINLOCK(transaction_queues_lock);

static LIST_HEAD(transaction_queues);

​

enum transaction_queue_state {

    STATE_PENDING,

    STATE_BUS_RESET,

    STATE_COMPLETE

};

​

struct transaction_queue {

    struct list_head list;

    struct fw_unit *unit;

    void *buf;

    unsigned int size;

    u32 seqnum;

    enum transaction_queue_state state;

    wait_queue_head_t wait;

};

​

int snd_efw_transaction_cmd(struct fw_unit *unit,

                const void *cmd, unsigned int size)

{

    return snd_fw_transaction(unit, TCODE_WRITE_BLOCK_REQUEST,

                  MEMORY_SPACE_EFW_COMMAND,

                  (void *)cmd, size, 0);

}

​

int snd_efw_transaction_run(struct fw_unit *unit,

                const void *cmd, unsigned int cmd_size,

                void *resp, unsigned int resp_size)

{

    struct transaction_queue t;

    unsigned int tries;

    int ret;

​

    t.unit = unit;

    t.buf = resp;

    t.size = resp_size;

    t.seqnum = be32_to_cpu(((struct snd_efw_transaction *)cmd)->seqnum) + 1;

    t.state = STATE_PENDING;

    init_waitqueue_head(&t.wait);

​

    spin_lock_irq(&transaction_queues_lock);

    list_add_tail(&t.list, &transaction_queues);

    spin_unlock_irq(&transaction_queues_lock);

​

    tries = 0;

    do {

        ret = snd_efw_transaction_cmd(t.unit, (void *)cmd, cmd_size);

        if (ret < 0)