1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Connection Management Procedures (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/module.h> 12 #include <linux/sched.h> 13 #include "lib.h" 14 #include "iso-resources.h" 15 #include "cmp.h" 16 17 /* MPR common fields */ 18 #define MPR_SPEED_MASK 0xc0000000 19 #define MPR_SPEED_SHIFT 30 20 #define MPR_XSPEED_MASK 0x00000060 21 #define MPR_XSPEED_SHIFT 5 22 #define MPR_PLUGS_MASK 0x0000001f 23 24 /* PCR common fields */ 25 #define PCR_ONLINE 0x80000000 26 #define PCR_BCAST_CONN 0x40000000 27 #define PCR_P2P_CONN_MASK 0x3f000000 28 #define PCR_P2P_CONN_SHIFT 24 29 #define PCR_CHANNEL_MASK 0x003f0000 30 #define PCR_CHANNEL_SHIFT 16 31 32 /* oPCR specific fields */ 33 #define OPCR_XSPEED_MASK 0x00C00000 34 #define OPCR_XSPEED_SHIFT 22 35 #define OPCR_SPEED_MASK 0x0000C000 36 #define OPCR_SPEED_SHIFT 14 37 #define OPCR_OVERHEAD_ID_MASK 0x00003C00 38 #define OPCR_OVERHEAD_ID_SHIFT 10 39 40 enum bus_reset_handling { 41 ABORT_ON_BUS_RESET, 42 SUCCEED_ON_BUS_RESET, 43 }; 44 45 static __printf(2, 3) 46 void cmp_error(struct cmp_connection *c, const char *fmt, ...) 47 { 48 va_list va; 49 50 va_start(va, fmt); 51 dev_err(&c->resources.unit->device, "%cPCR%u: %pV", 52 (c->direction == CMP_INPUT) ? 'i' : 'o', 53 c->pcr_index, &(struct va_format){ fmt, &va }); 54 va_end(va); 55 } 56 57 static u64 mpr_address(struct cmp_connection *c) 58 { 59 if (c->direction == CMP_INPUT) 60 return CSR_REGISTER_BASE + CSR_IMPR; 61 else 62 return CSR_REGISTER_BASE + CSR_OMPR; 63 } 64 65 static u64 pcr_address(struct cmp_connection *c) 66 { 67 if (c->direction == CMP_INPUT) 68 return CSR_REGISTER_BASE + CSR_IPCR(c->pcr_index); 69 else 70 return CSR_REGISTER_BASE + CSR_OPCR(c->pcr_index); 71 } 72 73 static int pcr_modify(struct cmp_connection *c, 74 __be32 (*modify)(struct cmp_connection *c, __be32 old), 75 int (*check)(struct cmp_connection *c, __be32 pcr), 76 enum bus_reset_handling bus_reset_handling) 77 { 78 __be32 old_arg, buffer[2]; 79 int err; 80 81 buffer[0] = c->last_pcr_value; 82 for (;;) { 83 old_arg = buffer[0]; 84 buffer[1] = modify(c, buffer[0]); 85 86 err = snd_fw_transaction( 87 c->resources.unit, TCODE_LOCK_COMPARE_SWAP, 88 pcr_address(c), buffer, 8, 89 FW_FIXED_GENERATION | c->resources.generation); 90 91 if (err < 0) { 92 if (err == -EAGAIN && 93 bus_reset_handling == SUCCEED_ON_BUS_RESET) 94 err = 0; 95 return err; 96 } 97 98 if (buffer[0] == old_arg) /* success? */ 99 break; 100 101 if (check) { 102 err = check(c, buffer[0]); 103 if (err < 0) 104 return err; 105 } 106 } 107 c->last_pcr_value = buffer[1]; 108 109 return 0; 110 } 111 112 113 /** 114 * cmp_connection_init - initializes a connection manager 115 * @c: the connection manager to initialize 116 * @unit: a unit of the target device 117 * @direction: input or output 118 * @pcr_index: the index of the iPCR/oPCR on the target device 119 */ 120 int cmp_connection_init(struct cmp_connection *c, 121 struct fw_unit *unit, 122 enum cmp_direction direction, 123 unsigned int pcr_index) 124 { 125 __be32 mpr_be; 126 u32 mpr; 127 int err; 128 129 c->direction = direction; 130 err = snd_fw_transaction(unit, TCODE_READ_QUADLET_REQUEST, 131 mpr_address(c), &mpr_be, 4, 0); 132 if (err < 0) 133 return err; 134 mpr = be32_to_cpu(mpr_be); 135 136 if (pcr_index >= (mpr & MPR_PLUGS_MASK)) 137 return -EINVAL; 138 139 err = fw_iso_resources_init(&c->resources, unit); 140 if (err < 0) 141 return err; 142 143 c->connected = false; 144 mutex_init(&c->mutex); 145 c->last_pcr_value = cpu_to_be32(0x80000000); 146 c->pcr_index = pcr_index; 147 c->max_speed = (mpr & MPR_SPEED_MASK) >> MPR_SPEED_SHIFT; 148 if (c->max_speed == SCODE_BETA) 149 c->max_speed += (mpr & MPR_XSPEED_MASK) >> MPR_XSPEED_SHIFT; 150 151 return 0; 152 } 153 EXPORT_SYMBOL(cmp_connection_init); 154 155 /** 156 * cmp_connection_check_used - check connection is already esablished or not 157 * @c: the connection manager to be checked 158 * @used: the pointer to store the result of checking the connection 159 */ 160 int cmp_connection_check_used(struct cmp_connection *c, bool *used) 161 { 162 __be32 pcr; 163 int err; 164 165 err = snd_fw_transaction( 166 c->resources.unit, TCODE_READ_QUADLET_REQUEST, 167 pcr_address(c), &pcr, 4, 0); 168 if (err >= 0) 169 *used = !!(pcr & cpu_to_be32(PCR_BCAST_CONN | 170 PCR_P2P_CONN_MASK)); 171 172 return err; 173 } 174 EXPORT_SYMBOL(cmp_connection_check_used); 175 176 /** 177 * cmp_connection_destroy - free connection manager resources 178 * @c: the connection manager 179 */ 180 void cmp_connection_destroy(struct cmp_connection *c) 181 { 182 WARN_ON(c->connected); 183 mutex_destroy(&c->mutex); 184 fw_iso_resources_destroy(&c->resources); 185 } 186 EXPORT_SYMBOL(cmp_connection_destroy); 187 188 int cmp_connection_reserve(struct cmp_connection *c, 189 unsigned int max_payload_bytes) 190 { 191 int err; 192 193 mutex_lock(&c->mutex); 194 195 if (WARN_ON(c->resources.allocated)) { 196 err = -EBUSY; 197 goto end; 198 } 199 200 c->speed = min(c->max_speed, 201 fw_parent_device(c->resources.unit)->max_speed); 202 203 err = fw_iso_resources_allocate(&c->resources, max_payload_bytes, 204 c->speed); 205 end: 206 mutex_unlock(&c->mutex); 207 208 return err; 209 } 210 EXPORT_SYMBOL(cmp_connection_reserve); 211 212 void cmp_connection_release(struct cmp_connection *c) 213 { 214 mutex_lock(&c->mutex); 215 fw_iso_resources_free(&c->resources); 216 mutex_unlock(&c->mutex); 217 } 218 EXPORT_SYMBOL(cmp_connection_release); 219 220 static __be32 ipcr_set_modify(struct cmp_connection *c, __be32 ipcr) 221 { 222 ipcr &= ~cpu_to_be32(PCR_BCAST_CONN | 223 PCR_P2P_CONN_MASK | 224 PCR_CHANNEL_MASK); 225 ipcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); 226 ipcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); 227 228 return ipcr; 229 } 230 231 static int get_overhead_id(struct cmp_connection *c) 232 { 233 int id; 234 235 /* 236 * apply "oPCR overhead ID encoding" 237 * the encoding table can convert up to 512. 238 * here the value over 512 is converted as the same way as 512. 239 */ 240 for (id = 1; id < 16; id++) { 241 if (c->resources.bandwidth_overhead < (id << 5)) 242 break; 243 } 244 if (id == 16) 245 id = 0; 246 247 return id; 248 } 249 250 static __be32 opcr_set_modify(struct cmp_connection *c, __be32 opcr) 251 { 252 unsigned int spd, xspd; 253 254 /* generate speed and extended speed field value */ 255 if (c->speed > SCODE_400) { 256 spd = SCODE_800; 257 xspd = c->speed - SCODE_800; 258 } else { 259 spd = c->speed; 260 xspd = 0; 261 } 262 263 opcr &= ~cpu_to_be32(PCR_BCAST_CONN | 264 PCR_P2P_CONN_MASK | 265 OPCR_XSPEED_MASK | 266 PCR_CHANNEL_MASK | 267 OPCR_SPEED_MASK | 268 OPCR_OVERHEAD_ID_MASK); 269 opcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); 270 opcr |= cpu_to_be32(xspd << OPCR_XSPEED_SHIFT); 271 opcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); 272 opcr |= cpu_to_be32(spd << OPCR_SPEED_SHIFT); 273 opcr |= cpu_to_be32(get_overhead_id(c) << OPCR_OVERHEAD_ID_SHIFT); 274 275 return opcr; 276 } 277 278 static int pcr_set_check(struct cmp_connection *c, __be32 pcr) 279 { 280 if (pcr & cpu_to_be32(PCR_BCAST_CONN | 281 PCR_P2P_CONN_MASK)) { 282 cmp_error(c, "plug is already in use\n"); 283 return -EBUSY; 284 } 285 if (!(pcr & cpu_to_be32(PCR_ONLINE))) { 286 cmp_error(c, "plug is not on-line\n"); 287 return -ECONNREFUSED; 288 } 289 290 return 0; 291 } 292 293 /** 294 * cmp_connection_establish - establish a connection to the target 295 * @c: the connection manager 296 * 297 * This function establishes a point-to-point connection from the local 298 * computer to the target by allocating isochronous resources (channel and 299 * bandwidth) and setting the target's input/output plug control register. 300 * When this function succeeds, the caller is responsible for starting 301 * transmitting packets. 302 */ 303 int cmp_connection_establish(struct cmp_connection *c) 304 { 305 int err; 306 307 mutex_lock(&c->mutex); 308 309 if (WARN_ON(c->connected)) { 310 mutex_unlock(&c->mutex); 311 return -EISCONN; 312 } 313 314 retry_after_bus_reset: 315 if (c->direction == CMP_OUTPUT) 316 err = pcr_modify(c, opcr_set_modify, pcr_set_check, 317 ABORT_ON_BUS_RESET); 318 else 319 err = pcr_modify(c, ipcr_set_modify, pcr_set_check, 320 ABORT_ON_BUS_RESET); 321 322 if (err == -EAGAIN) { 323 err = fw_iso_resources_update(&c->resources); 324 if (err >= 0) 325 goto retry_after_bus_reset; 326 } 327 if (err >= 0) 328 c->connected = true; 329 330 mutex_unlock(&c->mutex); 331 332 return err; 333 } 334 EXPORT_SYMBOL(cmp_connection_establish); 335 336 /** 337 * cmp_connection_update - update the connection after a bus reset 338 * @c: the connection manager 339 * 340 * This function must be called from the driver's .update handler to 341 * reestablish any connection that might have been active. 342 * 343 * Returns zero on success, or a negative error code. On an error, the 344 * connection is broken and the caller must stop transmitting iso packets. 345 */ 346 int cmp_connection_update(struct cmp_connection *c) 347 { 348 int err; 349 350 mutex_lock(&c->mutex); 351 352 if (!c->connected) { 353 mutex_unlock(&c->mutex); 354 return 0; 355 } 356 357 err = fw_iso_resources_update(&c->resources); 358 if (err < 0) 359 goto err_unconnect; 360 361 if (c->direction == CMP_OUTPUT) 362 err = pcr_modify(c, opcr_set_modify, pcr_set_check, 363 SUCCEED_ON_BUS_RESET); 364 else 365 err = pcr_modify(c, ipcr_set_modify, pcr_set_check, 366 SUCCEED_ON_BUS_RESET); 367 368 if (err < 0) 369 goto err_unconnect; 370 371 mutex_unlock(&c->mutex); 372 373 return 0; 374 375 err_unconnect: 376 c->connected = false; 377 mutex_unlock(&c->mutex); 378 379 return err; 380 } 381 EXPORT_SYMBOL(cmp_connection_update); 382 383 static __be32 pcr_break_modify(struct cmp_connection *c, __be32 pcr) 384 { 385 return pcr & ~cpu_to_be32(PCR_BCAST_CONN | PCR_P2P_CONN_MASK); 386 } 387 388 /** 389 * cmp_connection_break - break the connection to the target 390 * @c: the connection manager 391 * 392 * This function deactives the connection in the target's input/output plug 393 * control register, and frees the isochronous resources of the connection. 394 * Before calling this function, the caller should cease transmitting packets. 395 */ 396 void cmp_connection_break(struct cmp_connection *c) 397 { 398 int err; 399 400 mutex_lock(&c->mutex); 401 402 if (!c->connected) { 403 mutex_unlock(&c->mutex); 404 return; 405 } 406 407 err = pcr_modify(c, pcr_break_modify, NULL, SUCCEED_ON_BUS_RESET); 408 if (err < 0) 409 cmp_error(c, "plug is still connected\n"); 410 411 c->connected = false; 412 413 mutex_unlock(&c->mutex); 414 } 415 EXPORT_SYMBOL(cmp_connection_break); 416