sound/firewire/fireworks/fireworks_transaction.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * fireworks_transaction.c - a part of driver for Fireworks based devices
   4  *
   5  * Copyright (c) 2013-2014 Takashi Sakamoto
   6  */
   7
   8 /*
   9  * Fireworks have its own transaction. The transaction can be delivered by AV/C
  10  * Vendor Specific command frame or usual asynchronous transaction. At least,
  11  * Windows driver and firmware version 5.5 or later don't use AV/C command.
  12  *
  13  * Transaction substance:
  14  *  At first, 6 data exist. Following to the data, parameters for each command
  15  *  exist. All of the parameters are 32 bit aligned to big endian.
  16  *   data[0]:   Length of transaction substance
  17  *   data[1]:   Transaction version
  18  *   data[2]:   Sequence number. This is incremented by the device
  19  *   data[3]:   Transaction category
  20  *   data[4]:   Transaction command
  21  *   data[5]:   Return value in response.
  22  *   data[6-]:  Parameters
  23  *
  24  * Transaction address:
  25  *  command:    0xecc000000000
  26  *  response:   0xecc080000000 (default)
  27  *
  28  * I note that the address for response can be changed by command. But this
  29  * module uses the default address.
  30  */
  31 #include "./fireworks.h"
  32
  33 #define MEMORY_SPACE_EFW_COMMAND        0xecc000000000ULL
  34 #define MEMORY_SPACE_EFW_RESPONSE       0xecc080000000ULL
  35
  36 #define ERROR_RETRIES 3
  37 #define ERROR_DELAY_MS 5
  38 #define EFC_TIMEOUT_MS 125
  39
  40 static DEFINE_SPINLOCK(instances_lock);
  41 static struct snd_efw *instances[SNDRV_CARDS] = SNDRV_DEFAULT_PTR;
  42
  43 static DEFINE_SPINLOCK(transaction_queues_lock);
  44 static LIST_HEAD(transaction_queues);
  45
  46 enum transaction_queue_state {
  47         STATE_PENDING,
  48         STATE_BUS_RESET,
  49         STATE_COMPLETE
  50 };
  51
  52 struct transaction_queue {
  53         struct list_head list;
  54         struct fw_unit *unit;
  55         void *buf;
  56         unsigned int size;
  57         u32 seqnum;
  58         enum transaction_queue_state state;
  59         wait_queue_head_t wait;
  60 };
  61
  62 int snd_efw_transaction_cmd(struct fw_unit *unit,
  63                             const void *cmd, unsigned int size)
  64 {
  65         return snd_fw_transaction(unit, TCODE_WRITE_BLOCK_REQUEST,
  66                                   MEMORY_SPACE_EFW_COMMAND,
  67                                   (void *)cmd, size, 0);
  68 }
  69
  70 int snd_efw_transaction_run(struct fw_unit *unit,
  71                             const void *cmd, unsigned int cmd_size,
  72                             void *resp, unsigned int resp_size)
  73 {
  74         struct transaction_queue t;
  75         unsigned int tries;
  76         int ret;
  77
  78         t.unit = unit;
  79         t.buf = resp;
  80         t.size = resp_size;
  81         t.seqnum = be32_to_cpu(((struct snd_efw_transaction *)cmd)->seqnum) + 1;
  82         t.state = STATE_PENDING;
  83         init_waitqueue_head(&t.wait);
  84
  85         spin_lock_irq(&transaction_queues_lock);
  86         list_add_tail(&t.list, &transaction_queues);
  87         spin_unlock_irq(&transaction_queues_lock);
  88
  89         tries = 0;
  90         do {
  91                 ret = snd_efw_transaction_cmd(t.unit, (void *)cmd, cmd_size);
  92                 if (ret < 0)
  93                         break;
  94
  95                 wait_event_timeout(t.wait, t.state != STATE_PENDING,
  96                                    msecs_to_jiffies(EFC_TIMEOUT_MS));
  97
  98                 if (t.state == STATE_COMPLETE) {
  99                         ret = t.size;
 100                         break;
 101                 } else if (t.state == STATE_BUS_RESET) {
 102                         msleep(ERROR_DELAY_MS);
 103                 } else if (++tries >= ERROR_RETRIES) {
 104                         dev_err(&t.unit->device, "EFW transaction timed out\n");
 105                         ret = -EIO;
 106                         break;
 107                 }
 108         } while (1);
 109
 110         spin_lock_irq(&transaction_queues_lock);
 111         list_del(&t.list);
 112         spin_unlock_irq(&transaction_queues_lock);
 113
 114         return ret;
 115 }
 116
 117 static void
 118 copy_resp_to_buf(struct snd_efw *efw, void *data, size_t length, int *rcode)
 119 {
 120         size_t capacity, till_end;
 121         struct snd_efw_transaction *t;
 122
 123         t = (struct snd_efw_transaction *)data;
 124         length = min_t(size_t, be32_to_cpu(t->length) * sizeof(u32), length);
 125
 126         spin_lock(&efw->lock);
 127
 128         if (efw->push_ptr < efw->pull_ptr)
 129                 capacity = (unsigned int)(efw->pull_ptr - efw->push_ptr);
 130         else
 131                 capacity = snd_efw_resp_buf_size -
 132                            (unsigned int)(efw->push_ptr - efw->pull_ptr);
 133
 134         /* confirm enough space for this response */
 135         if (capacity < length) {
 136                 *rcode = RCODE_CONFLICT_ERROR;
 137                 goto end;
 138         }
 139
 140         /* copy to ring buffer */
 141         while (length > 0) {
 142                 till_end = snd_efw_resp_buf_size -
 143                            (unsigned int)(efw->push_ptr - efw->resp_buf);
 144                 till_end = min_t(unsigned int, length, till_end);
 145
 146                 memcpy(efw->push_ptr, data, till_end);
 147
 148                 efw->push_ptr += till_end;
 149                 if (efw->push_ptr >= efw->resp_buf + snd_efw_resp_buf_size)
 150                         efw->push_ptr -= snd_efw_resp_buf_size;
 151
 152                 length -= till_end;
 153                 data += till_end;
 154         }
 155
 156         /* for hwdep */
 157         wake_up(&efw->hwdep_wait);
 158
 159         *rcode = RCODE_COMPLETE;
 160 end:
 161         spin_unlock_irq(&efw->lock);
 162 }
 163
 164 static void
 165 handle_resp_for_user(struct fw_card *card, int generation, int source,
 166                      void *data, size_t length, int *rcode)
 167 {
 168         struct fw_device *device;
 169         struct snd_efw *efw;
 170         unsigned int i;
 171
 172         spin_lock_irq(&instances_lock);
 173
 174         for (i = 0; i < SNDRV_CARDS; i++) {
 175                 efw = instances[i];
 176                 if (efw == NULL)
 177                         continue;
 178                 device = fw_parent_device(efw->unit);
 179                 if ((device->card != card) ||
 180                     (device->generation != generation))
 181                         continue;
 182                 smp_rmb();      /* node id vs. generation */
 183                 if (device->node_id != source)
 184                         continue;
 185
 186                 break;
 187         }
 188         if (i == SNDRV_CARDS)
 189                 goto end;
 190
 191         copy_resp_to_buf(efw, data, length, rcode);
 192 end:
 193         spin_unlock(&instances_lock);
 194 }
 195
 196 static void
 197 handle_resp_for_kernel(struct fw_card *card, int generation, int source,
 198                        void *data, size_t length, int *rcode, u32 seqnum)
 199 {
 200         struct fw_device *device;
 201         struct transaction_queue *t;
 202         unsigned long flags;
 203
 204         spin_lock_irqsave(&transaction_queues_lock, flags);
 205         list_for_each_entry(t, &transaction_queues, list) {
 206                 device = fw_parent_device(t->unit);
 207                 if ((device->card != card) ||
 208                     (device->generation != generation))
 209                         continue;
 210                 smp_rmb();      /* node_id vs. generation */
 211                 if (device->node_id != source)
 212                         continue;
 213
 214                 if ((t->state == STATE_PENDING) && (t->seqnum == seqnum)) {
 215                         t->state = STATE_COMPLETE;
 216                         t->size = min_t(unsigned int, length, t->size);
 217                         memcpy(t->buf, data, t->size);
 218                         wake_up(&t->wait);
 219                         *rcode = RCODE_COMPLETE;
 220                 }
 221         }
 222         spin_unlock_irqrestore(&transaction_queues_lock, flags);
 223 }
 224
 225 static void
 226 efw_response(struct fw_card *card, struct fw_request *request,
 227              int tcode, int destination, int source,
 228              int generation, unsigned long long offset,
 229              void *data, size_t length, void *callback_data)
 230 {
 231         int rcode, dummy;
 232         u32 seqnum;
 233
 234         rcode = RCODE_TYPE_ERROR;
 235         if (length < sizeof(struct snd_efw_transaction)) {
 236                 rcode = RCODE_DATA_ERROR;
 237                 goto end;
 238         } else if (offset != MEMORY_SPACE_EFW_RESPONSE) {
 239                 rcode = RCODE_ADDRESS_ERROR;
 240                 goto end;
 241         }
 242
 243         seqnum = be32_to_cpu(((struct snd_efw_transaction *)data)->seqnum);
 244         if (seqnum > SND_EFW_TRANSACTION_USER_SEQNUM_MAX + 1) {
 245                 handle_resp_for_kernel(card, generation, source,
 246                                        data, length, &rcode, seqnum);
 247                 if (snd_efw_resp_buf_debug)
 248                         handle_resp_for_user(card, generation, source,
 249                                              data, length, &dummy);
 250         } else {
 251                 handle_resp_for_user(card, generation, source,
 252                                      data, length, &rcode);
 253         }
 254 end:
 255         fw_send_response(card, request, rcode);
 256 }
 257
 258 void snd_efw_transaction_add_instance(struct snd_efw *efw)
 259 {
 260         unsigned int i;
 261
 262         spin_lock_irq(&instances_lock);
 263
 264         for (i = 0; i < SNDRV_CARDS; i++) {
 265                 if (instances[i] != NULL)
 266                         continue;
 267                 instances[i] = efw;
 268                 break;
 269         }
 270
 271         spin_unlock_irq(&instances_lock);
 272 }
 273
 274 void snd_efw_transaction_remove_instance(struct snd_efw *efw)
 275 {
 276         unsigned int i;
 277
 278         spin_lock_irq(&instances_lock);
 279
 280         for (i = 0; i < SNDRV_CARDS; i++) {
 281                 if (instances[i] != efw)
 282                         continue;
 283                 instances[i] = NULL;
 284         }
 285
 286         spin_unlock_irq(&instances_lock);
 287 }
 288
 289 void snd_efw_transaction_bus_reset(struct fw_unit *unit)
 290 {
 291         struct transaction_queue *t;
 292
 293         spin_lock_irq(&transaction_queues_lock);
 294         list_for_each_entry(t, &transaction_queues, list) {
 295                 if ((t->unit == unit) &&
 296                     (t->state == STATE_PENDING)) {
 297                         t->state = STATE_BUS_RESET;
 298                         wake_up(&t->wait);
 299                 }
 300         }
 301         spin_unlock_irq(&transaction_queues_lock);
 302 }
 303
 304 static struct fw_address_handler resp_register_handler = {
 305         .length = SND_EFW_RESPONSE_MAXIMUM_BYTES,
 306         .address_callback = efw_response
 307 };
 308
 309 int snd_efw_transaction_register(void)
 310 {
 311         static const struct fw_address_region resp_register_region = {
 312                 .start  = MEMORY_SPACE_EFW_RESPONSE,
 313                 .end    = MEMORY_SPACE_EFW_RESPONSE +
 314                           SND_EFW_RESPONSE_MAXIMUM_BYTES
 315         };
 316         return fw_core_add_address_handler(&resp_register_handler,
 317                                            &resp_register_region);
 318 }
 319
 320 void snd_efw_transaction_unregister(void)
 321 {
 322         WARN_ON(!list_empty(&transaction_queues));
 323         fw_core_remove_address_handler(&resp_register_handler);
 324 }