1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Function Control Protocol (IEC 61883-1) helper functions 4 * 5 * Copyright (c) Clemens Ladisch <clemens@ladisch.de> 6 */ 7 8 #include <linux/device.h> 9 #include <linux/firewire.h> 10 #include <linux/firewire-constants.h> 11 #include <linux/list.h> 12 #include <linux/module.h> 13 #include <linux/slab.h> 14 #include <linux/sched.h> 15 #include <linux/spinlock.h> 16 #include <linux/wait.h> 17 #include <linux/delay.h> 18 #include "fcp.h" 19 #include "lib.h" 20 #include "amdtp-stream.h" 21 22 #define CTS_AVC 0x00 23 24 #define ERROR_RETRIES 3 25 #define ERROR_DELAY_MS 5 26 #define FCP_TIMEOUT_MS 125 27 28 int avc_general_set_sig_fmt(struct fw_unit *unit, unsigned int rate, 29 enum avc_general_plug_dir dir, 30 unsigned short pid) 31 { 32 unsigned int sfc; 33 u8 *buf; 34 bool flag; 35 int err; 36 37 flag = false; 38 for (sfc = 0; sfc < CIP_SFC_COUNT; sfc++) { 39 if (amdtp_rate_table[sfc] == rate) { 40 flag = true; 41 break; 42 } 43 } 44 if (!flag) 45 return -EINVAL; 46 47 buf = kzalloc(8, GFP_KERNEL); 48 if (buf == NULL) 49 return -ENOMEM; 50 51 buf[0] = 0x00; /* AV/C CONTROL */ 52 buf[1] = 0xff; /* UNIT */ 53 if (dir == AVC_GENERAL_PLUG_DIR_IN) 54 buf[2] = 0x19; /* INPUT PLUG SIGNAL FORMAT */ 55 else 56 buf[2] = 0x18; /* OUTPUT PLUG SIGNAL FORMAT */ 57 buf[3] = 0xff & pid; /* plug id */ 58 buf[4] = 0x90; /* EOH_1, Form_1, FMT. AM824 */ 59 buf[5] = 0x07 & sfc; /* FDF-hi. AM824, frequency */ 60 buf[6] = 0xff; /* FDF-mid. AM824, SYT hi (not used)*/ 61 buf[7] = 0xff; /* FDF-low. AM824, SYT lo (not used) */ 62 63 /* do transaction and check buf[1-5] are the same against command */ 64 err = fcp_avc_transaction(unit, buf, 8, buf, 8, 65 BIT(1) | BIT(2) | BIT(3) | BIT(4) | BIT(5)); 66 if (err < 0) 67 ; 68 else if (err < 8) 69 err = -EIO; 70 else if (buf[0] == 0x08) /* NOT IMPLEMENTED */ 71 err = -ENOSYS; 72 else if (buf[0] == 0x0a) /* REJECTED */ 73 err = -EINVAL; 74 if (err < 0) 75 goto end; 76 77 err = 0; 78 end: 79 kfree(buf); 80 return err; 81 } 82 EXPORT_SYMBOL(avc_general_set_sig_fmt); 83 84 int avc_general_get_sig_fmt(struct fw_unit *unit, unsigned int *rate, 85 enum avc_general_plug_dir dir, 86 unsigned short pid) 87 { 88 unsigned int sfc; 89 u8 *buf; 90 int err; 91 92 buf = kzalloc(8, GFP_KERNEL); 93 if (buf == NULL) 94 return -ENOMEM; 95 96 buf[0] = 0x01; /* AV/C STATUS */ 97 buf[1] = 0xff; /* Unit */ 98 if (dir == AVC_GENERAL_PLUG_DIR_IN) 99 buf[2] = 0x19; /* INPUT PLUG SIGNAL FORMAT */ 100 else 101 buf[2] = 0x18; /* OUTPUT PLUG SIGNAL FORMAT */ 102 buf[3] = 0xff & pid; /* plug id */ 103 buf[4] = 0x90; /* EOH_1, Form_1, FMT. AM824 */ 104 buf[5] = 0xff; /* FDF-hi. AM824, frequency */ 105 buf[6] = 0xff; /* FDF-mid. AM824, SYT hi (not used) */ 106 buf[7] = 0xff; /* FDF-low. AM824, SYT lo (not used) */ 107 108 /* do transaction and check buf[1-4] are the same against command */ 109 err = fcp_avc_transaction(unit, buf, 8, buf, 8, 110 BIT(1) | BIT(2) | BIT(3) | BIT(4)); 111 if (err < 0) 112 ; 113 else if (err < 8) 114 err = -EIO; 115 else if (buf[0] == 0x08) /* NOT IMPLEMENTED */ 116 err = -ENOSYS; 117 else if (buf[0] == 0x0a) /* REJECTED */ 118 err = -EINVAL; 119 else if (buf[0] == 0x0b) /* IN TRANSITION */ 120 err = -EAGAIN; 121 if (err < 0) 122 goto end; 123 124 /* check sfc field and pick up rate */ 125 sfc = 0x07 & buf[5]; 126 if (sfc >= CIP_SFC_COUNT) { 127 err = -EAGAIN; /* also in transition */ 128 goto end; 129 } 130 131 *rate = amdtp_rate_table[sfc]; 132 err = 0; 133 end: 134 kfree(buf); 135 return err; 136 } 137 EXPORT_SYMBOL(avc_general_get_sig_fmt); 138 139 int avc_general_get_plug_info(struct fw_unit *unit, unsigned int subunit_type, 140 unsigned int subunit_id, unsigned int subfunction, 141 u8 info[AVC_PLUG_INFO_BUF_BYTES]) 142 { 143 u8 *buf; 144 int err; 145 146 /* extended subunit in spec.4.2 is not supported */ 147 if ((subunit_type == 0x1E) || (subunit_id == 5)) 148 return -EINVAL; 149 150 buf = kzalloc(8, GFP_KERNEL); 151 if (buf == NULL) 152 return -ENOMEM; 153 154 buf[0] = 0x01; /* AV/C STATUS */ 155 /* UNIT or Subunit, Functionblock */ 156 buf[1] = ((subunit_type & 0x1f) << 3) | (subunit_id & 0x7); 157 buf[2] = 0x02; /* PLUG INFO */ 158 buf[3] = 0xff & subfunction; 159 160 err = fcp_avc_transaction(unit, buf, 8, buf, 8, BIT(1) | BIT(2)); 161 if (err < 0) 162 ; 163 else if (err < 8) 164 err = -EIO; 165 else if (buf[0] == 0x08) /* NOT IMPLEMENTED */ 166 err = -ENOSYS; 167 else if (buf[0] == 0x0a) /* REJECTED */ 168 err = -EINVAL; 169 else if (buf[0] == 0x0b) /* IN TRANSITION */ 170 err = -EAGAIN; 171 if (err < 0) 172 goto end; 173 174 info[0] = buf[4]; 175 info[1] = buf[5]; 176 info[2] = buf[6]; 177 info[3] = buf[7]; 178 179 err = 0; 180 end: 181 kfree(buf); 182 return err; 183 } 184 EXPORT_SYMBOL(avc_general_get_plug_info); 185 186 static DEFINE_SPINLOCK(transactions_lock); 187 static LIST_HEAD(transactions); 188 189 enum fcp_state { 190 STATE_PENDING, 191 STATE_BUS_RESET, 192 STATE_COMPLETE, 193 STATE_DEFERRED, 194 }; 195 196 struct fcp_transaction { 197 struct list_head list; 198 struct fw_unit *unit; 199 void *response_buffer; 200 unsigned int response_size; 201 unsigned int response_match_bytes; 202 enum fcp_state state; 203 wait_queue_head_t wait; 204 bool deferrable; 205 }; 206 207 /** 208 * fcp_avc_transaction - send an AV/C command and wait for its response 209 * @unit: a unit on the target device 210 * @command: a buffer containing the command frame; must be DMA-able 211 * @command_size: the size of @command 212 * @response: a buffer for the response frame 213 * @response_size: the maximum size of @response 214 * @response_match_bytes: a bitmap specifying the bytes used to detect the 215 * correct response frame 216 * 217 * This function sends a FCP command frame to the target and waits for the 218 * corresponding response frame to be returned. 219 * 220 * Because it is possible for multiple FCP transactions to be active at the 221 * same time, the correct response frame is detected by the value of certain 222 * bytes. These bytes must be set in @response before calling this function, 223 * and the corresponding bits must be set in @response_match_bytes. 224 * 225 * @command and @response can point to the same buffer. 226 * 227 * Returns the actual size of the response frame, or a negative error code. 228 */ 229 int fcp_avc_transaction(struct fw_unit *unit, 230 const void *command, unsigned int command_size, 231 void *response, unsigned int response_size, 232 unsigned int response_match_bytes) 233 { 234 struct fcp_transaction t; 235 int tcode, ret, tries = 0; 236 237 t.unit = unit; 238 t.response_buffer = response; 239 t.response_size = response_size; 240 t.response_match_bytes = response_match_bytes; 241 t.state = STATE_PENDING; 242 init_waitqueue_head(&t.wait); 243 244 if (*(const u8 *)command == 0x00 || *(const u8 *)command == 0x03) 245 t.deferrable = true; 246 247 spin_lock_irq(&transactions_lock); 248 list_add_tail(&t.list, &transactions); 249 spin_unlock_irq(&transactions_lock); 250 251 for (;;) { 252 tcode = command_size == 4 ? TCODE_WRITE_QUADLET_REQUEST 253 : TCODE_WRITE_BLOCK_REQUEST; 254 ret = snd_fw_transaction(t.unit, tcode, 255 CSR_REGISTER_BASE + CSR_FCP_COMMAND, 256 (void *)command, command_size, 0); 257 if (ret < 0) 258 break; 259 deferred: 260 wait_event_timeout(t.wait, t.state != STATE_PENDING, 261 msecs_to_jiffies(FCP_TIMEOUT_MS)); 262 263 if (t.state == STATE_DEFERRED) { 264 /* 265 * 'AV/C General Specification' define no time limit 266 * on command completion once an INTERIM response has 267 * been sent. but we promise to finish this function 268 * for a caller. Here we use FCP_TIMEOUT_MS for next 269 * interval. This is not in the specification. 270 */ 271 t.state = STATE_PENDING; 272 goto deferred; 273 } else if (t.state == STATE_COMPLETE) { 274 ret = t.response_size; 275 break; 276 } else if (t.state == STATE_BUS_RESET) { 277 msleep(ERROR_DELAY_MS); 278 } else if (++tries >= ERROR_RETRIES) { 279 dev_err(&t.unit->device, "FCP command timed out\n"); 280 ret = -EIO; 281 break; 282 } 283 } 284 285 spin_lock_irq(&transactions_lock); 286 list_del(&t.list); 287 spin_unlock_irq(&transactions_lock); 288 289 return ret; 290 } 291 EXPORT_SYMBOL(fcp_avc_transaction); 292 293 /** 294 * fcp_bus_reset - inform the target handler about a bus reset 295 * @unit: the unit that might be used by fcp_avc_transaction() 296 * 297 * This function must be called from the driver's .update handler to inform 298 * the FCP transaction handler that a bus reset has happened. Any pending FCP 299 * transactions are retried. 300 */ 301 void fcp_bus_reset(struct fw_unit *unit) 302 { 303 struct fcp_transaction *t; 304 305 spin_lock_irq(&transactions_lock); 306 list_for_each_entry(t, &transactions, list) { 307 if (t->unit == unit && 308 (t->state == STATE_PENDING || 309 t->state == STATE_DEFERRED)) { 310 t->state = STATE_BUS_RESET; 311 wake_up(&t->wait); 312 } 313 } 314 spin_unlock_irq(&transactions_lock); 315 } 316 EXPORT_SYMBOL(fcp_bus_reset); 317 318 /* checks whether the response matches the masked bytes in response_buffer */ 319 static bool is_matching_response(struct fcp_transaction *transaction, 320 const void *response, size_t length) 321 { 322 const u8 *p1, *p2; 323 unsigned int mask, i; 324 325 p1 = response; 326 p2 = transaction->response_buffer; 327 mask = transaction->response_match_bytes; 328 329 for (i = 0; ; ++i) { 330 if ((mask & 1) && p1[i] != p2[i]) 331 return false; 332 mask >>= 1; 333 if (!mask) 334 return true; 335 if (--length == 0) 336 return false; 337 } 338 } 339 340 static void fcp_response(struct fw_card *card, struct fw_request *request, 341 int tcode, int destination, int source, 342 int generation, unsigned long long offset, 343 void *data, size_t length, void *callback_data) 344 { 345 struct fcp_transaction *t; 346 unsigned long flags; 347 348 if (length < 1 || (*(const u8 *)data & 0xf0) != CTS_AVC) 349 return; 350 351 spin_lock_irqsave(&transactions_lock, flags); 352 list_for_each_entry(t, &transactions, list) { 353 struct fw_device *device = fw_parent_device(t->unit); 354 if (device->card != card || 355 device->generation != generation) 356 continue; 357 smp_rmb(); /* node_id vs. generation */ 358 if (device->node_id != source) 359 continue; 360 361 if (t->state == STATE_PENDING && 362 is_matching_response(t, data, length)) { 363 if (t->deferrable && *(const u8 *)data == 0x0f) { 364 t->state = STATE_DEFERRED; 365 } else { 366 t->state = STATE_COMPLETE; 367 t->response_size = min_t(unsigned int, length, 368 t->response_size); 369 memcpy(t->response_buffer, data, 370 t->response_size); 371 } 372 wake_up(&t->wait); 373 } 374 } 375 spin_unlock_irqrestore(&transactions_lock, flags); 376 } 377 378 static struct fw_address_handler response_register_handler = { 379 .length = 0x200, 380 .address_callback = fcp_response, 381 }; 382 383 static int __init fcp_module_init(void) 384 { 385 static const struct fw_address_region response_register_region = { 386 .start = CSR_REGISTER_BASE + CSR_FCP_RESPONSE, 387 .end = CSR_REGISTER_BASE + CSR_FCP_END, 388 }; 389 390 fw_core_add_address_handler(&response_register_handler, 391 &response_register_region); 392 393 return 0; 394 } 395 396 static void __exit fcp_module_exit(void) 397 { 398 WARN_ON(!list_empty(&transactions)); 399 fw_core_remove_address_handler(&response_register_handler); 400 } 401 402 module_init(fcp_module_init); 403 module_exit(fcp_module_exit); 404