1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Socionext SPI flash controller F_OSPI driver 4 * Copyright (C) 2021 Socionext Inc. 5 */ 6 7 #include <linux/bitfield.h> 8 #include <linux/clk.h> 9 #include <linux/io.h> 10 #include <linux/iopoll.h> 11 #include <linux/module.h> 12 #include <linux/mutex.h> 13 #include <linux/of.h> 14 #include <linux/platform_device.h> 15 #include <linux/spi/spi.h> 16 #include <linux/spi/spi-mem.h> 17 18 /* Registers */ 19 #define OSPI_PROT_CTL_INDIR 0x00 20 #define OSPI_PROT_MODE_DATA_MASK GENMASK(31, 30) 21 #define OSPI_PROT_MODE_ALT_MASK GENMASK(29, 28) 22 #define OSPI_PROT_MODE_ADDR_MASK GENMASK(27, 26) 23 #define OSPI_PROT_MODE_CODE_MASK GENMASK(25, 24) 24 #define OSPI_PROT_MODE_SINGLE 0 25 #define OSPI_PROT_MODE_DUAL 1 26 #define OSPI_PROT_MODE_QUAD 2 27 #define OSPI_PROT_MODE_OCTAL 3 28 #define OSPI_PROT_DATA_RATE_DATA BIT(23) 29 #define OSPI_PROT_DATA_RATE_ALT BIT(22) 30 #define OSPI_PROT_DATA_RATE_ADDR BIT(21) 31 #define OSPI_PROT_DATA_RATE_CODE BIT(20) 32 #define OSPI_PROT_SDR 0 33 #define OSPI_PROT_DDR 1 34 #define OSPI_PROT_BIT_POS_DATA BIT(19) 35 #define OSPI_PROT_BIT_POS_ALT BIT(18) 36 #define OSPI_PROT_BIT_POS_ADDR BIT(17) 37 #define OSPI_PROT_BIT_POS_CODE BIT(16) 38 #define OSPI_PROT_SAMP_EDGE BIT(12) 39 #define OSPI_PROT_DATA_UNIT_MASK GENMASK(11, 10) 40 #define OSPI_PROT_DATA_UNIT_1B 0 41 #define OSPI_PROT_DATA_UNIT_2B 1 42 #define OSPI_PROT_DATA_UNIT_4B 3 43 #define OSPI_PROT_TRANS_DIR_WRITE BIT(9) 44 #define OSPI_PROT_DATA_EN BIT(8) 45 #define OSPI_PROT_ALT_SIZE_MASK GENMASK(7, 5) 46 #define OSPI_PROT_ADDR_SIZE_MASK GENMASK(4, 2) 47 #define OSPI_PROT_CODE_SIZE_MASK GENMASK(1, 0) 48 49 #define OSPI_CLK_CTL 0x10 50 #define OSPI_CLK_CTL_BOOT_INT_CLK_EN BIT(16) 51 #define OSPI_CLK_CTL_PHA BIT(12) 52 #define OSPI_CLK_CTL_PHA_180 0 53 #define OSPI_CLK_CTL_PHA_90 1 54 #define OSPI_CLK_CTL_DIV GENMASK(9, 8) 55 #define OSPI_CLK_CTL_DIV_1 0 56 #define OSPI_CLK_CTL_DIV_2 1 57 #define OSPI_CLK_CTL_DIV_4 2 58 #define OSPI_CLK_CTL_DIV_8 3 59 #define OSPI_CLK_CTL_INT_CLK_EN BIT(0) 60 61 #define OSPI_CS_CTL1 0x14 62 #define OSPI_CS_CTL2 0x18 63 #define OSPI_SSEL 0x20 64 #define OSPI_CMD_IDX_INDIR 0x40 65 #define OSPI_ADDR 0x50 66 #define OSPI_ALT_INDIR 0x60 67 #define OSPI_DMY_INDIR 0x70 68 #define OSPI_DAT 0x80 69 #define OSPI_DAT_SWP_INDIR 0x90 70 71 #define OSPI_DAT_SIZE_INDIR 0xA0 72 #define OSPI_DAT_SIZE_EN BIT(15) 73 #define OSPI_DAT_SIZE_MASK GENMASK(10, 0) 74 #define OSPI_DAT_SIZE_MAX (OSPI_DAT_SIZE_MASK + 1) 75 76 #define OSPI_TRANS_CTL 0xC0 77 #define OSPI_TRANS_CTL_STOP_REQ BIT(1) /* RW1AC */ 78 #define OSPI_TRANS_CTL_START_REQ BIT(0) /* RW1AC */ 79 80 #define OSPI_ACC_MODE 0xC4 81 #define OSPI_ACC_MODE_BOOT_DISABLE BIT(0) 82 83 #define OSPI_SWRST 0xD0 84 #define OSPI_SWRST_INDIR_WRITE_FIFO BIT(9) /* RW1AC */ 85 #define OSPI_SWRST_INDIR_READ_FIFO BIT(8) /* RW1AC */ 86 87 #define OSPI_STAT 0xE0 88 #define OSPI_STAT_IS_AXI_WRITING BIT(10) 89 #define OSPI_STAT_IS_AXI_READING BIT(9) 90 #define OSPI_STAT_IS_SPI_INT_CLK_STOP BIT(4) 91 #define OSPI_STAT_IS_SPI_IDLE BIT(3) 92 93 #define OSPI_IRQ 0xF0 94 #define OSPI_IRQ_CS_DEASSERT BIT(8) 95 #define OSPI_IRQ_WRITE_BUF_READY BIT(2) 96 #define OSPI_IRQ_READ_BUF_READY BIT(1) 97 #define OSPI_IRQ_CS_TRANS_COMP BIT(0) 98 #define OSPI_IRQ_ALL \ 99 (OSPI_IRQ_CS_DEASSERT | OSPI_IRQ_WRITE_BUF_READY \ 100 | OSPI_IRQ_READ_BUF_READY | OSPI_IRQ_CS_TRANS_COMP) 101 102 #define OSPI_IRQ_STAT_EN 0xF4 103 #define OSPI_IRQ_SIG_EN 0xF8 104 105 /* Parameters */ 106 #define OSPI_NUM_CS 4 107 #define OSPI_DUMMY_CYCLE_MAX 255 108 #define OSPI_WAIT_MAX_MSEC 100 109 110 struct f_ospi { 111 void __iomem *base; 112 struct device *dev; 113 struct clk *clk; 114 struct mutex mlock; 115 }; 116 117 static u32 f_ospi_get_dummy_cycle(const struct spi_mem_op *op) 118 { 119 return (op->dummy.nbytes * 8) / op->dummy.buswidth; 120 } 121 122 static void f_ospi_clear_irq(struct f_ospi *ospi) 123 { 124 writel(OSPI_IRQ_CS_DEASSERT | OSPI_IRQ_CS_TRANS_COMP, 125 ospi->base + OSPI_IRQ); 126 } 127 128 static void f_ospi_enable_irq_status(struct f_ospi *ospi, u32 irq_bits) 129 { 130 u32 val; 131 132 val = readl(ospi->base + OSPI_IRQ_STAT_EN); 133 val |= irq_bits; 134 writel(val, ospi->base + OSPI_IRQ_STAT_EN); 135 } 136 137 static void f_ospi_disable_irq_status(struct f_ospi *ospi, u32 irq_bits) 138 { 139 u32 val; 140 141 val = readl(ospi->base + OSPI_IRQ_STAT_EN); 142 val &= ~irq_bits; 143 writel(val, ospi->base + OSPI_IRQ_STAT_EN); 144 } 145 146 static void f_ospi_disable_irq_output(struct f_ospi *ospi, u32 irq_bits) 147 { 148 u32 val; 149 150 val = readl(ospi->base + OSPI_IRQ_SIG_EN); 151 val &= ~irq_bits; 152 writel(val, ospi->base + OSPI_IRQ_SIG_EN); 153 } 154 155 static int f_ospi_prepare_config(struct f_ospi *ospi) 156 { 157 u32 val, stat0, stat1; 158 159 /* G4: Disable internal clock */ 160 val = readl(ospi->base + OSPI_CLK_CTL); 161 val &= ~(OSPI_CLK_CTL_BOOT_INT_CLK_EN | OSPI_CLK_CTL_INT_CLK_EN); 162 writel(val, ospi->base + OSPI_CLK_CTL); 163 164 /* G5: Wait for stop */ 165 stat0 = OSPI_STAT_IS_AXI_WRITING | OSPI_STAT_IS_AXI_READING; 166 stat1 = OSPI_STAT_IS_SPI_IDLE | OSPI_STAT_IS_SPI_INT_CLK_STOP; 167 168 return readl_poll_timeout(ospi->base + OSPI_STAT, 169 val, (val & (stat0 | stat1)) == stat1, 170 0, OSPI_WAIT_MAX_MSEC); 171 } 172 173 static int f_ospi_unprepare_config(struct f_ospi *ospi) 174 { 175 u32 val; 176 177 /* G11: Enable internal clock */ 178 val = readl(ospi->base + OSPI_CLK_CTL); 179 val |= OSPI_CLK_CTL_BOOT_INT_CLK_EN | OSPI_CLK_CTL_INT_CLK_EN; 180 writel(val, ospi->base + OSPI_CLK_CTL); 181 182 /* G12: Wait for clock to start */ 183 return readl_poll_timeout(ospi->base + OSPI_STAT, 184 val, !(val & OSPI_STAT_IS_SPI_INT_CLK_STOP), 185 0, OSPI_WAIT_MAX_MSEC); 186 } 187 188 static void f_ospi_config_clk(struct f_ospi *ospi, u32 device_hz) 189 { 190 long rate_hz = clk_get_rate(ospi->clk); 191 u32 div = DIV_ROUND_UP(rate_hz, device_hz); 192 u32 div_reg; 193 u32 val; 194 195 if (rate_hz < device_hz) { 196 dev_warn(ospi->dev, "Device frequency too large: %d\n", 197 device_hz); 198 div_reg = OSPI_CLK_CTL_DIV_1; 199 } else { 200 if (div == 1) { 201 div_reg = OSPI_CLK_CTL_DIV_1; 202 } else if (div == 2) { 203 div_reg = OSPI_CLK_CTL_DIV_2; 204 } else if (div <= 4) { 205 div_reg = OSPI_CLK_CTL_DIV_4; 206 } else if (div <= 8) { 207 div_reg = OSPI_CLK_CTL_DIV_8; 208 } else { 209 dev_warn(ospi->dev, "Device frequency too small: %d\n", 210 device_hz); 211 div_reg = OSPI_CLK_CTL_DIV_8; 212 } 213 } 214 215 /* 216 * G7: Set clock mode 217 * clock phase is fixed at 180 degrees and configure edge direction 218 * instead. 219 */ 220 val = readl(ospi->base + OSPI_CLK_CTL); 221 222 val &= ~(OSPI_CLK_CTL_PHA | OSPI_CLK_CTL_DIV); 223 val |= FIELD_PREP(OSPI_CLK_CTL_PHA, OSPI_CLK_CTL_PHA_180) 224 | FIELD_PREP(OSPI_CLK_CTL_DIV, div_reg); 225 226 writel(val, ospi->base + OSPI_CLK_CTL); 227 } 228 229 static void f_ospi_config_dll(struct f_ospi *ospi) 230 { 231 /* G8: Configure DLL, nothing */ 232 } 233 234 static u8 f_ospi_get_mode(struct f_ospi *ospi, int width, int data_size) 235 { 236 u8 mode = OSPI_PROT_MODE_SINGLE; 237 238 switch (width) { 239 case 1: 240 mode = OSPI_PROT_MODE_SINGLE; 241 break; 242 case 2: 243 mode = OSPI_PROT_MODE_DUAL; 244 break; 245 case 4: 246 mode = OSPI_PROT_MODE_QUAD; 247 break; 248 case 8: 249 mode = OSPI_PROT_MODE_OCTAL; 250 break; 251 default: 252 if (data_size) 253 dev_err(ospi->dev, "Invalid buswidth: %d\n", width); 254 break; 255 } 256 257 return mode; 258 } 259 260 static void f_ospi_config_indir_protocol(struct f_ospi *ospi, 261 struct spi_mem *mem, 262 const struct spi_mem_op *op) 263 { 264 struct spi_device *spi = mem->spi; 265 u8 mode; 266 u32 prot = 0, val; 267 int unit; 268 269 /* Set one chip select */ 270 writel(BIT(spi_get_chipselect(spi, 0)), ospi->base + OSPI_SSEL); 271 272 mode = f_ospi_get_mode(ospi, op->cmd.buswidth, 1); 273 prot |= FIELD_PREP(OSPI_PROT_MODE_CODE_MASK, mode); 274 275 mode = f_ospi_get_mode(ospi, op->addr.buswidth, op->addr.nbytes); 276 prot |= FIELD_PREP(OSPI_PROT_MODE_ADDR_MASK, mode); 277 278 mode = f_ospi_get_mode(ospi, op->data.buswidth, op->data.nbytes); 279 prot |= FIELD_PREP(OSPI_PROT_MODE_DATA_MASK, mode); 280 281 prot |= FIELD_PREP(OSPI_PROT_DATA_RATE_DATA, OSPI_PROT_SDR); 282 prot |= FIELD_PREP(OSPI_PROT_DATA_RATE_ALT, OSPI_PROT_SDR); 283 prot |= FIELD_PREP(OSPI_PROT_DATA_RATE_ADDR, OSPI_PROT_SDR); 284 prot |= FIELD_PREP(OSPI_PROT_DATA_RATE_CODE, OSPI_PROT_SDR); 285 286 if (spi->mode & SPI_LSB_FIRST) 287 prot |= OSPI_PROT_BIT_POS_DATA | OSPI_PROT_BIT_POS_ALT 288 | OSPI_PROT_BIT_POS_ADDR | OSPI_PROT_BIT_POS_CODE; 289 290 if (spi->mode & SPI_CPHA) 291 prot |= OSPI_PROT_SAMP_EDGE; 292 293 /* Examine nbytes % 4 */ 294 switch (op->data.nbytes & 0x3) { 295 case 0: 296 unit = OSPI_PROT_DATA_UNIT_4B; 297 val = 0; 298 break; 299 case 2: 300 unit = OSPI_PROT_DATA_UNIT_2B; 301 val = OSPI_DAT_SIZE_EN | (op->data.nbytes - 1); 302 break; 303 default: 304 unit = OSPI_PROT_DATA_UNIT_1B; 305 val = OSPI_DAT_SIZE_EN | (op->data.nbytes - 1); 306 break; 307 } 308 prot |= FIELD_PREP(OSPI_PROT_DATA_UNIT_MASK, unit); 309 310 switch (op->data.dir) { 311 case SPI_MEM_DATA_IN: 312 prot |= OSPI_PROT_DATA_EN; 313 break; 314 315 case SPI_MEM_DATA_OUT: 316 prot |= OSPI_PROT_TRANS_DIR_WRITE | OSPI_PROT_DATA_EN; 317 break; 318 319 case SPI_MEM_NO_DATA: 320 prot |= OSPI_PROT_TRANS_DIR_WRITE; 321 break; 322 323 default: 324 dev_warn(ospi->dev, "Unsupported direction"); 325 break; 326 } 327 328 prot |= FIELD_PREP(OSPI_PROT_ADDR_SIZE_MASK, op->addr.nbytes); 329 prot |= FIELD_PREP(OSPI_PROT_CODE_SIZE_MASK, 1); /* 1byte */ 330 331 writel(prot, ospi->base + OSPI_PROT_CTL_INDIR); 332 writel(val, ospi->base + OSPI_DAT_SIZE_INDIR); 333 } 334 335 static int f_ospi_indir_prepare_op(struct f_ospi *ospi, struct spi_mem *mem, 336 const struct spi_mem_op *op) 337 { 338 u32 irq_stat_en; 339 int ret; 340 341 ret = f_ospi_prepare_config(ospi); 342 if (ret) 343 return ret; 344 345 f_ospi_config_clk(ospi, op->max_freq); 346 347 f_ospi_config_indir_protocol(ospi, mem, op); 348 349 writel(f_ospi_get_dummy_cycle(op), ospi->base + OSPI_DMY_INDIR); 350 writel(op->addr.val, ospi->base + OSPI_ADDR); 351 writel(op->cmd.opcode, ospi->base + OSPI_CMD_IDX_INDIR); 352 353 f_ospi_clear_irq(ospi); 354 355 switch (op->data.dir) { 356 case SPI_MEM_DATA_IN: 357 irq_stat_en = OSPI_IRQ_READ_BUF_READY | OSPI_IRQ_CS_TRANS_COMP; 358 break; 359 360 case SPI_MEM_DATA_OUT: 361 irq_stat_en = OSPI_IRQ_WRITE_BUF_READY | OSPI_IRQ_CS_TRANS_COMP; 362 break; 363 364 case SPI_MEM_NO_DATA: 365 irq_stat_en = OSPI_IRQ_CS_TRANS_COMP; 366 break; 367 368 default: 369 dev_warn(ospi->dev, "Unsupported direction"); 370 irq_stat_en = 0; 371 } 372 373 f_ospi_disable_irq_status(ospi, ~irq_stat_en); 374 f_ospi_enable_irq_status(ospi, irq_stat_en); 375 376 return f_ospi_unprepare_config(ospi); 377 } 378 379 static void f_ospi_indir_start_xfer(struct f_ospi *ospi) 380 { 381 /* Write only 1, auto cleared */ 382 writel(OSPI_TRANS_CTL_START_REQ, ospi->base + OSPI_TRANS_CTL); 383 } 384 385 static void f_ospi_indir_stop_xfer(struct f_ospi *ospi) 386 { 387 /* Write only 1, auto cleared */ 388 writel(OSPI_TRANS_CTL_STOP_REQ, ospi->base + OSPI_TRANS_CTL); 389 } 390 391 static int f_ospi_indir_wait_xfer_complete(struct f_ospi *ospi) 392 { 393 u32 val; 394 395 return readl_poll_timeout(ospi->base + OSPI_IRQ, val, 396 val & OSPI_IRQ_CS_TRANS_COMP, 397 0, OSPI_WAIT_MAX_MSEC); 398 } 399 400 static int f_ospi_indir_read(struct f_ospi *ospi, struct spi_mem *mem, 401 const struct spi_mem_op *op) 402 { 403 u8 *buf = op->data.buf.in; 404 u32 val; 405 int i, ret; 406 407 mutex_lock(&ospi->mlock); 408 409 /* E1-2: Prepare transfer operation */ 410 ret = f_ospi_indir_prepare_op(ospi, mem, op); 411 if (ret) 412 goto out; 413 414 f_ospi_indir_start_xfer(ospi); 415 416 /* E3-4: Wait for ready and read data */ 417 for (i = 0; i < op->data.nbytes; i++) { 418 ret = readl_poll_timeout(ospi->base + OSPI_IRQ, val, 419 val & OSPI_IRQ_READ_BUF_READY, 420 0, OSPI_WAIT_MAX_MSEC); 421 if (ret) 422 goto out; 423 424 buf[i] = readl(ospi->base + OSPI_DAT) & 0xFF; 425 } 426 427 /* E5-6: Stop transfer if data size is nothing */ 428 if (!(readl(ospi->base + OSPI_DAT_SIZE_INDIR) & OSPI_DAT_SIZE_EN)) 429 f_ospi_indir_stop_xfer(ospi); 430 431 /* E7-8: Wait for completion and clear */ 432 ret = f_ospi_indir_wait_xfer_complete(ospi); 433 if (ret) 434 goto out; 435 436 writel(OSPI_IRQ_CS_TRANS_COMP, ospi->base + OSPI_IRQ); 437 438 /* E9: Do nothing if data size is valid */ 439 if (readl(ospi->base + OSPI_DAT_SIZE_INDIR) & OSPI_DAT_SIZE_EN) 440 goto out; 441 442 /* E10-11: Reset and check read fifo */ 443 writel(OSPI_SWRST_INDIR_READ_FIFO, ospi->base + OSPI_SWRST); 444 445 ret = readl_poll_timeout(ospi->base + OSPI_SWRST, val, 446 !(val & OSPI_SWRST_INDIR_READ_FIFO), 447 0, OSPI_WAIT_MAX_MSEC); 448 out: 449 mutex_unlock(&ospi->mlock); 450 451 return ret; 452 } 453 454 static int f_ospi_indir_write(struct f_ospi *ospi, struct spi_mem *mem, 455 const struct spi_mem_op *op) 456 { 457 u8 *buf = (u8 *)op->data.buf.out; 458 u32 val; 459 int i, ret; 460 461 mutex_lock(&ospi->mlock); 462 463 /* F1-3: Prepare transfer operation */ 464 ret = f_ospi_indir_prepare_op(ospi, mem, op); 465 if (ret) 466 goto out; 467 468 f_ospi_indir_start_xfer(ospi); 469 470 if (!(readl(ospi->base + OSPI_PROT_CTL_INDIR) & OSPI_PROT_DATA_EN)) 471 goto nodata; 472 473 /* F4-5: Wait for buffer ready and write data */ 474 for (i = 0; i < op->data.nbytes; i++) { 475 ret = readl_poll_timeout(ospi->base + OSPI_IRQ, val, 476 val & OSPI_IRQ_WRITE_BUF_READY, 477 0, OSPI_WAIT_MAX_MSEC); 478 if (ret) 479 goto out; 480 481 writel(buf[i], ospi->base + OSPI_DAT); 482 } 483 484 /* F6-7: Stop transfer if data size is nothing */ 485 if (!(readl(ospi->base + OSPI_DAT_SIZE_INDIR) & OSPI_DAT_SIZE_EN)) 486 f_ospi_indir_stop_xfer(ospi); 487 488 nodata: 489 /* F8-9: Wait for completion and clear */ 490 ret = f_ospi_indir_wait_xfer_complete(ospi); 491 if (ret) 492 goto out; 493 494 writel(OSPI_IRQ_CS_TRANS_COMP, ospi->base + OSPI_IRQ); 495 out: 496 mutex_unlock(&ospi->mlock); 497 498 return ret; 499 } 500 501 static int f_ospi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op) 502 { 503 struct f_ospi *ospi = spi_controller_get_devdata(mem->spi->controller); 504 int err = 0; 505 506 switch (op->data.dir) { 507 case SPI_MEM_DATA_IN: 508 err = f_ospi_indir_read(ospi, mem, op); 509 break; 510 511 case SPI_MEM_DATA_OUT: 512 fallthrough; 513 case SPI_MEM_NO_DATA: 514 err = f_ospi_indir_write(ospi, mem, op); 515 break; 516 517 default: 518 dev_warn(ospi->dev, "Unsupported direction"); 519 err = -EOPNOTSUPP; 520 } 521 522 return err; 523 } 524 525 static bool f_ospi_supports_op_width(struct spi_mem *mem, 526 const struct spi_mem_op *op) 527 { 528 static const u8 width_available[] = { 0, 1, 2, 4, 8 }; 529 u8 width_op[] = { op->cmd.buswidth, op->addr.buswidth, 530 op->dummy.buswidth, op->data.buswidth }; 531 bool is_match_found; 532 int i, j; 533 534 for (i = 0; i < ARRAY_SIZE(width_op); i++) { 535 is_match_found = false; 536 537 for (j = 0; j < ARRAY_SIZE(width_available); j++) { 538 if (width_op[i] == width_available[j]) { 539 is_match_found = true; 540 break; 541 } 542 } 543 544 if (!is_match_found) 545 return false; 546 } 547 548 return true; 549 } 550 551 static bool f_ospi_supports_op(struct spi_mem *mem, 552 const struct spi_mem_op *op) 553 { 554 if (f_ospi_get_dummy_cycle(op) > OSPI_DUMMY_CYCLE_MAX) 555 return false; 556 557 if (op->addr.nbytes > 4) 558 return false; 559 560 if (!f_ospi_supports_op_width(mem, op)) 561 return false; 562 563 return spi_mem_default_supports_op(mem, op); 564 } 565 566 static int f_ospi_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op) 567 { 568 op->data.nbytes = min_t(int, op->data.nbytes, OSPI_DAT_SIZE_MAX); 569 570 return 0; 571 } 572 573 static const struct spi_controller_mem_ops f_ospi_mem_ops = { 574 .adjust_op_size = f_ospi_adjust_op_size, 575 .supports_op = f_ospi_supports_op, 576 .exec_op = f_ospi_exec_op, 577 }; 578 579 static const struct spi_controller_mem_caps f_ospi_mem_caps = { 580 .per_op_freq = true, 581 }; 582 583 static int f_ospi_init(struct f_ospi *ospi) 584 { 585 int ret; 586 587 ret = f_ospi_prepare_config(ospi); 588 if (ret) 589 return ret; 590 591 /* Disable boot signal */ 592 writel(OSPI_ACC_MODE_BOOT_DISABLE, ospi->base + OSPI_ACC_MODE); 593 594 f_ospi_config_dll(ospi); 595 596 /* Disable IRQ */ 597 f_ospi_clear_irq(ospi); 598 f_ospi_disable_irq_status(ospi, OSPI_IRQ_ALL); 599 f_ospi_disable_irq_output(ospi, OSPI_IRQ_ALL); 600 601 return f_ospi_unprepare_config(ospi); 602 } 603 604 static int f_ospi_probe(struct platform_device *pdev) 605 { 606 struct spi_controller *ctlr; 607 struct device *dev = &pdev->dev; 608 struct f_ospi *ospi; 609 u32 num_cs = OSPI_NUM_CS; 610 int ret; 611 612 ctlr = spi_alloc_host(dev, sizeof(*ospi)); 613 if (!ctlr) 614 return -ENOMEM; 615 616 ctlr->mode_bits = SPI_TX_DUAL | SPI_TX_QUAD | SPI_TX_OCTAL 617 | SPI_RX_DUAL | SPI_RX_QUAD | SPI_RX_OCTAL 618 | SPI_MODE_0 | SPI_MODE_1 | SPI_LSB_FIRST; 619 ctlr->mem_ops = &f_ospi_mem_ops; 620 ctlr->mem_caps = &f_ospi_mem_caps; 621 ctlr->bus_num = -1; 622 of_property_read_u32(dev->of_node, "num-cs", &num_cs); 623 if (num_cs > OSPI_NUM_CS) { 624 dev_err(dev, "num-cs too large: %d\n", num_cs); 625 return -ENOMEM; 626 } 627 ctlr->num_chipselect = num_cs; 628 ctlr->dev.of_node = dev->of_node; 629 630 ospi = spi_controller_get_devdata(ctlr); 631 ospi->dev = dev; 632 633 platform_set_drvdata(pdev, ospi); 634 635 ospi->base = devm_platform_ioremap_resource(pdev, 0); 636 if (IS_ERR(ospi->base)) { 637 ret = PTR_ERR(ospi->base); 638 goto err_put_ctlr; 639 } 640 641 ospi->clk = devm_clk_get_enabled(dev, NULL); 642 if (IS_ERR(ospi->clk)) { 643 ret = PTR_ERR(ospi->clk); 644 goto err_put_ctlr; 645 } 646 647 mutex_init(&ospi->mlock); 648 649 ret = f_ospi_init(ospi); 650 if (ret) 651 goto err_destroy_mutex; 652 653 ret = devm_spi_register_controller(dev, ctlr); 654 if (ret) 655 goto err_destroy_mutex; 656 657 return 0; 658 659 err_destroy_mutex: 660 mutex_destroy(&ospi->mlock); 661 662 err_put_ctlr: 663 spi_controller_put(ctlr); 664 665 return ret; 666 } 667 668 static void f_ospi_remove(struct platform_device *pdev) 669 { 670 struct f_ospi *ospi = platform_get_drvdata(pdev); 671 672 mutex_destroy(&ospi->mlock); 673 } 674 675 static const struct of_device_id f_ospi_dt_ids[] = { 676 { .compatible = "socionext,f-ospi" }, 677 {} 678 }; 679 MODULE_DEVICE_TABLE(of, f_ospi_dt_ids); 680 681 static struct platform_driver f_ospi_driver = { 682 .driver = { 683 .name = "socionext,f-ospi", 684 .of_match_table = f_ospi_dt_ids, 685 }, 686 .probe = f_ospi_probe, 687 .remove = f_ospi_remove, 688 }; 689 module_platform_driver(f_ospi_driver); 690 691 MODULE_DESCRIPTION("Socionext F_OSPI controller driver"); 692 MODULE_AUTHOR("Socionext Inc."); 693 MODULE_AUTHOR("Kunihiko Hayashi <hayashi.kunihiko@socionext.com>"); 694 MODULE_LICENSE("GPL"); 695