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 guard(mutex)(&c->mutex); 192 193 if (WARN_ON(c->resources.allocated)) 194 return -EBUSY; 195 196 c->speed = min(c->max_speed, 197 fw_parent_device(c->resources.unit)->max_speed); 198 199 return fw_iso_resources_allocate(&c->resources, max_payload_bytes, 200 c->speed); 201 } 202 EXPORT_SYMBOL(cmp_connection_reserve); 203 204 void cmp_connection_release(struct cmp_connection *c) 205 { 206 guard(mutex)(&c->mutex); 207 fw_iso_resources_free(&c->resources); 208 } 209 EXPORT_SYMBOL(cmp_connection_release); 210 211 static __be32 ipcr_set_modify(struct cmp_connection *c, __be32 ipcr) 212 { 213 ipcr &= ~cpu_to_be32(PCR_BCAST_CONN | 214 PCR_P2P_CONN_MASK | 215 PCR_CHANNEL_MASK); 216 ipcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); 217 ipcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); 218 219 return ipcr; 220 } 221 222 static int get_overhead_id(struct cmp_connection *c) 223 { 224 int id; 225 226 /* 227 * apply "oPCR overhead ID encoding" 228 * the encoding table can convert up to 512. 229 * here the value over 512 is converted as the same way as 512. 230 */ 231 for (id = 1; id < 16; id++) { 232 if (c->resources.bandwidth_overhead < (id << 5)) 233 break; 234 } 235 if (id == 16) 236 id = 0; 237 238 return id; 239 } 240 241 static __be32 opcr_set_modify(struct cmp_connection *c, __be32 opcr) 242 { 243 unsigned int spd, xspd; 244 245 /* generate speed and extended speed field value */ 246 if (c->speed > SCODE_400) { 247 spd = SCODE_800; 248 xspd = c->speed - SCODE_800; 249 } else { 250 spd = c->speed; 251 xspd = 0; 252 } 253 254 opcr &= ~cpu_to_be32(PCR_BCAST_CONN | 255 PCR_P2P_CONN_MASK | 256 OPCR_XSPEED_MASK | 257 PCR_CHANNEL_MASK | 258 OPCR_SPEED_MASK | 259 OPCR_OVERHEAD_ID_MASK); 260 opcr |= cpu_to_be32(1 << PCR_P2P_CONN_SHIFT); 261 opcr |= cpu_to_be32(xspd << OPCR_XSPEED_SHIFT); 262 opcr |= cpu_to_be32(c->resources.channel << PCR_CHANNEL_SHIFT); 263 opcr |= cpu_to_be32(spd << OPCR_SPEED_SHIFT); 264 opcr |= cpu_to_be32(get_overhead_id(c) << OPCR_OVERHEAD_ID_SHIFT); 265 266 return opcr; 267 } 268 269 static int pcr_set_check(struct cmp_connection *c, __be32 pcr) 270 { 271 if (pcr & cpu_to_be32(PCR_BCAST_CONN | 272 PCR_P2P_CONN_MASK)) { 273 cmp_error(c, "plug is already in use\n"); 274 return -EBUSY; 275 } 276 if (!(pcr & cpu_to_be32(PCR_ONLINE))) { 277 cmp_error(c, "plug is not on-line\n"); 278 return -ECONNREFUSED; 279 } 280 281 return 0; 282 } 283 284 /** 285 * cmp_connection_establish - establish a connection to the target 286 * @c: the connection manager 287 * 288 * This function establishes a point-to-point connection from the local 289 * computer to the target by allocating isochronous resources (channel and 290 * bandwidth) and setting the target's input/output plug control register. 291 * When this function succeeds, the caller is responsible for starting 292 * transmitting packets. 293 */ 294 int cmp_connection_establish(struct cmp_connection *c) 295 { 296 int err; 297 298 guard(mutex)(&c->mutex); 299 300 if (WARN_ON(c->connected)) 301 return -EISCONN; 302 303 retry_after_bus_reset: 304 if (c->direction == CMP_OUTPUT) 305 err = pcr_modify(c, opcr_set_modify, pcr_set_check, 306 ABORT_ON_BUS_RESET); 307 else 308 err = pcr_modify(c, ipcr_set_modify, pcr_set_check, 309 ABORT_ON_BUS_RESET); 310 311 if (err == -EAGAIN) { 312 err = fw_iso_resources_update(&c->resources); 313 if (err >= 0) 314 goto retry_after_bus_reset; 315 } 316 if (err >= 0) 317 c->connected = true; 318 319 return err; 320 } 321 EXPORT_SYMBOL(cmp_connection_establish); 322 323 static __be32 pcr_break_modify(struct cmp_connection *c, __be32 pcr) 324 { 325 return pcr & ~cpu_to_be32(PCR_BCAST_CONN | PCR_P2P_CONN_MASK); 326 } 327 328 /** 329 * cmp_connection_break - break the connection to the target 330 * @c: the connection manager 331 * 332 * This function deactives the connection in the target's input/output plug 333 * control register, and frees the isochronous resources of the connection. 334 * Before calling this function, the caller should cease transmitting packets. 335 */ 336 void cmp_connection_break(struct cmp_connection *c) 337 { 338 int err; 339 340 guard(mutex)(&c->mutex); 341 342 if (!c->connected) 343 return; 344 345 err = pcr_modify(c, pcr_break_modify, NULL, SUCCEED_ON_BUS_RESET); 346 if (err < 0) 347 cmp_error(c, "plug is still connected\n"); 348 349 c->connected = false; 350 } 351 EXPORT_SYMBOL(cmp_connection_break); 352