1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Marvell Armada-3700 SPI controller driver 4 * 5 * Copyright (C) 2016 Marvell Ltd. 6 * 7 * Author: Wilson Ding <dingwei@marvell.com> 8 * Author: Romain Perier <romain.perier@free-electrons.com> 9 */ 10 11 #include <linux/clk.h> 12 #include <linux/completion.h> 13 #include <linux/delay.h> 14 #include <linux/err.h> 15 #include <linux/interrupt.h> 16 #include <linux/io.h> 17 #include <linux/kernel.h> 18 #include <linux/module.h> 19 #include <linux/of.h> 20 #include <linux/platform_device.h> 21 #include <linux/pinctrl/consumer.h> 22 #include <linux/spi/spi.h> 23 24 #define DRIVER_NAME "armada_3700_spi" 25 26 #define A3700_SPI_MAX_SPEED_HZ 100000000 27 #define A3700_SPI_MAX_PRESCALE 30 28 #define A3700_SPI_TIMEOUT 10 29 30 /* SPI Register Offest */ 31 #define A3700_SPI_IF_CTRL_REG 0x00 32 #define A3700_SPI_IF_CFG_REG 0x04 33 #define A3700_SPI_DATA_OUT_REG 0x08 34 #define A3700_SPI_DATA_IN_REG 0x0C 35 #define A3700_SPI_IF_INST_REG 0x10 36 #define A3700_SPI_IF_ADDR_REG 0x14 37 #define A3700_SPI_IF_RMODE_REG 0x18 38 #define A3700_SPI_IF_HDR_CNT_REG 0x1C 39 #define A3700_SPI_IF_DIN_CNT_REG 0x20 40 #define A3700_SPI_IF_TIME_REG 0x24 41 #define A3700_SPI_INT_STAT_REG 0x28 42 #define A3700_SPI_INT_MASK_REG 0x2C 43 44 /* A3700_SPI_IF_CTRL_REG */ 45 #define A3700_SPI_EN BIT(16) 46 #define A3700_SPI_ADDR_NOT_CONFIG BIT(12) 47 #define A3700_SPI_WFIFO_OVERFLOW BIT(11) 48 #define A3700_SPI_WFIFO_UNDERFLOW BIT(10) 49 #define A3700_SPI_RFIFO_OVERFLOW BIT(9) 50 #define A3700_SPI_RFIFO_UNDERFLOW BIT(8) 51 #define A3700_SPI_WFIFO_FULL BIT(7) 52 #define A3700_SPI_WFIFO_EMPTY BIT(6) 53 #define A3700_SPI_RFIFO_FULL BIT(5) 54 #define A3700_SPI_RFIFO_EMPTY BIT(4) 55 #define A3700_SPI_WFIFO_RDY BIT(3) 56 #define A3700_SPI_RFIFO_RDY BIT(2) 57 #define A3700_SPI_XFER_RDY BIT(1) 58 #define A3700_SPI_XFER_DONE BIT(0) 59 60 /* A3700_SPI_IF_CFG_REG */ 61 #define A3700_SPI_WFIFO_THRS BIT(28) 62 #define A3700_SPI_RFIFO_THRS BIT(24) 63 #define A3700_SPI_AUTO_CS BIT(20) 64 #define A3700_SPI_DMA_RD_EN BIT(18) 65 #define A3700_SPI_FIFO_MODE BIT(17) 66 #define A3700_SPI_SRST BIT(16) 67 #define A3700_SPI_XFER_START BIT(15) 68 #define A3700_SPI_XFER_STOP BIT(14) 69 #define A3700_SPI_INST_PIN BIT(13) 70 #define A3700_SPI_ADDR_PIN BIT(12) 71 #define A3700_SPI_DATA_PIN1 BIT(11) 72 #define A3700_SPI_DATA_PIN0 BIT(10) 73 #define A3700_SPI_FIFO_FLUSH BIT(9) 74 #define A3700_SPI_RW_EN BIT(8) 75 #define A3700_SPI_CLK_POL BIT(7) 76 #define A3700_SPI_CLK_PHA BIT(6) 77 #define A3700_SPI_BYTE_LEN BIT(5) 78 #define A3700_SPI_CLK_PRESCALE BIT(0) 79 #define A3700_SPI_CLK_PRESCALE_MASK (0x1f) 80 #define A3700_SPI_CLK_EVEN_OFFS (0x10) 81 82 #define A3700_SPI_WFIFO_THRS_BIT 28 83 #define A3700_SPI_RFIFO_THRS_BIT 24 84 #define A3700_SPI_FIFO_THRS_MASK 0x7 85 86 #define A3700_SPI_DATA_PIN_MASK 0x3 87 88 /* A3700_SPI_IF_HDR_CNT_REG */ 89 #define A3700_SPI_DUMMY_CNT_BIT 12 90 #define A3700_SPI_DUMMY_CNT_MASK 0x7 91 #define A3700_SPI_RMODE_CNT_BIT 8 92 #define A3700_SPI_RMODE_CNT_MASK 0x3 93 #define A3700_SPI_ADDR_CNT_BIT 4 94 #define A3700_SPI_ADDR_CNT_MASK 0x7 95 #define A3700_SPI_INSTR_CNT_BIT 0 96 #define A3700_SPI_INSTR_CNT_MASK 0x3 97 98 /* A3700_SPI_IF_TIME_REG */ 99 #define A3700_SPI_CLK_CAPT_EDGE BIT(7) 100 101 struct a3700_spi { 102 struct spi_controller *host; 103 void __iomem *base; 104 struct clk *clk; 105 unsigned int irq; 106 unsigned int flags; 107 bool xmit_data; 108 const u8 *tx_buf; 109 u8 *rx_buf; 110 size_t buf_len; 111 u8 byte_len; 112 u32 wait_mask; 113 struct completion done; 114 }; 115 116 static u32 spireg_read(struct a3700_spi *a3700_spi, u32 offset) 117 { 118 return readl(a3700_spi->base + offset); 119 } 120 121 static void spireg_write(struct a3700_spi *a3700_spi, u32 offset, u32 data) 122 { 123 writel(data, a3700_spi->base + offset); 124 } 125 126 static void a3700_spi_auto_cs_unset(struct a3700_spi *a3700_spi) 127 { 128 u32 val; 129 130 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 131 val &= ~A3700_SPI_AUTO_CS; 132 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 133 } 134 135 static void a3700_spi_activate_cs(struct a3700_spi *a3700_spi, unsigned int cs) 136 { 137 u32 val; 138 139 val = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG); 140 val |= (A3700_SPI_EN << cs); 141 spireg_write(a3700_spi, A3700_SPI_IF_CTRL_REG, val); 142 } 143 144 static void a3700_spi_deactivate_cs(struct a3700_spi *a3700_spi, 145 unsigned int cs) 146 { 147 u32 val; 148 149 val = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG); 150 val &= ~(A3700_SPI_EN << cs); 151 spireg_write(a3700_spi, A3700_SPI_IF_CTRL_REG, val); 152 } 153 154 static int a3700_spi_pin_mode_set(struct a3700_spi *a3700_spi, 155 unsigned int pin_mode, bool receiving) 156 { 157 u32 val; 158 159 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 160 val &= ~(A3700_SPI_INST_PIN | A3700_SPI_ADDR_PIN); 161 val &= ~(A3700_SPI_DATA_PIN0 | A3700_SPI_DATA_PIN1); 162 163 switch (pin_mode) { 164 case SPI_NBITS_SINGLE: 165 break; 166 case SPI_NBITS_DUAL: 167 val |= A3700_SPI_DATA_PIN0; 168 break; 169 case SPI_NBITS_QUAD: 170 val |= A3700_SPI_DATA_PIN1; 171 /* RX during address reception uses 4-pin */ 172 if (receiving) 173 val |= A3700_SPI_ADDR_PIN; 174 break; 175 default: 176 dev_err(&a3700_spi->host->dev, "wrong pin mode %u", pin_mode); 177 return -EINVAL; 178 } 179 180 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 181 182 return 0; 183 } 184 185 static void a3700_spi_fifo_mode_set(struct a3700_spi *a3700_spi, bool enable) 186 { 187 u32 val; 188 189 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 190 if (enable) 191 val |= A3700_SPI_FIFO_MODE; 192 else 193 val &= ~A3700_SPI_FIFO_MODE; 194 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 195 } 196 197 static void a3700_spi_mode_set(struct a3700_spi *a3700_spi, 198 unsigned int mode_bits) 199 { 200 u32 val; 201 202 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 203 204 if (mode_bits & SPI_CPOL) 205 val |= A3700_SPI_CLK_POL; 206 else 207 val &= ~A3700_SPI_CLK_POL; 208 209 if (mode_bits & SPI_CPHA) 210 val |= A3700_SPI_CLK_PHA; 211 else 212 val &= ~A3700_SPI_CLK_PHA; 213 214 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 215 } 216 217 static void a3700_spi_clock_set(struct a3700_spi *a3700_spi, 218 unsigned int speed_hz) 219 { 220 u32 val; 221 u32 prescale; 222 223 prescale = DIV_ROUND_UP(clk_get_rate(a3700_spi->clk), speed_hz); 224 225 /* For prescaler values over 15, we can only set it by steps of 2. 226 * Starting from A3700_SPI_CLK_EVEN_OFFS, we set values from 0 up to 227 * 30. We only use this range from 16 to 30. 228 */ 229 if (prescale > 15) 230 prescale = A3700_SPI_CLK_EVEN_OFFS + DIV_ROUND_UP(prescale, 2); 231 232 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 233 val = val & ~A3700_SPI_CLK_PRESCALE_MASK; 234 235 val = val | (prescale & A3700_SPI_CLK_PRESCALE_MASK); 236 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 237 238 if (prescale <= 2) { 239 val = spireg_read(a3700_spi, A3700_SPI_IF_TIME_REG); 240 val |= A3700_SPI_CLK_CAPT_EDGE; 241 spireg_write(a3700_spi, A3700_SPI_IF_TIME_REG, val); 242 } 243 } 244 245 static void a3700_spi_bytelen_set(struct a3700_spi *a3700_spi, unsigned int len) 246 { 247 u32 val; 248 249 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 250 if (len == 4) 251 val |= A3700_SPI_BYTE_LEN; 252 else 253 val &= ~A3700_SPI_BYTE_LEN; 254 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 255 256 a3700_spi->byte_len = len; 257 } 258 259 static int a3700_spi_fifo_flush(struct a3700_spi *a3700_spi) 260 { 261 int timeout = A3700_SPI_TIMEOUT; 262 u32 val; 263 264 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 265 val |= A3700_SPI_FIFO_FLUSH; 266 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 267 268 while (--timeout) { 269 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 270 if (!(val & A3700_SPI_FIFO_FLUSH)) 271 return 0; 272 udelay(1); 273 } 274 275 return -ETIMEDOUT; 276 } 277 278 static void a3700_spi_init(struct a3700_spi *a3700_spi) 279 { 280 struct spi_controller *host = a3700_spi->host; 281 u32 val; 282 int i; 283 284 /* Reset SPI unit */ 285 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 286 val |= A3700_SPI_SRST; 287 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 288 289 udelay(A3700_SPI_TIMEOUT); 290 291 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 292 val &= ~A3700_SPI_SRST; 293 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 294 295 /* Disable AUTO_CS and deactivate all chip-selects */ 296 a3700_spi_auto_cs_unset(a3700_spi); 297 for (i = 0; i < host->num_chipselect; i++) 298 a3700_spi_deactivate_cs(a3700_spi, i); 299 300 /* Enable FIFO mode */ 301 a3700_spi_fifo_mode_set(a3700_spi, true); 302 303 /* Set SPI mode */ 304 a3700_spi_mode_set(a3700_spi, host->mode_bits); 305 306 /* Reset counters */ 307 spireg_write(a3700_spi, A3700_SPI_IF_HDR_CNT_REG, 0); 308 spireg_write(a3700_spi, A3700_SPI_IF_DIN_CNT_REG, 0); 309 310 /* Mask the interrupts and clear cause bits */ 311 spireg_write(a3700_spi, A3700_SPI_INT_MASK_REG, 0); 312 spireg_write(a3700_spi, A3700_SPI_INT_STAT_REG, ~0U); 313 } 314 315 static irqreturn_t a3700_spi_interrupt(int irq, void *dev_id) 316 { 317 struct spi_controller *host = dev_id; 318 struct a3700_spi *a3700_spi; 319 u32 cause; 320 321 a3700_spi = spi_controller_get_devdata(host); 322 323 /* Get interrupt causes */ 324 cause = spireg_read(a3700_spi, A3700_SPI_INT_STAT_REG); 325 326 if (!cause || !(a3700_spi->wait_mask & cause)) 327 return IRQ_NONE; 328 329 /* mask and acknowledge the SPI interrupts */ 330 spireg_write(a3700_spi, A3700_SPI_INT_MASK_REG, 0); 331 spireg_write(a3700_spi, A3700_SPI_INT_STAT_REG, cause); 332 333 /* Wake up the transfer */ 334 complete(&a3700_spi->done); 335 336 return IRQ_HANDLED; 337 } 338 339 static bool a3700_spi_wait_completion(struct spi_device *spi) 340 { 341 struct a3700_spi *a3700_spi; 342 unsigned int timeout; 343 unsigned int ctrl_reg; 344 unsigned long timeout_jiffies; 345 346 a3700_spi = spi_controller_get_devdata(spi->controller); 347 348 /* SPI interrupt is edge-triggered, which means an interrupt will 349 * be generated only when detecting a specific status bit changed 350 * from '0' to '1'. So when we start waiting for a interrupt, we 351 * need to check status bit in control reg first, if it is already 1, 352 * then we do not need to wait for interrupt 353 */ 354 ctrl_reg = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG); 355 if (a3700_spi->wait_mask & ctrl_reg) 356 return true; 357 358 reinit_completion(&a3700_spi->done); 359 360 spireg_write(a3700_spi, A3700_SPI_INT_MASK_REG, 361 a3700_spi->wait_mask); 362 363 timeout_jiffies = msecs_to_jiffies(A3700_SPI_TIMEOUT); 364 timeout = wait_for_completion_timeout(&a3700_spi->done, 365 timeout_jiffies); 366 367 a3700_spi->wait_mask = 0; 368 369 if (timeout) 370 return true; 371 372 /* there might be the case that right after we checked the 373 * status bits in this routine and before start to wait for 374 * interrupt by wait_for_completion_timeout, the interrupt 375 * happens, to avoid missing it we need to double check 376 * status bits in control reg, if it is already 1, then 377 * consider that we have the interrupt successfully and 378 * return true. 379 */ 380 ctrl_reg = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG); 381 if (a3700_spi->wait_mask & ctrl_reg) 382 return true; 383 384 spireg_write(a3700_spi, A3700_SPI_INT_MASK_REG, 0); 385 386 /* Timeout was reached */ 387 return false; 388 } 389 390 static bool a3700_spi_transfer_wait(struct spi_device *spi, 391 unsigned int bit_mask) 392 { 393 struct a3700_spi *a3700_spi; 394 395 a3700_spi = spi_controller_get_devdata(spi->controller); 396 a3700_spi->wait_mask = bit_mask; 397 398 return a3700_spi_wait_completion(spi); 399 } 400 401 static void a3700_spi_fifo_thres_set(struct a3700_spi *a3700_spi, 402 unsigned int bytes) 403 { 404 u32 val; 405 406 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 407 val &= ~(A3700_SPI_FIFO_THRS_MASK << A3700_SPI_RFIFO_THRS_BIT); 408 val |= (bytes - 1) << A3700_SPI_RFIFO_THRS_BIT; 409 val &= ~(A3700_SPI_FIFO_THRS_MASK << A3700_SPI_WFIFO_THRS_BIT); 410 val |= (7 - bytes) << A3700_SPI_WFIFO_THRS_BIT; 411 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 412 } 413 414 static void a3700_spi_transfer_setup(struct spi_device *spi, 415 struct spi_transfer *xfer) 416 { 417 struct a3700_spi *a3700_spi; 418 419 a3700_spi = spi_controller_get_devdata(spi->controller); 420 421 a3700_spi_clock_set(a3700_spi, xfer->speed_hz); 422 423 /* Use 4 bytes long transfers. Each transfer method has its way to deal 424 * with the remaining bytes for non 4-bytes aligned transfers. 425 */ 426 a3700_spi_bytelen_set(a3700_spi, 4); 427 428 /* Initialize the working buffers */ 429 a3700_spi->tx_buf = xfer->tx_buf; 430 a3700_spi->rx_buf = xfer->rx_buf; 431 a3700_spi->buf_len = xfer->len; 432 } 433 434 static void a3700_spi_set_cs(struct spi_device *spi, bool enable) 435 { 436 struct a3700_spi *a3700_spi = spi_controller_get_devdata(spi->controller); 437 438 if (!enable) 439 a3700_spi_activate_cs(a3700_spi, spi_get_chipselect(spi, 0)); 440 else 441 a3700_spi_deactivate_cs(a3700_spi, spi_get_chipselect(spi, 0)); 442 } 443 444 static void a3700_spi_header_set(struct a3700_spi *a3700_spi) 445 { 446 unsigned int addr_cnt; 447 u32 val = 0; 448 449 /* Clear the header registers */ 450 spireg_write(a3700_spi, A3700_SPI_IF_INST_REG, 0); 451 spireg_write(a3700_spi, A3700_SPI_IF_ADDR_REG, 0); 452 spireg_write(a3700_spi, A3700_SPI_IF_RMODE_REG, 0); 453 spireg_write(a3700_spi, A3700_SPI_IF_HDR_CNT_REG, 0); 454 455 /* Set header counters */ 456 if (a3700_spi->tx_buf) { 457 /* 458 * when tx data is not 4 bytes aligned, there will be unexpected 459 * bytes out of SPI output register, since it always shifts out 460 * as whole 4 bytes. This might cause incorrect transaction with 461 * some devices. To avoid that, use SPI header count feature to 462 * transfer up to 3 bytes of data first, and then make the rest 463 * of data 4-byte aligned. 464 */ 465 addr_cnt = a3700_spi->buf_len % 4; 466 if (addr_cnt) { 467 val = (addr_cnt & A3700_SPI_ADDR_CNT_MASK) 468 << A3700_SPI_ADDR_CNT_BIT; 469 spireg_write(a3700_spi, A3700_SPI_IF_HDR_CNT_REG, val); 470 471 /* Update the buffer length to be transferred */ 472 a3700_spi->buf_len -= addr_cnt; 473 474 /* transfer 1~3 bytes through address count */ 475 val = 0; 476 while (addr_cnt--) { 477 val = (val << 8) | a3700_spi->tx_buf[0]; 478 a3700_spi->tx_buf++; 479 } 480 spireg_write(a3700_spi, A3700_SPI_IF_ADDR_REG, val); 481 } 482 } 483 } 484 485 static int a3700_is_wfifo_full(struct a3700_spi *a3700_spi) 486 { 487 u32 val; 488 489 val = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG); 490 return (val & A3700_SPI_WFIFO_FULL); 491 } 492 493 static int a3700_spi_fifo_write(struct a3700_spi *a3700_spi) 494 { 495 u32 val; 496 497 while (!a3700_is_wfifo_full(a3700_spi) && a3700_spi->buf_len) { 498 val = *(u32 *)a3700_spi->tx_buf; 499 spireg_write(a3700_spi, A3700_SPI_DATA_OUT_REG, cpu_to_le32(val)); 500 a3700_spi->buf_len -= 4; 501 a3700_spi->tx_buf += 4; 502 } 503 504 return 0; 505 } 506 507 static int a3700_is_rfifo_empty(struct a3700_spi *a3700_spi) 508 { 509 u32 val = spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG); 510 511 return (val & A3700_SPI_RFIFO_EMPTY); 512 } 513 514 static int a3700_spi_fifo_read(struct a3700_spi *a3700_spi) 515 { 516 u32 val; 517 518 while (!a3700_is_rfifo_empty(a3700_spi) && a3700_spi->buf_len) { 519 val = spireg_read(a3700_spi, A3700_SPI_DATA_IN_REG); 520 if (a3700_spi->buf_len >= 4) { 521 val = le32_to_cpu(val); 522 memcpy(a3700_spi->rx_buf, &val, 4); 523 524 a3700_spi->buf_len -= 4; 525 a3700_spi->rx_buf += 4; 526 } else { 527 /* 528 * When remain bytes is not larger than 4, we should 529 * avoid memory overwriting and just write the left rx 530 * buffer bytes. 531 */ 532 while (a3700_spi->buf_len) { 533 *a3700_spi->rx_buf = val & 0xff; 534 val >>= 8; 535 536 a3700_spi->buf_len--; 537 a3700_spi->rx_buf++; 538 } 539 } 540 } 541 542 return 0; 543 } 544 545 static void a3700_spi_transfer_abort_fifo(struct a3700_spi *a3700_spi) 546 { 547 int timeout = A3700_SPI_TIMEOUT; 548 u32 val; 549 550 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 551 val |= A3700_SPI_XFER_STOP; 552 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 553 554 while (--timeout) { 555 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 556 if (!(val & A3700_SPI_XFER_START)) 557 break; 558 udelay(1); 559 } 560 561 a3700_spi_fifo_flush(a3700_spi); 562 563 val &= ~A3700_SPI_XFER_STOP; 564 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 565 } 566 567 static int a3700_spi_prepare_message(struct spi_controller *host, 568 struct spi_message *message) 569 { 570 struct a3700_spi *a3700_spi = spi_controller_get_devdata(host); 571 struct spi_device *spi = message->spi; 572 int ret; 573 574 ret = clk_enable(a3700_spi->clk); 575 if (ret) { 576 dev_err(&spi->dev, "failed to enable clk with error %d\n", ret); 577 return ret; 578 } 579 580 /* Flush the FIFOs */ 581 ret = a3700_spi_fifo_flush(a3700_spi); 582 if (ret) 583 return ret; 584 585 a3700_spi_mode_set(a3700_spi, spi->mode); 586 587 return 0; 588 } 589 590 static int a3700_spi_transfer_one_fifo(struct spi_controller *host, 591 struct spi_device *spi, 592 struct spi_transfer *xfer) 593 { 594 struct a3700_spi *a3700_spi = spi_controller_get_devdata(host); 595 int ret = 0, timeout = A3700_SPI_TIMEOUT; 596 unsigned int nbits = 0, byte_len; 597 u32 val; 598 599 /* Make sure we use FIFO mode */ 600 a3700_spi_fifo_mode_set(a3700_spi, true); 601 602 /* Configure FIFO thresholds */ 603 byte_len = xfer->bits_per_word >> 3; 604 a3700_spi_fifo_thres_set(a3700_spi, byte_len); 605 606 if (xfer->tx_buf) 607 nbits = xfer->tx_nbits; 608 else if (xfer->rx_buf) 609 nbits = xfer->rx_nbits; 610 611 a3700_spi_pin_mode_set(a3700_spi, nbits, xfer->rx_buf ? true : false); 612 613 /* Flush the FIFOs */ 614 a3700_spi_fifo_flush(a3700_spi); 615 616 /* Transfer first bytes of data when buffer is not 4-byte aligned */ 617 a3700_spi_header_set(a3700_spi); 618 619 if (xfer->rx_buf) { 620 /* Clear WFIFO, since it's last 2 bytes are shifted out during 621 * a read operation 622 */ 623 spireg_write(a3700_spi, A3700_SPI_DATA_OUT_REG, 0); 624 625 /* Set read data length */ 626 spireg_write(a3700_spi, A3700_SPI_IF_DIN_CNT_REG, 627 a3700_spi->buf_len); 628 /* Start READ transfer */ 629 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 630 val &= ~A3700_SPI_RW_EN; 631 val |= A3700_SPI_XFER_START; 632 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 633 } else if (xfer->tx_buf) { 634 /* Start Write transfer */ 635 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 636 val |= (A3700_SPI_XFER_START | A3700_SPI_RW_EN); 637 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 638 639 /* 640 * If there are data to be written to the SPI device, xmit_data 641 * flag is set true; otherwise the instruction in SPI_INSTR does 642 * not require data to be written to the SPI device, then 643 * xmit_data flag is set false. 644 */ 645 a3700_spi->xmit_data = (a3700_spi->buf_len != 0); 646 } 647 648 while (a3700_spi->buf_len) { 649 if (a3700_spi->tx_buf) { 650 /* Wait wfifo ready */ 651 if (!a3700_spi_transfer_wait(spi, 652 A3700_SPI_WFIFO_RDY)) { 653 dev_err(&spi->dev, 654 "wait wfifo ready timed out\n"); 655 ret = -ETIMEDOUT; 656 goto error; 657 } 658 /* Fill up the wfifo */ 659 ret = a3700_spi_fifo_write(a3700_spi); 660 if (ret) 661 goto error; 662 } else if (a3700_spi->rx_buf) { 663 /* Wait rfifo ready */ 664 if (!a3700_spi_transfer_wait(spi, 665 A3700_SPI_RFIFO_RDY)) { 666 dev_err(&spi->dev, 667 "wait rfifo ready timed out\n"); 668 ret = -ETIMEDOUT; 669 goto error; 670 } 671 /* Drain out the rfifo */ 672 ret = a3700_spi_fifo_read(a3700_spi); 673 if (ret) 674 goto error; 675 } 676 } 677 678 /* 679 * Stop a write transfer in fifo mode: 680 * - wait all the bytes in wfifo to be shifted out 681 * - set XFER_STOP bit 682 * - wait XFER_START bit clear 683 * - clear XFER_STOP bit 684 * Stop a read transfer in fifo mode: 685 * - the hardware is to reset the XFER_START bit 686 * after the number of bytes indicated in DIN_CNT 687 * register 688 * - just wait XFER_START bit clear 689 */ 690 if (a3700_spi->tx_buf) { 691 if (a3700_spi->xmit_data) { 692 /* 693 * If there are data written to the SPI device, wait 694 * until SPI_WFIFO_EMPTY is 1 to wait for all data to 695 * transfer out of write FIFO. 696 */ 697 if (!a3700_spi_transfer_wait(spi, 698 A3700_SPI_WFIFO_EMPTY)) { 699 dev_err(&spi->dev, "wait wfifo empty timed out\n"); 700 return -ETIMEDOUT; 701 } 702 } 703 704 if (!a3700_spi_transfer_wait(spi, A3700_SPI_XFER_RDY)) { 705 dev_err(&spi->dev, "wait xfer ready timed out\n"); 706 return -ETIMEDOUT; 707 } 708 709 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 710 val |= A3700_SPI_XFER_STOP; 711 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 712 } 713 714 while (--timeout) { 715 val = spireg_read(a3700_spi, A3700_SPI_IF_CFG_REG); 716 if (!(val & A3700_SPI_XFER_START)) 717 break; 718 udelay(1); 719 } 720 721 if (timeout == 0) { 722 dev_err(&spi->dev, "wait transfer start clear timed out\n"); 723 ret = -ETIMEDOUT; 724 goto error; 725 } 726 727 val &= ~A3700_SPI_XFER_STOP; 728 spireg_write(a3700_spi, A3700_SPI_IF_CFG_REG, val); 729 goto out; 730 731 error: 732 a3700_spi_transfer_abort_fifo(a3700_spi); 733 out: 734 spi_finalize_current_transfer(host); 735 736 return ret; 737 } 738 739 static int a3700_spi_transfer_one_full_duplex(struct spi_controller *host, 740 struct spi_device *spi, 741 struct spi_transfer *xfer) 742 { 743 struct a3700_spi *a3700_spi = spi_controller_get_devdata(host); 744 u32 val; 745 746 /* Disable FIFO mode */ 747 a3700_spi_fifo_mode_set(a3700_spi, false); 748 749 while (a3700_spi->buf_len) { 750 751 /* When we have less than 4 bytes to transfer, switch to 1 byte 752 * mode. This is reset after each transfer 753 */ 754 if (a3700_spi->buf_len < 4) 755 a3700_spi_bytelen_set(a3700_spi, 1); 756 757 if (a3700_spi->byte_len == 1) 758 val = *a3700_spi->tx_buf; 759 else 760 val = *(u32 *)a3700_spi->tx_buf; 761 762 spireg_write(a3700_spi, A3700_SPI_DATA_OUT_REG, val); 763 764 /* Wait for all the data to be shifted in / out */ 765 while (!(spireg_read(a3700_spi, A3700_SPI_IF_CTRL_REG) & 766 A3700_SPI_XFER_DONE)) 767 cpu_relax(); 768 769 val = spireg_read(a3700_spi, A3700_SPI_DATA_IN_REG); 770 771 memcpy(a3700_spi->rx_buf, &val, a3700_spi->byte_len); 772 773 a3700_spi->buf_len -= a3700_spi->byte_len; 774 a3700_spi->tx_buf += a3700_spi->byte_len; 775 a3700_spi->rx_buf += a3700_spi->byte_len; 776 777 } 778 779 spi_finalize_current_transfer(host); 780 781 return 0; 782 } 783 784 static int a3700_spi_transfer_one(struct spi_controller *host, 785 struct spi_device *spi, 786 struct spi_transfer *xfer) 787 { 788 a3700_spi_transfer_setup(spi, xfer); 789 790 if (xfer->tx_buf && xfer->rx_buf) 791 return a3700_spi_transfer_one_full_duplex(host, spi, xfer); 792 793 return a3700_spi_transfer_one_fifo(host, spi, xfer); 794 } 795 796 static int a3700_spi_unprepare_message(struct spi_controller *host, 797 struct spi_message *message) 798 { 799 struct a3700_spi *a3700_spi = spi_controller_get_devdata(host); 800 801 clk_disable(a3700_spi->clk); 802 803 return 0; 804 } 805 806 static const struct of_device_id a3700_spi_dt_ids[] = { 807 { .compatible = "marvell,armada-3700-spi", .data = NULL }, 808 {}, 809 }; 810 811 MODULE_DEVICE_TABLE(of, a3700_spi_dt_ids); 812 813 static int a3700_spi_probe(struct platform_device *pdev) 814 { 815 struct device *dev = &pdev->dev; 816 struct device_node *of_node = dev->of_node; 817 struct spi_controller *host; 818 struct a3700_spi *spi; 819 u32 num_cs = 0; 820 int irq, ret = 0; 821 822 host = spi_alloc_host(dev, sizeof(*spi)); 823 if (!host) { 824 dev_err(dev, "host allocation failed\n"); 825 ret = -ENOMEM; 826 goto out; 827 } 828 829 if (of_property_read_u32(of_node, "num-cs", &num_cs)) { 830 dev_err(dev, "could not find num-cs\n"); 831 ret = -ENXIO; 832 goto error; 833 } 834 835 host->bus_num = pdev->id; 836 host->dev.of_node = of_node; 837 host->mode_bits = SPI_MODE_3; 838 host->num_chipselect = num_cs; 839 host->bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(32); 840 host->prepare_message = a3700_spi_prepare_message; 841 host->transfer_one = a3700_spi_transfer_one; 842 host->unprepare_message = a3700_spi_unprepare_message; 843 host->set_cs = a3700_spi_set_cs; 844 host->mode_bits |= (SPI_RX_DUAL | SPI_TX_DUAL | 845 SPI_RX_QUAD | SPI_TX_QUAD); 846 847 platform_set_drvdata(pdev, host); 848 849 spi = spi_controller_get_devdata(host); 850 851 spi->host = host; 852 853 spi->base = devm_platform_ioremap_resource(pdev, 0); 854 if (IS_ERR(spi->base)) { 855 ret = PTR_ERR(spi->base); 856 goto error; 857 } 858 859 irq = platform_get_irq(pdev, 0); 860 if (irq < 0) { 861 ret = -ENXIO; 862 goto error; 863 } 864 spi->irq = irq; 865 866 init_completion(&spi->done); 867 868 spi->clk = devm_clk_get(dev, NULL); 869 if (IS_ERR(spi->clk)) { 870 dev_err(dev, "could not find clk: %ld\n", PTR_ERR(spi->clk)); 871 goto error; 872 } 873 874 ret = clk_prepare(spi->clk); 875 if (ret) { 876 dev_err(dev, "could not prepare clk: %d\n", ret); 877 goto error; 878 } 879 880 host->max_speed_hz = min_t(unsigned long, A3700_SPI_MAX_SPEED_HZ, 881 clk_get_rate(spi->clk)); 882 host->min_speed_hz = DIV_ROUND_UP(clk_get_rate(spi->clk), 883 A3700_SPI_MAX_PRESCALE); 884 885 a3700_spi_init(spi); 886 887 ret = devm_request_irq(dev, spi->irq, a3700_spi_interrupt, 0, 888 dev_name(dev), host); 889 if (ret) { 890 dev_err(dev, "could not request IRQ: %d\n", ret); 891 goto error_clk; 892 } 893 894 ret = devm_spi_register_controller(dev, host); 895 if (ret) { 896 dev_err(dev, "Failed to register host\n"); 897 goto error_clk; 898 } 899 900 return 0; 901 902 error_clk: 903 clk_unprepare(spi->clk); 904 error: 905 spi_controller_put(host); 906 out: 907 return ret; 908 } 909 910 static void a3700_spi_remove(struct platform_device *pdev) 911 { 912 struct spi_controller *host = platform_get_drvdata(pdev); 913 struct a3700_spi *spi = spi_controller_get_devdata(host); 914 915 clk_unprepare(spi->clk); 916 } 917 918 static struct platform_driver a3700_spi_driver = { 919 .driver = { 920 .name = DRIVER_NAME, 921 .of_match_table = of_match_ptr(a3700_spi_dt_ids), 922 }, 923 .probe = a3700_spi_probe, 924 .remove_new = a3700_spi_remove, 925 }; 926 927 module_platform_driver(a3700_spi_driver); 928 929 MODULE_DESCRIPTION("Armada-3700 SPI driver"); 930 MODULE_AUTHOR("Wilson Ding <dingwei@marvell.com>"); 931 MODULE_LICENSE("GPL"); 932 MODULE_ALIAS("platform:" DRIVER_NAME); 933