aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorAurelien Jacquiot2014-11-21 08:40:00 -0600
committerMurali Karicheri2014-11-21 10:57:53 -0600
commitbdec1c4c21be8c50a39bc7eaeeddfb6d64d63ce5 (patch)
tree6cc728ada73a98b4ee5f46b30f60528fff1eb0c2
parentbeeddab58ee75347f3552f3c3833dbd9b4228e5d (diff)
downloadlinux-v3.13/keystone-drivers.tar.gz
linux-v3.13/keystone-drivers.tar.xz
linux-v3.13/keystone-drivers.zip
rapidio: keystone: enhance SerDes management and port initializationv3.13/keystone-drivers
- Add sysfs entries for initiating SerDes calibration ('calibrate') and starting/stopping the SRIO controller ('start'). Writting a non-zero value in these file will start the service, writting a zero will stop it. Calibration can only be performed when SRIO controller has not been started. - Add 'serdes_calibration' (default 0) and 'enable_ports' (default 1) module parameters - Fix SRIO controller stop and shutdown - Fix error recovery - Cosmetic cleanup and code simplification Signed-off-by: Aurelien Jacquiot <a-jacquiot@ti.com>
-rw-r--r--drivers/rapidio/devices/keystone_rio.c863
-rw-r--r--drivers/rapidio/devices/keystone_rio.h17
2 files changed, 585 insertions, 295 deletions
diff --git a/drivers/rapidio/devices/keystone_rio.c b/drivers/rapidio/devices/keystone_rio.c
index ab0d920ec64..75398932e89 100644
--- a/drivers/rapidio/devices/keystone_rio.c
+++ b/drivers/rapidio/devices/keystone_rio.c
@@ -37,6 +37,18 @@
37 37
38#define DRIVER_VER "v1.2" 38#define DRIVER_VER "v1.2"
39 39
40static bool serdes_calibration;
41module_param(serdes_calibration, bool, 0);
42MODULE_PARM_DESC(
43 serdes_calibration,
44 "Perform Serdes calibration before starting RapidIO (default = 0)");
45
46static bool enable_ports = 1;
47module_param(enable_ports, bool, 0);
48MODULE_PARM_DESC(
49 enable_port,
50 "Enable RapidIO ports at boottime (default = 1)");
51
40/* 52/*
41 * Main KeyStone RapidIO driver data 53 * Main KeyStone RapidIO driver data
42 */ 54 */
@@ -44,6 +56,10 @@ struct keystone_rio_data {
44 struct device *dev; 56 struct device *dev;
45 struct rio_mport *mport[KEYSTONE_RIO_MAX_PORT]; 57 struct rio_mport *mport[KEYSTONE_RIO_MAX_PORT];
46 struct clk *clk; 58 struct clk *clk;
59
60 u32 started;
61 u32 calibrating;
62
47 struct completion lsu_completion; 63 struct completion lsu_completion;
48 struct mutex lsu_lock; 64 struct mutex lsu_lock;
49 u8 lsu_dio; 65 u8 lsu_dio;
@@ -97,11 +113,19 @@ struct keystone_rio_data {
97 113
98 struct keystone_rio_board_controller_info board_rio_cfg; 114 struct keystone_rio_board_controller_info board_rio_cfg;
99 115
100 const struct keystone_serdes_ops *serdes_ops; 116 struct keystone_serdes_data serdes;
101}; 117};
102 118
103static void dbell_handler(struct keystone_rio_data *krio_priv); 119static void dbell_handler(
104static void keystone_rio_port_write_handler(struct keystone_rio_data *krio_priv); 120 struct keystone_rio_data *krio_priv);
121static void keystone_rio_port_write_handler(
122 struct keystone_rio_data *krio_priv);
123static void keystone_rio_handle_logical_error(
124 struct keystone_rio_data *krio_priv);
125static int keystone_rio_setup_controller(
126 struct keystone_rio_data *krio_priv);
127static void keystone_rio_shutdown_controller(
128 struct keystone_rio_data *krio_priv);
105 129
106struct keystone_lane_config { 130struct keystone_lane_config {
107 int start; /* lane start number of the port */ 131 int start; /* lane start number of the port */
@@ -147,8 +171,7 @@ static void special_interrupt_handler(int ics, struct keystone_rio_data *krio_pr
147 171
148 switch (ics) { 172 switch (ics) {
149 case KEYSTONE_RIO_MCAST_EVT_INT: 173 case KEYSTONE_RIO_MCAST_EVT_INT:
150 /* Multi-cast event control symbol interrupt 174 /* Multi-cast event control symbol interrupt received */
151 received on any port */
152 break; 175 break;
153 176
154 case KEYSTONE_RIO_PORT_WRITEIN_INT: 177 case KEYSTONE_RIO_PORT_WRITEIN_INT:
@@ -158,6 +181,7 @@ static void special_interrupt_handler(int ics, struct keystone_rio_data *krio_pr
158 181
159 case KEYSTONE_RIO_EVT_CAP_ERROR_INT: 182 case KEYSTONE_RIO_EVT_CAP_ERROR_INT:
160 /* Logical layer error management event capture */ 183 /* Logical layer error management event capture */
184 keystone_rio_handle_logical_error(krio_priv);
161 break; 185 break;
162 186
163 case KEYSTONE_RIO_PORT0_ERROR_INT: 187 case KEYSTONE_RIO_PORT0_ERROR_INT:
@@ -193,7 +217,7 @@ static irqreturn_t rio_interrupt_handler(int irq, void *data)
193 /* Handle special interrupts (error, reset, special event) */ 217 /* Handle special interrupts (error, reset, special event) */
194 while (pending_err_rst_evnt_int) { 218 while (pending_err_rst_evnt_int) {
195 u32 ics = __ffs(pending_err_rst_evnt_int); 219 u32 ics = __ffs(pending_err_rst_evnt_int);
196 pending_err_rst_evnt_int &= ~(1 << ics); 220 pending_err_rst_evnt_int &= ~BIT(ics);
197 special_interrupt_handler(ics, krio_priv); 221 special_interrupt_handler(ics, krio_priv);
198 } 222 }
199 223
@@ -389,7 +413,7 @@ retry_transfer:
389 res = -EIO; 413 res = -EIO;
390 goto out; 414 goto out;
391 } 415 }
392 ndelay(1000); 416 ndelay(KEYSTONE_RIO_TIMEOUT_NSEC);
393 } 417 }
394 418
395 /* Get LCB and LTID, LSU reg 6 is already read */ 419 /* Get LCB and LTID, LSU reg 6 is already read */
@@ -418,7 +442,7 @@ retry_transfer:
418 * interrupt request = 1 */ 442 * interrupt request = 1 */
419 __raw_writel(((port_id << 8) 443 __raw_writel(((port_id << 8)
420 | (KEYSTONE_RIO_LSU_PRIO << 4) 444 | (KEYSTONE_RIO_LSU_PRIO << 4)
421 | (size ? (1 << 10) : 0) 445 | (size ? BIT(10) : 0)
422 | ((u32) dest_id << 16) 446 | ((u32) dest_id << 16)
423 | 1), 447 | 1),
424 &(krio_priv->regs->lsu_reg[lsu].destid)); 448 &(krio_priv->regs->lsu_reg[lsu].destid));
@@ -454,7 +478,7 @@ retry_transfer:
454 res = -EIO; 478 res = -EIO;
455 break; 479 break;
456 } 480 }
457 ndelay(1000); 481 ndelay(KEYSTONE_RIO_TIMEOUT_NSEC);
458 } 482 }
459out: 483out:
460 mutex_unlock(&krio_priv->lsu_lock); 484 mutex_unlock(&krio_priv->lsu_lock);
@@ -489,7 +513,7 @@ out:
489 * or canceled LSU transfer. 513 * or canceled LSU transfer.
490 */ 514 */
491 if ((res == -EAGAIN) && (retry_count-- > 0)) { 515 if ((res == -EAGAIN) && (retry_count-- > 0)) {
492 ndelay(1000); 516 ndelay(KEYSTONE_RIO_TIMEOUT_NSEC);
493 goto retry_transfer; 517 goto retry_transfer;
494 } 518 }
495 519
@@ -576,7 +600,7 @@ static inline int dbell_get(u32 *pending)
576{ 600{
577 if (*pending) { 601 if (*pending) {
578 int n = __ffs(*pending); 602 int n = __ffs(*pending);
579 *pending &= ~(1 << n); 603 *pending &= ~BIT(n);
580 return n; 604 return n;
581 } else 605 } else
582 return -1; 606 return -1;
@@ -704,7 +728,7 @@ static int keystone_rio_dbell_send(struct rio_mport *mport,
704 /* LSU Reg 4 - */ 728 /* LSU Reg 4 - */
705 __raw_writel(((port_id << 8) 729 __raw_writel(((port_id << 8)
706 | (KEYSTONE_RIO_LSU_PRIO << 4) 730 | (KEYSTONE_RIO_LSU_PRIO << 4)
707 | ((mport->sys_size) ? (1 << 10) : 0) 731 | ((mport->sys_size) ? BIT(10) : 0)
708 | ((u32) dest_id << 16) 732 | ((u32) dest_id << 16)
709 | 1), 733 | 1),
710 &(krio_priv->regs->lsu_reg[lsu].destid)); 734 &(krio_priv->regs->lsu_reg[lsu].destid));
@@ -844,7 +868,7 @@ static inline int keystone_rio_maint_request(int port_id,
844 /* LSU Reg 4 - */ 868 /* LSU Reg 4 - */
845 __raw_writel(((port_id << 8) 869 __raw_writel(((port_id << 8)
846 | (KEYSTONE_RIO_LSU_PRIO << 4) 870 | (KEYSTONE_RIO_LSU_PRIO << 4)
847 | (size ? (1 << 10) : 0) 871 | (size ? BIT(10) : 0)
848 | ((u32) dest_id << 16)), 872 | ((u32) dest_id << 16)),
849 &(krio_priv->regs->lsu_reg[lsu].destid)); 873 &(krio_priv->regs->lsu_reg[lsu].destid));
850 874
@@ -1013,7 +1037,7 @@ static int keystone_rio_get_lane_config(u32 ports, u32 path_mode)
1013 while (ports) { 1037 while (ports) {
1014 u32 lane; 1038 u32 lane;
1015 u32 port = __ffs(ports); 1039 u32 port = __ffs(ports);
1016 ports &= ~(1 << port); 1040 ports &= ~BIT(port);
1017 1041
1018 if (keystone_lane_configs[path_mode][port].start == -1) 1042 if (keystone_lane_configs[path_mode][port].start == -1)
1019 return -1; 1043 return -1;
@@ -1024,6 +1048,7 @@ static int keystone_rio_get_lane_config(u32 ports, u32 path_mode)
1024 lanes |= KEYSTONE_SERDES_LANE(lane); 1048 lanes |= KEYSTONE_SERDES_LANE(lane);
1025 } 1049 }
1026 } 1050 }
1051
1027 return (int) lanes; 1052 return (int) lanes;
1028} 1053}
1029 1054
@@ -1033,6 +1058,7 @@ static int keystone_rio_get_lane_config(u32 ports, u32 path_mode)
1033 * 1058 *
1034 * @port: RIO port 1059 * @port: RIO port
1035 * @start: if non null, lanes will be started 1060 * @start: if non null, lanes will be started
1061 * @init_rx: if non null, lanes Rx coefficients will be applied
1036 * 1062 *
1037 * Returns %0 on success or %1 if lane is not OK during the expected timeout 1063 * Returns %0 on success or %1 if lane is not OK during the expected timeout
1038 */ 1064 */
@@ -1040,30 +1066,26 @@ static int keystone_rio_lanes_init_and_wait(u32 port, int start,
1040 struct keystone_rio_data *krio_priv) 1066 struct keystone_rio_data *krio_priv)
1041{ 1067{
1042 u32 path_mode = krio_priv->board_rio_cfg.path_mode; 1068 u32 path_mode = krio_priv->board_rio_cfg.path_mode;
1043 int lanes = keystone_rio_get_lane_config(BIT(port), path_mode); 1069 int lanes = keystone_rio_get_lane_config(BIT(port), path_mode);
1044 struct keystone_serdes_config *serdes_config =
1045 &(krio_priv->board_rio_cfg.serdes_config);
1046 int res; 1070 int res;
1047 1071
1048 dev_dbg(krio_priv->dev, 1072 dev_dbg(krio_priv->dev,
1049 "Initializing lane mask 0x%x for port %d", 1073 "initializing lane mask 0x%x for port %d",
1050 lanes, port); 1074 lanes, port);
1051 1075
1052 /* Eventually start the lanes */ 1076 /* Eventually start the lane */
1053 if (start) { 1077 if (start) {
1054 dev_dbg(krio_priv->dev, 1078 dev_dbg(krio_priv->dev,
1055 "Starting lane mask 0x%x for port %d", 1079 "starting lane mask 0x%x for port %d",
1056 lanes, port); 1080 lanes, port);
1057 1081
1058 krio_priv->serdes_ops->start_tx_lanes((u32) lanes, 1082 krio_priv->serdes.ops->start_tx_lanes((u32) lanes,
1059 krio_priv->dev, 1083 &krio_priv->serdes);
1060 krio_priv->serdes_regs,
1061 serdes_config);
1062 } 1084 }
1063 1085
1064 /* Wait lanes to be OK */ 1086 /* Wait lanes to be OK */
1065 res = krio_priv->serdes_ops->wait_lanes_ok(lanes, 1087 res = krio_priv->serdes.ops->wait_lanes_ok(lanes,
1066 krio_priv->serdes_regs); 1088 &krio_priv->serdes);
1067 if (res < 0) { 1089 if (res < 0) {
1068 dev_dbg(krio_priv->dev, 1090 dev_dbg(krio_priv->dev,
1069 "port %d lane mask 0x%x is not OK\n", 1091 "port %d lane mask 0x%x is not OK\n",
@@ -1075,6 +1097,51 @@ static int keystone_rio_lanes_init_and_wait(u32 port, int start,
1075 return 0; 1097 return 0;
1076} 1098}
1077 1099
1100/*
1101 * SerDes main configuration
1102 */
1103static int keystone_rio_serdes_init(u32 baud,
1104 int calibrate,
1105 struct keystone_rio_data *krio_priv)
1106{
1107 u32 path_mode = krio_priv->board_rio_cfg.path_mode;
1108 u32 ports = krio_priv->board_rio_cfg.ports;
1109 u32 lanes;
1110 int res;
1111
1112 /* Retrieve lane termination */
1113 res = keystone_rio_get_lane_config(ports, path_mode);
1114 if (res <= 0)
1115 return res;
1116
1117 /* Initialize SerDes */
1118 lanes = (u32) res;
1119 res = krio_priv->serdes.ops->config_lanes(lanes,
1120 baud,
1121 &krio_priv->serdes);
1122 if (res < 0)
1123 return res;
1124
1125 /* Check if we need to perform SerDes calibration */
1126 if ((calibrate) && (!krio_priv->calibrating)) {
1127
1128 krio_priv->calibrating = 1;
1129
1130 /* Set calibration timeout */
1131 krio_priv->board_rio_cfg.serdes_config.cal_timeout =
1132 krio_priv->board_rio_cfg.port_register_timeout;
1133
1134 /* Do the calibration */
1135 krio_priv->serdes.ops->calibrate_lanes(
1136 lanes,
1137 &krio_priv->serdes);
1138
1139 krio_priv->calibrating = 0;
1140 }
1141
1142 return 0;
1143}
1144
1078/** 1145/**
1079 * keystone_rio_hw_init - Configure a RapidIO controller 1146 * keystone_rio_hw_init - Configure a RapidIO controller
1080 * @baud: serdes baudrate 1147 * @baud: serdes baudrate
@@ -1085,8 +1152,6 @@ static int keystone_rio_hw_init(u32 baud, struct keystone_rio_data *krio_priv)
1085{ 1152{
1086 struct keystone_serdes_config *serdes_config 1153 struct keystone_serdes_config *serdes_config
1087 = &(krio_priv->board_rio_cfg.serdes_config); 1154 = &(krio_priv->board_rio_cfg.serdes_config);
1088 u32 path_mode = krio_priv->board_rio_cfg.path_mode;
1089 u32 ports = krio_priv->board_rio_cfg.ports;
1090 u32 val; 1155 u32 val;
1091 u32 block; 1156 u32 block;
1092 int res = 0; 1157 int res = 0;
@@ -1097,7 +1162,7 @@ static int keystone_rio_hw_init(u32 baud, struct keystone_rio_data *krio_priv)
1097 for (block = 0; block <= KEYSTONE_RIO_BLK_NUM; block++) 1162 for (block = 0; block <= KEYSTONE_RIO_BLK_NUM; block++)
1098 __raw_writel(0, &(krio_priv->regs->blk[block].enable)); 1163 __raw_writel(0, &(krio_priv->regs->blk[block].enable));
1099 1164
1100 ndelay(1000); 1165 ndelay(KEYSTONE_RIO_TIMEOUT_NSEC);
1101 1166
1102 /* Set sRIO out of reset */ 1167 /* Set sRIO out of reset */
1103 __raw_writel((KEYSTONE_RIO_PER_RESTORE | KEYSTONE_RIO_PER_FREE), 1168 __raw_writel((KEYSTONE_RIO_PER_RESTORE | KEYSTONE_RIO_PER_FREE),
@@ -1130,20 +1195,11 @@ static int keystone_rio_hw_init(u32 baud, struct keystone_rio_data *krio_priv)
1130 BIT(21) | BIT(8) : 0), 1195 BIT(21) | BIT(8) : 0),
1131 &krio_priv->regs->per_set_cntl); 1196 &krio_priv->regs->per_set_cntl);
1132 1197
1133 /* SerDes main configuration */ 1198 /* Initialize SerDes and eventually perform their calibration */
1134 res = keystone_rio_get_lane_config(ports, path_mode); 1199 res = keystone_rio_serdes_init(
1135 if (res > 0) { 1200 baud,
1136 u32 lanes = (u32) res; 1201 krio_priv->board_rio_cfg.serdes_calibration,
1137 1202 krio_priv);
1138 /* Initialize Serdes */
1139 res = krio_priv->serdes_ops->config_lanes(
1140 lanes,
1141 baud,
1142 krio_priv->dev,
1143 krio_priv->serdes_regs,
1144 krio_priv->serdes_sts_reg,
1145 serdes_config);
1146 }
1147 1203
1148 if (res < 0) { 1204 if (res < 0) {
1149 dev_err(krio_priv->dev, "initialization of SerDes failed\n"); 1205 dev_err(krio_priv->dev, "initialization of SerDes failed\n");
@@ -1211,48 +1267,53 @@ static int keystone_rio_hw_init(u32 baud, struct keystone_rio_data *krio_priv)
1211 KEYSTONE_RIO_SP_HDR_EP_REC_ID); 1267 KEYSTONE_RIO_SP_HDR_EP_REC_ID);
1212 __raw_writel(val, &krio_priv->serial_port_regs->sp_maint_blk_hdr); 1268 __raw_writel(val, &krio_priv->serial_port_regs->sp_maint_blk_hdr);
1213 1269
1214 /* clear high bits of local config space base addr */ 1270 /* Clear high bits of local config space base addr */
1215 __raw_writel(0x00000000, &krio_priv->car_csr_regs->local_cfg_hbar); 1271 __raw_writel(0x00000000, &krio_priv->car_csr_regs->local_cfg_hbar);
1216 1272
1217 /* set local config space base addr */ 1273 /* Set local config space base addr */
1218 __raw_writel(0x00520000, &krio_priv->car_csr_regs->local_cfg_bar); 1274 __raw_writel(0x00520000, &krio_priv->car_csr_regs->local_cfg_bar);
1219 1275
1220 /* Enable HOST BIT(31) & MASTER_ENABLE BIT(30) bits */ 1276 /* Enable HOST BIT(31) & MASTER_ENABLE BIT(30) bits */
1221 __raw_writel(0xc0000000, &krio_priv->serial_port_regs->sp_gen_ctl); 1277 __raw_writel(0xc0000000, &krio_priv->serial_port_regs->sp_gen_ctl);
1222 1278
1223 /* set link timeout value */ 1279 /* Set link timeout value */
1224 __raw_writel(0x000FFF00, 1280 __raw_writel(0x000FFF00,
1225 &krio_priv->serial_port_regs->sp_link_timeout_ctl); 1281 &krio_priv->serial_port_regs->sp_link_timeout_ctl);
1226 1282
1227 /* set response timeout value */ 1283 /* Set response timeout value */
1228 __raw_writel(0x000FFF00, 1284 __raw_writel(0x000FFF00,
1229 &krio_priv->serial_port_regs->sp_rsp_timeout_ctl); 1285 &krio_priv->serial_port_regs->sp_rsp_timeout_ctl);
1230 1286
1231 /* allows SELF_RESET and PWDN_PORT resets to clear stcky reg bits */ 1287 /* Allows SELF_RESET and PWDN_PORT resets to clear stcky reg bits */
1232 __raw_writel(0x00000001, &krio_priv->link_regs->reg_rst_ctl); 1288 __raw_writel(0x00000001, &krio_priv->link_regs->reg_rst_ctl);
1233 1289
1234 /* clear all errors */ 1290 /* Clear all errors */
1235 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->err_det); 1291 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->err_det);
1236 1292
1237 /* disable all error detection */ 1293 /* Disable all error detection */
1238 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->err_en); 1294 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->err_en);
1239 __raw_writel(0x00000000, &krio_priv->link_regs->local_err_en); 1295 if (krio_priv->board_rio_cfg.pkt_forwarding)
1296 __raw_writel(0x00000000,
1297 &krio_priv->link_regs->local_err_en);
1298 else
1299 __raw_writel(BIT(24) | BIT(25) | BIT(31),
1300 &krio_priv->err_mgmt_regs->err_en);
1240 1301
1241 /* set err det block header */ 1302 /* Set err det block header */
1242 val = (((KEYSTONE_RIO_ERR_HDR_NEXT_BLK_PTR & 0xffff) << 16) | 1303 val = (((KEYSTONE_RIO_ERR_HDR_NEXT_BLK_PTR & 0xffff) << 16) |
1243 KEYSTONE_RIO_ERR_EXT_FEAT_ID); 1304 KEYSTONE_RIO_ERR_EXT_FEAT_ID);
1244 __raw_writel(val, &krio_priv->err_mgmt_regs->err_report_blk_hdr); 1305 __raw_writel(val, &krio_priv->err_mgmt_regs->err_report_blk_hdr);
1245 1306
1246 /* clear msb of err captured addr reg */ 1307 /* Clear msb of err captured addr reg */
1247 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->h_addr_capt); 1308 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->h_addr_capt);
1248 1309
1249 /* clear lsb of err captured addr reg */ 1310 /* Clear lsb of err captured addr reg */
1250 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->addr_capt); 1311 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->addr_capt);
1251 1312
1252 /* clear err captured source and dest DevID reg */ 1313 /* Clear err captured source and dest DevID reg */
1253 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->id_capt); 1314 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->id_capt);
1254 1315
1255 /* clear err captured packet info */ 1316 /* Clear err captured packet info */
1256 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->ctrl_capt); 1317 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->ctrl_capt);
1257 1318
1258 __raw_writel(0x41004141, &krio_priv->phy_regs->phy_sp[0].__rsvd[3]); 1319 __raw_writel(0x41004141, &krio_priv->phy_regs->phy_sp[0].__rsvd[3]);
@@ -1280,6 +1341,7 @@ static int keystone_rio_hw_init(u32 baud, struct keystone_rio_data *krio_priv)
1280 __raw_writel(0x0003ffff, &(krio_priv->regs->pkt_fwd_cntl[i].pf_8b)); 1341 __raw_writel(0x0003ffff, &(krio_priv->regs->pkt_fwd_cntl[i].pf_8b));
1281 } 1342 }
1282 } 1343 }
1344
1283 if (!krio_priv->board_rio_cfg.pkt_forwarding) 1345 if (!krio_priv->board_rio_cfg.pkt_forwarding)
1284 dev_info(krio_priv->dev, "packet forwarding disabled\n"); 1346 dev_info(krio_priv->dev, "packet forwarding disabled\n");
1285 1347
@@ -1315,12 +1377,38 @@ static void keystone_rio_stop(struct keystone_rio_data *krio_priv)
1315 1377
1316 /* Disable PEREN bit to stop all new logical layer transactions */ 1378 /* Disable PEREN bit to stop all new logical layer transactions */
1317 val = __raw_readl(&krio_priv->regs->pcr); 1379 val = __raw_readl(&krio_priv->regs->pcr);
1318 val &= ~KEYSTONE_RIO_PER_EN; 1380 __raw_writel(val & ~KEYSTONE_RIO_PER_EN, &krio_priv->regs->pcr);
1319 __raw_writel(val, &krio_priv->regs->pcr); 1381
1382 /* Clear BOOT_COMPLETE bit */
1383 val = __raw_readl(&krio_priv->regs->per_set_cntl);
1384 __raw_writel(val & ~KEYSTONE_RIO_BOOT_COMPLETE,
1385 &krio_priv->regs->per_set_cntl);
1320} 1386}
1321 1387
1322static int keystone_rio_get_remote_port(u8 port, 1388static void keystone_rio_handle_logical_error(
1323 struct keystone_rio_data *krio_priv) 1389 struct keystone_rio_data *krio_priv)
1390{
1391 u32 err_det = __raw_readl(&krio_priv->err_mgmt_regs->err_det);
1392
1393 if (!err_det)
1394 return;
1395
1396 while (err_det) {
1397 u32 err = __ffs(err_det);
1398 err_det &= ~BIT(err);
1399
1400 /* TODO: perform better error management here */
1401 dev_warn(krio_priv->dev,
1402 "logical layer error %d detected\n", err);
1403 }
1404
1405 /* Acknowledge logical layer error */
1406 __raw_writel(0x00000000, &krio_priv->err_mgmt_regs->err_det);
1407}
1408
1409static int keystone_rio_get_remote_port(
1410 u8 port,
1411 struct keystone_rio_data *krio_priv)
1324{ 1412{
1325 int res; 1413 int res;
1326 u32 value; 1414 u32 value;
@@ -1526,49 +1614,50 @@ static void keystone_rio_pe_dpc(struct work_struct *work)
1526 to_delayed_work(work), struct keystone_rio_data, pe_work); 1614 to_delayed_work(work), struct keystone_rio_data, pe_work);
1527 u32 port; 1615 u32 port;
1528 1616
1529 dev_dbg(krio_priv->dev, "errors on ports: 0x%x\n", krio_priv->pe_ports); 1617 dev_dbg(krio_priv->dev,
1618 "ER errors on ports: 0x%x\n",
1619 krio_priv->pe_ports);
1530 1620
1531 for (port = 0; port < KEYSTONE_RIO_MAX_PORT; port++) { 1621 for (port = 0; port < KEYSTONE_RIO_MAX_PORT; port++) {
1532 if (test_and_clear_bit(port, (void *)&krio_priv->pe_ports)) {
1533 1622
1623 /* Skip port if we are currently registering it */
1624 if (krio_priv->ports_registering & BIT(port))
1625 continue;
1626
1627 if (test_and_clear_bit(port, (void *)&krio_priv->pe_ports)) {
1534 /* Wait lanes to be OK */ 1628 /* Wait lanes to be OK */
1535 if (keystone_rio_lanes_init_and_wait(port, 0, 1629 if (keystone_rio_lanes_init_and_wait(port, 0,
1536 krio_priv)) { 1630 krio_priv)) {
1537 dev_dbg(krio_priv->dev, 1631 dev_dbg(krio_priv->dev,
1538 "port %d: lanes are not OK\n", port); 1632 "ER port %d: lanes are not OK\n", port);
1539 goto retry; 1633 krio_priv->pe_ports |= BIT(port);
1540 } 1634 }
1541 1635
1542 /* Recover from port error state */ 1636 /* Recover from port error state */
1543 if (keystone_rio_port_error_recovery(port, 1637 if (keystone_rio_port_error_recovery(port,
1544 krio_priv)) { 1638 krio_priv)) {
1545 dev_dbg(krio_priv->dev, 1639 dev_dbg(krio_priv->dev,
1546 "port %d: failed to perform error" 1640 "ER port %d: failed to perform error"
1547 " recovery\n", 1641 " recovery\n",
1548 port); 1642 port);
1549 goto retry;
1550 }
1551
1552 /* Continue to next port */
1553 continue;
1554retry:
1555 /*
1556 * If error recovery failed schedule another one if
1557 * there is time left
1558 */
1559 if (krio_priv->pe_cnt-- > 1) {
1560 krio_priv->pe_ports |= BIT(port); 1643 krio_priv->pe_ports |= BIT(port);
1561 schedule_delayed_work(
1562 &krio_priv->pe_work,
1563 KEYSTONE_RIO_REGISTER_DELAY);
1564 } else {
1565 dev_err(krio_priv->dev,
1566 "port %d: failed to recover from "
1567 "errors\n",
1568 port);
1569 } 1644 }
1570 } 1645 }
1571 } 1646 }
1647
1648 /* If error recovery failed delay another one if there is time left */
1649 if (krio_priv->pe_ports) {
1650 if (krio_priv->pe_cnt-- > 1) {
1651 schedule_delayed_work(
1652 &krio_priv->pe_work,
1653 KEYSTONE_RIO_REGISTER_DELAY);
1654 } else {
1655 dev_err(krio_priv->dev,
1656 "ER port %d: failed to recover from "
1657 "errors\n",
1658 port);
1659 }
1660 }
1572} 1661}
1573 1662
1574/** 1663/**
@@ -1646,9 +1735,8 @@ port_phy_error:
1646 "fix unstable lane mask 0x%x for port %d\n", 1735 "fix unstable lane mask 0x%x for port %d\n",
1647 lanes, port); 1736 lanes, port);
1648 1737
1649 krio_priv->serdes_ops->fix_unstable_lanes(lanes, 1738 krio_priv->serdes.ops->fix_unstable_lanes(lanes,
1650 krio_priv->dev, 1739 &krio_priv->serdes);
1651 krio_priv->serdes_regs);
1652port_error: 1740port_error:
1653 return -EIO; 1741 return -EIO;
1654} 1742}
@@ -1657,19 +1745,38 @@ port_error:
1657 * keystone_rio_port_disable - Disable a RapidIO port 1745 * keystone_rio_port_disable - Disable a RapidIO port
1658 * @port: index of the port to configure 1746 * @port: index of the port to configure
1659 */ 1747 */
1660static void keystone_rio_port_disable(u32 port, struct keystone_rio_data *krio_priv) 1748static void keystone_rio_port_disable(
1749 u32 port,
1750 struct keystone_rio_data *krio_priv)
1661{ 1751{
1662 /* Disable port */ 1752 /* Disable port */
1663 __raw_writel(0x800000, &(krio_priv->serial_port_regs->sp[port].ctl)); 1753 __raw_writel(0x800000, &(krio_priv->serial_port_regs->sp[port].ctl));
1664} 1754}
1665 1755
1666/** 1756/**
1757 * keystone_rio_port_enable - Enable a RapidIO port
1758 * @port: index of the port to configure
1759 */
1760static void keystone_rio_port_enable(
1761 u32 port,
1762 struct keystone_rio_data *krio_priv)
1763{
1764 /* Enable port in input and output */
1765 __raw_writel(0x600000, &(krio_priv->serial_port_regs->sp[port].ctl));
1766}
1767
1768/**
1667 * keystone_rio_port_init - Configure a RapidIO port 1769 * keystone_rio_port_init - Configure a RapidIO port
1668 * @port: index of the port to configure 1770 * @port: index of the port to configure
1669 * @mode: serdes configuration 1771 * @mode: serdes configuration
1670 */ 1772 */
1671static int keystone_rio_port_init(u32 port, u32 path_mode, struct keystone_rio_data *krio_priv) 1773static int keystone_rio_port_init(
1774 u32 port,
1775 u32 path_mode,
1776 struct keystone_rio_data *krio_priv)
1672{ 1777{
1778 u32 val;
1779
1673 if (port >= KEYSTONE_RIO_MAX_PORT) 1780 if (port >= KEYSTONE_RIO_MAX_PORT)
1674 return -EINVAL; 1781 return -EINVAL;
1675 1782
@@ -1684,73 +1791,9 @@ static int keystone_rio_port_init(u32 port, u32 path_mode, struct keystone_rio_d
1684 /* Increase the number of valid code-groups required for sync */ 1791 /* Increase the number of valid code-groups required for sync */
1685 __raw_writel(0x0f030300, &(krio_priv->phy_regs->phy_sp[port].vmin_exp)); 1792 __raw_writel(0x0f030300, &(krio_priv->phy_regs->phy_sp[port].vmin_exp));
1686 1793
1687 /* Enable port in input and output */
1688 __raw_writel(0x600000, &(krio_priv->serial_port_regs->sp[port].ctl));
1689
1690 /* Program channel allocation to ports (1x, 2x or 4x) */ 1794 /* Program channel allocation to ports (1x, 2x or 4x) */
1691 __raw_writel(path_mode, &(krio_priv->phy_regs->phy_sp[port].path_ctl)); 1795 __raw_writel(path_mode, &(krio_priv->phy_regs->phy_sp[port].path_ctl));
1692 1796
1693 return 0;
1694}
1695
1696/**
1697 * keystone_rio_port_set_routing - Configure routing for a RapidIO port
1698 * @port: index of the port to configure
1699 */
1700static void keystone_rio_port_set_routing(u32 port, struct keystone_rio_data *krio_priv)
1701{
1702 u32 base_dev_id = krio_priv->board_rio_cfg.size ?
1703 __raw_readl(&krio_priv->car_csr_regs->base_dev_id) & 0xffff :
1704 (__raw_readl(&krio_priv->car_csr_regs->base_dev_id) >> 16) & 0xff;
1705
1706 u32 brr = KEYSTONE_RIO_PKT_FW_BRR_NUM;
1707
1708 /* Enable routing to LLM for this BRR and port */
1709 __raw_writel(0x84000000,
1710 &(krio_priv->transport_regs->transport_sp[port].base_route[brr].ctl));
1711
1712 /*
1713 * Configure the Base Routing Register (BRR) to ensure that all packets
1714 * matching our DevId are admitted.
1715 */
1716 __raw_writel((base_dev_id << 16) |
1717 (krio_priv->board_rio_cfg.size ? 0xffff : 0xff),
1718 &(krio_priv->transport_regs->transport_sp[port].base_route[brr].pattern_match));
1719
1720 dev_dbg(krio_priv->dev, "pattern_match = 0x%x for BRR %d\n",
1721 __raw_readl(&krio_priv->transport_regs->transport_sp[port].base_route[brr].pattern_match),
1722 brr);
1723
1724 /* Enable routing to LLM for this BRR and port */
1725 brr += 1;
1726 __raw_writel(0x84000000,
1727 &(krio_priv->transport_regs->transport_sp[port].base_route[brr].ctl));
1728
1729 /*
1730 * Configure the Base Routing Register (BRR) to ensure that all broadcast
1731 * packets are admitted as well.
1732 */
1733 __raw_writel((0xffff << 16) |
1734 (krio_priv->board_rio_cfg.size ? 0xffff : 0xff),
1735 &(krio_priv->transport_regs->transport_sp[port].base_route[brr].pattern_match));
1736
1737 dev_dbg(krio_priv->dev, "pattern_match = 0x%x for BRR %d\n",
1738 __raw_readl(&krio_priv->transport_regs->transport_sp[port].base_route[brr].pattern_match),
1739 brr);
1740
1741 /* Set multicast and packet forwarding mode */
1742 __raw_writel(0x00209000,
1743 &(krio_priv->transport_regs->transport_sp[port].control));
1744}
1745
1746/**
1747 * keystone_rio_port_activate - Start using a RapidIO port
1748 * @port: index of the port to configure
1749 */
1750static int keystone_rio_port_activate(u32 port, struct keystone_rio_data *krio_priv)
1751{
1752 u32 val;
1753
1754 /* 1797 /*
1755 * Disable all errors reporting if using packet forwarding 1798 * Disable all errors reporting if using packet forwarding
1756 * otherwise enable them. 1799 * otherwise enable them.
@@ -1766,7 +1809,7 @@ static int keystone_rio_port_activate(u32 port, struct keystone_rio_data *krio_p
1766 1809
1767 /* Enable interrupt for reset request */ 1810 /* Enable interrupt for reset request */
1768 val = __raw_readl(&(krio_priv->evt_mgmt_regs->evt_mgmt_rst_int_en)); 1811 val = __raw_readl(&(krio_priv->evt_mgmt_regs->evt_mgmt_rst_int_en));
1769 __raw_writel(val | (1 << port), 1812 __raw_writel(val | BIT(port),
1770 &(krio_priv->evt_mgmt_regs->evt_mgmt_rst_int_en)); 1813 &(krio_priv->evt_mgmt_regs->evt_mgmt_rst_int_en));
1771 1814
1772 /* Enable all PLM interrupts */ 1815 /* Enable all PLM interrupts */
@@ -1803,6 +1846,63 @@ static int keystone_rio_port_activate(u32 port, struct keystone_rio_data *krio_p
1803 return 0; 1846 return 0;
1804} 1847}
1805 1848
1849/**
1850 * keystone_rio_port_set_routing - Configure routing for a RapidIO port
1851 * @port: index of the port to configure
1852 */
1853static void keystone_rio_port_set_routing(
1854 u32 port,
1855 struct keystone_rio_data *krio_priv)
1856{
1857 struct keystone_rio_transport_layer_regs *t = krio_priv->transport_regs;
1858 u32 base_dev_id = krio_priv->board_rio_cfg.size ?
1859 __raw_readl(&krio_priv->car_csr_regs->base_dev_id) & 0xffff :
1860 (__raw_readl(&krio_priv->car_csr_regs->base_dev_id) >> 16)
1861 & 0xff;
1862 u32 brr = KEYSTONE_RIO_PKT_FW_BRR_NUM;
1863
1864 /*
1865 * Configure the Base Routing Register (BRR) to ensure that all packets
1866 * matching our DevId are admitted.
1867 */
1868 __raw_writel((base_dev_id << 16) |
1869 (krio_priv->board_rio_cfg.size ? 0xffff : 0xff),
1870 &(t->transport_sp[port].base_route[brr].pattern_match));
1871
1872 dev_dbg(krio_priv->dev, "pattern_match = 0x%x for BRR %d\n",
1873 __raw_readl(
1874 &(t->transport_sp[port].base_route[brr].pattern_match)),
1875 brr);
1876
1877 /* Enable routing to LLM for this BRR and port */
1878 __raw_writel(0x84000000,
1879 &(t->transport_sp[port].base_route[brr].ctl));
1880
1881 /* Use next BRR */
1882 brr += 1;
1883
1884 /*
1885 * Configure the Base Routing Register (BRR) to ensure that all
1886 * broadcast packets are admitted as well.
1887 */
1888 __raw_writel((0xffff << 16) |
1889 (krio_priv->board_rio_cfg.size ? 0xffff : 0xff),
1890 &(t->transport_sp[port].base_route[brr].pattern_match));
1891
1892 dev_dbg(krio_priv->dev, "pattern_match = 0x%x for BRR %d\n",
1893 __raw_readl(
1894 &(t->transport_sp[port].base_route[brr].pattern_match)),
1895 brr);
1896
1897 /* Enable routing to LLM for this BRR and port */
1898 __raw_writel(0x84000000,
1899 &(t->transport_sp[port].base_route[brr].ctl));
1900
1901 /* Set multicast and packet forwarding mode */
1902 __raw_writel(0x00209000,
1903 &(t->transport_sp[port].control));
1904}
1905
1806/*------------------------- Configuration space mngt ----------------------*/ 1906/*------------------------- Configuration space mngt ----------------------*/
1807 1907
1808/** 1908/**
@@ -2477,24 +2577,17 @@ static int keystone_rio_open_inb_mbox(struct rio_mport *mport,
2477 return res; 2577 return res;
2478} 2578}
2479 2579
2480/** 2580static void keystone_rio_close_rx_mbox(int mbox,
2481 * keystone_rio_close_inb_mbox - Shut down KeyStone inbound mailbox 2581 struct keystone_rio_data *krio_priv)
2482 * @mport: Master port implementing the inbound message unit
2483 * @mbox: Mailbox to close
2484 *
2485 * Disables the outbound message unit, stop queues and free all resources
2486 */
2487static void keystone_rio_close_inb_mbox(struct rio_mport *mport, int mbox)
2488{ 2582{
2489 struct keystone_rio_data *krio_priv = mport->priv;
2490 struct keystone_rio_mbox_info *rx_mbox = &krio_priv->rx_mbox[mbox]; 2583 struct keystone_rio_mbox_info *rx_mbox = &krio_priv->rx_mbox[mbox];
2491 2584
2492 dev_info(krio_priv->dev, "close inb mbox: mport = 0x%x, mbox = %d\n", 2585 if (mbox >= KEYSTONE_RIO_MAX_MBOX)
2493 (u32) mport, mbox); 2586 return;
2494 2587
2495 rx_mbox->running = 0; 2588 rx_mbox->running = 0;
2496 2589
2497 if (!(rx_mbox->port)) 2590 if (!rx_mbox->port)
2498 return; 2591 return;
2499 2592
2500 rx_mbox->port = NULL; 2593 rx_mbox->port = NULL;
@@ -2504,8 +2597,23 @@ static void keystone_rio_close_inb_mbox(struct rio_mport *mport, int mbox)
2504 keystone_rio_free_rxu_map(rx_mbox->rxu_map_id[1], krio_priv); 2597 keystone_rio_free_rxu_map(rx_mbox->rxu_map_id[1], krio_priv);
2505 2598
2506 keystone_rio_mp_inb_exit(mbox, krio_priv); 2599 keystone_rio_mp_inb_exit(mbox, krio_priv);
2600}
2507 2601
2508 return; 2602/**
2603 * keystone_rio_close_inb_mbox - Shutdown KeyStone inbound mailbox
2604 * @mport: Master port implementing the inbound message unit
2605 * @mbox: Mailbox to close
2606 *
2607 * Disables the outbound message unit, stop queues and free all resources
2608 */
2609static void keystone_rio_close_inb_mbox(struct rio_mport *mport, int mbox)
2610{
2611 struct keystone_rio_data *krio_priv = mport->priv;
2612
2613 dev_info(krio_priv->dev, "close inb mbox: mport = 0x%x, mbox = %d\n",
2614 (u32) mport, mbox);
2615
2616 keystone_rio_close_rx_mbox(mbox, krio_priv);
2509} 2617}
2510 2618
2511/** 2619/**
@@ -2719,8 +2827,26 @@ static int keystone_rio_open_outb_mbox(struct rio_mport *mport,
2719 return 0; 2827 return 0;
2720} 2828}
2721 2829
2830static void keystone_rio_close_tx_mbox(int mbox,
2831 struct keystone_rio_data *krio_priv)
2832{
2833 struct keystone_rio_mbox_info *tx_mbox = &(krio_priv->tx_mbox[mbox]);
2834
2835 if (mbox >= KEYSTONE_RIO_MAX_MBOX)
2836 return;
2837
2838 tx_mbox->running = 0;
2839
2840 if (!tx_mbox->port)
2841 return;
2842
2843 tx_mbox->port = NULL;
2844
2845 keystone_rio_mp_outb_exit(krio_priv);
2846}
2847
2722/** 2848/**
2723 * keystone_rio_close_outb_mbox - Shut down KeyStone outbound mailbox 2849 * keystone_rio_close_outb_mbox - Shutdown KeyStone outbound mailbox
2724 * @mport: Master port implementing the outbound message unit 2850 * @mport: Master port implementing the outbound message unit
2725 * @mbox: Mailbox to close 2851 * @mbox: Mailbox to close
2726 * 2852 *
@@ -2729,20 +2855,11 @@ static int keystone_rio_open_outb_mbox(struct rio_mport *mport,
2729static void keystone_rio_close_outb_mbox(struct rio_mport *mport, int mbox) 2855static void keystone_rio_close_outb_mbox(struct rio_mport *mport, int mbox)
2730{ 2856{
2731 struct keystone_rio_data *krio_priv = mport->priv; 2857 struct keystone_rio_data *krio_priv = mport->priv;
2732 struct keystone_rio_mbox_info *tx_mbox = &(krio_priv->tx_mbox[mbox]);
2733
2734 if (mbox >= KEYSTONE_RIO_MAX_MBOX)
2735 return;
2736 2858
2737 dev_info(krio_priv->dev, "close_outb_mbox: mport = 0x%x, mbox = %d\n", 2859 dev_info(krio_priv->dev, "close outb mbox: mport = 0x%x, mbox = %d\n",
2738 (u32) mport, mbox); 2860 (u32) mport, mbox);
2739 2861
2740 tx_mbox->port = NULL; 2862 keystone_rio_close_tx_mbox(mbox, krio_priv);
2741 tx_mbox->running = 0;
2742
2743 keystone_rio_mp_outb_exit(krio_priv);
2744
2745 return;
2746} 2863}
2747 2864
2748static void keystone_rio_tx_complete(void *data) 2865static void keystone_rio_tx_complete(void *data)
@@ -3132,11 +3249,13 @@ static void keystone_rio_get_controller_defaults(struct device_node *node,
3132 /* K1 setup*/ 3249 /* K1 setup*/
3133 c->serdes_type = KEYSTONE_SERDES_TYPE_K1; 3250 c->serdes_type = KEYSTONE_SERDES_TYPE_K1;
3134 c->serdes_config.prescalar_srv_clk = 0x001e; 3251 c->serdes_config.prescalar_srv_clk = 0x001e;
3252 c->serdes_config.do_dfe_cal = 0; /* no DFE calibration */
3135 c->path_mode = 0x0000; 3253 c->path_mode = 0x0000;
3136 } else { 3254 } else {
3137 /* K2 setup*/ 3255 /* K2 setup*/
3138 c->serdes_type = KEYSTONE_SERDES_TYPE_K2; 3256 c->serdes_type = KEYSTONE_SERDES_TYPE_K2;
3139 c->serdes_config.prescalar_srv_clk = 0x001f; 3257 c->serdes_config.prescalar_srv_clk = 0x001f;
3258 c->serdes_config.do_dfe_cal = 0; /* no DFE calibration */
3140 c->path_mode = 0x0004; 3259 c->path_mode = 0x0004;
3141 3260
3142 if (of_property_read_u32(node, "baudrate", &c->serdes_baudrate)) { 3261 if (of_property_read_u32(node, "baudrate", &c->serdes_baudrate)) {
@@ -3147,58 +3266,105 @@ static void keystone_rio_get_controller_defaults(struct device_node *node,
3147 } 3266 }
3148 } 3267 }
3149 3268
3269 /* Set if performing optional SerDes calibration sequence at boot */
3270 c->serdes_calibration = serdes_calibration;
3271
3150 /* SerDes pre-1lsb, c1, c2, cm, att and vreg config */ 3272 /* SerDes pre-1lsb, c1, c2, cm, att and vreg config */
3151 if (of_property_read_u32_array(node, "serdes_1sb", &temp[0], 4)) { 3273 if (of_property_read_u32_array(node, "serdes_1sb", &temp[0], 4)) {
3152 for (i = 0; i < 4; i++) 3274 for (i = 0; i < 4; i++)
3153 c->serdes_config.lane[i].pre_1lsb = 0; 3275 c->serdes_config.tx[i].pre_1lsb = 0;
3154 } else { 3276 } else {
3155 for (i = 0; i < 4; i++) 3277 for (i = 0; i < 4; i++)
3156 c->serdes_config.lane[i].pre_1lsb = temp[i]; 3278 c->serdes_config.tx[i].pre_1lsb = temp[i];
3157 } 3279 }
3158 3280
3159 if (of_property_read_u32_array(node, "serdes_c1", &temp[0], 4)) { 3281 if (of_property_read_u32_array(node, "serdes_c1", &temp[0], 4)) {
3160 if (c->serdes_baudrate == KEYSTONE_SERDES_BAUD_3_125) { 3282 if (c->serdes_baudrate == KEYSTONE_SERDES_BAUD_3_125) {
3161 for (i = 0; i < 4; i++) 3283 for (i = 0; i < 4; i++)
3162 c->serdes_config.lane[i].c1_coeff = 4; 3284 c->serdes_config.tx[i].c1_coeff = 4;
3163 } else { 3285 } else {
3164 for (i = 0; i < 4; i++) 3286 for (i = 0; i < 4; i++)
3165 c->serdes_config.lane[i].c1_coeff = 6; 3287 c->serdes_config.tx[i].c1_coeff = 6;
3166 } 3288 }
3167 } else { 3289 } else {
3168 for (i = 0; i < 4; i++) 3290 for (i = 0; i < 4; i++)
3169 c->serdes_config.lane[i].c1_coeff = temp[i]; 3291 c->serdes_config.tx[i].c1_coeff = temp[i];
3170 } 3292 }
3171 3293
3172 if (of_property_read_u32_array(node, "serdes_c2", &temp[0], 4)) { 3294 if (of_property_read_u32_array(node, "serdes_c2", &temp[0], 4)) {
3173 for (i = 0; i < 4; i++) 3295 for (i = 0; i < 4; i++)
3174 c->serdes_config.lane[i].c2_coeff = 0; 3296 c->serdes_config.tx[i].c2_coeff = 0;
3175 } else { 3297 } else {
3176 for (i = 0; i < 4; i++) 3298 for (i = 0; i < 4; i++)
3177 c->serdes_config.lane[i].c2_coeff = temp[i]; 3299 c->serdes_config.tx[i].c2_coeff = temp[i];
3178 } 3300 }
3179 3301
3180 if (of_property_read_u32_array(node, "serdes_cm", &temp[0], 4)) { 3302 if (of_property_read_u32_array(node, "serdes_cm", &temp[0], 4)) {
3181 for (i = 0; i < 4; i++) 3303 for (i = 0; i < 4; i++)
3182 c->serdes_config.lane[i].cm_coeff = 0; 3304 c->serdes_config.tx[i].cm_coeff = 0;
3183 } else { 3305 } else {
3184 for (i = 0; i < 4; i++) 3306 for (i = 0; i < 4; i++)
3185 c->serdes_config.lane[i].cm_coeff = temp[i]; 3307 c->serdes_config.tx[i].cm_coeff = temp[i];
3186 } 3308 }
3187 3309
3188 if (of_property_read_u32_array(node, "serdes_att", &temp[0], 4)) { 3310 if (of_property_read_u32_array(node, "serdes_att", &temp[0], 4)) {
3189 for (i = 0; i < 4; i++) 3311 for (i = 0; i < 4; i++)
3190 c->serdes_config.lane[i].att = 12; 3312 c->serdes_config.tx[i].att = 12;
3191 } else { 3313 } else {
3192 for (i = 0; i < 4; i++) 3314 for (i = 0; i < 4; i++)
3193 c->serdes_config.lane[i].att = temp[i]; 3315 c->serdes_config.tx[i].att = temp[i];
3194 } 3316 }
3195 3317
3196 if (of_property_read_u32_array(node, "serdes_vreg", &temp[0], 4)) { 3318 if (of_property_read_u32_array(node, "serdes_vreg", &temp[0], 4)) {
3197 for (i = 0; i < 4; i++) 3319 for (i = 0; i < 4; i++)
3198 c->serdes_config.lane[i].vreg = 4; 3320 c->serdes_config.tx[i].vreg = 4;
3321 } else {
3322 for (i = 0; i < 4; i++)
3323 c->serdes_config.tx[i].vreg = temp[i];
3324 }
3325
3326 if (of_property_read_u32_array(node, "serdes_vdreg", &temp[0], 4)) {
3327 for (i = 0; i < 4; i++)
3328 c->serdes_config.tx[i].vdreg = 1;
3329 } else {
3330 for (i = 0; i < 4; i++)
3331 c->serdes_config.tx[i].vdreg = temp[i];
3332 }
3333
3334 if (of_property_read_u32_array(node, "serdes_rx_att_start",
3335 &temp[0], 4)) {
3336 for (i = 0; i < 4; i++)
3337 c->serdes_config.rx[i].start_att = 3;
3338 } else {
3339 for (i = 0; i < 4; i++)
3340 c->serdes_config.rx[i].start_att = temp[i];
3341 }
3342
3343 if (of_property_read_u32_array(node, "serdes_rx_boost_start",
3344 &temp[0], 4)) {
3345 for (i = 0; i < 4; i++)
3346 c->serdes_config.rx[i].start_boost = 3;
3347 } else {
3348 for (i = 0; i < 4; i++)
3349 c->serdes_config.rx[i].start_boost = temp[i];
3350 }
3351
3352 if (of_property_read_u32_array(node, "serdes_rx_att", &temp[0], 4)) {
3353 for (i = 0; i < 4; i++)
3354 /* Use dynamic Rx calibration */
3355 c->serdes_config.rx[i].mean_att = -1;
3199 } else { 3356 } else {
3200 for (i = 0; i < 4; i++) 3357 for (i = 0; i < 4; i++)
3201 c->serdes_config.lane[i].vreg = temp[i]; 3358 c->serdes_config.rx[i].mean_att = temp[i];
3359 }
3360
3361 if (of_property_read_u32_array(node, "serdes_rx_boost", &temp[0], 4)) {
3362 for (i = 0; i < 4; i++)
3363 /* Use dynamic Rx calibration */
3364 c->serdes_config.rx[i].mean_boost = -1;
3365 } else {
3366 for (i = 0; i < 4; i++)
3367 c->serdes_config.rx[i].mean_boost = temp[i];
3202 } 3368 }
3203 3369
3204 /* Path mode config (mapping of SerDes lanes to port widths) */ 3370 /* Path mode config (mapping of SerDes lanes to port widths) */
@@ -3207,7 +3373,7 @@ static void keystone_rio_get_controller_defaults(struct device_node *node,
3207 "Missing \"path_mode\" parameter\n"); 3373 "Missing \"path_mode\" parameter\n");
3208 } 3374 }
3209 3375
3210 /* Max possible ports configurations per path_mode */ 3376 /* Max possible ports configurations per path_mode */
3211 if ((c->path_mode == 0 && 3377 if ((c->path_mode == 0 &&
3212 c->ports & ~KEYSTONE_MAX_PORTS_PATH_MODE_0) || 3378 c->ports & ~KEYSTONE_MAX_PORTS_PATH_MODE_0) ||
3213 (c->path_mode == 1 && 3379 (c->path_mode == 1 &&
@@ -3294,7 +3460,7 @@ static void keystone_rio_get_controller_defaults(struct device_node *node,
3294 } 3460 }
3295} 3461}
3296 3462
3297static int keystone_rio_port_chk(struct keystone_rio_data *krio_priv) 3463static int keystone_rio_port_chk(struct keystone_rio_data *krio_priv, int init)
3298{ 3464{
3299 u32 ports = krio_priv->ports_registering; 3465 u32 ports = krio_priv->ports_registering;
3300 u32 size = krio_priv->board_rio_cfg.size; 3466 u32 size = krio_priv->board_rio_cfg.size;
@@ -3303,13 +3469,18 @@ static int keystone_rio_port_chk(struct keystone_rio_data *krio_priv)
3303 while (ports) { 3469 while (ports) {
3304 int status; 3470 int status;
3305 u32 port = __ffs(ports); 3471 u32 port = __ffs(ports);
3306 ports &= ~(1 << port); 3472 ports &= ~BIT(port);
3307 3473
3308 /* Wait lanes to be OK */ 3474 /* Eventually start lanes and wait them to be OK and with SD */
3309 if (keystone_rio_lanes_init_and_wait(port, 0, krio_priv)) 3475 if (keystone_rio_lanes_init_and_wait(port, init, krio_priv))
3310 continue; 3476 continue;
3311 3477
3312 /* Check port status */ 3478 /*
3479 * Check the port status here before calling the generic RapidIO
3480 * layer. Port status check is done in rio_mport_is_active() as
3481 * well but we need to do it our way first due to some delays in
3482 * hw initialization.
3483 */
3313 status = keystone_rio_port_status(port, krio_priv); 3484 status = keystone_rio_port_status(port, krio_priv);
3314 if (status == 0) { 3485 if (status == 0) {
3315 unsigned long flags; 3486 unsigned long flags;
@@ -3320,24 +3491,25 @@ static int keystone_rio_port_chk(struct keystone_rio_data *krio_priv)
3320 * Only mport registration may fail now. 3491 * Only mport registration may fail now.
3321 */ 3492 */
3322 spin_lock_irqsave(&krio_priv->port_chk_lock, flags); 3493 spin_lock_irqsave(&krio_priv->port_chk_lock, flags);
3323 krio_priv->ports |= (1 << port); 3494 krio_priv->ports |= BIT(port);
3324 krio_priv->ports_registering &= ~(1 << port); 3495 krio_priv->ports_registering &= ~BIT(port);
3325 spin_unlock_irqrestore(&krio_priv->port_chk_lock, 3496 spin_unlock_irqrestore(&krio_priv->port_chk_lock,
3326 flags); 3497 flags);
3327 3498
3328 /* Register mport only if this is initial port check */ 3499 /* Register mport only if this is initial port check */
3329 if (!krio_priv->mport[port]) { 3500 if (!krio_priv->mport[port]) {
3330 mport = keystone_rio_register_mport(port, size, 3501 mport = keystone_rio_register_mport(
3331 krio_priv); 3502 port, size, krio_priv);
3503
3332 if (!mport) { 3504 if (!mport) {
3333 dev_err(krio_priv->dev, 3505 dev_err(krio_priv->dev,
3334 "failed to register mport %d\n", 3506 "failed to register mport %d\n",
3335 port); 3507 port);
3336 return -1; 3508 return -1;
3337 } 3509 }
3510
3338 dev_info(krio_priv->dev, 3511 dev_info(krio_priv->dev,
3339 "port RIO%d host_deviceid %d " 3512 "port RIO%d host_deviceid %d registered\n",
3340 "registered\n",
3341 port, mport->host_deviceid); 3513 port, mport->host_deviceid);
3342 } else { 3514 } else {
3343 dev_info(krio_priv->dev, 3515 dev_info(krio_priv->dev,
@@ -3352,7 +3524,6 @@ static int keystone_rio_port_chk(struct keystone_rio_data *krio_priv)
3352 */ 3524 */
3353 if (krio_priv->board_rio_cfg.pkt_forwarding) 3525 if (krio_priv->board_rio_cfg.pkt_forwarding)
3354 keystone_rio_port_set_routing(port, krio_priv); 3526 keystone_rio_port_set_routing(port, krio_priv);
3355
3356 } else { 3527 } else {
3357 if (status == -EINVAL) 3528 if (status == -EINVAL)
3358 return -1; 3529 return -1;
@@ -3370,10 +3541,13 @@ static void keystone_rio_port_chk_task(struct work_struct *work)
3370 to_delayed_work(work), struct keystone_rio_data, port_chk_task); 3541 to_delayed_work(work), struct keystone_rio_data, port_chk_task);
3371 int res; 3542 int res;
3372 3543
3373 res = keystone_rio_port_chk(krio_priv); 3544 res = keystone_rio_port_chk(krio_priv, 0);
3374 if (res) { 3545 if (res) {
3375 unsigned long flags; 3546 unsigned long flags;
3376 3547
3548 if (res == -1)
3549 return;
3550
3377 /* If port check failed schedule next check (if any) */ 3551 /* If port check failed schedule next check (if any) */
3378 spin_lock_irqsave(&krio_priv->port_chk_lock, flags); 3552 spin_lock_irqsave(&krio_priv->port_chk_lock, flags);
3379 if (krio_priv->port_chk_cnt-- > 1) { 3553 if (krio_priv->port_chk_cnt-- > 1) {
@@ -3410,14 +3584,14 @@ static ssize_t keystone_rio_ports_store(struct device *dev,
3410 if (kstrtoul(buf, 0, &ports)) 3584 if (kstrtoul(buf, 0, &ports))
3411 return -EINVAL; 3585 return -EINVAL;
3412 3586
3413 if (ports > ((1 << KEYSTONE_RIO_MAX_PORT) - 1)) 3587 if (ports > (BIT(KEYSTONE_RIO_MAX_PORT) - 1))
3414 return -EINVAL; 3588 return -EINVAL;
3415 3589
3416 /* 3590 /*
3417 * Only the ports defined in DTS can be rescanned because SerDes 3591 * Only the ports defined in DTS can be rescanned because SerDes
3418 * initialization is not restarted here, only link status check. 3592 * initialization is not restarted here, only link status check.
3419 */ 3593 */
3420 ports &= krio_priv->board_rio_cfg.ports; 3594 ports &= krio_priv->board_rio_cfg.ports;
3421 3595
3422 spin_lock_irqsave(&krio_priv->port_chk_lock, flags); 3596 spin_lock_irqsave(&krio_priv->port_chk_lock, flags);
3423 krio_priv->ports_registering = (ports & ~krio_priv->ports); 3597 krio_priv->ports_registering = (ports & ~krio_priv->ports);
@@ -3454,14 +3628,117 @@ static ssize_t keystone_rio_ports_show(struct device *dev,
3454 return scnprintf(buf, PAGE_SIZE, "0x%x\n", krio_priv->ports); 3628 return scnprintf(buf, PAGE_SIZE, "0x%x\n", krio_priv->ports);
3455} 3629}
3456 3630
3631static ssize_t keystone_rio_start_store(struct device *dev,
3632 struct device_attribute *attr,
3633 const char *buf,
3634 size_t count)
3635{
3636 struct keystone_rio_data *krio_priv = (struct keystone_rio_data *)
3637 dev->platform_data;
3638 long unsigned int new_start;
3639
3640 if (kstrtoul(buf, 0, &new_start))
3641 return -EINVAL;
3642
3643 /* Start SRIO peripheral if not started */
3644 if ((new_start) && (krio_priv->started == 0)) {
3645 keystone_rio_setup_controller(krio_priv);
3646 return count;
3647 }
3648
3649 /* Stop SRIO peripheral if started */
3650 if ((new_start == 0) && (krio_priv->started == 1)) {
3651 keystone_rio_shutdown_controller(krio_priv);
3652 return count;
3653 }
3654
3655 return count;
3656}
3657
3658static ssize_t keystone_rio_start_show(struct device *dev,
3659 struct device_attribute *attr,
3660 char *buf)
3661{
3662 struct keystone_rio_data *krio_priv = (struct keystone_rio_data *)
3663 dev->platform_data;
3664
3665 if (krio_priv == NULL)
3666 return -EINVAL;
3667
3668 return scnprintf(buf, PAGE_SIZE, "%d\n", krio_priv->started);
3669}
3670
3671static ssize_t keystone_rio_calibrate_store(struct device *dev,
3672 struct device_attribute *attr,
3673 const char *buf,
3674 size_t count)
3675{
3676 struct keystone_rio_data *krio_priv = (struct keystone_rio_data *)
3677 dev->platform_data;
3678 long unsigned int new_calibrate;
3679
3680 if (kstrtoul(buf, 0, &new_calibrate))
3681 return -EINVAL;
3682
3683 /* Start SRIO calibration */
3684 if ((new_calibrate) && (krio_priv->started == 0)) {
3685 int res;
3686 u32 block;
3687
3688 /* Enable RIO SerDes blocks */
3689 __raw_writel(1, &krio_priv->regs->gbl_en);
3690 for (block = KEYSTONE_RIO_BLK_PORT0;
3691 block <= KEYSTONE_RIO_BLK_PORT3;
3692 block++)
3693 __raw_writel(1, &(krio_priv->regs->blk[block].enable));
3694
3695 /* Do SerDes initialization and calibration */
3696 res = keystone_rio_serdes_init(
3697 krio_priv->board_rio_cfg.serdes_baudrate,
3698 1,
3699 krio_priv);
3700
3701 if (res < 0)
3702 dev_err(krio_priv->dev,
3703 "calibration of SerDes failed\n");
3704 }
3705
3706 return count;
3707}
3708
3709static ssize_t keystone_rio_calibrate_show(struct device *dev,
3710 struct device_attribute *attr,
3711 char *buf)
3712{
3713 struct keystone_rio_data *krio_priv = (struct keystone_rio_data *)
3714 dev->platform_data;
3715
3716 if (krio_priv == NULL)
3717 return -EINVAL;
3718
3719 return scnprintf(buf, PAGE_SIZE, "%d\n", krio_priv->calibrating);
3720}
3721
3457static DEVICE_ATTR(ports, 3722static DEVICE_ATTR(ports,
3458 S_IRUGO | S_IWUSR, 3723 S_IRUGO | S_IWUSR,
3459 keystone_rio_ports_show, 3724 keystone_rio_ports_show,
3460 keystone_rio_ports_store); 3725 keystone_rio_ports_store);
3461 3726
3727static DEVICE_ATTR(start,
3728 S_IRUGO | S_IWUSR,
3729 keystone_rio_start_show,
3730 keystone_rio_start_store);
3731
3732static DEVICE_ATTR(calibrate,
3733 S_IRUGO | S_IWUSR,
3734 keystone_rio_calibrate_show,
3735 keystone_rio_calibrate_store);
3736
3462static void keystone_rio_sysfs_remove(struct device *dev) 3737static void keystone_rio_sysfs_remove(struct device *dev)
3463{ 3738{
3464 device_remove_file(dev, &dev_attr_ports); 3739 device_remove_file(dev, &dev_attr_ports);
3740 device_remove_file(dev, &dev_attr_start);
3741 device_remove_file(dev, &dev_attr_calibrate);
3465} 3742}
3466 3743
3467static int keystone_rio_sysfs_create(struct device *dev) 3744static int keystone_rio_sysfs_create(struct device *dev)
@@ -3469,8 +3746,20 @@ static int keystone_rio_sysfs_create(struct device *dev)
3469 int res = 0; 3746 int res = 0;
3470 3747
3471 res = device_create_file(dev, &dev_attr_ports); 3748 res = device_create_file(dev, &dev_attr_ports);
3472 if (res) 3749 if (res) {
3473 dev_err(dev, "unable create sysfs ports file\n"); 3750 dev_err(dev, "unable create sysfs ports file\n");
3751 return res;
3752 }
3753
3754 res = device_create_file(dev, &dev_attr_start);
3755 if (res) {
3756 dev_err(dev, "unable create sysfs start file\n");
3757 return res;
3758 }
3759
3760 res = device_create_file(dev, &dev_attr_calibrate);
3761 if (res)
3762 dev_err(dev, "unable create sysfs calibrate file\n");
3474 3763
3475 return res; 3764 return res;
3476} 3765}
@@ -3486,7 +3775,6 @@ static int keystone_rio_setup_controller(struct keystone_rio_data *krio_priv)
3486 u32 path_mode; 3775 u32 path_mode;
3487 u32 size = 0; 3776 u32 size = 0;
3488 int res = 0; 3777 int res = 0;
3489 struct rio_mport *mport;
3490 char str[8]; 3778 char str[8];
3491 unsigned long flags; 3779 unsigned long flags;
3492 3780
@@ -3495,6 +3783,8 @@ static int keystone_rio_setup_controller(struct keystone_rio_data *krio_priv)
3495 baud = krio_priv->board_rio_cfg.serdes_baudrate; 3783 baud = krio_priv->board_rio_cfg.serdes_baudrate;
3496 path_mode = krio_priv->board_rio_cfg.path_mode; 3784 path_mode = krio_priv->board_rio_cfg.path_mode;
3497 3785
3786 krio_priv->started = 1;
3787
3498 dev_dbg(krio_priv->dev, "size = %d, ports = 0x%x, baud = %d, path_mode = %d\n", 3788 dev_dbg(krio_priv->dev, "size = %d, ports = 0x%x, baud = %d, path_mode = %d\n",
3499 size, ports, baud, path_mode); 3789 size, ports, baud, path_mode);
3500 3790
@@ -3518,8 +3808,7 @@ static int keystone_rio_setup_controller(struct keystone_rio_data *krio_priv)
3518 snprintf(str, sizeof(str), "5.00"); 3808 snprintf(str, sizeof(str), "5.00");
3519 break; 3809 break;
3520 default: 3810 default:
3521 res = -EINVAL; 3811 return -EINVAL;
3522 goto out;
3523 } 3812 }
3524 3813
3525 dev_info(krio_priv->dev, 3814 dev_info(krio_priv->dev,
@@ -3543,6 +3832,9 @@ static int keystone_rio_setup_controller(struct keystone_rio_data *krio_priv)
3543 for (p = 0; p < KEYSTONE_RIO_MAX_PORT; p++) 3832 for (p = 0; p < KEYSTONE_RIO_MAX_PORT; p++)
3544 keystone_rio_port_disable(p, krio_priv); 3833 keystone_rio_port_disable(p, krio_priv);
3545 3834
3835 /* Register all configured ports */
3836 krio_priv->ports_registering = krio_priv->board_rio_cfg.ports;
3837
3546 /* Initialize interrupts */ 3838 /* Initialize interrupts */
3547 res = keystone_rio_interrupt_setup(krio_priv); 3839 res = keystone_rio_interrupt_setup(krio_priv);
3548 if (res) 3840 if (res)
@@ -3551,15 +3843,9 @@ static int keystone_rio_setup_controller(struct keystone_rio_data *krio_priv)
3551 /* Start the controller */ 3843 /* Start the controller */
3552 keystone_rio_start(krio_priv); 3844 keystone_rio_start(krio_priv);
3553 3845
3554 /* Use and check ports status (but only the requested ones) */
3555 spin_lock_irqsave(&krio_priv->port_chk_lock, flags);
3556 krio_priv->ports_registering = 0;
3557 spin_unlock_irqrestore(&krio_priv->port_chk_lock, flags);
3558
3559 while (ports) { 3846 while (ports) {
3560 int status;
3561 u32 port = __ffs(ports); 3847 u32 port = __ffs(ports);
3562 ports &= ~(1 << port); 3848 ports &= ~BIT(port);
3563 3849
3564 res = keystone_rio_port_init(port, path_mode, krio_priv); 3850 res = keystone_rio_port_init(port, path_mode, krio_priv);
3565 if (res < 0) { 3851 if (res < 0) {
@@ -3569,56 +3855,16 @@ static int keystone_rio_setup_controller(struct keystone_rio_data *krio_priv)
3569 } 3855 }
3570 3856
3571 /* Start the port */ 3857 /* Start the port */
3572 keystone_rio_port_activate(port, krio_priv); 3858 keystone_rio_port_enable(port, krio_priv);
3573
3574 /* Start lanes and wait them to be OK */
3575 if (keystone_rio_lanes_init_and_wait(port, 1, krio_priv))
3576 goto port_not_ready;
3577
3578 /*
3579 * Check the port status here before calling the generic RapidIO
3580 * layer. Port status check is done in rio_mport_is_active() as
3581 * well but we need to do it our way first due to some delays in
3582 * hw initialization.
3583 */
3584 status = keystone_rio_port_status(port, krio_priv);
3585 if (status == 0) {
3586 /* Register this port */
3587 mport = keystone_rio_register_mport(port, size, krio_priv);
3588 if (!mport)
3589 goto out;
3590
3591 /*
3592 * Update routing after discovery/enumeration
3593 * with new dev id
3594 */
3595 if (krio_priv->board_rio_cfg.pkt_forwarding)
3596 keystone_rio_port_set_routing(port, krio_priv);
3597
3598 spin_lock_irqsave(&krio_priv->port_chk_lock, flags);
3599 krio_priv->ports |= (1 << port);
3600 spin_unlock_irqrestore(&krio_priv->port_chk_lock,
3601 flags);
3602
3603 dev_info(krio_priv->dev,
3604 "port RIO%d host_deviceid %d registered\n",
3605 port, mport->host_deviceid);
3606
3607 continue;
3608 }
3609 if (status == -EINVAL)
3610 return status;
3611port_not_ready:
3612 spin_lock_irqsave(&krio_priv->port_chk_lock, flags);
3613 krio_priv->ports_registering |= (1 << port);
3614 spin_unlock_irqrestore(&krio_priv->port_chk_lock, flags);
3615
3616 dev_warn(krio_priv->dev, "port %d not ready\n", port);
3617 } 3859 }
3618 3860
3619 if (krio_priv->ports_registering) { 3861 /* Complete port initialization and wait link */
3620 unsigned long flags; 3862 res = keystone_rio_port_chk(krio_priv, 1);
3863 if (res) {
3864 if (res == -1)
3865 return -ENOMEM;
3621 3866
3867 /* If port check failed schedule asynchronous periodic check */
3622 spin_lock_irqsave(&krio_priv->port_chk_lock, flags); 3868 spin_lock_irqsave(&krio_priv->port_chk_lock, flags);
3623 krio_priv->port_chk_cnt = 3869 krio_priv->port_chk_cnt =
3624 krio_priv->board_rio_cfg.port_register_timeout / 3870 krio_priv->board_rio_cfg.port_register_timeout /
@@ -3628,7 +3874,7 @@ port_not_ready:
3628 schedule_delayed_work(&krio_priv->port_chk_task, 3874 schedule_delayed_work(&krio_priv->port_chk_task,
3629 KEYSTONE_RIO_REGISTER_DELAY); 3875 KEYSTONE_RIO_REGISTER_DELAY);
3630 } 3876 }
3631out: 3877
3632 return res; 3878 return res;
3633} 3879}
3634 3880
@@ -3663,8 +3909,10 @@ static int keystone_rio_probe(struct platform_device *pdev)
3663 mutex_init(&krio_priv->lsu_lock); 3909 mutex_init(&krio_priv->lsu_lock);
3664 init_completion(&krio_priv->lsu_completion); 3910 init_completion(&krio_priv->lsu_completion);
3665 spin_lock_init(&krio_priv->port_chk_lock); 3911 spin_lock_init(&krio_priv->port_chk_lock);
3912
3666 INIT_DELAYED_WORK(&krio_priv->port_chk_task, 3913 INIT_DELAYED_WORK(&krio_priv->port_chk_task,
3667 keystone_rio_port_chk_task); 3914 keystone_rio_port_chk_task);
3915 INIT_DELAYED_WORK(&krio_priv->pe_work, keystone_rio_pe_dpc);
3668 3916
3669 regs = ioremap(krio_priv->board_rio_cfg.boot_cfg_regs_base, 3917 regs = ioremap(krio_priv->board_rio_cfg.boot_cfg_regs_base,
3670 krio_priv->board_rio_cfg.boot_cfg_regs_size); 3918 krio_priv->board_rio_cfg.boot_cfg_regs_size);
@@ -3693,11 +3941,15 @@ static int keystone_rio_probe(struct platform_device *pdev)
3693 krio_priv->fabric_regs = regs + 0x1be00; 3941 krio_priv->fabric_regs = regs + 0x1be00;
3694 krio_priv->car_csr_regs_base = (u32) regs + 0xb000; 3942 krio_priv->car_csr_regs_base = (u32) regs + 0xb000;
3695 3943
3696 INIT_DELAYED_WORK(&krio_priv->pe_work, keystone_rio_pe_dpc); 3944 /* Register SerDes */
3945 res = keystone_rio_serdes_register(
3946 serdes_type,
3947 krio_priv->serdes_regs,
3948 krio_priv->serdes_sts_reg,
3949 &pdev->dev,
3950 &krio_priv->serdes,
3951 &krio_priv->board_rio_cfg.serdes_config);
3697 3952
3698 /* Retrieve SerDes ops */
3699 res = keystone_rio_serdes_register(serdes_type,
3700 &krio_priv->serdes_ops);
3701 if (res < 0) { 3953 if (res < 0) {
3702 dev_err(&pdev->dev, "cannot register SerDes type %d\n", 3954 dev_err(&pdev->dev, "cannot register SerDes type %d\n",
3703 serdes_type); 3955 serdes_type);
@@ -3728,59 +3980,82 @@ static int keystone_rio_probe(struct platform_device *pdev)
3728 dev_info(&pdev->dev, "KeyStone RapidIO driver %s\n", DRIVER_VER); 3980 dev_info(&pdev->dev, "KeyStone RapidIO driver %s\n", DRIVER_VER);
3729 3981
3730 /* Setup the sRIO controller */ 3982 /* Setup the sRIO controller */
3731 res = keystone_rio_setup_controller(krio_priv); 3983 if (enable_ports) {
3732 if (res < 0) { 3984 res = keystone_rio_setup_controller(krio_priv);
3733 clk_disable_unprepare(krio_priv->clk); 3985 if (res < 0) {
3734 clk_put(krio_priv->clk); 3986 clk_disable_unprepare(krio_priv->clk);
3735 kfree(krio_priv); 3987 clk_put(krio_priv->clk);
3736 return res; 3988 kfree(krio_priv);
3989 return res;
3990 }
3737 } 3991 }
3738 3992
3739 return 0; 3993 return 0;
3740} 3994}
3741 3995
3742static void keystone_rio_shutdown(struct platform_device *pdev) 3996static void keystone_rio_shutdown_controller(
3997 struct keystone_rio_data *krio_priv)
3743{ 3998{
3744 struct keystone_rio_data *krio_priv = platform_get_drvdata(pdev); 3999 u32 lanes = keystone_rio_get_lane_config(
4000 krio_priv->board_rio_cfg.ports,
4001 krio_priv->board_rio_cfg.path_mode);
3745 int i; 4002 int i;
3746 u32 lanes = keystone_rio_get_lane_config(krio_priv->board_rio_cfg.ports, 4003
3747 krio_priv->board_rio_cfg.path_mode); 4004 dev_dbg(krio_priv->dev, "shutdown controller\n");
3748 4005
3749 keystone_rio_interrupt_release(krio_priv); 4006 keystone_rio_interrupt_release(krio_priv);
3750 keystone_rio_mp_outb_exit(krio_priv);
3751 4007
3752 for (i = 0; i < KEYSTONE_RIO_MAX_MBOX; i++) 4008 /* Shutdown associated SerDes */
3753 keystone_rio_mp_inb_exit(i, krio_priv); 4009 krio_priv->serdes.ops->shutdown_lanes(lanes, &krio_priv->serdes);
3754 4010
4011 /* Stop the hw controller */
3755 keystone_rio_stop(krio_priv); 4012 keystone_rio_stop(krio_priv);
3756 4013
3757 /* Wait current DMA transfers to finish */
3758 mdelay(10);
3759
3760 /* Disable blocks */ 4014 /* Disable blocks */
3761 __raw_writel(0, &krio_priv->regs->gbl_en); 4015 __raw_writel(0, &krio_priv->regs->gbl_en);
3762 for (i = 0; i <= KEYSTONE_RIO_BLK_NUM; i++) 4016 for (i = 0; i < KEYSTONE_RIO_BLK_NUM; i++) {
3763 __raw_writel(0, &(krio_priv->regs->blk[i].enable)); 4017 __raw_writel(0, &(krio_priv->regs->blk[i].enable));
4018 while (__raw_readl(&(krio_priv->regs->blk[i].status)) & 0x1)
4019 usleep_range(10, 50);
4020 }
3764 4021
3765 /* Shutdown associated SerDes */ 4022 krio_priv->started = 0;
3766 krio_priv->serdes_ops->shutdown_lanes(lanes, krio_priv->serdes_regs); 4023}
4024
4025static void keystone_rio_shutdown(struct platform_device *pdev)
4026{
4027 struct keystone_rio_data *krio_priv = platform_get_drvdata(pdev);
4028 int i;
4029
4030 if (krio_priv->started)
4031 keystone_rio_shutdown_controller(krio_priv);
4032
4033 for (i = 0; i < KEYSTONE_RIO_MAX_MBOX; i++) {
4034 keystone_rio_close_tx_mbox(i, krio_priv);
4035 keystone_rio_close_rx_mbox(i, krio_priv);
4036 }
4037
4038 /* Wait current DMA transfers to finish */
4039 mdelay(10);
3767 4040
3768 if (krio_priv->clk) { 4041 if (krio_priv->clk) {
3769 clk_disable_unprepare(krio_priv->clk); 4042 clk_disable_unprepare(krio_priv->clk);
3770 clk_put(krio_priv->clk); 4043 clk_put(krio_priv->clk);
3771 } 4044 }
3772
3773 platform_set_drvdata(pdev, NULL);
3774
3775 kfree(krio_priv);
3776} 4045}
3777 4046
3778static int __exit keystone_rio_remove(struct platform_device *pdev) 4047static int __exit keystone_rio_remove(struct platform_device *pdev)
3779{ 4048{
4049 struct keystone_rio_data *krio_priv = platform_get_drvdata(pdev);
4050
3780 keystone_rio_shutdown(pdev); 4051 keystone_rio_shutdown(pdev);
3781 4052
3782 keystone_rio_sysfs_remove(&pdev->dev); 4053 keystone_rio_sysfs_remove(&pdev->dev);
3783 4054
4055 platform_set_drvdata(pdev, NULL);
4056
4057 kfree(krio_priv);
4058
3784 return 0; 4059 return 0;
3785} 4060}
3786 4061
diff --git a/drivers/rapidio/devices/keystone_rio.h b/drivers/rapidio/devices/keystone_rio.h
index 074f5a9ff97..93bc6173051 100644
--- a/drivers/rapidio/devices/keystone_rio.h
+++ b/drivers/rapidio/devices/keystone_rio.h
@@ -145,7 +145,6 @@
145 * RapidIO global definitions 145 * RapidIO global definitions
146 */ 146 */
147#define KEYSTONE_RIO_MAX_PORT 4 147#define KEYSTONE_RIO_MAX_PORT 4
148#define KEYSTONE_RIO_BLK_NUM 9
149#define KEYSTONE_RIO_MAX_MBOX 4 /* 4 in multi-segment, 148#define KEYSTONE_RIO_MAX_MBOX 4 /* 4 in multi-segment,
150 64 in single-seg */ 149 64 in single-seg */
151#define KEYSTONE_RIO_MAX_PKT_FW_ENTRIES 8 /* max of packet forwarding 150#define KEYSTONE_RIO_MAX_PKT_FW_ENTRIES 8 /* max of packet forwarding
@@ -157,6 +156,21 @@
157#define KEYSTONE_RIO_PKT_FW_BRR_NUM 1 /* BRR used for packet forwarding */ 156#define KEYSTONE_RIO_PKT_FW_BRR_NUM 1 /* BRR used for packet forwarding */
158 157
159/* 158/*
159 * Block definition
160 */
161#define KEYSTONE_RIO_BLK_NUM 9
162
163#define KEYSTONE_RIO_BLK_MMR 0
164#define KEYSTONE_RIO_BLK_LSU 1
165#define KEYSTONE_RIO_BLK_MAU 2
166#define KEYSTONE_RIO_BLK_TXU 3
167#define KEYSTONE_RIO_BLK_RXU 4
168#define KEYSTONE_RIO_BLK_PORT0 5
169#define KEYSTONE_RIO_BLK_PORT1 6
170#define KEYSTONE_RIO_BLK_PORT2 7
171#define KEYSTONE_RIO_BLK_PORT3 8
172
173/*
160 * Dev Id and dev revision 174 * Dev Id and dev revision
161 */ 175 */
162#define KEYSTONE_RIO_DEV_ID_VAL \ 176#define KEYSTONE_RIO_DEV_ID_VAL \
@@ -234,6 +248,7 @@ struct keystone_rio_board_controller_info {
234 * 1 - Large size, 65536 devices. */ 248 * 1 - Large size, 65536 devices. */
235 u16 serdes_type; 249 u16 serdes_type;
236 u32 serdes_baudrate; 250 u32 serdes_baudrate;
251 u32 serdes_calibration;
237 u32 path_mode; 252 u32 path_mode;
238 u32 port_register_timeout; 253 u32 port_register_timeout;
239 u32 pkt_forwarding; 254 u32 pkt_forwarding;