2 * Internal Thunderbolt Connection Manager. This is a firmware running on
3 * the Thunderbolt host controller performing most of the low-level
6 * Copyright (C) 2017, Intel Corporation
7 * Authors: Michael Jamet <michael.jamet@intel.com>
8 * Mika Westerberg <mika.westerberg@linux.intel.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/delay.h>
16 #include <linux/dmi.h>
17 #include <linux/mutex.h>
18 #include <linux/pci.h>
19 #include <linux/sizes.h>
20 #include <linux/slab.h>
21 #include <linux/workqueue.h>
27 #define PCIE2CIO_CMD 0x30
28 #define PCIE2CIO_CMD_TIMEOUT BIT(31)
29 #define PCIE2CIO_CMD_START BIT(30)
30 #define PCIE2CIO_CMD_WRITE BIT(21)
31 #define PCIE2CIO_CMD_CS_MASK GENMASK(20, 19)
32 #define PCIE2CIO_CMD_CS_SHIFT 19
33 #define PCIE2CIO_CMD_PORT_MASK GENMASK(18, 13)
34 #define PCIE2CIO_CMD_PORT_SHIFT 13
36 #define PCIE2CIO_WRDATA 0x34
37 #define PCIE2CIO_RDDATA 0x38
39 #define PHY_PORT_CS1 0x37
40 #define PHY_PORT_CS1_LINK_DISABLE BIT(14)
41 #define PHY_PORT_CS1_LINK_STATE_MASK GENMASK(29, 26)
42 #define PHY_PORT_CS1_LINK_STATE_SHIFT 26
44 #define ICM_TIMEOUT 5000 /* ms */
45 #define ICM_MAX_LINK 4
46 #define ICM_MAX_DEPTH 6
49 * struct icm - Internal connection manager private data
50 * @request_lock: Makes sure only one message is send to ICM at time
51 * @rescan_work: Work used to rescan the surviving switches after resume
52 * @upstream_port: Pointer to the PCIe upstream port this host
53 * controller is connected. This is only set for systems
54 * where ICM needs to be started manually
55 * @vnd_cap: Vendor defined capability where PCIe2CIO mailbox resides
56 * (only set when @upstream_port is not %NULL)
57 * @safe_mode: ICM is in safe mode
58 * @is_supported: Checks if we can support ICM on this controller
59 * @get_mode: Read and return the ICM firmware mode (optional)
60 * @get_route: Find a route string for given switch
61 * @device_connected: Handle device connected ICM message
62 * @device_disconnected: Handle device disconnected ICM message
65 struct mutex request_lock
;
66 struct delayed_work rescan_work
;
67 struct pci_dev
*upstream_port
;
70 bool (*is_supported
)(struct tb
*tb
);
71 int (*get_mode
)(struct tb
*tb
);
72 int (*get_route
)(struct tb
*tb
, u8 link
, u8 depth
, u64
*route
);
73 void (*device_connected
)(struct tb
*tb
,
74 const struct icm_pkg_header
*hdr
);
75 void (*device_disconnected
)(struct tb
*tb
,
76 const struct icm_pkg_header
*hdr
);
79 struct icm_notification
{
80 struct work_struct work
;
81 struct icm_pkg_header
*pkg
;
85 static inline struct tb
*icm_to_tb(struct icm
*icm
)
87 return ((void *)icm
- sizeof(struct tb
));
90 static inline u8
phy_port_from_route(u64 route
, u8 depth
)
92 return tb_switch_phy_port_from_link(route
>> ((depth
- 1) * 8));
95 static inline u8
dual_link_from_link(u8 link
)
97 return link
? ((link
- 1) ^ 0x01) + 1 : 0;
100 static inline u64
get_route(u32 route_hi
, u32 route_lo
)
102 return (u64
)route_hi
<< 32 | route_lo
;
105 static inline bool is_apple(void)
107 return dmi_match(DMI_BOARD_VENDOR
, "Apple Inc.");
110 static bool icm_match(const struct tb_cfg_request
*req
,
111 const struct ctl_pkg
*pkg
)
113 const struct icm_pkg_header
*res_hdr
= pkg
->buffer
;
114 const struct icm_pkg_header
*req_hdr
= req
->request
;
116 if (pkg
->frame
.eof
!= req
->response_type
)
118 if (res_hdr
->code
!= req_hdr
->code
)
124 static bool icm_copy(struct tb_cfg_request
*req
, const struct ctl_pkg
*pkg
)
126 const struct icm_pkg_header
*hdr
= pkg
->buffer
;
128 if (hdr
->packet_id
< req
->npackets
) {
129 size_t offset
= hdr
->packet_id
* req
->response_size
;
131 memcpy(req
->response
+ offset
, pkg
->buffer
, req
->response_size
);
134 return hdr
->packet_id
== hdr
->total_packets
- 1;
137 static int icm_request(struct tb
*tb
, const void *request
, size_t request_size
,
138 void *response
, size_t response_size
, size_t npackets
,
139 unsigned int timeout_msec
)
141 struct icm
*icm
= tb_priv(tb
);
145 struct tb_cfg_request
*req
;
146 struct tb_cfg_result res
;
148 req
= tb_cfg_request_alloc();
152 req
->match
= icm_match
;
153 req
->copy
= icm_copy
;
154 req
->request
= request
;
155 req
->request_size
= request_size
;
156 req
->request_type
= TB_CFG_PKG_ICM_CMD
;
157 req
->response
= response
;
158 req
->npackets
= npackets
;
159 req
->response_size
= response_size
;
160 req
->response_type
= TB_CFG_PKG_ICM_RESP
;
162 mutex_lock(&icm
->request_lock
);
163 res
= tb_cfg_request_sync(tb
->ctl
, req
, timeout_msec
);
164 mutex_unlock(&icm
->request_lock
);
166 tb_cfg_request_put(req
);
168 if (res
.err
!= -ETIMEDOUT
)
169 return res
.err
== 1 ? -EIO
: res
.err
;
171 usleep_range(20, 50);
177 static bool icm_fr_is_supported(struct tb
*tb
)
182 static inline int icm_fr_get_switch_index(u32 port
)
186 if ((port
& ICM_PORT_TYPE_MASK
) != TB_TYPE_PORT
)
189 index
= port
>> ICM_PORT_INDEX_SHIFT
;
190 return index
!= 0xff ? index
: 0;
193 static int icm_fr_get_route(struct tb
*tb
, u8 link
, u8 depth
, u64
*route
)
195 struct icm_fr_pkg_get_topology_response
*switches
, *sw
;
196 struct icm_fr_pkg_get_topology request
= {
197 .hdr
= { .code
= ICM_GET_TOPOLOGY
},
199 size_t npackets
= ICM_GET_TOPOLOGY_PACKETS
;
203 switches
= kcalloc(npackets
, sizeof(*switches
), GFP_KERNEL
);
207 ret
= icm_request(tb
, &request
, sizeof(request
), switches
,
208 sizeof(*switches
), npackets
, ICM_TIMEOUT
);
213 index
= icm_fr_get_switch_index(sw
->ports
[link
]);
219 sw
= &switches
[index
];
220 for (i
= 1; i
< depth
; i
++) {
223 if (!(sw
->first_data
& ICM_SWITCH_USED
)) {
228 for (j
= 0; j
< ARRAY_SIZE(sw
->ports
); j
++) {
229 index
= icm_fr_get_switch_index(sw
->ports
[j
]);
230 if (index
> sw
->switch_index
) {
231 sw
= &switches
[index
];
237 *route
= get_route(sw
->route_hi
, sw
->route_lo
);
244 static int icm_fr_approve_switch(struct tb
*tb
, struct tb_switch
*sw
)
246 struct icm_fr_pkg_approve_device request
;
247 struct icm_fr_pkg_approve_device reply
;
250 memset(&request
, 0, sizeof(request
));
251 memcpy(&request
.ep_uuid
, sw
->uuid
, sizeof(request
.ep_uuid
));
252 request
.hdr
.code
= ICM_APPROVE_DEVICE
;
253 request
.connection_id
= sw
->connection_id
;
254 request
.connection_key
= sw
->connection_key
;
256 memset(&reply
, 0, sizeof(reply
));
257 /* Use larger timeout as establishing tunnels can take some time */
258 ret
= icm_request(tb
, &request
, sizeof(request
), &reply
, sizeof(reply
),
263 if (reply
.hdr
.flags
& ICM_FLAGS_ERROR
) {
264 tb_warn(tb
, "PCIe tunnel creation failed\n");
271 static int icm_fr_add_switch_key(struct tb
*tb
, struct tb_switch
*sw
)
273 struct icm_fr_pkg_add_device_key request
;
274 struct icm_fr_pkg_add_device_key_response reply
;
277 memset(&request
, 0, sizeof(request
));
278 memcpy(&request
.ep_uuid
, sw
->uuid
, sizeof(request
.ep_uuid
));
279 request
.hdr
.code
= ICM_ADD_DEVICE_KEY
;
280 request
.connection_id
= sw
->connection_id
;
281 request
.connection_key
= sw
->connection_key
;
282 memcpy(request
.key
, sw
->key
, TB_SWITCH_KEY_SIZE
);
284 memset(&reply
, 0, sizeof(reply
));
285 ret
= icm_request(tb
, &request
, sizeof(request
), &reply
, sizeof(reply
),
290 if (reply
.hdr
.flags
& ICM_FLAGS_ERROR
) {
291 tb_warn(tb
, "Adding key to switch failed\n");
298 static int icm_fr_challenge_switch_key(struct tb
*tb
, struct tb_switch
*sw
,
299 const u8
*challenge
, u8
*response
)
301 struct icm_fr_pkg_challenge_device request
;
302 struct icm_fr_pkg_challenge_device_response reply
;
305 memset(&request
, 0, sizeof(request
));
306 memcpy(&request
.ep_uuid
, sw
->uuid
, sizeof(request
.ep_uuid
));
307 request
.hdr
.code
= ICM_CHALLENGE_DEVICE
;
308 request
.connection_id
= sw
->connection_id
;
309 request
.connection_key
= sw
->connection_key
;
310 memcpy(request
.challenge
, challenge
, TB_SWITCH_KEY_SIZE
);
312 memset(&reply
, 0, sizeof(reply
));
313 ret
= icm_request(tb
, &request
, sizeof(request
), &reply
, sizeof(reply
),
318 if (reply
.hdr
.flags
& ICM_FLAGS_ERROR
)
319 return -EKEYREJECTED
;
320 if (reply
.hdr
.flags
& ICM_FLAGS_NO_KEY
)
323 memcpy(response
, reply
.response
, TB_SWITCH_KEY_SIZE
);
328 static void remove_switch(struct tb_switch
*sw
)
330 struct tb_switch
*parent_sw
;
332 parent_sw
= tb_to_switch(sw
->dev
.parent
);
333 tb_port_at(tb_route(sw
), parent_sw
)->remote
= NULL
;
334 tb_switch_remove(sw
);
338 icm_fr_device_connected(struct tb
*tb
, const struct icm_pkg_header
*hdr
)
340 const struct icm_fr_event_device_connected
*pkg
=
341 (const struct icm_fr_event_device_connected
*)hdr
;
342 struct tb_switch
*sw
, *parent_sw
;
343 struct icm
*icm
= tb_priv(tb
);
344 bool authorized
= false;
349 link
= pkg
->link_info
& ICM_LINK_INFO_LINK_MASK
;
350 depth
= (pkg
->link_info
& ICM_LINK_INFO_DEPTH_MASK
) >>
351 ICM_LINK_INFO_DEPTH_SHIFT
;
352 authorized
= pkg
->link_info
& ICM_LINK_INFO_APPROVED
;
354 ret
= icm
->get_route(tb
, link
, depth
, &route
);
356 tb_err(tb
, "failed to find route string for switch at %u.%u\n",
361 sw
= tb_switch_find_by_uuid(tb
, &pkg
->ep_uuid
);
363 u8 phy_port
, sw_phy_port
;
365 parent_sw
= tb_to_switch(sw
->dev
.parent
);
366 sw_phy_port
= phy_port_from_route(tb_route(sw
), sw
->depth
);
367 phy_port
= phy_port_from_route(route
, depth
);
370 * On resume ICM will send us connected events for the
371 * devices that still are present. However, that
372 * information might have changed for example by the
373 * fact that a switch on a dual-link connection might
374 * have been enumerated using the other link now. Make
375 * sure our book keeping matches that.
377 if (sw
->depth
== depth
&& sw_phy_port
== phy_port
&&
378 !!sw
->authorized
== authorized
) {
379 tb_port_at(tb_route(sw
), parent_sw
)->remote
= NULL
;
380 tb_port_at(route
, parent_sw
)->remote
=
381 tb_upstream_port(sw
);
382 sw
->config
.route_hi
= upper_32_bits(route
);
383 sw
->config
.route_lo
= lower_32_bits(route
);
384 sw
->connection_id
= pkg
->connection_id
;
385 sw
->connection_key
= pkg
->connection_key
;
388 sw
->is_unplugged
= false;
394 * User connected the same switch to another physical
395 * port or to another part of the topology. Remove the
396 * existing switch now before adding the new one.
403 * If the switch was not found by UUID, look for a switch on
404 * same physical port (taking possible link aggregation into
405 * account) and depth. If we found one it is definitely a stale
406 * one so remove it first.
408 sw
= tb_switch_find_by_link_depth(tb
, link
, depth
);
412 dual_link
= dual_link_from_link(link
);
414 sw
= tb_switch_find_by_link_depth(tb
, dual_link
, depth
);
421 parent_sw
= tb_switch_find_by_link_depth(tb
, link
, depth
- 1);
423 tb_err(tb
, "failed to find parent switch for %u.%u\n",
428 sw
= tb_switch_alloc(tb
, &parent_sw
->dev
, route
);
430 tb_switch_put(parent_sw
);
434 sw
->uuid
= kmemdup(&pkg
->ep_uuid
, sizeof(pkg
->ep_uuid
), GFP_KERNEL
);
435 sw
->connection_id
= pkg
->connection_id
;
436 sw
->connection_key
= pkg
->connection_key
;
439 sw
->authorized
= authorized
;
440 sw
->security_level
= (pkg
->hdr
.flags
& ICM_FLAGS_SLEVEL_MASK
) >>
441 ICM_FLAGS_SLEVEL_SHIFT
;
443 /* Link the two switches now */
444 tb_port_at(route
, parent_sw
)->remote
= tb_upstream_port(sw
);
445 tb_upstream_port(sw
)->remote
= tb_port_at(route
, parent_sw
);
447 ret
= tb_switch_add(sw
);
449 tb_port_at(tb_route(sw
), parent_sw
)->remote
= NULL
;
452 tb_switch_put(parent_sw
);
456 icm_fr_device_disconnected(struct tb
*tb
, const struct icm_pkg_header
*hdr
)
458 const struct icm_fr_event_device_disconnected
*pkg
=
459 (const struct icm_fr_event_device_disconnected
*)hdr
;
460 struct tb_switch
*sw
;
463 link
= pkg
->link_info
& ICM_LINK_INFO_LINK_MASK
;
464 depth
= (pkg
->link_info
& ICM_LINK_INFO_DEPTH_MASK
) >>
465 ICM_LINK_INFO_DEPTH_SHIFT
;
467 if (link
> ICM_MAX_LINK
|| depth
> ICM_MAX_DEPTH
) {
468 tb_warn(tb
, "invalid topology %u.%u, ignoring\n", link
, depth
);
472 sw
= tb_switch_find_by_link_depth(tb
, link
, depth
);
474 tb_warn(tb
, "no switch exists at %u.%u, ignoring\n", link
,
483 static struct pci_dev
*get_upstream_port(struct pci_dev
*pdev
)
485 struct pci_dev
*parent
;
487 parent
= pci_upstream_bridge(pdev
);
489 if (!pci_is_pcie(parent
))
491 if (pci_pcie_type(parent
) == PCI_EXP_TYPE_UPSTREAM
)
493 parent
= pci_upstream_bridge(parent
);
499 switch (parent
->device
) {
500 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_2C_BRIDGE
:
501 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_4C_BRIDGE
:
502 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_BRIDGE
:
503 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_BRIDGE
:
504 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_BRIDGE
:
511 static bool icm_ar_is_supported(struct tb
*tb
)
513 struct pci_dev
*upstream_port
;
514 struct icm
*icm
= tb_priv(tb
);
517 * Starting from Alpine Ridge we can use ICM on Apple machines
518 * as well. We just need to reset and re-enable it first.
524 * Find the upstream PCIe port in case we need to do reset
525 * through its vendor specific registers.
527 upstream_port
= get_upstream_port(tb
->nhi
->pdev
);
531 cap
= pci_find_ext_capability(upstream_port
,
532 PCI_EXT_CAP_ID_VNDR
);
534 icm
->upstream_port
= upstream_port
;
544 static int icm_ar_get_mode(struct tb
*tb
)
546 struct tb_nhi
*nhi
= tb
->nhi
;
551 val
= ioread32(nhi
->iobase
+ REG_FW_STS
);
552 if (val
& REG_FW_STS_NVM_AUTH_DONE
)
558 dev_err(&nhi
->pdev
->dev
, "ICM firmware not authenticated\n");
562 return nhi_mailbox_mode(nhi
);
565 static int icm_ar_get_route(struct tb
*tb
, u8 link
, u8 depth
, u64
*route
)
567 struct icm_ar_pkg_get_route_response reply
;
568 struct icm_ar_pkg_get_route request
= {
569 .hdr
= { .code
= ICM_GET_ROUTE
},
570 .link_info
= depth
<< ICM_LINK_INFO_DEPTH_SHIFT
| link
,
574 memset(&reply
, 0, sizeof(reply
));
575 ret
= icm_request(tb
, &request
, sizeof(request
), &reply
, sizeof(reply
),
580 if (reply
.hdr
.flags
& ICM_FLAGS_ERROR
)
583 *route
= get_route(reply
.route_hi
, reply
.route_lo
);
587 static void icm_handle_notification(struct work_struct
*work
)
589 struct icm_notification
*n
= container_of(work
, typeof(*n
), work
);
590 struct tb
*tb
= n
->tb
;
591 struct icm
*icm
= tb_priv(tb
);
593 mutex_lock(&tb
->lock
);
595 switch (n
->pkg
->code
) {
596 case ICM_EVENT_DEVICE_CONNECTED
:
597 icm
->device_connected(tb
, n
->pkg
);
599 case ICM_EVENT_DEVICE_DISCONNECTED
:
600 icm
->device_disconnected(tb
, n
->pkg
);
604 mutex_unlock(&tb
->lock
);
610 static void icm_handle_event(struct tb
*tb
, enum tb_cfg_pkg_type type
,
611 const void *buf
, size_t size
)
613 struct icm_notification
*n
;
615 n
= kmalloc(sizeof(*n
), GFP_KERNEL
);
619 INIT_WORK(&n
->work
, icm_handle_notification
);
620 n
->pkg
= kmemdup(buf
, size
, GFP_KERNEL
);
623 queue_work(tb
->wq
, &n
->work
);
627 __icm_driver_ready(struct tb
*tb
, enum tb_security_level
*security_level
)
629 struct icm_pkg_driver_ready_response reply
;
630 struct icm_pkg_driver_ready request
= {
631 .hdr
.code
= ICM_DRIVER_READY
,
633 unsigned int retries
= 10;
636 memset(&reply
, 0, sizeof(reply
));
637 ret
= icm_request(tb
, &request
, sizeof(request
), &reply
, sizeof(reply
),
643 *security_level
= reply
.security_level
& 0xf;
646 * Hold on here until the switch config space is accessible so
647 * that we can read root switch config successfully.
650 struct tb_cfg_result res
;
653 res
= tb_cfg_read_raw(tb
->ctl
, &tmp
, 0, 0, TB_CFG_SWITCH
,
664 static int pci2cio_wait_completion(struct icm
*icm
, unsigned long timeout_msec
)
666 unsigned long end
= jiffies
+ msecs_to_jiffies(timeout_msec
);
670 pci_read_config_dword(icm
->upstream_port
,
671 icm
->vnd_cap
+ PCIE2CIO_CMD
, &cmd
);
672 if (!(cmd
& PCIE2CIO_CMD_START
)) {
673 if (cmd
& PCIE2CIO_CMD_TIMEOUT
)
679 } while (time_before(jiffies
, end
));
684 static int pcie2cio_read(struct icm
*icm
, enum tb_cfg_space cs
,
685 unsigned int port
, unsigned int index
, u32
*data
)
687 struct pci_dev
*pdev
= icm
->upstream_port
;
688 int ret
, vnd_cap
= icm
->vnd_cap
;
692 cmd
|= (port
<< PCIE2CIO_CMD_PORT_SHIFT
) & PCIE2CIO_CMD_PORT_MASK
;
693 cmd
|= (cs
<< PCIE2CIO_CMD_CS_SHIFT
) & PCIE2CIO_CMD_CS_MASK
;
694 cmd
|= PCIE2CIO_CMD_START
;
695 pci_write_config_dword(pdev
, vnd_cap
+ PCIE2CIO_CMD
, cmd
);
697 ret
= pci2cio_wait_completion(icm
, 5000);
701 pci_read_config_dword(pdev
, vnd_cap
+ PCIE2CIO_RDDATA
, data
);
705 static int pcie2cio_write(struct icm
*icm
, enum tb_cfg_space cs
,
706 unsigned int port
, unsigned int index
, u32 data
)
708 struct pci_dev
*pdev
= icm
->upstream_port
;
709 int vnd_cap
= icm
->vnd_cap
;
712 pci_write_config_dword(pdev
, vnd_cap
+ PCIE2CIO_WRDATA
, data
);
715 cmd
|= (port
<< PCIE2CIO_CMD_PORT_SHIFT
) & PCIE2CIO_CMD_PORT_MASK
;
716 cmd
|= (cs
<< PCIE2CIO_CMD_CS_SHIFT
) & PCIE2CIO_CMD_CS_MASK
;
717 cmd
|= PCIE2CIO_CMD_WRITE
| PCIE2CIO_CMD_START
;
718 pci_write_config_dword(pdev
, vnd_cap
+ PCIE2CIO_CMD
, cmd
);
720 return pci2cio_wait_completion(icm
, 5000);
723 static int icm_firmware_reset(struct tb
*tb
, struct tb_nhi
*nhi
)
725 struct icm
*icm
= tb_priv(tb
);
728 /* Put ARC to wait for CIO reset event to happen */
729 val
= ioread32(nhi
->iobase
+ REG_FW_STS
);
730 val
|= REG_FW_STS_CIO_RESET_REQ
;
731 iowrite32(val
, nhi
->iobase
+ REG_FW_STS
);
734 val
= ioread32(nhi
->iobase
+ REG_FW_STS
);
735 val
|= REG_FW_STS_ICM_EN_INVERT
;
736 val
|= REG_FW_STS_ICM_EN_CPU
;
737 iowrite32(val
, nhi
->iobase
+ REG_FW_STS
);
739 /* Trigger CIO reset now */
740 return pcie2cio_write(icm
, TB_CFG_SWITCH
, 0, 0x50, BIT(9));
743 static int icm_firmware_start(struct tb
*tb
, struct tb_nhi
*nhi
)
745 unsigned int retries
= 10;
749 /* Check if the ICM firmware is already running */
750 val
= ioread32(nhi
->iobase
+ REG_FW_STS
);
751 if (val
& REG_FW_STS_ICM_EN
)
754 dev_info(&nhi
->pdev
->dev
, "starting ICM firmware\n");
756 ret
= icm_firmware_reset(tb
, nhi
);
760 /* Wait until the ICM firmware tells us it is up and running */
762 /* Check that the ICM firmware is running */
763 val
= ioread32(nhi
->iobase
+ REG_FW_STS
);
764 if (val
& REG_FW_STS_NVM_AUTH_DONE
)
773 static int icm_reset_phy_port(struct tb
*tb
, int phy_port
)
775 struct icm
*icm
= tb_priv(tb
);
781 if (!icm
->upstream_port
)
793 * Read link status of both null ports belonging to a single
796 ret
= pcie2cio_read(icm
, TB_CFG_PORT
, port0
, PHY_PORT_CS1
, &val0
);
799 ret
= pcie2cio_read(icm
, TB_CFG_PORT
, port1
, PHY_PORT_CS1
, &val1
);
803 state0
= val0
& PHY_PORT_CS1_LINK_STATE_MASK
;
804 state0
>>= PHY_PORT_CS1_LINK_STATE_SHIFT
;
805 state1
= val1
& PHY_PORT_CS1_LINK_STATE_MASK
;
806 state1
>>= PHY_PORT_CS1_LINK_STATE_SHIFT
;
808 /* If they are both up we need to reset them now */
809 if (state0
!= TB_PORT_UP
|| state1
!= TB_PORT_UP
)
812 val0
|= PHY_PORT_CS1_LINK_DISABLE
;
813 ret
= pcie2cio_write(icm
, TB_CFG_PORT
, port0
, PHY_PORT_CS1
, val0
);
817 val1
|= PHY_PORT_CS1_LINK_DISABLE
;
818 ret
= pcie2cio_write(icm
, TB_CFG_PORT
, port1
, PHY_PORT_CS1
, val1
);
822 /* Wait a bit and then re-enable both ports */
823 usleep_range(10, 100);
825 ret
= pcie2cio_read(icm
, TB_CFG_PORT
, port0
, PHY_PORT_CS1
, &val0
);
828 ret
= pcie2cio_read(icm
, TB_CFG_PORT
, port1
, PHY_PORT_CS1
, &val1
);
832 val0
&= ~PHY_PORT_CS1_LINK_DISABLE
;
833 ret
= pcie2cio_write(icm
, TB_CFG_PORT
, port0
, PHY_PORT_CS1
, val0
);
837 val1
&= ~PHY_PORT_CS1_LINK_DISABLE
;
838 return pcie2cio_write(icm
, TB_CFG_PORT
, port1
, PHY_PORT_CS1
, val1
);
841 static int icm_firmware_init(struct tb
*tb
)
843 struct icm
*icm
= tb_priv(tb
);
844 struct tb_nhi
*nhi
= tb
->nhi
;
847 ret
= icm_firmware_start(tb
, nhi
);
849 dev_err(&nhi
->pdev
->dev
, "could not start ICM firmware\n");
854 ret
= icm
->get_mode(tb
);
857 case NHI_FW_SAFE_MODE
:
858 icm
->safe_mode
= true;
862 /* Ask ICM to accept all Thunderbolt devices */
863 nhi_mailbox_cmd(nhi
, NHI_MAILBOX_ALLOW_ALL_DEVS
, 0);
867 tb_err(tb
, "ICM firmware is in wrong mode: %u\n", ret
);
873 * Reset both physical ports if there is anything connected to
876 ret
= icm_reset_phy_port(tb
, 0);
878 dev_warn(&nhi
->pdev
->dev
, "failed to reset links on port0\n");
879 ret
= icm_reset_phy_port(tb
, 1);
881 dev_warn(&nhi
->pdev
->dev
, "failed to reset links on port1\n");
886 static int icm_driver_ready(struct tb
*tb
)
888 struct icm
*icm
= tb_priv(tb
);
891 ret
= icm_firmware_init(tb
);
895 if (icm
->safe_mode
) {
896 tb_info(tb
, "Thunderbolt host controller is in safe mode.\n");
897 tb_info(tb
, "You need to update NVM firmware of the controller before it can be used.\n");
898 tb_info(tb
, "For latest updates check https://thunderbolttechnology.net/updates.\n");
902 return __icm_driver_ready(tb
, &tb
->security_level
);
905 static int icm_suspend(struct tb
*tb
)
909 ret
= nhi_mailbox_cmd(tb
->nhi
, NHI_MAILBOX_SAVE_DEVS
, 0);
911 tb_info(tb
, "Ignoring mailbox command error (%d) in %s\n",
918 * Mark all switches (except root switch) below this one unplugged. ICM
919 * firmware will send us an updated list of switches after we have send
920 * it driver ready command. If a switch is not in that list it will be
921 * removed when we perform rescan.
923 static void icm_unplug_children(struct tb_switch
*sw
)
928 sw
->is_unplugged
= true;
930 for (i
= 1; i
<= sw
->config
.max_port_number
; i
++) {
931 struct tb_port
*port
= &sw
->ports
[i
];
933 if (tb_is_upstream_port(port
))
938 icm_unplug_children(port
->remote
->sw
);
942 static void icm_free_unplugged_children(struct tb_switch
*sw
)
946 for (i
= 1; i
<= sw
->config
.max_port_number
; i
++) {
947 struct tb_port
*port
= &sw
->ports
[i
];
949 if (tb_is_upstream_port(port
))
954 if (port
->remote
->sw
->is_unplugged
) {
955 tb_switch_remove(port
->remote
->sw
);
958 icm_free_unplugged_children(port
->remote
->sw
);
963 static void icm_rescan_work(struct work_struct
*work
)
965 struct icm
*icm
= container_of(work
, struct icm
, rescan_work
.work
);
966 struct tb
*tb
= icm_to_tb(icm
);
968 mutex_lock(&tb
->lock
);
970 icm_free_unplugged_children(tb
->root_switch
);
971 mutex_unlock(&tb
->lock
);
974 static void icm_complete(struct tb
*tb
)
976 struct icm
*icm
= tb_priv(tb
);
978 if (tb
->nhi
->going_away
)
981 icm_unplug_children(tb
->root_switch
);
984 * Now all existing children should be resumed, start events
985 * from ICM to get updated status.
987 __icm_driver_ready(tb
, NULL
);
990 * We do not get notifications of devices that have been
991 * unplugged during suspend so schedule rescan to clean them up
994 queue_delayed_work(tb
->wq
, &icm
->rescan_work
, msecs_to_jiffies(500));
997 static int icm_start(struct tb
*tb
)
999 struct icm
*icm
= tb_priv(tb
);
1003 tb
->root_switch
= tb_switch_alloc_safe_mode(tb
, &tb
->dev
, 0);
1005 tb
->root_switch
= tb_switch_alloc(tb
, &tb
->dev
, 0);
1006 if (!tb
->root_switch
)
1010 * NVM upgrade has not been tested on Apple systems and they
1011 * don't provide images publicly either. To be on the safe side
1012 * prevent root switch NVM upgrade on Macs for now.
1014 tb
->root_switch
->no_nvm_upgrade
= is_apple();
1016 ret
= tb_switch_add(tb
->root_switch
);
1018 tb_switch_put(tb
->root_switch
);
1023 static void icm_stop(struct tb
*tb
)
1025 struct icm
*icm
= tb_priv(tb
);
1027 cancel_delayed_work(&icm
->rescan_work
);
1028 tb_switch_remove(tb
->root_switch
);
1029 tb
->root_switch
= NULL
;
1030 nhi_mailbox_cmd(tb
->nhi
, NHI_MAILBOX_DRV_UNLOADS
, 0);
1033 static int icm_disconnect_pcie_paths(struct tb
*tb
)
1035 return nhi_mailbox_cmd(tb
->nhi
, NHI_MAILBOX_DISCONNECT_PCIE_PATHS
, 0);
1038 /* Falcon Ridge and Alpine Ridge */
1039 static const struct tb_cm_ops icm_fr_ops
= {
1040 .driver_ready
= icm_driver_ready
,
1043 .suspend
= icm_suspend
,
1044 .complete
= icm_complete
,
1045 .handle_event
= icm_handle_event
,
1046 .approve_switch
= icm_fr_approve_switch
,
1047 .add_switch_key
= icm_fr_add_switch_key
,
1048 .challenge_switch_key
= icm_fr_challenge_switch_key
,
1049 .disconnect_pcie_paths
= icm_disconnect_pcie_paths
,
1052 struct tb
*icm_probe(struct tb_nhi
*nhi
)
1057 tb
= tb_domain_alloc(nhi
, sizeof(struct icm
));
1062 INIT_DELAYED_WORK(&icm
->rescan_work
, icm_rescan_work
);
1063 mutex_init(&icm
->request_lock
);
1065 switch (nhi
->pdev
->device
) {
1066 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_2C_NHI
:
1067 case PCI_DEVICE_ID_INTEL_FALCON_RIDGE_4C_NHI
:
1068 icm
->is_supported
= icm_fr_is_supported
;
1069 icm
->get_route
= icm_fr_get_route
;
1070 icm
->device_connected
= icm_fr_device_connected
;
1071 icm
->device_disconnected
= icm_fr_device_disconnected
;
1072 tb
->cm_ops
= &icm_fr_ops
;
1075 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_2C_NHI
:
1076 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_4C_NHI
:
1077 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_LP_NHI
:
1078 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_4C_NHI
:
1079 case PCI_DEVICE_ID_INTEL_ALPINE_RIDGE_C_2C_NHI
:
1080 icm
->is_supported
= icm_ar_is_supported
;
1081 icm
->get_mode
= icm_ar_get_mode
;
1082 icm
->get_route
= icm_ar_get_route
;
1083 icm
->device_connected
= icm_fr_device_connected
;
1084 icm
->device_disconnected
= icm_fr_device_disconnected
;
1085 tb
->cm_ops
= &icm_fr_ops
;
1089 if (!icm
->is_supported
|| !icm
->is_supported(tb
)) {
1090 dev_dbg(&nhi
->pdev
->dev
, "ICM not supported on this controller\n");