1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
// SPDX-License-Identifier: GPL-2.0+
/*
Copyright (c) 2016 Broadcom Corporation
All Rights Reserved
*/
/*
* Created on: Apr 2019
* Author: samyon.furman@broadcom.com
*/
#include "os_dep.h"
#include "bcm_bca_leds_dt_bindings.h"
#include "bcm_bca_leds.h"
#include "dt_access.h"
static uintptr_t xrdpled_base;
static int xrdpled_probe(dt_device_t *pdev)
{
int ret;
xrdpled_base = dt_dev_remap_resource(pdev, 0);
if (IS_ERR(xrdpled_base))
{
ret = PTR_ERR(xrdpled_base);
xrdpled_base = NULL;
dev_err(&pdev->dev, "Missing xrdpled_base entry\n");
goto Exit;
}
dev_dbg(&pdev->dev, "xrdpled_base=0x%lx\n", xrdpled_base);
dev_info(&pdev->dev, "registered\n");
return 0;
Exit:
return ret;
}
#ifdef __UBOOT__
static const struct udevice_id xrdpled_ids[] = {
{ .compatible = "brcm,xrdp-led" },
{ /* end of list */ },
};
U_BOOT_DRIVER(brcm_xrdpled) = {
.name = "brcm-xrdpled",
.id = UCLASS_MISC,
.of_match = xrdpled_ids,
.probe = xrdpled_probe,
};
#else
static const struct of_device_id of_platform_table[] = {
{ .compatible = "brcm,xrdp-led" },
{ /* end of list */ },
};
static struct platform_driver of_platform_driver = {
.driver = {
.name = "brcm-xrdpled",
.of_match_table = of_platform_table,
},
.probe = xrdpled_probe,
};
module_platform_driver(of_platform_driver);
#endif
typedef union {
struct {
uint32_t rx_act_en :1 ; // [00:00]
uint32_t tx_act_en :1 ; // [01:01]
uint32_t spdlnk_led0_act_sel :1 ; // [02:02]
uint32_t spdlnk_led1_act_sel :1 ; // [03:03]
uint32_t spdlnk_led2_act_sel :1 ; // [04:04]
uint32_t act_led_act_sel :1 ; // [05:05]
uint32_t spdlnk_led0_act_pol_sel :1 ; // [06:06]
uint32_t spdlnk_led1_act_pol_sel :1 ; // [07:07]
uint32_t spdlnk_led2_act_pol_sel :1 ; // [08:08]
uint32_t act_led_pol_sel :1 ; // [09:09]
uint32_t led_spd_ovrd :3 ; // [12:10]
uint32_t lnk_status_ovrd :1 ; // [13:13]
uint32_t spd_ovrd_en :1 ; // [14:14]
uint32_t lnk_ovrd_en :1 ; // [15:15]
uint32_t r1 :16; // [31:16]
}Bits;
uint32_t Reg32;
}XRDP_LED_CTRL;
typedef union {
struct {
uint32_t sel_no_link_encode :3 ; // [02:00]
uint32_t sel_10m_encode :3 ; // [05:03]
uint32_t sel_100m_encode :3 ; // [08:06]
uint32_t sel_1000m_encode :3 ; // [11:09]
uint32_t sel_2500m_encode :3 ; // [14:12]
uint32_t sel_10g_encode :3 ; // [17:15]
uint32_t r1 :14; // [31:18]
}Bits;
uint32_t Reg32;
}XRDP_LED_LINK_SPEED_ENC_SEL;
typedef union {
struct {
uint32_t no_link_encode :3 ; // [02:00]
uint32_t m10_encode :3 ; // [05:03]
uint32_t m100_encode :3 ; // [08:06]
uint32_t m1000_encode :3 ; // [11:09]
uint32_t m2500_encode :3 ; // [14:12]
uint32_t m10g_encode :3 ; // [17:15]
uint32_t r1 :14; // [31:18]
}Bits;
uint32_t Reg32;
}XRDP_LED_LINK_SPEED_ENC;
typedef union {
struct {
uint32_t port_en :16; // [15:00]
uint32_t act_sel :1 ; // [16:16]
uint32_t act_pol_sel :1 ; // [17:17]
uint32_t lnk_pol_sel :1 ; // [18:18]
uint32_t r1 :13; // [31:19]
}Bits;
uint32_t Reg32;
}XRDP_LED_AGGREGATE_CTRL;
typedef struct XrdpLedRegs {
XRDP_LED_CTRL led_ctrl[5];
uint32_t reserved0[3];
XRDP_LED_LINK_SPEED_ENC_SEL led_link_speed_enc_sel[5];
uint32_t reserved1[3];
XRDP_LED_LINK_SPEED_ENC led_link_speed_enc[5];
uint32_t reserved2[3];
uint32_t led_blink_rate_ctrl;
uint32_t led_pwm_ctrl;
uint32_t led_intensity_ctrl;
XRDP_LED_AGGREGATE_CTRL led_aggregate_ctrl;
uint32_t led_aggregate_blink_rate_ctrl;
uint32_t led_aggregate_pwm_ctrl;
uint32_t led_aggregate_intensity_ctrl;
uint32_t led_sw_init_ctrl;
} XrdpLedRegs;
#define XRDP_LED_BASE (void *)xrdpled_base
#define XRDP_LED ((volatile XrdpLedRegs * const) XRDP_LED_BASE)
int xrdp_leds_init(void *_leds_info)
{
bca_leds_info_t *leds_info = (bca_leds_info_t *)_leds_info;
int ret = 0;
int j;
XRDP_LED_CTRL led_ctrl;
XRDP_LED_LINK_SPEED_ENC_SEL spdlnk_sel;
XRDP_LED_LINK_SPEED_ENC spdlnk;
uint32_t port = leds_info->port_id;
XRDP_LED_AGGREGATE_CTRL agg_ctrl;
uint8_t activity;
if(port == 0xff)
{
/* No Led info provided */
return 0;
}
spdlnk_sel.Bits.sel_10g_encode = 0;
spdlnk_sel.Bits.sel_1000m_encode = 0;
spdlnk_sel.Bits.sel_100m_encode = 0;
spdlnk_sel.Bits.sel_2500m_encode = 0;
spdlnk_sel.Bits.sel_10m_encode = 0;
spdlnk_sel.Bits.sel_no_link_encode = 0;
spdlnk.Bits.m10g_encode = 7;
spdlnk.Bits.m2500_encode = 7;
spdlnk.Bits.m1000_encode = 7;
spdlnk.Bits.m100_encode = 7;
spdlnk.Bits.m10_encode = 7;
spdlnk.Bits.no_link_encode = 7;
led_ctrl.Reg32 = XRDP_LED->led_ctrl[port].Reg32;
agg_ctrl.Reg32 = XRDP_LED->led_aggregate_ctrl.Reg32;
agg_ctrl.Bits.act_sel = 1;
agg_ctrl.Bits.act_pol_sel = 0;
agg_ctrl.Bits.lnk_pol_sel = 1;
if (!leds_info->skip_in_aggregate)
agg_ctrl.Bits.port_en |= 1<<port;
XRDP_LED->led_aggregate_ctrl.Reg32 = agg_ctrl.Reg32;
if (!leds_info->skip_in_aggregate)
XRDP_LED->led_aggregate_ctrl.Bits.port_en |= 1<<port;
for (j = 0; j < 3; j++)
{
uint32_t led_mux = leds_info->link[j];
uint32_t led_activity = leds_info->activity[j];
activity = 0;
if (led_mux & LED_SPEED_10G)
spdlnk.Bits.m10g_encode &= ~(1<<j);
if (led_mux & LED_SPEED_2500)
spdlnk.Bits.m2500_encode &= ~(1<<j);
if (led_mux & LED_SPEED_1G)
spdlnk.Bits.m1000_encode &= ~(1<<j);
if (led_mux & LED_SPEED_100)
spdlnk.Bits.m100_encode &= ~(1<<j);
if (led_mux & LED_SPEED_10)
spdlnk.Bits.m10_encode &= ~(1<<j);
if (led_activity & LED_SPEED_10G)
spdlnk_sel.Bits.sel_10g_encode |= (1<<j);
if (led_activity & LED_SPEED_2500)
spdlnk_sel.Bits.sel_2500m_encode |= (1<<j);
if (led_activity & LED_SPEED_1G)
spdlnk_sel.Bits.sel_1000m_encode |= (1<<j);
if (led_activity & LED_SPEED_100)
spdlnk_sel.Bits.sel_100m_encode |= (1<<j);
if (led_activity & LED_SPEED_10)
spdlnk_sel.Bits.sel_10m_encode |= (1<<j);
/* to configure the speed led to show activity only for specified
speeds */
if (led_activity && !(led_mux & led_activity))
activity = 1;
switch (j)
{
case 0:
led_ctrl.Bits.spdlnk_led0_act_sel = activity;
break;
case 1:
led_ctrl.Bits.spdlnk_led1_act_sel = activity;
break;
case 2:
led_ctrl.Bits.spdlnk_led2_act_sel = activity;
break;
}
}
if (leds_info->activity[3] || leds_info->link[3])
led_ctrl.Bits.act_led_act_sel = leds_info->link[3] ? 0 : 1;
XRDP_LED->led_link_speed_enc_sel[port].Reg32 = spdlnk_sel.Reg32;
XRDP_LED->led_link_speed_enc[port].Reg32 = spdlnk.Reg32;
XRDP_LED->led_ctrl[port].Reg32 = led_ctrl.Reg32;
printk("%s Port %d configured \n", __FUNCTION__, port);
return ret;
}
|
