1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // mcp251xfd - Microchip MCP251xFD Family CAN controller driver 4 // 5 // Copyright (c) 2019, 2020 Pengutronix, 6 // Marc Kleine-Budde <kernel@pengutronix.de> 7 // 8 9 #include "mcp251xfd.h" 10 11 #include <asm/unaligned.h> 12 13 static const struct regmap_config mcp251xfd_regmap_crc; 14 15 static int 16 mcp251xfd_regmap_nocrc_write(void *context, const void *data, size_t count) 17 { 18 struct spi_device *spi = context; 19 20 return spi_write(spi, data, count); 21 } 22 23 static int 24 mcp251xfd_regmap_nocrc_gather_write(void *context, 25 const void *reg, size_t reg_len, 26 const void *val, size_t val_len) 27 { 28 struct spi_device *spi = context; 29 struct mcp251xfd_priv *priv = spi_get_drvdata(spi); 30 struct mcp251xfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx; 31 struct spi_transfer xfer[] = { 32 { 33 .tx_buf = buf_tx, 34 .len = sizeof(buf_tx->cmd) + val_len, 35 }, 36 }; 37 38 BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16)); 39 40 if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) && 41 reg_len != sizeof(buf_tx->cmd.cmd)) 42 return -EINVAL; 43 44 memcpy(&buf_tx->cmd, reg, sizeof(buf_tx->cmd)); 45 memcpy(buf_tx->data, val, val_len); 46 47 return spi_sync_transfer(spi, xfer, ARRAY_SIZE(xfer)); 48 } 49 50 static inline bool mcp251xfd_update_bits_read_reg(unsigned int reg) 51 { 52 switch (reg) { 53 case MCP251XFD_REG_INT: 54 case MCP251XFD_REG_TEFCON: 55 case MCP251XFD_REG_FIFOCON(MCP251XFD_RX_FIFO(0)): 56 case MCP251XFD_REG_FLTCON(0): 57 case MCP251XFD_REG_ECCSTAT: 58 case MCP251XFD_REG_CRC: 59 return false; 60 case MCP251XFD_REG_CON: 61 case MCP251XFD_REG_FIFOSTA(MCP251XFD_RX_FIFO(0)): 62 case MCP251XFD_REG_OSC: 63 case MCP251XFD_REG_ECCCON: 64 return true; 65 default: 66 WARN(1, "Status of reg 0x%04x unknown.\n", reg); 67 } 68 69 return true; 70 } 71 72 static int 73 mcp251xfd_regmap_nocrc_update_bits(void *context, unsigned int reg, 74 unsigned int mask, unsigned int val) 75 { 76 struct spi_device *spi = context; 77 struct mcp251xfd_priv *priv = spi_get_drvdata(spi); 78 struct mcp251xfd_map_buf_nocrc *buf_rx = priv->map_buf_nocrc_rx; 79 struct mcp251xfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx; 80 __le32 orig_le32 = 0, mask_le32, val_le32, tmp_le32; 81 u8 first_byte, last_byte, len; 82 int err; 83 84 BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof(__be16)); 85 BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16)); 86 87 if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) && 88 mask == 0) 89 return -EINVAL; 90 91 first_byte = mcp251xfd_first_byte_set(mask); 92 last_byte = mcp251xfd_last_byte_set(mask); 93 len = last_byte - first_byte + 1; 94 95 if (mcp251xfd_update_bits_read_reg(reg)) { 96 struct spi_transfer xfer[2] = { }; 97 struct spi_message msg; 98 99 spi_message_init(&msg); 100 spi_message_add_tail(&xfer[0], &msg); 101 102 if (priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX) { 103 xfer[0].tx_buf = buf_tx; 104 xfer[0].len = sizeof(buf_tx->cmd); 105 106 xfer[1].rx_buf = buf_rx->data; 107 xfer[1].len = len; 108 spi_message_add_tail(&xfer[1], &msg); 109 } else { 110 xfer[0].tx_buf = buf_tx; 111 xfer[0].rx_buf = buf_rx; 112 xfer[0].len = sizeof(buf_tx->cmd) + len; 113 114 if (MCP251XFD_SANITIZE_SPI) 115 memset(buf_tx->data, 0x0, len); 116 } 117 118 mcp251xfd_spi_cmd_read_nocrc(&buf_tx->cmd, reg + first_byte); 119 err = spi_sync(spi, &msg); 120 if (err) 121 return err; 122 123 memcpy(&orig_le32, buf_rx->data, len); 124 } 125 126 mask_le32 = cpu_to_le32(mask >> BITS_PER_BYTE * first_byte); 127 val_le32 = cpu_to_le32(val >> BITS_PER_BYTE * first_byte); 128 129 tmp_le32 = orig_le32 & ~mask_le32; 130 tmp_le32 |= val_le32 & mask_le32; 131 132 mcp251xfd_spi_cmd_write_nocrc(&buf_tx->cmd, reg + first_byte); 133 memcpy(buf_tx->data, &tmp_le32, len); 134 135 return spi_write(spi, buf_tx, sizeof(buf_tx->cmd) + len); 136 } 137 138 static int 139 mcp251xfd_regmap_nocrc_read(void *context, 140 const void *reg, size_t reg_len, 141 void *val_buf, size_t val_len) 142 { 143 struct spi_device *spi = context; 144 struct mcp251xfd_priv *priv = spi_get_drvdata(spi); 145 struct mcp251xfd_map_buf_nocrc *buf_rx = priv->map_buf_nocrc_rx; 146 struct mcp251xfd_map_buf_nocrc *buf_tx = priv->map_buf_nocrc_tx; 147 struct spi_transfer xfer[2] = { }; 148 struct spi_message msg; 149 int err; 150 151 BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof(__be16)); 152 BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16)); 153 154 if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) && 155 reg_len != sizeof(buf_tx->cmd.cmd)) 156 return -EINVAL; 157 158 spi_message_init(&msg); 159 spi_message_add_tail(&xfer[0], &msg); 160 161 if (priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX) { 162 xfer[0].tx_buf = reg; 163 xfer[0].len = sizeof(buf_tx->cmd); 164 165 xfer[1].rx_buf = val_buf; 166 xfer[1].len = val_len; 167 spi_message_add_tail(&xfer[1], &msg); 168 } else { 169 xfer[0].tx_buf = buf_tx; 170 xfer[0].rx_buf = buf_rx; 171 xfer[0].len = sizeof(buf_tx->cmd) + val_len; 172 173 memcpy(&buf_tx->cmd, reg, sizeof(buf_tx->cmd)); 174 if (MCP251XFD_SANITIZE_SPI) 175 memset(buf_tx->data, 0x0, val_len); 176 } 177 178 err = spi_sync(spi, &msg); 179 if (err) 180 return err; 181 182 if (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX)) 183 memcpy(val_buf, buf_rx->data, val_len); 184 185 return 0; 186 } 187 188 static int 189 mcp251xfd_regmap_crc_gather_write(void *context, 190 const void *reg_p, size_t reg_len, 191 const void *val, size_t val_len) 192 { 193 struct spi_device *spi = context; 194 struct mcp251xfd_priv *priv = spi_get_drvdata(spi); 195 struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx; 196 struct spi_transfer xfer[] = { 197 { 198 .tx_buf = buf_tx, 199 .len = sizeof(buf_tx->cmd) + val_len + 200 sizeof(buf_tx->crc), 201 }, 202 }; 203 u16 reg = *(u16 *)reg_p; 204 u16 crc; 205 206 BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16) + sizeof(u8)); 207 208 if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) && 209 reg_len != sizeof(buf_tx->cmd.cmd) + 210 mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE) 211 return -EINVAL; 212 213 mcp251xfd_spi_cmd_write_crc(&buf_tx->cmd, reg, val_len); 214 memcpy(buf_tx->data, val, val_len); 215 216 crc = mcp251xfd_crc16_compute(buf_tx, sizeof(buf_tx->cmd) + val_len); 217 put_unaligned_be16(crc, buf_tx->data + val_len); 218 219 return spi_sync_transfer(spi, xfer, ARRAY_SIZE(xfer)); 220 } 221 222 static int 223 mcp251xfd_regmap_crc_write(void *context, 224 const void *data, size_t count) 225 { 226 const size_t data_offset = sizeof(__be16) + 227 mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE; 228 229 return mcp251xfd_regmap_crc_gather_write(context, 230 data, data_offset, 231 data + data_offset, 232 count - data_offset); 233 } 234 235 static int 236 mcp251xfd_regmap_crc_read_one(struct mcp251xfd_priv *priv, 237 struct spi_message *msg, unsigned int data_len) 238 { 239 const struct mcp251xfd_map_buf_crc *buf_rx = priv->map_buf_crc_rx; 240 const struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx; 241 u16 crc_received, crc_calculated; 242 int err; 243 244 BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof(__be16) + sizeof(u8)); 245 BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16) + sizeof(u8)); 246 247 err = spi_sync(priv->spi, msg); 248 if (err) 249 return err; 250 251 crc_received = get_unaligned_be16(buf_rx->data + data_len); 252 crc_calculated = mcp251xfd_crc16_compute2(&buf_tx->cmd, 253 sizeof(buf_tx->cmd), 254 buf_rx->data, 255 data_len); 256 if (crc_received != crc_calculated) 257 return -EBADMSG; 258 259 return 0; 260 } 261 262 static int 263 mcp251xfd_regmap_crc_read(void *context, 264 const void *reg_p, size_t reg_len, 265 void *val_buf, size_t val_len) 266 { 267 struct spi_device *spi = context; 268 struct mcp251xfd_priv *priv = spi_get_drvdata(spi); 269 struct mcp251xfd_map_buf_crc *buf_rx = priv->map_buf_crc_rx; 270 struct mcp251xfd_map_buf_crc *buf_tx = priv->map_buf_crc_tx; 271 struct spi_transfer xfer[2] = { }; 272 struct spi_message msg; 273 u16 reg = *(u16 *)reg_p; 274 int i, err; 275 276 BUILD_BUG_ON(sizeof(buf_rx->cmd) != sizeof(__be16) + sizeof(u8)); 277 BUILD_BUG_ON(sizeof(buf_tx->cmd) != sizeof(__be16) + sizeof(u8)); 278 279 if (IS_ENABLED(CONFIG_CAN_MCP251XFD_SANITY) && 280 reg_len != sizeof(buf_tx->cmd.cmd) + 281 mcp251xfd_regmap_crc.pad_bits / BITS_PER_BYTE) 282 return -EINVAL; 283 284 spi_message_init(&msg); 285 spi_message_add_tail(&xfer[0], &msg); 286 287 if (priv->devtype_data.quirks & MCP251XFD_QUIRK_HALF_DUPLEX) { 288 xfer[0].tx_buf = buf_tx; 289 xfer[0].len = sizeof(buf_tx->cmd); 290 291 xfer[1].rx_buf = buf_rx->data; 292 xfer[1].len = val_len + sizeof(buf_tx->crc); 293 spi_message_add_tail(&xfer[1], &msg); 294 } else { 295 xfer[0].tx_buf = buf_tx; 296 xfer[0].rx_buf = buf_rx; 297 xfer[0].len = sizeof(buf_tx->cmd) + val_len + 298 sizeof(buf_tx->crc); 299 300 if (MCP251XFD_SANITIZE_SPI) 301 memset(buf_tx->data, 0x0, val_len + 302 sizeof(buf_tx->crc)); 303 } 304 305 mcp251xfd_spi_cmd_read_crc(&buf_tx->cmd, reg, val_len); 306 307 for (i = 0; i < MCP251XFD_READ_CRC_RETRIES_MAX; i++) { 308 err = mcp251xfd_regmap_crc_read_one(priv, &msg, val_len); 309 if (!err) 310 goto out; 311 if (err != -EBADMSG) 312 return err; 313 314 /* MCP251XFD_REG_OSC is the first ever reg we read from. 315 * 316 * The chip may be in deep sleep and this SPI transfer 317 * (i.e. the assertion of the CS) will wake the chip 318 * up. This takes about 3ms. The CRC of this transfer 319 * is wrong. 320 * 321 * Or there isn't a chip at all, in this case the CRC 322 * will be wrong, too. 323 * 324 * In both cases ignore the CRC and copy the read data 325 * to the caller. It will take care of both cases. 326 * 327 */ 328 if (reg == MCP251XFD_REG_OSC) { 329 err = 0; 330 goto out; 331 } 332 333 netdev_info(priv->ndev, 334 "CRC read error at address 0x%04x (length=%zd, data=%*ph, CRC=0x%04x) retrying.\n", 335 reg, val_len, (int)val_len, buf_rx->data, 336 get_unaligned_be16(buf_rx->data + val_len)); 337 } 338 339 if (err) { 340 netdev_err(priv->ndev, 341 "CRC read error at address 0x%04x (length=%zd, data=%*ph, CRC=0x%04x).\n", 342 reg, val_len, (int)val_len, buf_rx->data, 343 get_unaligned_be16(buf_rx->data + val_len)); 344 345 return err; 346 } 347 out: 348 memcpy(val_buf, buf_rx->data, val_len); 349 350 return 0; 351 } 352 353 static const struct regmap_range mcp251xfd_reg_table_yes_range[] = { 354 regmap_reg_range(0x000, 0x2ec), /* CAN FD Controller Module SFR */ 355 regmap_reg_range(0x400, 0xbfc), /* RAM */ 356 regmap_reg_range(0xe00, 0xe14), /* MCP2517/18FD SFR */ 357 }; 358 359 static const struct regmap_access_table mcp251xfd_reg_table = { 360 .yes_ranges = mcp251xfd_reg_table_yes_range, 361 .n_yes_ranges = ARRAY_SIZE(mcp251xfd_reg_table_yes_range), 362 }; 363 364 static const struct regmap_config mcp251xfd_regmap_nocrc = { 365 .name = "nocrc", 366 .reg_bits = 16, 367 .reg_stride = 4, 368 .pad_bits = 0, 369 .val_bits = 32, 370 .max_register = 0xffc, 371 .wr_table = &mcp251xfd_reg_table, 372 .rd_table = &mcp251xfd_reg_table, 373 .cache_type = REGCACHE_NONE, 374 .read_flag_mask = (__force unsigned long) 375 cpu_to_be16(MCP251XFD_SPI_INSTRUCTION_READ), 376 .write_flag_mask = (__force unsigned long) 377 cpu_to_be16(MCP251XFD_SPI_INSTRUCTION_WRITE), 378 }; 379 380 static const struct regmap_bus mcp251xfd_bus_nocrc = { 381 .write = mcp251xfd_regmap_nocrc_write, 382 .gather_write = mcp251xfd_regmap_nocrc_gather_write, 383 .reg_update_bits = mcp251xfd_regmap_nocrc_update_bits, 384 .read = mcp251xfd_regmap_nocrc_read, 385 .reg_format_endian_default = REGMAP_ENDIAN_BIG, 386 .val_format_endian_default = REGMAP_ENDIAN_LITTLE, 387 .max_raw_read = sizeof_field(struct mcp251xfd_map_buf_nocrc, data), 388 .max_raw_write = sizeof_field(struct mcp251xfd_map_buf_nocrc, data), 389 }; 390 391 static const struct regmap_config mcp251xfd_regmap_crc = { 392 .name = "crc", 393 .reg_bits = 16, 394 .reg_stride = 4, 395 .pad_bits = 16, /* keep data bits aligned */ 396 .val_bits = 32, 397 .max_register = 0xffc, 398 .wr_table = &mcp251xfd_reg_table, 399 .rd_table = &mcp251xfd_reg_table, 400 .cache_type = REGCACHE_NONE, 401 }; 402 403 static const struct regmap_bus mcp251xfd_bus_crc = { 404 .write = mcp251xfd_regmap_crc_write, 405 .gather_write = mcp251xfd_regmap_crc_gather_write, 406 .read = mcp251xfd_regmap_crc_read, 407 .reg_format_endian_default = REGMAP_ENDIAN_NATIVE, 408 .val_format_endian_default = REGMAP_ENDIAN_LITTLE, 409 .max_raw_read = sizeof_field(struct mcp251xfd_map_buf_crc, data), 410 .max_raw_write = sizeof_field(struct mcp251xfd_map_buf_crc, data), 411 }; 412 413 static inline bool 414 mcp251xfd_regmap_use_nocrc(struct mcp251xfd_priv *priv) 415 { 416 return (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_REG)) || 417 (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX)); 418 } 419 420 static inline bool 421 mcp251xfd_regmap_use_crc(struct mcp251xfd_priv *priv) 422 { 423 return (priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_REG) || 424 (priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX); 425 } 426 427 static int 428 mcp251xfd_regmap_init_nocrc(struct mcp251xfd_priv *priv) 429 { 430 if (!priv->map_nocrc) { 431 struct regmap *map; 432 433 map = devm_regmap_init(&priv->spi->dev, &mcp251xfd_bus_nocrc, 434 priv->spi, &mcp251xfd_regmap_nocrc); 435 if (IS_ERR(map)) 436 return PTR_ERR(map); 437 438 priv->map_nocrc = map; 439 } 440 441 if (!priv->map_buf_nocrc_rx) { 442 priv->map_buf_nocrc_rx = 443 devm_kzalloc(&priv->spi->dev, 444 sizeof(*priv->map_buf_nocrc_rx), 445 GFP_KERNEL); 446 if (!priv->map_buf_nocrc_rx) 447 return -ENOMEM; 448 } 449 450 if (!priv->map_buf_nocrc_tx) { 451 priv->map_buf_nocrc_tx = 452 devm_kzalloc(&priv->spi->dev, 453 sizeof(*priv->map_buf_nocrc_tx), 454 GFP_KERNEL); 455 if (!priv->map_buf_nocrc_tx) 456 return -ENOMEM; 457 } 458 459 if (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_REG)) 460 priv->map_reg = priv->map_nocrc; 461 462 if (!(priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX)) 463 priv->map_rx = priv->map_nocrc; 464 465 return 0; 466 } 467 468 static void mcp251xfd_regmap_destroy_nocrc(struct mcp251xfd_priv *priv) 469 { 470 if (priv->map_buf_nocrc_rx) { 471 devm_kfree(&priv->spi->dev, priv->map_buf_nocrc_rx); 472 priv->map_buf_nocrc_rx = NULL; 473 } 474 if (priv->map_buf_nocrc_tx) { 475 devm_kfree(&priv->spi->dev, priv->map_buf_nocrc_tx); 476 priv->map_buf_nocrc_tx = NULL; 477 } 478 } 479 480 static int 481 mcp251xfd_regmap_init_crc(struct mcp251xfd_priv *priv) 482 { 483 if (!priv->map_crc) { 484 struct regmap *map; 485 486 map = devm_regmap_init(&priv->spi->dev, &mcp251xfd_bus_crc, 487 priv->spi, &mcp251xfd_regmap_crc); 488 if (IS_ERR(map)) 489 return PTR_ERR(map); 490 491 priv->map_crc = map; 492 } 493 494 if (!priv->map_buf_crc_rx) { 495 priv->map_buf_crc_rx = 496 devm_kzalloc(&priv->spi->dev, 497 sizeof(*priv->map_buf_crc_rx), 498 GFP_KERNEL); 499 if (!priv->map_buf_crc_rx) 500 return -ENOMEM; 501 } 502 503 if (!priv->map_buf_crc_tx) { 504 priv->map_buf_crc_tx = 505 devm_kzalloc(&priv->spi->dev, 506 sizeof(*priv->map_buf_crc_tx), 507 GFP_KERNEL); 508 if (!priv->map_buf_crc_tx) 509 return -ENOMEM; 510 } 511 512 if (priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_REG) 513 priv->map_reg = priv->map_crc; 514 515 if (priv->devtype_data.quirks & MCP251XFD_QUIRK_CRC_RX) 516 priv->map_rx = priv->map_crc; 517 518 return 0; 519 } 520 521 static void mcp251xfd_regmap_destroy_crc(struct mcp251xfd_priv *priv) 522 { 523 if (priv->map_buf_crc_rx) { 524 devm_kfree(&priv->spi->dev, priv->map_buf_crc_rx); 525 priv->map_buf_crc_rx = NULL; 526 } 527 if (priv->map_buf_crc_tx) { 528 devm_kfree(&priv->spi->dev, priv->map_buf_crc_tx); 529 priv->map_buf_crc_tx = NULL; 530 } 531 } 532 533 int mcp251xfd_regmap_init(struct mcp251xfd_priv *priv) 534 { 535 int err; 536 537 if (mcp251xfd_regmap_use_nocrc(priv)) { 538 err = mcp251xfd_regmap_init_nocrc(priv); 539 540 if (err) 541 return err; 542 } else { 543 mcp251xfd_regmap_destroy_nocrc(priv); 544 } 545 546 if (mcp251xfd_regmap_use_crc(priv)) { 547 err = mcp251xfd_regmap_init_crc(priv); 548 549 if (err) 550 return err; 551 } else { 552 mcp251xfd_regmap_destroy_crc(priv); 553 } 554 555 return 0; 556 } 557