1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for the Microchip PD692X0 PoE PSE Controller driver (I2C bus) 4 * 5 * Copyright (c) 2023 Bootlin, Kory Maincent <kory.maincent@bootlin.com> 6 */ 7 8 #include <linux/delay.h> 9 #include <linux/firmware.h> 10 #include <linux/i2c.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/platform_device.h> 14 #include <linux/pse-pd/pse.h> 15 #include <linux/regulator/driver.h> 16 #include <linux/regulator/machine.h> 17 18 #define PD692X0_PSE_NAME "pd692x0_pse" 19 20 #define PD692X0_MAX_PIS 48 21 #define PD692X0_MAX_MANAGERS 12 22 #define PD692X0_MAX_MANAGER_PORTS 8 23 #define PD692X0_MAX_HW_PORTS (PD692X0_MAX_MANAGERS * PD692X0_MAX_MANAGER_PORTS) 24 25 #define PD69200_BT_PROD_VER 24 26 #define PD69210_BT_PROD_VER 26 27 #define PD69220_BT_PROD_VER 29 28 29 #define PD692X0_FW_MAJ_VER 3 30 #define PD692X0_FW_MIN_VER 5 31 #define PD692X0_FW_PATCH_VER 5 32 33 enum pd692x0_fw_state { 34 PD692X0_FW_UNKNOWN, 35 PD692X0_FW_OK, 36 PD692X0_FW_BROKEN, 37 PD692X0_FW_NEED_UPDATE, 38 PD692X0_FW_PREPARE, 39 PD692X0_FW_WRITE, 40 PD692X0_FW_COMPLETE, 41 }; 42 43 struct pd692x0_msg { 44 u8 key; 45 u8 echo; 46 u8 sub[3]; 47 u8 data[8]; 48 __be16 chksum; 49 } __packed; 50 51 struct pd692x0_msg_ver { 52 u8 prod; 53 u8 maj_sw_ver; 54 u8 min_sw_ver; 55 u8 pa_sw_ver; 56 u8 param; 57 u8 build; 58 }; 59 60 enum { 61 PD692X0_KEY_CMD, 62 PD692X0_KEY_PRG, 63 PD692X0_KEY_REQ, 64 PD692X0_KEY_TLM, 65 PD692X0_KEY_TEST, 66 PD692X0_KEY_REPORT = 0x52 67 }; 68 69 enum { 70 PD692X0_MSG_RESET, 71 PD692X0_MSG_GET_SYS_STATUS, 72 PD692X0_MSG_GET_SW_VER, 73 PD692X0_MSG_SET_TMP_PORT_MATRIX, 74 PD692X0_MSG_PRG_PORT_MATRIX, 75 PD692X0_MSG_SET_PORT_PARAM, 76 PD692X0_MSG_GET_PORT_STATUS, 77 PD692X0_MSG_DOWNLOAD_CMD, 78 PD692X0_MSG_GET_PORT_CLASS, 79 PD692X0_MSG_GET_PORT_MEAS, 80 PD692X0_MSG_GET_PORT_PARAM, 81 PD692X0_MSG_GET_POWER_BANK, 82 PD692X0_MSG_SET_POWER_BANK, 83 84 /* add new message above here */ 85 PD692X0_MSG_CNT 86 }; 87 88 struct pd692x0_priv { 89 struct i2c_client *client; 90 struct pse_controller_dev pcdev; 91 struct device_node *np; 92 93 enum pd692x0_fw_state fw_state; 94 struct fw_upload *fwl; 95 bool cancel_request; 96 97 u8 msg_id; 98 bool last_cmd_key; 99 unsigned long last_cmd_key_time; 100 101 enum ethtool_c33_pse_admin_state admin_state[PD692X0_MAX_PIS]; 102 struct regulator_dev *manager_reg[PD692X0_MAX_MANAGERS]; 103 int manager_pw_budget[PD692X0_MAX_MANAGERS]; 104 }; 105 106 /* Template list of communication messages. The non-null bytes defined here 107 * constitute the fixed portion of the messages. The remaining bytes will 108 * be configured later within the functions. Refer to the "PD692x0 BT Serial 109 * Communication Protocol User Guide" for comprehensive details on messages 110 * content. 111 */ 112 static const struct pd692x0_msg pd692x0_msg_template_list[PD692X0_MSG_CNT] = { 113 [PD692X0_MSG_RESET] = { 114 .key = PD692X0_KEY_CMD, 115 .sub = {0x07, 0x55, 0x00}, 116 .data = {0x55, 0x00, 0x55, 0x4e, 117 0x4e, 0x4e, 0x4e, 0x4e}, 118 }, 119 [PD692X0_MSG_GET_SYS_STATUS] = { 120 .key = PD692X0_KEY_REQ, 121 .sub = {0x07, 0xd0, 0x4e}, 122 .data = {0x4e, 0x4e, 0x4e, 0x4e, 123 0x4e, 0x4e, 0x4e, 0x4e}, 124 }, 125 [PD692X0_MSG_GET_SW_VER] = { 126 .key = PD692X0_KEY_REQ, 127 .sub = {0x07, 0x1e, 0x21}, 128 .data = {0x4e, 0x4e, 0x4e, 0x4e, 129 0x4e, 0x4e, 0x4e, 0x4e}, 130 }, 131 [PD692X0_MSG_SET_TMP_PORT_MATRIX] = { 132 .key = PD692X0_KEY_CMD, 133 .sub = {0x05, 0x43}, 134 .data = { 0, 0x4e, 0x4e, 0x4e, 135 0x4e, 0x4e, 0x4e, 0x4e}, 136 }, 137 [PD692X0_MSG_PRG_PORT_MATRIX] = { 138 .key = PD692X0_KEY_CMD, 139 .sub = {0x07, 0x43, 0x4e}, 140 .data = {0x4e, 0x4e, 0x4e, 0x4e, 141 0x4e, 0x4e, 0x4e, 0x4e}, 142 }, 143 [PD692X0_MSG_SET_PORT_PARAM] = { 144 .key = PD692X0_KEY_CMD, 145 .sub = {0x05, 0xc0}, 146 .data = { 0xf, 0xff, 0xff, 0xff, 147 0x4e, 0x4e, 0x4e, 0x4e}, 148 }, 149 [PD692X0_MSG_GET_PORT_STATUS] = { 150 .key = PD692X0_KEY_REQ, 151 .sub = {0x05, 0xc1}, 152 .data = {0x4e, 0x4e, 0x4e, 0x4e, 153 0x4e, 0x4e, 0x4e, 0x4e}, 154 }, 155 [PD692X0_MSG_DOWNLOAD_CMD] = { 156 .key = PD692X0_KEY_PRG, 157 .sub = {0xff, 0x99, 0x15}, 158 .data = {0x16, 0x16, 0x99, 0x4e, 159 0x4e, 0x4e, 0x4e, 0x4e}, 160 }, 161 [PD692X0_MSG_GET_PORT_CLASS] = { 162 .key = PD692X0_KEY_REQ, 163 .sub = {0x05, 0xc4}, 164 .data = {0x4e, 0x4e, 0x4e, 0x4e, 165 0x4e, 0x4e, 0x4e, 0x4e}, 166 }, 167 [PD692X0_MSG_GET_PORT_MEAS] = { 168 .key = PD692X0_KEY_REQ, 169 .sub = {0x05, 0xc5}, 170 .data = {0x4e, 0x4e, 0x4e, 0x4e, 171 0x4e, 0x4e, 0x4e, 0x4e}, 172 }, 173 [PD692X0_MSG_GET_PORT_PARAM] = { 174 .key = PD692X0_KEY_REQ, 175 .sub = {0x05, 0xc0}, 176 .data = {0x4e, 0x4e, 0x4e, 0x4e, 177 0x4e, 0x4e, 0x4e, 0x4e}, 178 }, 179 [PD692X0_MSG_GET_POWER_BANK] = { 180 .key = PD692X0_KEY_REQ, 181 .sub = {0x07, 0x0b, 0x57}, 182 .data = { 0, 0x4e, 0x4e, 0x4e, 183 0x4e, 0x4e, 0x4e, 0x4e}, 184 }, 185 [PD692X0_MSG_SET_POWER_BANK] = { 186 .key = PD692X0_KEY_CMD, 187 .sub = {0x07, 0x0b, 0x57}, 188 }, 189 }; 190 191 static u8 pd692x0_build_msg(struct pd692x0_msg *msg, u8 echo) 192 { 193 u8 *data = (u8 *)msg; 194 u16 chksum = 0; 195 int i; 196 197 msg->echo = echo++; 198 if (echo == 0xff) 199 echo = 0; 200 201 for (i = 0; i < sizeof(*msg) - sizeof(msg->chksum); i++) 202 chksum += data[i]; 203 204 msg->chksum = cpu_to_be16(chksum); 205 206 return echo; 207 } 208 209 static int pd692x0_send_msg(struct pd692x0_priv *priv, struct pd692x0_msg *msg) 210 { 211 const struct i2c_client *client = priv->client; 212 int ret; 213 214 if (msg->key == PD692X0_KEY_CMD && priv->last_cmd_key) { 215 int cmd_msleep; 216 217 cmd_msleep = 30 - jiffies_to_msecs(jiffies - priv->last_cmd_key_time); 218 if (cmd_msleep > 0) 219 msleep(cmd_msleep); 220 } 221 222 /* Add echo and checksum bytes to the message */ 223 priv->msg_id = pd692x0_build_msg(msg, priv->msg_id); 224 225 ret = i2c_master_send(client, (u8 *)msg, sizeof(*msg)); 226 if (ret != sizeof(*msg)) 227 return -EIO; 228 229 return 0; 230 } 231 232 static int pd692x0_reset(struct pd692x0_priv *priv) 233 { 234 const struct i2c_client *client = priv->client; 235 struct pd692x0_msg msg, buf = {0}; 236 int ret; 237 238 msg = pd692x0_msg_template_list[PD692X0_MSG_RESET]; 239 ret = pd692x0_send_msg(priv, &msg); 240 if (ret) { 241 dev_err(&client->dev, 242 "Failed to reset the controller (%pe)\n", ERR_PTR(ret)); 243 return ret; 244 } 245 246 msleep(30); 247 248 ret = i2c_master_recv(client, (u8 *)&buf, sizeof(buf)); 249 if (ret != sizeof(buf)) 250 return ret < 0 ? ret : -EIO; 251 252 /* Is the reply a successful report message */ 253 if (buf.key != PD692X0_KEY_REPORT || buf.sub[0] || buf.sub[1]) 254 return -EIO; 255 256 msleep(300); 257 258 ret = i2c_master_recv(client, (u8 *)&buf, sizeof(buf)); 259 if (ret != sizeof(buf)) 260 return ret < 0 ? ret : -EIO; 261 262 /* Is the boot status without error */ 263 if (buf.key != 0x03 || buf.echo != 0xff || buf.sub[0] & 0x1) { 264 dev_err(&client->dev, "PSE controller error\n"); 265 return -EIO; 266 } 267 268 return 0; 269 } 270 271 static bool pd692x0_try_recv_msg(const struct i2c_client *client, 272 struct pd692x0_msg *msg, 273 struct pd692x0_msg *buf) 274 { 275 /* Wait 30ms before readback as mandated by the protocol */ 276 msleep(30); 277 278 memset(buf, 0, sizeof(*buf)); 279 i2c_master_recv(client, (u8 *)buf, sizeof(*buf)); 280 if (buf->key) 281 return 0; 282 283 msleep(100); 284 285 memset(buf, 0, sizeof(*buf)); 286 i2c_master_recv(client, (u8 *)buf, sizeof(*buf)); 287 if (buf->key) 288 return 0; 289 290 return 1; 291 } 292 293 /* Implementation of I2C communication, specifically addressing scenarios 294 * involving communication loss. Refer to the "Synchronization During 295 * Communication Loss" section in the Communication Protocol document for 296 * further details. 297 */ 298 static int pd692x0_recv_msg(struct pd692x0_priv *priv, 299 struct pd692x0_msg *msg, 300 struct pd692x0_msg *buf) 301 { 302 const struct i2c_client *client = priv->client; 303 int ret; 304 305 ret = pd692x0_try_recv_msg(client, msg, buf); 306 if (!ret) 307 goto out_success; 308 309 dev_warn(&client->dev, 310 "Communication lost, rtnl is locked until communication is back!"); 311 312 ret = pd692x0_send_msg(priv, msg); 313 if (ret) 314 return ret; 315 316 ret = pd692x0_try_recv_msg(client, msg, buf); 317 if (!ret) 318 goto out_success2; 319 320 msleep(10000); 321 322 ret = pd692x0_send_msg(priv, msg); 323 if (ret) 324 return ret; 325 326 ret = pd692x0_try_recv_msg(client, msg, buf); 327 if (!ret) 328 goto out_success2; 329 330 return pd692x0_reset(priv); 331 332 out_success2: 333 dev_warn(&client->dev, "Communication is back, rtnl is unlocked!"); 334 out_success: 335 if (msg->key == PD692X0_KEY_CMD) { 336 priv->last_cmd_key = true; 337 priv->last_cmd_key_time = jiffies; 338 } else { 339 priv->last_cmd_key = false; 340 } 341 342 return 0; 343 } 344 345 static int pd692x0_sendrecv_msg(struct pd692x0_priv *priv, 346 struct pd692x0_msg *msg, 347 struct pd692x0_msg *buf) 348 { 349 struct device *dev = &priv->client->dev; 350 int ret; 351 352 ret = pd692x0_send_msg(priv, msg); 353 if (ret) 354 return ret; 355 356 ret = pd692x0_recv_msg(priv, msg, buf); 357 if (ret) 358 return ret; 359 360 if (msg->echo != buf->echo) { 361 dev_err(dev, 362 "Wrong match in message ID, expect %d received %d.\n", 363 msg->echo, buf->echo); 364 return -EIO; 365 } 366 367 /* If the reply is a report message is it successful */ 368 if (buf->key == PD692X0_KEY_REPORT && 369 (buf->sub[0] || buf->sub[1])) { 370 return -EIO; 371 } 372 373 return 0; 374 } 375 376 static struct pd692x0_priv *to_pd692x0_priv(struct pse_controller_dev *pcdev) 377 { 378 return container_of(pcdev, struct pd692x0_priv, pcdev); 379 } 380 381 static int pd692x0_fw_unavailable(struct pd692x0_priv *priv) 382 { 383 switch (priv->fw_state) { 384 case PD692X0_FW_OK: 385 return 0; 386 case PD692X0_FW_PREPARE: 387 case PD692X0_FW_WRITE: 388 case PD692X0_FW_COMPLETE: 389 dev_err(&priv->client->dev, "Firmware update in progress!\n"); 390 return -EBUSY; 391 case PD692X0_FW_BROKEN: 392 case PD692X0_FW_NEED_UPDATE: 393 default: 394 dev_err(&priv->client->dev, 395 "Firmware issue. Please update it!\n"); 396 return -EOPNOTSUPP; 397 } 398 } 399 400 static int pd692x0_pi_enable(struct pse_controller_dev *pcdev, int id) 401 { 402 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 403 struct pd692x0_msg msg, buf = {0}; 404 int ret; 405 406 ret = pd692x0_fw_unavailable(priv); 407 if (ret) 408 return ret; 409 410 if (priv->admin_state[id] == ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED) 411 return 0; 412 413 msg = pd692x0_msg_template_list[PD692X0_MSG_SET_PORT_PARAM]; 414 msg.data[0] = 0x1; 415 msg.sub[2] = id; 416 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 417 if (ret < 0) 418 return ret; 419 420 priv->admin_state[id] = ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED; 421 422 return 0; 423 } 424 425 static int pd692x0_pi_disable(struct pse_controller_dev *pcdev, int id) 426 { 427 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 428 struct pd692x0_msg msg, buf = {0}; 429 int ret; 430 431 ret = pd692x0_fw_unavailable(priv); 432 if (ret) 433 return ret; 434 435 if (priv->admin_state[id] == ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED) 436 return 0; 437 438 msg = pd692x0_msg_template_list[PD692X0_MSG_SET_PORT_PARAM]; 439 msg.data[0] = 0x0; 440 msg.sub[2] = id; 441 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 442 if (ret < 0) 443 return ret; 444 445 priv->admin_state[id] = ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED; 446 447 return 0; 448 } 449 450 struct pd692x0_pse_ext_state_mapping { 451 u32 status_code; 452 enum ethtool_c33_pse_ext_state pse_ext_state; 453 u32 pse_ext_substate; 454 }; 455 456 static const struct pd692x0_pse_ext_state_mapping 457 pd692x0_pse_ext_state_map[] = { 458 {0x06, ETHTOOL_C33_PSE_EXT_STATE_OPTION_VPORT_LIM, 459 ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_VPORT_LIM_HIGH_VOLTAGE}, 460 {0x07, ETHTOOL_C33_PSE_EXT_STATE_OPTION_VPORT_LIM, 461 ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_VPORT_LIM_LOW_VOLTAGE}, 462 {0x08, ETHTOOL_C33_PSE_EXT_STATE_MR_PSE_ENABLE, 463 ETHTOOL_C33_PSE_EXT_SUBSTATE_MR_PSE_ENABLE_DISABLE_PIN_ACTIVE}, 464 {0x0C, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 465 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_NON_EXISTING_PORT}, 466 {0x11, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 467 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_UNDEFINED_PORT}, 468 {0x12, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 469 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_INTERNAL_HW_FAULT}, 470 {0x1B, ETHTOOL_C33_PSE_EXT_STATE_OPTION_DETECT_TED, 471 ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_DETECT_TED_DET_IN_PROCESS}, 472 {0x1C, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 473 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_UNKNOWN_PORT_STATUS}, 474 {0x1E, ETHTOOL_C33_PSE_EXT_STATE_MR_MPS_VALID, 475 ETHTOOL_C33_PSE_EXT_SUBSTATE_MR_MPS_VALID_DETECTED_UNDERLOAD}, 476 {0x1F, ETHTOOL_C33_PSE_EXT_STATE_OVLD_DETECTED, 477 ETHTOOL_C33_PSE_EXT_SUBSTATE_OVLD_DETECTED_OVERLOAD}, 478 {0x20, ETHTOOL_C33_PSE_EXT_STATE_POWER_NOT_AVAILABLE, 479 ETHTOOL_C33_PSE_EXT_SUBSTATE_POWER_NOT_AVAILABLE_BUDGET_EXCEEDED}, 480 {0x21, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 481 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_INTERNAL_HW_FAULT}, 482 {0x22, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 483 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_CONFIG_CHANGE}, 484 {0x24, ETHTOOL_C33_PSE_EXT_STATE_OPTION_VPORT_LIM, 485 ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_VPORT_LIM_VOLTAGE_INJECTION}, 486 {0x25, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 487 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_UNKNOWN_PORT_STATUS}, 488 {0x34, ETHTOOL_C33_PSE_EXT_STATE_SHORT_DETECTED, 489 ETHTOOL_C33_PSE_EXT_SUBSTATE_SHORT_DETECTED_SHORT_CONDITION}, 490 {0x35, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 491 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_DETECTED_OVER_TEMP}, 492 {0x36, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 493 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_DETECTED_OVER_TEMP}, 494 {0x37, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 495 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_UNKNOWN_PORT_STATUS}, 496 {0x3C, ETHTOOL_C33_PSE_EXT_STATE_POWER_NOT_AVAILABLE, 497 ETHTOOL_C33_PSE_EXT_SUBSTATE_POWER_NOT_AVAILABLE_PORT_PW_LIMIT_EXCEEDS_CONTROLLER_BUDGET}, 498 {0x3D, ETHTOOL_C33_PSE_EXT_STATE_POWER_NOT_AVAILABLE, 499 ETHTOOL_C33_PSE_EXT_SUBSTATE_POWER_NOT_AVAILABLE_PD_REQUEST_EXCEEDS_PORT_LIMIT}, 500 {0x41, ETHTOOL_C33_PSE_EXT_STATE_POWER_NOT_AVAILABLE, 501 ETHTOOL_C33_PSE_EXT_SUBSTATE_POWER_NOT_AVAILABLE_HW_PW_LIMIT}, 502 {0x43, ETHTOOL_C33_PSE_EXT_STATE_ERROR_CONDITION, 503 ETHTOOL_C33_PSE_EXT_SUBSTATE_ERROR_CONDITION_UNKNOWN_PORT_STATUS}, 504 {0xA7, ETHTOOL_C33_PSE_EXT_STATE_OPTION_DETECT_TED, 505 ETHTOOL_C33_PSE_EXT_SUBSTATE_OPTION_DETECT_TED_CONNECTION_CHECK_ERROR}, 506 {0xA8, ETHTOOL_C33_PSE_EXT_STATE_MR_MPS_VALID, 507 ETHTOOL_C33_PSE_EXT_SUBSTATE_MR_MPS_VALID_CONNECTION_OPEN}, 508 { /* sentinel */ } 509 }; 510 511 static int 512 pd692x0_pi_get_ext_state(struct pse_controller_dev *pcdev, int id, 513 struct pse_ext_state_info *ext_state_info) 514 { 515 struct ethtool_c33_pse_ext_state_info *c33_ext_state_info; 516 const struct pd692x0_pse_ext_state_mapping *ext_state_map; 517 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 518 struct pd692x0_msg msg, buf = {0}; 519 int ret; 520 521 ret = pd692x0_fw_unavailable(priv); 522 if (ret) 523 return ret; 524 525 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_STATUS]; 526 msg.sub[2] = id; 527 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 528 if (ret < 0) 529 return ret; 530 531 c33_ext_state_info = &ext_state_info->c33_ext_state_info; 532 ext_state_map = pd692x0_pse_ext_state_map; 533 while (ext_state_map->status_code) { 534 if (ext_state_map->status_code == buf.sub[0]) { 535 c33_ext_state_info->c33_pse_ext_state = ext_state_map->pse_ext_state; 536 c33_ext_state_info->__c33_pse_ext_substate = ext_state_map->pse_ext_substate; 537 return 0; 538 } 539 ext_state_map++; 540 } 541 542 return 0; 543 } 544 545 struct pd692x0_class_pw { 546 int class; 547 int class_cfg_value; 548 int class_pw; 549 int max_added_class_pw; 550 }; 551 552 #define PD692X0_CLASS_PW_TABLE_SIZE 4 553 /* 4/2 pairs class configuration power table in compliance mode. 554 * Need to be arranged in ascending order of power support. 555 */ 556 static const struct pd692x0_class_pw 557 pd692x0_class_pw_table[PD692X0_CLASS_PW_TABLE_SIZE] = { 558 {.class = 3, .class_cfg_value = 0x3, .class_pw = 15000, .max_added_class_pw = 3100}, 559 {.class = 4, .class_cfg_value = 0x2, .class_pw = 30000, .max_added_class_pw = 8000}, 560 {.class = 6, .class_cfg_value = 0x1, .class_pw = 60000, .max_added_class_pw = 5000}, 561 {.class = 8, .class_cfg_value = 0x0, .class_pw = 90000, .max_added_class_pw = 7500}, 562 }; 563 564 static int pd692x0_pi_get_pw_from_table(int op_mode, int added_pw) 565 { 566 const struct pd692x0_class_pw *pw_table; 567 int i; 568 569 pw_table = pd692x0_class_pw_table; 570 for (i = 0; i < PD692X0_CLASS_PW_TABLE_SIZE; i++, pw_table++) { 571 if (pw_table->class_cfg_value == op_mode) 572 return pw_table->class_pw + added_pw * 100; 573 } 574 575 return -ERANGE; 576 } 577 578 static int pd692x0_pi_set_pw_from_table(struct device *dev, 579 struct pd692x0_msg *msg, int pw) 580 { 581 const struct pd692x0_class_pw *pw_table; 582 int i; 583 584 pw_table = pd692x0_class_pw_table; 585 if (pw < pw_table->class_pw) { 586 dev_err(dev, 587 "Power limit %dmW not supported. Ranges minimal available: [%d-%d]\n", 588 pw, 589 pw_table->class_pw, 590 pw_table->class_pw + pw_table->max_added_class_pw); 591 return -ERANGE; 592 } 593 594 for (i = 0; i < PD692X0_CLASS_PW_TABLE_SIZE; i++, pw_table++) { 595 if (pw > (pw_table->class_pw + pw_table->max_added_class_pw)) 596 continue; 597 598 if (pw < pw_table->class_pw) { 599 dev_err(dev, 600 "Power limit %dmW not supported. Ranges available: [%d-%d] or [%d-%d]\n", 601 pw, 602 (pw_table - 1)->class_pw, 603 (pw_table - 1)->class_pw + (pw_table - 1)->max_added_class_pw, 604 pw_table->class_pw, 605 pw_table->class_pw + pw_table->max_added_class_pw); 606 return -ERANGE; 607 } 608 609 msg->data[2] = pw_table->class_cfg_value; 610 msg->data[3] = (pw - pw_table->class_pw) / 100; 611 return 0; 612 } 613 614 pw_table--; 615 dev_warn(dev, 616 "Power limit %dmW not supported. Set to highest power limit %dmW\n", 617 pw, pw_table->class_pw + pw_table->max_added_class_pw); 618 msg->data[2] = pw_table->class_cfg_value; 619 msg->data[3] = pw_table->max_added_class_pw / 100; 620 return 0; 621 } 622 623 static int 624 pd692x0_pi_get_pw_limit_ranges(struct pse_controller_dev *pcdev, int id, 625 struct pse_pw_limit_ranges *pw_limit_ranges) 626 { 627 struct ethtool_c33_pse_pw_limit_range *c33_pw_limit_ranges; 628 const struct pd692x0_class_pw *pw_table; 629 int i; 630 631 pw_table = pd692x0_class_pw_table; 632 c33_pw_limit_ranges = kcalloc(PD692X0_CLASS_PW_TABLE_SIZE, 633 sizeof(*c33_pw_limit_ranges), 634 GFP_KERNEL); 635 if (!c33_pw_limit_ranges) 636 return -ENOMEM; 637 638 for (i = 0; i < PD692X0_CLASS_PW_TABLE_SIZE; i++, pw_table++) { 639 c33_pw_limit_ranges[i].min = pw_table->class_pw; 640 c33_pw_limit_ranges[i].max = pw_table->class_pw + 641 pw_table->max_added_class_pw; 642 } 643 644 pw_limit_ranges->c33_pw_limit_ranges = c33_pw_limit_ranges; 645 return i; 646 } 647 648 static int 649 pd692x0_pi_get_admin_state(struct pse_controller_dev *pcdev, int id, 650 struct pse_admin_state *admin_state) 651 { 652 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 653 struct pd692x0_msg msg, buf = {0}; 654 int ret; 655 656 ret = pd692x0_fw_unavailable(priv); 657 if (ret) 658 return ret; 659 660 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_STATUS]; 661 msg.sub[2] = id; 662 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 663 if (ret < 0) 664 return ret; 665 666 if (buf.sub[1]) 667 admin_state->c33_admin_state = 668 ETHTOOL_C33_PSE_ADMIN_STATE_ENABLED; 669 else 670 admin_state->c33_admin_state = 671 ETHTOOL_C33_PSE_ADMIN_STATE_DISABLED; 672 673 priv->admin_state[id] = admin_state->c33_admin_state; 674 675 return 0; 676 } 677 678 static int 679 pd692x0_pi_get_pw_status(struct pse_controller_dev *pcdev, int id, 680 struct pse_pw_status *pw_status) 681 { 682 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 683 struct pd692x0_msg msg, buf = {0}; 684 int ret; 685 686 ret = pd692x0_fw_unavailable(priv); 687 if (ret) 688 return ret; 689 690 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_STATUS]; 691 msg.sub[2] = id; 692 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 693 if (ret < 0) 694 return ret; 695 696 /* Compare Port Status (Communication Protocol Document par. 7.1) */ 697 if ((buf.sub[0] & 0xf0) == 0x80 || (buf.sub[0] & 0xf0) == 0x90) 698 pw_status->c33_pw_status = 699 ETHTOOL_C33_PSE_PW_D_STATUS_DELIVERING; 700 else if (buf.sub[0] == 0x1b || buf.sub[0] == 0x22) 701 pw_status->c33_pw_status = 702 ETHTOOL_C33_PSE_PW_D_STATUS_SEARCHING; 703 else if (buf.sub[0] == 0x12) 704 pw_status->c33_pw_status = 705 ETHTOOL_C33_PSE_PW_D_STATUS_FAULT; 706 else 707 pw_status->c33_pw_status = 708 ETHTOOL_C33_PSE_PW_D_STATUS_DISABLED; 709 710 return 0; 711 } 712 713 static int 714 pd692x0_pi_get_pw_class(struct pse_controller_dev *pcdev, int id) 715 { 716 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 717 struct pd692x0_msg msg, buf = {0}; 718 u32 class; 719 int ret; 720 721 ret = pd692x0_fw_unavailable(priv); 722 if (ret) 723 return ret; 724 725 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_CLASS]; 726 msg.sub[2] = id; 727 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 728 if (ret < 0) 729 return ret; 730 731 class = buf.data[3] >> 4; 732 if (class <= 8) 733 return class; 734 735 return 0; 736 } 737 738 static int 739 pd692x0_pi_get_actual_pw(struct pse_controller_dev *pcdev, int id) 740 { 741 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 742 struct pd692x0_msg msg, buf = {0}; 743 int ret; 744 745 ret = pd692x0_fw_unavailable(priv); 746 if (ret) 747 return ret; 748 749 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_STATUS]; 750 msg.sub[2] = id; 751 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 752 if (ret < 0) 753 return ret; 754 755 return (buf.data[0] << 4 | buf.data[1]) * 100; 756 } 757 758 static int 759 pd692x0_pi_get_prio(struct pse_controller_dev *pcdev, int id) 760 { 761 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 762 struct pd692x0_msg msg, buf = {0}; 763 int ret; 764 765 ret = pd692x0_fw_unavailable(priv); 766 if (ret) 767 return ret; 768 769 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_PARAM]; 770 msg.sub[2] = id; 771 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 772 if (ret < 0) 773 return ret; 774 if (!buf.data[2] || buf.data[2] > pcdev->pis_prio_max + 1) 775 return -ERANGE; 776 777 /* PSE core priority start at 0 */ 778 return buf.data[2] - 1; 779 } 780 781 static struct pd692x0_msg_ver pd692x0_get_sw_version(struct pd692x0_priv *priv) 782 { 783 struct device *dev = &priv->client->dev; 784 struct pd692x0_msg msg, buf = {0}; 785 struct pd692x0_msg_ver ver = {0}; 786 int ret; 787 788 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_SW_VER]; 789 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 790 if (ret < 0) { 791 dev_err(dev, "Failed to get PSE version (%pe)\n", ERR_PTR(ret)); 792 return ver; 793 } 794 795 /* Extract version from the message */ 796 ver.prod = buf.sub[2]; 797 ver.maj_sw_ver = (buf.data[0] << 8 | buf.data[1]) / 100; 798 ver.min_sw_ver = ((buf.data[0] << 8 | buf.data[1]) / 10) % 10; 799 ver.pa_sw_ver = (buf.data[0] << 8 | buf.data[1]) % 10; 800 ver.param = buf.data[2]; 801 ver.build = buf.data[3]; 802 803 return ver; 804 } 805 806 struct pd692x0_manager { 807 struct device_node *port_node[PD692X0_MAX_MANAGER_PORTS]; 808 struct device_node *node; 809 int nports; 810 }; 811 812 struct pd692x0_matrix { 813 u8 hw_port_a; 814 u8 hw_port_b; 815 }; 816 817 static int 818 pd692x0_of_get_ports_manager(struct pd692x0_priv *priv, 819 struct pd692x0_manager *manager, 820 struct device_node *np) 821 { 822 struct device_node *node; 823 int ret, nports, i; 824 825 nports = 0; 826 for_each_child_of_node(np, node) { 827 u32 port; 828 829 if (!of_node_name_eq(node, "port")) 830 continue; 831 832 ret = of_property_read_u32(node, "reg", &port); 833 if (ret) 834 goto out; 835 836 if (port >= PD692X0_MAX_MANAGER_PORTS || port != nports) { 837 dev_err(&priv->client->dev, 838 "wrong number or order of manager ports (%d)\n", 839 port); 840 ret = -EINVAL; 841 goto out; 842 } 843 844 of_node_get(node); 845 manager->port_node[port] = node; 846 nports++; 847 } 848 849 manager->nports = nports; 850 return 0; 851 852 out: 853 for (i = 0; i < nports; i++) { 854 of_node_put(manager->port_node[i]); 855 manager->port_node[i] = NULL; 856 } 857 of_node_put(node); 858 return ret; 859 } 860 861 static int 862 pd692x0_of_get_managers(struct pd692x0_priv *priv, 863 struct pd692x0_manager *manager) 864 { 865 struct device_node *managers_node, *node; 866 int ret, nmanagers, i, j; 867 868 if (!priv->np) 869 return -EINVAL; 870 871 nmanagers = 0; 872 managers_node = of_get_child_by_name(priv->np, "managers"); 873 if (!managers_node) 874 return -EINVAL; 875 876 for_each_child_of_node(managers_node, node) { 877 u32 manager_id; 878 879 if (!of_node_name_eq(node, "manager")) 880 continue; 881 882 ret = of_property_read_u32(node, "reg", &manager_id); 883 if (ret) 884 goto out; 885 886 if (manager_id >= PD692X0_MAX_MANAGERS || 887 manager_id != nmanagers) { 888 dev_err(&priv->client->dev, 889 "wrong number or order of managers (%d)\n", 890 manager_id); 891 ret = -EINVAL; 892 goto out; 893 } 894 895 ret = pd692x0_of_get_ports_manager(priv, &manager[manager_id], 896 node); 897 if (ret) 898 goto out; 899 900 of_node_get(node); 901 manager[manager_id].node = node; 902 nmanagers++; 903 } 904 905 of_node_put(managers_node); 906 return nmanagers; 907 908 out: 909 for (i = 0; i < nmanagers; i++) { 910 for (j = 0; j < manager[i].nports; j++) { 911 of_node_put(manager[i].port_node[j]); 912 manager[i].port_node[j] = NULL; 913 } 914 of_node_put(manager[i].node); 915 manager[i].node = NULL; 916 } 917 918 of_node_put(node); 919 of_node_put(managers_node); 920 return ret; 921 } 922 923 static const struct regulator_ops dummy_ops; 924 925 static struct regulator_dev * 926 pd692x0_register_manager_regulator(struct device *dev, char *reg_name, 927 struct device_node *node) 928 { 929 struct regulator_init_data *rinit_data; 930 struct regulator_config rconfig = {0}; 931 struct regulator_desc *rdesc; 932 struct regulator_dev *rdev; 933 934 rinit_data = devm_kzalloc(dev, sizeof(*rinit_data), 935 GFP_KERNEL); 936 if (!rinit_data) 937 return ERR_PTR(-ENOMEM); 938 939 rdesc = devm_kzalloc(dev, sizeof(*rdesc), GFP_KERNEL); 940 if (!rdesc) 941 return ERR_PTR(-ENOMEM); 942 943 rdesc->name = reg_name; 944 rdesc->type = REGULATOR_VOLTAGE; 945 rdesc->ops = &dummy_ops; 946 rdesc->owner = THIS_MODULE; 947 948 rinit_data->supply_regulator = "vmain"; 949 950 rconfig.dev = dev; 951 rconfig.init_data = rinit_data; 952 rconfig.of_node = node; 953 954 rdev = devm_regulator_register(dev, rdesc, &rconfig); 955 if (IS_ERR(rdev)) { 956 dev_err_probe(dev, PTR_ERR(rdev), 957 "Failed to register regulator\n"); 958 return rdev; 959 } 960 961 return rdev; 962 } 963 964 static int 965 pd692x0_register_managers_regulator(struct pd692x0_priv *priv, 966 const struct pd692x0_manager *manager, 967 int nmanagers) 968 { 969 struct device *dev = &priv->client->dev; 970 size_t reg_name_len; 971 int i; 972 973 /* Each regulator name len is dev name + 12 char + 974 * int max digit number (10) + 1 975 */ 976 reg_name_len = strlen(dev_name(dev)) + 23; 977 978 for (i = 0; i < nmanagers; i++) { 979 static const char * const regulators[] = { "vaux5", "vaux3p3" }; 980 struct regulator_dev *rdev; 981 char *reg_name; 982 int ret; 983 984 reg_name = devm_kzalloc(dev, reg_name_len, GFP_KERNEL); 985 if (!reg_name) 986 return -ENOMEM; 987 snprintf(reg_name, 26, "pse-%s-manager%d", dev_name(dev), i); 988 rdev = pd692x0_register_manager_regulator(dev, reg_name, 989 manager[i].node); 990 if (IS_ERR(rdev)) 991 return PTR_ERR(rdev); 992 993 /* VMAIN is described as main supply for the manager. 994 * Add other VAUX power supplies and link them to the 995 * virtual device rdev->dev. 996 */ 997 ret = devm_regulator_bulk_get_enable(&rdev->dev, 998 ARRAY_SIZE(regulators), 999 regulators); 1000 if (ret) 1001 return dev_err_probe(&rdev->dev, ret, 1002 "Failed to enable regulators\n"); 1003 1004 priv->manager_reg[i] = rdev; 1005 } 1006 1007 return 0; 1008 } 1009 1010 static int 1011 pd692x0_conf_manager_power_budget(struct pd692x0_priv *priv, int id, int pw) 1012 { 1013 struct pd692x0_msg msg, buf; 1014 int ret, pw_mW = pw / 1000; 1015 1016 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_POWER_BANK]; 1017 msg.data[0] = id; 1018 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 1019 if (ret < 0) 1020 return ret; 1021 1022 msg = pd692x0_msg_template_list[PD692X0_MSG_SET_POWER_BANK]; 1023 msg.data[0] = id; 1024 msg.data[1] = pw_mW >> 8; 1025 msg.data[2] = pw_mW & 0xff; 1026 msg.data[3] = buf.sub[2]; 1027 msg.data[4] = buf.data[0]; 1028 msg.data[5] = buf.data[1]; 1029 msg.data[6] = buf.data[2]; 1030 msg.data[7] = buf.data[3]; 1031 return pd692x0_sendrecv_msg(priv, &msg, &buf); 1032 } 1033 1034 static int 1035 pd692x0_configure_managers(struct pd692x0_priv *priv, int nmanagers) 1036 { 1037 int i, ret; 1038 1039 for (i = 0; i < nmanagers; i++) { 1040 struct regulator *supply = priv->manager_reg[i]->supply; 1041 int pw_budget; 1042 1043 pw_budget = regulator_get_unclaimed_power_budget(supply); 1044 if (!pw_budget) 1045 /* Do nothing if no power budget */ 1046 continue; 1047 1048 /* Max power budget per manager */ 1049 if (pw_budget > 6000000) 1050 pw_budget = 6000000; 1051 ret = regulator_request_power_budget(supply, pw_budget); 1052 if (ret < 0) 1053 return ret; 1054 1055 priv->manager_pw_budget[i] = pw_budget; 1056 ret = pd692x0_conf_manager_power_budget(priv, i, pw_budget); 1057 if (ret < 0) 1058 return ret; 1059 } 1060 1061 return 0; 1062 } 1063 1064 static int 1065 pd692x0_set_port_matrix(const struct pse_pi_pairset *pairset, 1066 const struct pd692x0_manager *manager, 1067 int nmanagers, struct pd692x0_matrix *port_matrix) 1068 { 1069 int i, j, port_cnt; 1070 bool found = false; 1071 1072 if (!pairset->np) 1073 return 0; 1074 1075 /* Look on every managers */ 1076 port_cnt = 0; 1077 for (i = 0; i < nmanagers; i++) { 1078 /* Look on every ports of the manager */ 1079 for (j = 0; j < manager[i].nports; j++) { 1080 if (pairset->np == manager[i].port_node[j]) { 1081 found = true; 1082 break; 1083 } 1084 } 1085 port_cnt += j; 1086 1087 if (found) 1088 break; 1089 } 1090 1091 if (!found) 1092 return -ENODEV; 1093 1094 if (pairset->pinout == ALTERNATIVE_A) 1095 port_matrix->hw_port_a = port_cnt; 1096 else if (pairset->pinout == ALTERNATIVE_B) 1097 port_matrix->hw_port_b = port_cnt; 1098 1099 return 0; 1100 } 1101 1102 static int 1103 pd692x0_set_ports_matrix(struct pd692x0_priv *priv, 1104 const struct pd692x0_manager *manager, 1105 int nmanagers, 1106 struct pd692x0_matrix port_matrix[PD692X0_MAX_PIS]) 1107 { 1108 struct pse_controller_dev *pcdev = &priv->pcdev; 1109 int i, ret; 1110 1111 /* Init Matrix */ 1112 for (i = 0; i < PD692X0_MAX_PIS; i++) { 1113 port_matrix[i].hw_port_a = 0xff; 1114 port_matrix[i].hw_port_b = 0xff; 1115 } 1116 1117 /* Update with values for every PSE PIs */ 1118 for (i = 0; i < pcdev->nr_lines; i++) { 1119 ret = pd692x0_set_port_matrix(&pcdev->pi[i].pairset[0], 1120 manager, nmanagers, 1121 &port_matrix[i]); 1122 if (ret) { 1123 dev_err(&priv->client->dev, 1124 "unable to configure pi %d pairset 0", i); 1125 return ret; 1126 } 1127 1128 ret = pd692x0_set_port_matrix(&pcdev->pi[i].pairset[1], 1129 manager, nmanagers, 1130 &port_matrix[i]); 1131 if (ret) { 1132 dev_err(&priv->client->dev, 1133 "unable to configure pi %d pairset 1", i); 1134 return ret; 1135 } 1136 } 1137 1138 return 0; 1139 } 1140 1141 static int 1142 pd692x0_write_ports_matrix(struct pd692x0_priv *priv, 1143 const struct pd692x0_matrix port_matrix[PD692X0_MAX_PIS]) 1144 { 1145 struct pd692x0_msg msg, buf; 1146 int ret, i; 1147 1148 /* Write temporary Matrix */ 1149 msg = pd692x0_msg_template_list[PD692X0_MSG_SET_TMP_PORT_MATRIX]; 1150 for (i = 0; i < PD692X0_MAX_PIS; i++) { 1151 msg.sub[2] = i; 1152 msg.data[0] = port_matrix[i].hw_port_b; 1153 msg.data[1] = port_matrix[i].hw_port_a; 1154 1155 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 1156 if (ret < 0) 1157 return ret; 1158 } 1159 1160 /* Program Matrix */ 1161 msg = pd692x0_msg_template_list[PD692X0_MSG_PRG_PORT_MATRIX]; 1162 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 1163 if (ret < 0) 1164 return ret; 1165 1166 return 0; 1167 } 1168 1169 static void pd692x0_of_put_managers(struct pd692x0_priv *priv, 1170 struct pd692x0_manager *manager, 1171 int nmanagers) 1172 { 1173 int i, j; 1174 1175 for (i = 0; i < nmanagers; i++) { 1176 for (j = 0; j < manager[i].nports; j++) 1177 of_node_put(manager[i].port_node[j]); 1178 of_node_put(manager[i].node); 1179 } 1180 } 1181 1182 static void pd692x0_managers_free_pw_budget(struct pd692x0_priv *priv) 1183 { 1184 int i; 1185 1186 for (i = 0; i < PD692X0_MAX_MANAGERS; i++) { 1187 struct regulator *supply; 1188 1189 if (!priv->manager_reg[i] || !priv->manager_pw_budget[i]) 1190 continue; 1191 1192 supply = priv->manager_reg[i]->supply; 1193 if (!supply) 1194 continue; 1195 1196 regulator_free_power_budget(supply, 1197 priv->manager_pw_budget[i]); 1198 } 1199 } 1200 1201 static int pd692x0_setup_pi_matrix(struct pse_controller_dev *pcdev) 1202 { 1203 struct pd692x0_manager *manager __free(kfree) = NULL; 1204 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 1205 struct pd692x0_matrix port_matrix[PD692X0_MAX_PIS]; 1206 int ret, nmanagers; 1207 1208 /* Should we flash the port matrix */ 1209 if (priv->fw_state != PD692X0_FW_OK && 1210 priv->fw_state != PD692X0_FW_COMPLETE) 1211 return 0; 1212 1213 manager = kcalloc(PD692X0_MAX_MANAGERS, sizeof(*manager), GFP_KERNEL); 1214 if (!manager) 1215 return -ENOMEM; 1216 1217 ret = pd692x0_of_get_managers(priv, manager); 1218 if (ret < 0) 1219 return ret; 1220 1221 nmanagers = ret; 1222 ret = pd692x0_register_managers_regulator(priv, manager, nmanagers); 1223 if (ret) 1224 goto err_of_managers; 1225 1226 ret = pd692x0_configure_managers(priv, nmanagers); 1227 if (ret) 1228 goto err_of_managers; 1229 1230 ret = pd692x0_set_ports_matrix(priv, manager, nmanagers, port_matrix); 1231 if (ret) 1232 goto err_managers_req_pw; 1233 1234 ret = pd692x0_write_ports_matrix(priv, port_matrix); 1235 if (ret) 1236 goto err_managers_req_pw; 1237 1238 pd692x0_of_put_managers(priv, manager, nmanagers); 1239 return 0; 1240 1241 err_managers_req_pw: 1242 pd692x0_managers_free_pw_budget(priv); 1243 err_of_managers: 1244 pd692x0_of_put_managers(priv, manager, nmanagers); 1245 return ret; 1246 } 1247 1248 static int pd692x0_pi_get_voltage(struct pse_controller_dev *pcdev, int id) 1249 { 1250 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 1251 struct pd692x0_msg msg, buf = {0}; 1252 int ret; 1253 1254 ret = pd692x0_fw_unavailable(priv); 1255 if (ret) 1256 return ret; 1257 1258 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_MEAS]; 1259 msg.sub[2] = id; 1260 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 1261 if (ret < 0) 1262 return ret; 1263 1264 /* Convert 0.1V unit to uV */ 1265 return (buf.sub[0] << 8 | buf.sub[1]) * 100000; 1266 } 1267 1268 static int pd692x0_pi_get_pw_limit(struct pse_controller_dev *pcdev, 1269 int id) 1270 { 1271 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 1272 struct pd692x0_msg msg, buf = {0}; 1273 int ret; 1274 1275 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_PORT_PARAM]; 1276 msg.sub[2] = id; 1277 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 1278 if (ret < 0) 1279 return ret; 1280 1281 return pd692x0_pi_get_pw_from_table(buf.data[0], buf.data[1]); 1282 } 1283 1284 static int pd692x0_pi_set_pw_limit(struct pse_controller_dev *pcdev, 1285 int id, int max_mW) 1286 { 1287 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 1288 struct device *dev = &priv->client->dev; 1289 struct pd692x0_msg msg, buf = {0}; 1290 int ret; 1291 1292 ret = pd692x0_fw_unavailable(priv); 1293 if (ret) 1294 return ret; 1295 1296 msg = pd692x0_msg_template_list[PD692X0_MSG_SET_PORT_PARAM]; 1297 msg.sub[2] = id; 1298 ret = pd692x0_pi_set_pw_from_table(dev, &msg, max_mW); 1299 if (ret) 1300 return ret; 1301 1302 return pd692x0_sendrecv_msg(priv, &msg, &buf); 1303 } 1304 1305 static int pd692x0_pi_set_prio(struct pse_controller_dev *pcdev, int id, 1306 unsigned int prio) 1307 { 1308 struct pd692x0_priv *priv = to_pd692x0_priv(pcdev); 1309 struct pd692x0_msg msg, buf = {0}; 1310 int ret; 1311 1312 ret = pd692x0_fw_unavailable(priv); 1313 if (ret) 1314 return ret; 1315 1316 msg = pd692x0_msg_template_list[PD692X0_MSG_SET_PORT_PARAM]; 1317 msg.sub[2] = id; 1318 /* Controller priority from 1 to 3 */ 1319 msg.data[4] = prio + 1; 1320 1321 return pd692x0_sendrecv_msg(priv, &msg, &buf); 1322 } 1323 1324 static const struct pse_controller_ops pd692x0_ops = { 1325 .setup_pi_matrix = pd692x0_setup_pi_matrix, 1326 .pi_get_admin_state = pd692x0_pi_get_admin_state, 1327 .pi_get_pw_status = pd692x0_pi_get_pw_status, 1328 .pi_get_ext_state = pd692x0_pi_get_ext_state, 1329 .pi_get_pw_class = pd692x0_pi_get_pw_class, 1330 .pi_get_actual_pw = pd692x0_pi_get_actual_pw, 1331 .pi_enable = pd692x0_pi_enable, 1332 .pi_disable = pd692x0_pi_disable, 1333 .pi_get_voltage = pd692x0_pi_get_voltage, 1334 .pi_get_pw_limit = pd692x0_pi_get_pw_limit, 1335 .pi_set_pw_limit = pd692x0_pi_set_pw_limit, 1336 .pi_get_pw_limit_ranges = pd692x0_pi_get_pw_limit_ranges, 1337 .pi_get_prio = pd692x0_pi_get_prio, 1338 .pi_set_prio = pd692x0_pi_set_prio, 1339 }; 1340 1341 #define PD692X0_FW_LINE_MAX_SZ 0xff 1342 static int pd692x0_fw_get_next_line(const u8 *data, 1343 char *line, size_t size) 1344 { 1345 size_t line_size; 1346 int i; 1347 1348 line_size = min_t(size_t, size, PD692X0_FW_LINE_MAX_SZ); 1349 1350 memset(line, 0, PD692X0_FW_LINE_MAX_SZ); 1351 for (i = 0; i < line_size - 1; i++) { 1352 if (*data == '\r' && *(data + 1) == '\n') { 1353 line[i] = '\r'; 1354 line[i + 1] = '\n'; 1355 return i + 2; 1356 } 1357 line[i] = *data; 1358 data++; 1359 } 1360 1361 return -EIO; 1362 } 1363 1364 static enum fw_upload_err 1365 pd692x0_fw_recv_resp(const struct i2c_client *client, unsigned long ms_timeout, 1366 const char *msg_ok, unsigned int msg_size) 1367 { 1368 /* Maximum controller response size */ 1369 char fw_msg_buf[5] = {0}; 1370 unsigned long timeout; 1371 int ret; 1372 1373 if (msg_size > sizeof(fw_msg_buf)) 1374 return FW_UPLOAD_ERR_RW_ERROR; 1375 1376 /* Read until we get something */ 1377 timeout = msecs_to_jiffies(ms_timeout) + jiffies; 1378 while (true) { 1379 if (time_is_before_jiffies(timeout)) 1380 return FW_UPLOAD_ERR_TIMEOUT; 1381 1382 ret = i2c_master_recv(client, fw_msg_buf, 1); 1383 if (ret < 0 || *fw_msg_buf == 0) { 1384 usleep_range(1000, 2000); 1385 continue; 1386 } else { 1387 break; 1388 } 1389 } 1390 1391 /* Read remaining characters */ 1392 ret = i2c_master_recv(client, fw_msg_buf + 1, msg_size - 1); 1393 if (strncmp(fw_msg_buf, msg_ok, msg_size)) { 1394 dev_err(&client->dev, 1395 "Wrong FW download process answer (%*pE)\n", 1396 msg_size, fw_msg_buf); 1397 return FW_UPLOAD_ERR_HW_ERROR; 1398 } 1399 1400 return FW_UPLOAD_ERR_NONE; 1401 } 1402 1403 static int pd692x0_fw_write_line(const struct i2c_client *client, 1404 const char line[PD692X0_FW_LINE_MAX_SZ], 1405 const bool last_line) 1406 { 1407 int ret; 1408 1409 while (*line != 0) { 1410 ret = i2c_master_send(client, line, 1); 1411 if (ret < 0) 1412 return FW_UPLOAD_ERR_RW_ERROR; 1413 line++; 1414 } 1415 1416 if (last_line) { 1417 ret = pd692x0_fw_recv_resp(client, 100, "TP\r\n", 1418 sizeof("TP\r\n") - 1); 1419 if (ret) 1420 return ret; 1421 } else { 1422 ret = pd692x0_fw_recv_resp(client, 100, "T*\r\n", 1423 sizeof("T*\r\n") - 1); 1424 if (ret) 1425 return ret; 1426 } 1427 1428 return FW_UPLOAD_ERR_NONE; 1429 } 1430 1431 static enum fw_upload_err pd692x0_fw_reset(const struct i2c_client *client) 1432 { 1433 const struct pd692x0_msg zero = {0}; 1434 struct pd692x0_msg buf = {0}; 1435 unsigned long timeout; 1436 char cmd[] = "RST"; 1437 int ret; 1438 1439 ret = i2c_master_send(client, cmd, strlen(cmd)); 1440 if (ret < 0) { 1441 dev_err(&client->dev, 1442 "Failed to reset the controller (%pe)\n", 1443 ERR_PTR(ret)); 1444 return ret; 1445 } 1446 1447 timeout = msecs_to_jiffies(10000) + jiffies; 1448 while (true) { 1449 if (time_is_before_jiffies(timeout)) 1450 return FW_UPLOAD_ERR_TIMEOUT; 1451 1452 ret = i2c_master_recv(client, (u8 *)&buf, sizeof(buf)); 1453 if (ret < 0 || 1454 !memcmp(&buf, &zero, sizeof(buf))) 1455 usleep_range(1000, 2000); 1456 else 1457 break; 1458 } 1459 1460 /* Is the reply a successful report message */ 1461 if (buf.key != PD692X0_KEY_TLM || buf.echo != 0xff || 1462 buf.sub[0] & 0x01) { 1463 dev_err(&client->dev, "PSE controller error\n"); 1464 return FW_UPLOAD_ERR_HW_ERROR; 1465 } 1466 1467 /* Is the firmware operational */ 1468 if (buf.sub[0] & 0x02) { 1469 dev_err(&client->dev, 1470 "PSE firmware error. Please update it.\n"); 1471 return FW_UPLOAD_ERR_HW_ERROR; 1472 } 1473 1474 return FW_UPLOAD_ERR_NONE; 1475 } 1476 1477 static enum fw_upload_err pd692x0_fw_prepare(struct fw_upload *fwl, 1478 const u8 *data, u32 size) 1479 { 1480 struct pd692x0_priv *priv = fwl->dd_handle; 1481 const struct i2c_client *client = priv->client; 1482 enum pd692x0_fw_state last_fw_state; 1483 int ret; 1484 1485 priv->cancel_request = false; 1486 last_fw_state = priv->fw_state; 1487 1488 priv->fw_state = PD692X0_FW_PREPARE; 1489 1490 /* Enter program mode */ 1491 if (last_fw_state == PD692X0_FW_BROKEN) { 1492 const char *msg = "ENTR"; 1493 const char *c; 1494 1495 c = msg; 1496 do { 1497 ret = i2c_master_send(client, c, 1); 1498 if (ret < 0) 1499 return FW_UPLOAD_ERR_RW_ERROR; 1500 if (*(c + 1)) 1501 usleep_range(10000, 20000); 1502 } while (*(++c)); 1503 } else { 1504 struct pd692x0_msg msg, buf; 1505 1506 msg = pd692x0_msg_template_list[PD692X0_MSG_DOWNLOAD_CMD]; 1507 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 1508 if (ret < 0) { 1509 dev_err(&client->dev, 1510 "Failed to enter programming mode (%pe)\n", 1511 ERR_PTR(ret)); 1512 return FW_UPLOAD_ERR_RW_ERROR; 1513 } 1514 } 1515 1516 ret = pd692x0_fw_recv_resp(client, 100, "TPE\r\n", sizeof("TPE\r\n") - 1); 1517 if (ret) 1518 goto err_out; 1519 1520 if (priv->cancel_request) { 1521 ret = FW_UPLOAD_ERR_CANCELED; 1522 goto err_out; 1523 } 1524 1525 return FW_UPLOAD_ERR_NONE; 1526 1527 err_out: 1528 pd692x0_fw_reset(priv->client); 1529 priv->fw_state = last_fw_state; 1530 return ret; 1531 } 1532 1533 static enum fw_upload_err pd692x0_fw_write(struct fw_upload *fwl, 1534 const u8 *data, u32 offset, 1535 u32 size, u32 *written) 1536 { 1537 struct pd692x0_priv *priv = fwl->dd_handle; 1538 char line[PD692X0_FW_LINE_MAX_SZ]; 1539 const struct i2c_client *client; 1540 int ret, i; 1541 char cmd; 1542 1543 client = priv->client; 1544 priv->fw_state = PD692X0_FW_WRITE; 1545 1546 /* Erase */ 1547 cmd = 'E'; 1548 ret = i2c_master_send(client, &cmd, 1); 1549 if (ret < 0) { 1550 dev_err(&client->dev, 1551 "Failed to boot programming mode (%pe)\n", 1552 ERR_PTR(ret)); 1553 return FW_UPLOAD_ERR_RW_ERROR; 1554 } 1555 1556 ret = pd692x0_fw_recv_resp(client, 100, "TOE\r\n", sizeof("TOE\r\n") - 1); 1557 if (ret) 1558 return ret; 1559 1560 ret = pd692x0_fw_recv_resp(client, 5000, "TE\r\n", sizeof("TE\r\n") - 1); 1561 if (ret) 1562 dev_warn(&client->dev, 1563 "Failed to erase internal memory, however still try to write Firmware\n"); 1564 1565 ret = pd692x0_fw_recv_resp(client, 100, "TPE\r\n", sizeof("TPE\r\n") - 1); 1566 if (ret) 1567 dev_warn(&client->dev, 1568 "Failed to erase internal memory, however still try to write Firmware\n"); 1569 1570 if (priv->cancel_request) 1571 return FW_UPLOAD_ERR_CANCELED; 1572 1573 /* Program */ 1574 cmd = 'P'; 1575 ret = i2c_master_send(client, &cmd, sizeof(char)); 1576 if (ret < 0) { 1577 dev_err(&client->dev, 1578 "Failed to boot programming mode (%pe)\n", 1579 ERR_PTR(ret)); 1580 return ret; 1581 } 1582 1583 ret = pd692x0_fw_recv_resp(client, 100, "TOP\r\n", sizeof("TOP\r\n") - 1); 1584 if (ret) 1585 return ret; 1586 1587 i = 0; 1588 while (i < size) { 1589 ret = pd692x0_fw_get_next_line(data, line, size - i); 1590 if (ret < 0) { 1591 ret = FW_UPLOAD_ERR_FW_INVALID; 1592 goto err; 1593 } 1594 1595 i += ret; 1596 data += ret; 1597 if (line[0] == 'S' && line[1] == '0') { 1598 continue; 1599 } else if (line[0] == 'S' && line[1] == '7') { 1600 ret = pd692x0_fw_write_line(client, line, true); 1601 if (ret) 1602 goto err; 1603 } else { 1604 ret = pd692x0_fw_write_line(client, line, false); 1605 if (ret) 1606 goto err; 1607 } 1608 1609 if (priv->cancel_request) { 1610 ret = FW_UPLOAD_ERR_CANCELED; 1611 goto err; 1612 } 1613 } 1614 *written = i; 1615 1616 msleep(400); 1617 1618 return FW_UPLOAD_ERR_NONE; 1619 1620 err: 1621 strscpy_pad(line, "S7\r\n", sizeof(line)); 1622 pd692x0_fw_write_line(client, line, true); 1623 return ret; 1624 } 1625 1626 static enum fw_upload_err pd692x0_fw_poll_complete(struct fw_upload *fwl) 1627 { 1628 struct pd692x0_priv *priv = fwl->dd_handle; 1629 const struct i2c_client *client = priv->client; 1630 struct pd692x0_msg_ver ver; 1631 int ret; 1632 1633 priv->fw_state = PD692X0_FW_COMPLETE; 1634 1635 ret = pd692x0_fw_reset(client); 1636 if (ret) 1637 return ret; 1638 1639 ver = pd692x0_get_sw_version(priv); 1640 if (ver.maj_sw_ver < PD692X0_FW_MAJ_VER) { 1641 dev_err(&client->dev, 1642 "Too old firmware version. Please update it\n"); 1643 priv->fw_state = PD692X0_FW_NEED_UPDATE; 1644 return FW_UPLOAD_ERR_FW_INVALID; 1645 } 1646 1647 ret = pd692x0_setup_pi_matrix(&priv->pcdev); 1648 if (ret < 0) { 1649 dev_err(&client->dev, "Error configuring ports matrix (%pe)\n", 1650 ERR_PTR(ret)); 1651 priv->fw_state = PD692X0_FW_NEED_UPDATE; 1652 return FW_UPLOAD_ERR_HW_ERROR; 1653 } 1654 1655 priv->fw_state = PD692X0_FW_OK; 1656 return FW_UPLOAD_ERR_NONE; 1657 } 1658 1659 static void pd692x0_fw_cancel(struct fw_upload *fwl) 1660 { 1661 struct pd692x0_priv *priv = fwl->dd_handle; 1662 1663 priv->cancel_request = true; 1664 } 1665 1666 static void pd692x0_fw_cleanup(struct fw_upload *fwl) 1667 { 1668 struct pd692x0_priv *priv = fwl->dd_handle; 1669 1670 switch (priv->fw_state) { 1671 case PD692X0_FW_WRITE: 1672 pd692x0_fw_reset(priv->client); 1673 fallthrough; 1674 case PD692X0_FW_COMPLETE: 1675 priv->fw_state = PD692X0_FW_BROKEN; 1676 break; 1677 default: 1678 break; 1679 } 1680 } 1681 1682 static const struct fw_upload_ops pd692x0_fw_ops = { 1683 .prepare = pd692x0_fw_prepare, 1684 .write = pd692x0_fw_write, 1685 .poll_complete = pd692x0_fw_poll_complete, 1686 .cancel = pd692x0_fw_cancel, 1687 .cleanup = pd692x0_fw_cleanup, 1688 }; 1689 1690 static int pd692x0_i2c_probe(struct i2c_client *client) 1691 { 1692 static const char * const regulators[] = { "vdd", "vdda" }; 1693 struct pd692x0_msg msg, buf = {0}, zero = {0}; 1694 struct device *dev = &client->dev; 1695 struct pd692x0_msg_ver ver; 1696 struct pd692x0_priv *priv; 1697 struct fw_upload *fwl; 1698 int ret; 1699 1700 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(regulators), 1701 regulators); 1702 if (ret) 1703 return dev_err_probe(dev, ret, 1704 "Failed to enable regulators\n"); 1705 1706 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 1707 dev_err(dev, "i2c check functionality failed\n"); 1708 return -ENXIO; 1709 } 1710 1711 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 1712 if (!priv) 1713 return -ENOMEM; 1714 1715 priv->client = client; 1716 i2c_set_clientdata(client, priv); 1717 1718 ret = i2c_master_recv(client, (u8 *)&buf, sizeof(buf)); 1719 if (ret != sizeof(buf)) { 1720 dev_err(dev, "Failed to get device status\n"); 1721 return -EIO; 1722 } 1723 1724 /* Probe has been already run and the status dumped */ 1725 if (!memcmp(&buf, &zero, sizeof(buf))) { 1726 /* Ask again the controller status */ 1727 msg = pd692x0_msg_template_list[PD692X0_MSG_GET_SYS_STATUS]; 1728 ret = pd692x0_sendrecv_msg(priv, &msg, &buf); 1729 if (ret < 0) { 1730 dev_err(dev, "Failed to get device status\n"); 1731 return ret; 1732 } 1733 } 1734 1735 if (buf.key != 0x03 || buf.sub[0] & 0x01) { 1736 dev_err(dev, "PSE controller error\n"); 1737 return -EIO; 1738 } 1739 if (buf.sub[0] & 0x02) { 1740 dev_err(dev, "PSE firmware error. Please update it.\n"); 1741 priv->fw_state = PD692X0_FW_BROKEN; 1742 } else { 1743 ver = pd692x0_get_sw_version(priv); 1744 dev_info(&client->dev, "Software version %d.%02d.%d.%d\n", 1745 ver.prod, ver.maj_sw_ver, ver.min_sw_ver, 1746 ver.pa_sw_ver); 1747 1748 if (ver.maj_sw_ver < PD692X0_FW_MAJ_VER) { 1749 dev_err(dev, "Too old firmware version. Please update it\n"); 1750 priv->fw_state = PD692X0_FW_NEED_UPDATE; 1751 } else { 1752 priv->fw_state = PD692X0_FW_OK; 1753 } 1754 } 1755 1756 priv->np = dev->of_node; 1757 priv->pcdev.nr_lines = PD692X0_MAX_PIS; 1758 priv->pcdev.owner = THIS_MODULE; 1759 priv->pcdev.ops = &pd692x0_ops; 1760 priv->pcdev.dev = dev; 1761 priv->pcdev.types = ETHTOOL_PSE_C33; 1762 priv->pcdev.supp_budget_eval_strategies = PSE_BUDGET_EVAL_STRAT_DYNAMIC; 1763 priv->pcdev.pis_prio_max = 2; 1764 ret = devm_pse_controller_register(dev, &priv->pcdev); 1765 if (ret) 1766 return dev_err_probe(dev, ret, 1767 "failed to register PSE controller\n"); 1768 1769 fwl = firmware_upload_register(THIS_MODULE, dev, dev_name(dev), 1770 &pd692x0_fw_ops, priv); 1771 if (IS_ERR(fwl)) 1772 return dev_err_probe(dev, PTR_ERR(fwl), 1773 "failed to register to the Firmware Upload API\n"); 1774 priv->fwl = fwl; 1775 1776 return 0; 1777 } 1778 1779 static void pd692x0_i2c_remove(struct i2c_client *client) 1780 { 1781 struct pd692x0_priv *priv = i2c_get_clientdata(client); 1782 1783 pd692x0_managers_free_pw_budget(priv); 1784 firmware_upload_unregister(priv->fwl); 1785 } 1786 1787 static const struct i2c_device_id pd692x0_id[] = { 1788 { PD692X0_PSE_NAME }, 1789 { } 1790 }; 1791 MODULE_DEVICE_TABLE(i2c, pd692x0_id); 1792 1793 static const struct of_device_id pd692x0_of_match[] = { 1794 { .compatible = "microchip,pd69200", }, 1795 { .compatible = "microchip,pd69210", }, 1796 { .compatible = "microchip,pd69220", }, 1797 { }, 1798 }; 1799 MODULE_DEVICE_TABLE(of, pd692x0_of_match); 1800 1801 static struct i2c_driver pd692x0_driver = { 1802 .probe = pd692x0_i2c_probe, 1803 .remove = pd692x0_i2c_remove, 1804 .id_table = pd692x0_id, 1805 .driver = { 1806 .name = PD692X0_PSE_NAME, 1807 .of_match_table = pd692x0_of_match, 1808 }, 1809 }; 1810 module_i2c_driver(pd692x0_driver); 1811 1812 MODULE_AUTHOR("Kory Maincent <kory.maincent@bootlin.com>"); 1813 MODULE_DESCRIPTION("Microchip PD692x0 PoE PSE Controller driver"); 1814 MODULE_LICENSE("GPL"); 1815