1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Lattice FPGA sysCONFIG interface functions independent of port type. 4 */ 5 6 #include <linux/delay.h> 7 #include <linux/fpga/fpga-mgr.h> 8 #include <linux/gpio/consumer.h> 9 #include <linux/iopoll.h> 10 11 #include "lattice-sysconfig.h" 12 sysconfig_cmd_write(struct sysconfig_priv * priv,const void * buf,size_t buf_len)13 static int sysconfig_cmd_write(struct sysconfig_priv *priv, const void *buf, 14 size_t buf_len) 15 { 16 return priv->command_transfer(priv, buf, buf_len, NULL, 0); 17 } 18 sysconfig_cmd_read(struct sysconfig_priv * priv,const void * tx_buf,size_t tx_len,void * rx_buf,size_t rx_len)19 static int sysconfig_cmd_read(struct sysconfig_priv *priv, const void *tx_buf, 20 size_t tx_len, void *rx_buf, size_t rx_len) 21 { 22 return priv->command_transfer(priv, tx_buf, tx_len, rx_buf, rx_len); 23 } 24 sysconfig_read_busy(struct sysconfig_priv * priv)25 static int sysconfig_read_busy(struct sysconfig_priv *priv) 26 { 27 const u8 lsc_check_busy[] = SYSCONFIG_LSC_CHECK_BUSY; 28 u8 busy; 29 int ret; 30 31 ret = sysconfig_cmd_read(priv, lsc_check_busy, sizeof(lsc_check_busy), 32 &busy, sizeof(busy)); 33 34 return ret ? : busy; 35 } 36 sysconfig_poll_busy(struct sysconfig_priv * priv)37 static int sysconfig_poll_busy(struct sysconfig_priv *priv) 38 { 39 int ret, busy; 40 41 ret = read_poll_timeout(sysconfig_read_busy, busy, busy <= 0, 42 SYSCONFIG_POLL_INTERVAL_US, 43 SYSCONFIG_POLL_BUSY_TIMEOUT_US, false, priv); 44 45 return ret ? : busy; 46 } 47 sysconfig_read_status(struct sysconfig_priv * priv,u32 * status)48 static int sysconfig_read_status(struct sysconfig_priv *priv, u32 *status) 49 { 50 const u8 lsc_read_status[] = SYSCONFIG_LSC_READ_STATUS; 51 __be32 device_status; 52 int ret; 53 54 ret = sysconfig_cmd_read(priv, lsc_read_status, sizeof(lsc_read_status), 55 &device_status, sizeof(device_status)); 56 if (ret) 57 return ret; 58 59 *status = be32_to_cpu(device_status); 60 61 return 0; 62 } 63 sysconfig_poll_status(struct sysconfig_priv * priv,u32 * status)64 static int sysconfig_poll_status(struct sysconfig_priv *priv, u32 *status) 65 { 66 int ret = sysconfig_poll_busy(priv); 67 68 if (ret) 69 return ret; 70 71 return sysconfig_read_status(priv, status); 72 } 73 sysconfig_poll_gpio(struct gpio_desc * gpio,bool is_active)74 static int sysconfig_poll_gpio(struct gpio_desc *gpio, bool is_active) 75 { 76 int ret, val; 77 78 ret = read_poll_timeout(gpiod_get_value, val, 79 val < 0 || !!val == is_active, 80 SYSCONFIG_POLL_INTERVAL_US, 81 SYSCONFIG_POLL_GPIO_TIMEOUT_US, false, gpio); 82 83 if (val < 0) 84 return val; 85 86 return ret; 87 } 88 sysconfig_gpio_refresh(struct sysconfig_priv * priv)89 static int sysconfig_gpio_refresh(struct sysconfig_priv *priv) 90 { 91 struct gpio_desc *program = priv->program; 92 struct gpio_desc *init = priv->init; 93 struct gpio_desc *done = priv->done; 94 int ret; 95 96 /* Enter init mode */ 97 gpiod_set_value(program, 1); 98 99 ret = sysconfig_poll_gpio(init, true); 100 if (!ret) 101 ret = sysconfig_poll_gpio(done, false); 102 103 if (ret) 104 return ret; 105 106 /* Enter program mode */ 107 gpiod_set_value(program, 0); 108 109 return sysconfig_poll_gpio(init, false); 110 } 111 sysconfig_lsc_refresh(struct sysconfig_priv * priv)112 static int sysconfig_lsc_refresh(struct sysconfig_priv *priv) 113 { 114 static const u8 lsc_refresh[] = SYSCONFIG_LSC_REFRESH; 115 int ret; 116 117 ret = sysconfig_cmd_write(priv, lsc_refresh, sizeof(lsc_refresh)); 118 if (ret) 119 return ret; 120 121 usleep_range(4000, 8000); 122 123 return 0; 124 } 125 sysconfig_refresh(struct sysconfig_priv * priv)126 static int sysconfig_refresh(struct sysconfig_priv *priv) 127 { 128 struct gpio_desc *program = priv->program; 129 struct gpio_desc *init = priv->init; 130 struct gpio_desc *done = priv->done; 131 132 if (program && init && done) 133 return sysconfig_gpio_refresh(priv); 134 135 return sysconfig_lsc_refresh(priv); 136 } 137 sysconfig_isc_enable(struct sysconfig_priv * priv)138 static int sysconfig_isc_enable(struct sysconfig_priv *priv) 139 { 140 u8 isc_enable[] = SYSCONFIG_ISC_ENABLE; 141 u32 status; 142 int ret; 143 144 ret = sysconfig_cmd_write(priv, isc_enable, sizeof(isc_enable)); 145 if (ret) 146 return ret; 147 148 ret = sysconfig_poll_status(priv, &status); 149 if (ret) 150 return ret; 151 152 if (status & SYSCONFIG_STATUS_FAIL) 153 return -EFAULT; 154 155 return 0; 156 } 157 sysconfig_isc_erase(struct sysconfig_priv * priv)158 static int sysconfig_isc_erase(struct sysconfig_priv *priv) 159 { 160 u8 isc_erase[] = SYSCONFIG_ISC_ERASE; 161 u32 status; 162 int ret; 163 164 ret = sysconfig_cmd_write(priv, isc_erase, sizeof(isc_erase)); 165 if (ret) 166 return ret; 167 168 ret = sysconfig_poll_status(priv, &status); 169 if (ret) 170 return ret; 171 172 if (status & SYSCONFIG_STATUS_FAIL) 173 return -EFAULT; 174 175 return 0; 176 } 177 sysconfig_isc_init(struct sysconfig_priv * priv)178 static int sysconfig_isc_init(struct sysconfig_priv *priv) 179 { 180 int ret = sysconfig_isc_enable(priv); 181 182 if (ret) 183 return ret; 184 185 return sysconfig_isc_erase(priv); 186 } 187 sysconfig_lsc_init_addr(struct sysconfig_priv * priv)188 static int sysconfig_lsc_init_addr(struct sysconfig_priv *priv) 189 { 190 const u8 lsc_init_addr[] = SYSCONFIG_LSC_INIT_ADDR; 191 192 return sysconfig_cmd_write(priv, lsc_init_addr, sizeof(lsc_init_addr)); 193 } 194 sysconfig_burst_write_init(struct sysconfig_priv * priv)195 static int sysconfig_burst_write_init(struct sysconfig_priv *priv) 196 { 197 return priv->bitstream_burst_write_init(priv); 198 } 199 sysconfig_burst_write_complete(struct sysconfig_priv * priv)200 static int sysconfig_burst_write_complete(struct sysconfig_priv *priv) 201 { 202 return priv->bitstream_burst_write_complete(priv); 203 } 204 sysconfig_bitstream_burst_write(struct sysconfig_priv * priv,const char * buf,size_t count)205 static int sysconfig_bitstream_burst_write(struct sysconfig_priv *priv, 206 const char *buf, size_t count) 207 { 208 int ret = priv->bitstream_burst_write(priv, buf, count); 209 210 if (ret) 211 sysconfig_burst_write_complete(priv); 212 213 return ret; 214 } 215 sysconfig_isc_disable(struct sysconfig_priv * priv)216 static int sysconfig_isc_disable(struct sysconfig_priv *priv) 217 { 218 const u8 isc_disable[] = SYSCONFIG_ISC_DISABLE; 219 220 return sysconfig_cmd_write(priv, isc_disable, sizeof(isc_disable)); 221 } 222 sysconfig_cleanup(struct sysconfig_priv * priv)223 static void sysconfig_cleanup(struct sysconfig_priv *priv) 224 { 225 sysconfig_isc_erase(priv); 226 sysconfig_refresh(priv); 227 } 228 sysconfig_isc_finish(struct sysconfig_priv * priv)229 static int sysconfig_isc_finish(struct sysconfig_priv *priv) 230 { 231 struct gpio_desc *done_gpio = priv->done; 232 u32 status; 233 int ret; 234 235 if (done_gpio) { 236 ret = sysconfig_isc_disable(priv); 237 if (ret) 238 return ret; 239 240 return sysconfig_poll_gpio(done_gpio, true); 241 } 242 243 ret = sysconfig_poll_status(priv, &status); 244 if (ret) 245 return ret; 246 247 if ((status & SYSCONFIG_STATUS_DONE) && 248 !(status & SYSCONFIG_STATUS_BUSY) && 249 !(status & SYSCONFIG_STATUS_ERR)) 250 return sysconfig_isc_disable(priv); 251 252 return -EFAULT; 253 } 254 sysconfig_ops_state(struct fpga_manager * mgr)255 static enum fpga_mgr_states sysconfig_ops_state(struct fpga_manager *mgr) 256 { 257 struct sysconfig_priv *priv = mgr->priv; 258 struct gpio_desc *done = priv->done; 259 u32 status; 260 int ret; 261 262 if (done && (gpiod_get_value(done) > 0)) 263 return FPGA_MGR_STATE_OPERATING; 264 265 ret = sysconfig_read_status(priv, &status); 266 if (!ret && (status & SYSCONFIG_STATUS_DONE)) 267 return FPGA_MGR_STATE_OPERATING; 268 269 return FPGA_MGR_STATE_UNKNOWN; 270 } 271 sysconfig_ops_write_init(struct fpga_manager * mgr,struct fpga_image_info * info,const char * buf,size_t count)272 static int sysconfig_ops_write_init(struct fpga_manager *mgr, 273 struct fpga_image_info *info, 274 const char *buf, size_t count) 275 { 276 struct sysconfig_priv *priv = mgr->priv; 277 struct device *dev = &mgr->dev; 278 int ret; 279 280 if (info->flags & FPGA_MGR_PARTIAL_RECONFIG) { 281 dev_err(dev, "Partial reconfiguration is not supported\n"); 282 return -EOPNOTSUPP; 283 } 284 285 /* Enter program mode */ 286 ret = sysconfig_refresh(priv); 287 if (ret) { 288 dev_err(dev, "Failed to go to program mode\n"); 289 return ret; 290 } 291 292 /* Enter ISC mode */ 293 ret = sysconfig_isc_init(priv); 294 if (ret) { 295 dev_err(dev, "Failed to go to ISC mode\n"); 296 return ret; 297 } 298 299 /* Initialize the Address Shift Register */ 300 ret = sysconfig_lsc_init_addr(priv); 301 if (ret) { 302 dev_err(dev, 303 "Failed to initialize the Address Shift Register\n"); 304 return ret; 305 } 306 307 /* Prepare for bitstream burst write */ 308 ret = sysconfig_burst_write_init(priv); 309 if (ret) 310 dev_err(dev, "Failed to prepare for bitstream burst write\n"); 311 312 return ret; 313 } 314 sysconfig_ops_write(struct fpga_manager * mgr,const char * buf,size_t count)315 static int sysconfig_ops_write(struct fpga_manager *mgr, const char *buf, 316 size_t count) 317 { 318 return sysconfig_bitstream_burst_write(mgr->priv, buf, count); 319 } 320 sysconfig_ops_write_complete(struct fpga_manager * mgr,struct fpga_image_info * info)321 static int sysconfig_ops_write_complete(struct fpga_manager *mgr, 322 struct fpga_image_info *info) 323 { 324 struct sysconfig_priv *priv = mgr->priv; 325 struct device *dev = &mgr->dev; 326 int ret; 327 328 ret = sysconfig_burst_write_complete(priv); 329 if (!ret) 330 ret = sysconfig_poll_busy(priv); 331 332 if (ret) { 333 dev_err(dev, "Error while waiting bitstream write to finish\n"); 334 goto fail; 335 } 336 337 ret = sysconfig_isc_finish(priv); 338 339 fail: 340 if (ret) 341 sysconfig_cleanup(priv); 342 343 return ret; 344 } 345 346 static const struct fpga_manager_ops sysconfig_fpga_mgr_ops = { 347 .state = sysconfig_ops_state, 348 .write_init = sysconfig_ops_write_init, 349 .write = sysconfig_ops_write, 350 .write_complete = sysconfig_ops_write_complete, 351 }; 352 sysconfig_probe(struct sysconfig_priv * priv)353 int sysconfig_probe(struct sysconfig_priv *priv) 354 { 355 struct gpio_desc *program, *init, *done; 356 struct device *dev = priv->dev; 357 struct fpga_manager *mgr; 358 359 if (!dev) 360 return -ENODEV; 361 362 if (!priv->command_transfer || 363 !priv->bitstream_burst_write_init || 364 !priv->bitstream_burst_write || 365 !priv->bitstream_burst_write_complete) { 366 dev_err(dev, "Essential callback is missing\n"); 367 return -EINVAL; 368 } 369 370 program = devm_gpiod_get_optional(dev, "program", GPIOD_OUT_LOW); 371 if (IS_ERR(program)) 372 return dev_err_probe(dev, PTR_ERR(program), 373 "Failed to get PROGRAM GPIO\n"); 374 375 init = devm_gpiod_get_optional(dev, "init", GPIOD_IN); 376 if (IS_ERR(init)) 377 return dev_err_probe(dev, PTR_ERR(init), 378 "Failed to get INIT GPIO\n"); 379 380 done = devm_gpiod_get_optional(dev, "done", GPIOD_IN); 381 if (IS_ERR(done)) 382 return dev_err_probe(dev, PTR_ERR(done), 383 "Failed to get DONE GPIO\n"); 384 385 priv->program = program; 386 priv->init = init; 387 priv->done = done; 388 389 mgr = devm_fpga_mgr_register(dev, "Lattice sysCONFIG FPGA Manager", 390 &sysconfig_fpga_mgr_ops, priv); 391 392 return PTR_ERR_OR_ZERO(mgr); 393 } 394 EXPORT_SYMBOL(sysconfig_probe); 395 396 MODULE_DESCRIPTION("Lattice sysCONFIG FPGA Manager Core"); 397 MODULE_LICENSE("GPL"); 398