drivers/thunderbolt/lc.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Thunderbolt link controller support
   4  *
   5  * Copyright (C) 2019, Intel Corporation
   6  * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
   7  */
   8
   9 #include "tb.h"
  10
  11 /**
  12  * tb_lc_read_uuid() - Read switch UUID from link controller common register
  13  * @sw: Switch whose UUID is read
  14  * @uuid: UUID is placed here
  15  */
  16 int tb_lc_read_uuid(struct tb_switch *sw, u32 *uuid)
  17 {
  18         if (!sw->cap_lc)
  19                 return -EINVAL;
  20         return tb_sw_read(sw, uuid, TB_CFG_SWITCH, sw->cap_lc + TB_LC_FUSE, 4);
  21 }
  22
  23 static int read_lc_desc(struct tb_switch *sw, u32 *desc)
  24 {
  25         if (!sw->cap_lc)
  26                 return -EINVAL;
  27         return tb_sw_read(sw, desc, TB_CFG_SWITCH, sw->cap_lc + TB_LC_DESC, 1);
  28 }
  29
  30 static int find_port_lc_cap(struct tb_port *port)
  31 {
  32         struct tb_switch *sw = port->sw;
  33         int start, phys, ret, size;
  34         u32 desc;
  35
  36         ret = read_lc_desc(sw, &desc);
  37         if (ret)
  38                 return ret;
  39
  40         /* Start of port LC registers */
  41         start = (desc & TB_LC_DESC_SIZE_MASK) >> TB_LC_DESC_SIZE_SHIFT;
  42         size = (desc & TB_LC_DESC_PORT_SIZE_MASK) >> TB_LC_DESC_PORT_SIZE_SHIFT;
  43         phys = tb_phy_port_from_link(port->port);
  44
  45         return sw->cap_lc + start + phys * size;
  46 }
  47
  48 static int tb_lc_set_port_configured(struct tb_port *port, bool configured)
  49 {
  50         bool upstream = tb_is_upstream_port(port);
  51         struct tb_switch *sw = port->sw;
  52         u32 ctrl, lane;
  53         int cap, ret;
  54
  55         if (sw->generation < 2)
  56                 return 0;
  57
  58         cap = find_port_lc_cap(port);
  59         if (cap < 0)
  60                 return cap;
  61
  62         ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
  63         if (ret)
  64                 return ret;
  65
  66         /* Resolve correct lane */
  67         if (port->port % 2)
  68                 lane = TB_LC_SX_CTRL_L1C;
  69         else
  70                 lane = TB_LC_SX_CTRL_L2C;
  71
  72         if (configured) {
  73                 ctrl |= lane;
  74                 if (upstream)
  75                         ctrl |= TB_LC_SX_CTRL_UPSTREAM;
  76         } else {
  77                 ctrl &= ~lane;
  78                 if (upstream)
  79                         ctrl &= ~TB_LC_SX_CTRL_UPSTREAM;
  80         }
  81
  82         return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
  83 }
  84
  85 /**
  86  * tb_lc_configure_port() - Let LC know about configured port
  87  * @port: Port that is set as configured
  88  *
  89  * Sets the port configured for power management purposes.
  90  */
  91 int tb_lc_configure_port(struct tb_port *port)
  92 {
  93         return tb_lc_set_port_configured(port, true);
  94 }
  95
  96 /**
  97  * tb_lc_unconfigure_port() - Let LC know about unconfigured port
  98  * @port: Port that is set as configured
  99  *
 100  * Sets the port unconfigured for power management purposes.
 101  */
 102 void tb_lc_unconfigure_port(struct tb_port *port)
 103 {
 104         tb_lc_set_port_configured(port, false);
 105 }
 106
 107 static int tb_lc_set_xdomain_configured(struct tb_port *port, bool configure)
 108 {
 109         struct tb_switch *sw = port->sw;
 110         u32 ctrl, lane;
 111         int cap, ret;
 112
 113         if (sw->generation < 2)
 114                 return 0;
 115
 116         cap = find_port_lc_cap(port);
 117         if (cap < 0)
 118                 return cap;
 119
 120         ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
 121         if (ret)
 122                 return ret;
 123
 124         /* Resolve correct lane */
 125         if (port->port % 2)
 126                 lane = TB_LC_SX_CTRL_L1D;
 127         else
 128                 lane = TB_LC_SX_CTRL_L2D;
 129
 130         if (configure)
 131                 ctrl |= lane;
 132         else
 133                 ctrl &= ~lane;
 134
 135         return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
 136 }
 137
 138 /**
 139  * tb_lc_configure_xdomain() - Inform LC that the link is XDomain
 140  * @port: Switch downstream port connected to another host
 141  *
 142  * Sets the lane configured for XDomain accordingly so that the LC knows
 143  * about this. Returns %0 in success and negative errno in failure.
 144  */
 145 int tb_lc_configure_xdomain(struct tb_port *port)
 146 {
 147         return tb_lc_set_xdomain_configured(port, true);
 148 }
 149
 150 /**
 151  * tb_lc_unconfigure_xdomain() - Unconfigure XDomain from port
 152  * @port: Switch downstream port that was connected to another host
 153  *
 154  * Unsets the lane XDomain configuration.
 155  */
 156 void tb_lc_unconfigure_xdomain(struct tb_port *port)
 157 {
 158         tb_lc_set_xdomain_configured(port, false);
 159 }
 160
 161 /**
 162  * tb_lc_start_lane_initialization() - Start lane initialization
 163  * @port: Device router lane 0 adapter
 164  *
 165  * Starts lane initialization for @port after the router resumed from
 166  * sleep. Should be called for those downstream lane adapters that were
 167  * not connected (tb_lc_configure_port() was not called) before sleep.
 168  *
 169  * Returns %0 in success and negative errno in case of failure.
 170  */
 171 int tb_lc_start_lane_initialization(struct tb_port *port)
 172 {
 173         struct tb_switch *sw = port->sw;
 174         int ret, cap;
 175         u32 ctrl;
 176
 177         if (!tb_route(sw))
 178                 return 0;
 179
 180         if (sw->generation < 2)
 181                 return 0;
 182
 183         cap = find_port_lc_cap(port);
 184         if (cap < 0)
 185                 return cap;
 186
 187         ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
 188         if (ret)
 189                 return ret;
 190
 191         ctrl |= TB_LC_SX_CTRL_SLI;
 192
 193         return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, cap + TB_LC_SX_CTRL, 1);
 194 }
 195
 196 static int tb_lc_set_wake_one(struct tb_switch *sw, unsigned int offset,
 197                               unsigned int flags)
 198 {
 199         u32 ctrl;
 200         int ret;
 201
 202         /*
 203          * Enable wake on PCIe and USB4 (wake coming from another
 204          * router).
 205          */
 206         ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH,
 207                          offset + TB_LC_SX_CTRL, 1);
 208         if (ret)
 209                 return ret;
 210
 211         ctrl &= ~(TB_LC_SX_CTRL_WOC | TB_LC_SX_CTRL_WOD | TB_LC_SX_CTRL_WODPC |
 212                   TB_LC_SX_CTRL_WODPD | TB_LC_SX_CTRL_WOP | TB_LC_SX_CTRL_WOU4);
 213
 214         if (flags & TB_WAKE_ON_CONNECT)
 215                 ctrl |= TB_LC_SX_CTRL_WOC | TB_LC_SX_CTRL_WOD;
 216         if (flags & TB_WAKE_ON_USB4)
 217                 ctrl |= TB_LC_SX_CTRL_WOU4;
 218         if (flags & TB_WAKE_ON_PCIE)
 219                 ctrl |= TB_LC_SX_CTRL_WOP;
 220         if (flags & TB_WAKE_ON_DP)
 221                 ctrl |= TB_LC_SX_CTRL_WODPC | TB_LC_SX_CTRL_WODPD;
 222
 223         return tb_sw_write(sw, &ctrl, TB_CFG_SWITCH, offset + TB_LC_SX_CTRL, 1);
 224 }
 225
 226 /**
 227  * tb_lc_set_wake() - Enable/disable wake
 228  * @sw: Switch whose wakes to configure
 229  * @flags: Wakeup flags (%0 to disable)
 230  *
 231  * For each LC sets wake bits accordingly.
 232  */
 233 int tb_lc_set_wake(struct tb_switch *sw, unsigned int flags)
 234 {
 235         int start, size, nlc, ret, i;
 236         u32 desc;
 237
 238         if (sw->generation < 2)
 239                 return 0;
 240
 241         if (!tb_route(sw))
 242                 return 0;
 243
 244         ret = read_lc_desc(sw, &desc);
 245         if (ret)
 246                 return ret;
 247
 248         /* Figure out number of link controllers */
 249         nlc = desc & TB_LC_DESC_NLC_MASK;
 250         start = (desc & TB_LC_DESC_SIZE_MASK) >> TB_LC_DESC_SIZE_SHIFT;
 251         size = (desc & TB_LC_DESC_PORT_SIZE_MASK) >> TB_LC_DESC_PORT_SIZE_SHIFT;
 252
 253         /* For each link controller set sleep bit */
 254         for (i = 0; i < nlc; i++) {
 255                 unsigned int offset = sw->cap_lc + start + i * size;
 256
 257                 ret = tb_lc_set_wake_one(sw, offset, flags);
 258                 if (ret)
 259                         return ret;
 260         }
 261
 262         return 0;
 263 }
 264
 265 /**
 266  * tb_lc_set_sleep() - Inform LC that the switch is going to sleep
 267  * @sw: Switch to set sleep
 268  *
 269  * Let the switch link controllers know that the switch is going to
 270  * sleep.
 271  */
 272 int tb_lc_set_sleep(struct tb_switch *sw)
 273 {
 274         int start, size, nlc, ret, i;
 275         u32 desc;
 276
 277         if (sw->generation < 2)
 278                 return 0;
 279
 280         ret = read_lc_desc(sw, &desc);
 281         if (ret)
 282                 return ret;
 283
 284         /* Figure out number of link controllers */
 285         nlc = desc & TB_LC_DESC_NLC_MASK;
 286         start = (desc & TB_LC_DESC_SIZE_MASK) >> TB_LC_DESC_SIZE_SHIFT;
 287         size = (desc & TB_LC_DESC_PORT_SIZE_MASK) >> TB_LC_DESC_PORT_SIZE_SHIFT;
 288
 289         /* For each link controller set sleep bit */
 290         for (i = 0; i < nlc; i++) {
 291                 unsigned int offset = sw->cap_lc + start + i * size;
 292                 u32 ctrl;
 293
 294                 ret = tb_sw_read(sw, &ctrl, TB_CFG_SWITCH,
 295                                  offset + TB_LC_SX_CTRL, 1);
 296                 if (ret)
 297                         return ret;
 298
 299                 ctrl |= TB_LC_SX_CTRL_SLP;
 300                 ret = tb_sw_write(sw, &ctrl, TB_CFG_SWITCH,
 301                                   offset + TB_LC_SX_CTRL, 1);
 302                 if (ret)
 303                         return ret;
 304         }
 305
 306         return 0;
 307 }
 308
 309 /**
 310  * tb_lc_lane_bonding_possible() - Is lane bonding possible towards switch
 311  * @sw: Switch to check
 312  *
 313  * Checks whether conditions for lane bonding from parent to @sw are
 314  * possible.
 315  */
 316 bool tb_lc_lane_bonding_possible(struct tb_switch *sw)
 317 {
 318         struct tb_port *up;
 319         int cap, ret;
 320         u32 val;
 321
 322         if (sw->generation < 2)
 323                 return false;
 324
 325         up = tb_upstream_port(sw);
 326         cap = find_port_lc_cap(up);
 327         if (cap < 0)
 328                 return false;
 329
 330         ret = tb_sw_read(sw, &val, TB_CFG_SWITCH, cap + TB_LC_PORT_ATTR, 1);
 331         if (ret)
 332                 return false;
 333
 334         return !!(val & TB_LC_PORT_ATTR_BE);
 335 }
 336
 337 static int tb_lc_dp_sink_from_port(const struct tb_switch *sw,
 338                                    struct tb_port *in)
 339 {
 340         struct tb_port *port;
 341
 342         /* The first DP IN port is sink 0 and second is sink 1 */
 343         tb_switch_for_each_port(sw, port) {
 344                 if (tb_port_is_dpin(port))
 345                         return in != port;
 346         }
 347
 348         return -EINVAL;
 349 }
 350
 351 static int tb_lc_dp_sink_available(struct tb_switch *sw, int sink)
 352 {
 353         u32 val, alloc;
 354         int ret;
 355
 356         ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
 357                          sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
 358         if (ret)
 359                 return ret;
 360
 361         /*
 362          * Sink is available for CM/SW to use if the allocation valie is
 363          * either 0 or 1.
 364          */
 365         if (!sink) {
 366                 alloc = val & TB_LC_SNK_ALLOCATION_SNK0_MASK;
 367                 if (!alloc || alloc == TB_LC_SNK_ALLOCATION_SNK0_CM)
 368                         return 0;
 369         } else {
 370                 alloc = (val & TB_LC_SNK_ALLOCATION_SNK1_MASK) >>
 371                         TB_LC_SNK_ALLOCATION_SNK1_SHIFT;
 372                 if (!alloc || alloc == TB_LC_SNK_ALLOCATION_SNK1_CM)
 373                         return 0;
 374         }
 375
 376         return -EBUSY;
 377 }
 378
 379 /**
 380  * tb_lc_dp_sink_query() - Is DP sink available for DP IN port
 381  * @sw: Switch whose DP sink is queried
 382  * @in: DP IN port to check
 383  *
 384  * Queries through LC SNK_ALLOCATION registers whether DP sink is available
 385  * for the given DP IN port or not.
 386  */
 387 bool tb_lc_dp_sink_query(struct tb_switch *sw, struct tb_port *in)
 388 {
 389         int sink;
 390
 391         /*
 392          * For older generations sink is always available as there is no
 393          * allocation mechanism.
 394          */
 395         if (sw->generation < 3)
 396                 return true;
 397
 398         sink = tb_lc_dp_sink_from_port(sw, in);
 399         if (sink < 0)
 400                 return false;
 401
 402         return !tb_lc_dp_sink_available(sw, sink);
 403 }
 404
 405 /**
 406  * tb_lc_dp_sink_alloc() - Allocate DP sink
 407  * @sw: Switch whose DP sink is allocated
 408  * @in: DP IN port the DP sink is allocated for
 409  *
 410  * Allocate DP sink for @in via LC SNK_ALLOCATION registers. If the
 411  * resource is available and allocation is successful returns %0. In all
 412  * other cases returs negative errno. In particular %-EBUSY is returned if
 413  * the resource was not available.
 414  */
 415 int tb_lc_dp_sink_alloc(struct tb_switch *sw, struct tb_port *in)
 416 {
 417         int ret, sink;
 418         u32 val;
 419
 420         if (sw->generation < 3)
 421                 return 0;
 422
 423         sink = tb_lc_dp_sink_from_port(sw, in);
 424         if (sink < 0)
 425                 return sink;
 426
 427         ret = tb_lc_dp_sink_available(sw, sink);
 428         if (ret)
 429                 return ret;
 430
 431         ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
 432                          sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
 433         if (ret)
 434                 return ret;
 435
 436         if (!sink) {
 437                 val &= ~TB_LC_SNK_ALLOCATION_SNK0_MASK;
 438                 val |= TB_LC_SNK_ALLOCATION_SNK0_CM;
 439         } else {
 440                 val &= ~TB_LC_SNK_ALLOCATION_SNK1_MASK;
 441                 val |= TB_LC_SNK_ALLOCATION_SNK1_CM <<
 442                         TB_LC_SNK_ALLOCATION_SNK1_SHIFT;
 443         }
 444
 445         ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
 446                           sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
 447
 448         if (ret)
 449                 return ret;
 450
 451         tb_port_dbg(in, "sink %d allocated\n", sink);
 452         return 0;
 453 }
 454
 455 /**
 456  * tb_lc_dp_sink_dealloc() - De-allocate DP sink
 457  * @sw: Switch whose DP sink is de-allocated
 458  * @in: DP IN port whose DP sink is de-allocated
 459  *
 460  * De-allocate DP sink from @in using LC SNK_ALLOCATION registers.
 461  */
 462 int tb_lc_dp_sink_dealloc(struct tb_switch *sw, struct tb_port *in)
 463 {
 464         int ret, sink;
 465         u32 val;
 466
 467         if (sw->generation < 3)
 468                 return 0;
 469
 470         sink = tb_lc_dp_sink_from_port(sw, in);
 471         if (sink < 0)
 472                 return sink;
 473
 474         /* Needs to be owned by CM/SW */
 475         ret = tb_lc_dp_sink_available(sw, sink);
 476         if (ret)
 477                 return ret;
 478
 479         ret = tb_sw_read(sw, &val, TB_CFG_SWITCH,
 480                          sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
 481         if (ret)
 482                 return ret;
 483
 484         if (!sink)
 485                 val &= ~TB_LC_SNK_ALLOCATION_SNK0_MASK;
 486         else
 487                 val &= ~TB_LC_SNK_ALLOCATION_SNK1_MASK;
 488
 489         ret = tb_sw_write(sw, &val, TB_CFG_SWITCH,
 490                           sw->cap_lc + TB_LC_SNK_ALLOCATION, 1);
 491         if (ret)
 492                 return ret;
 493
 494         tb_port_dbg(in, "sink %d de-allocated\n", sink);
 495         return 0;
 496 }
 497
 498 /**
 499  * tb_lc_force_power() - Forces LC to be powered on
 500  * @sw: Thunderbolt switch
 501  *
 502  * This is useful to let authentication cycle pass even without
 503  * a Thunderbolt link present.
 504  */
 505 int tb_lc_force_power(struct tb_switch *sw)
 506 {
 507         u32 in = 0xffff;
 508
 509         return tb_sw_write(sw, &in, TB_CFG_SWITCH, TB_LC_POWER, 1);
 510 }