1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * FPGA Freeze Bridge Controller 4 * 5 * Copyright (C) 2016 Altera Corporation. All rights reserved. 6 */ 7 #include <linux/delay.h> 8 #include <linux/io.h> 9 #include <linux/kernel.h> 10 #include <linux/of_device.h> 11 #include <linux/module.h> 12 #include <linux/fpga/fpga-bridge.h> 13 14 #define FREEZE_CSR_STATUS_OFFSET 0 15 #define FREEZE_CSR_CTRL_OFFSET 4 16 #define FREEZE_CSR_ILLEGAL_REQ_OFFSET 8 17 #define FREEZE_CSR_REG_VERSION 12 18 19 #define FREEZE_CSR_SUPPORTED_VERSION 2 20 #define FREEZE_CSR_OFFICIAL_VERSION 0xad000003 21 22 #define FREEZE_CSR_STATUS_FREEZE_REQ_DONE BIT(0) 23 #define FREEZE_CSR_STATUS_UNFREEZE_REQ_DONE BIT(1) 24 25 #define FREEZE_CSR_CTRL_FREEZE_REQ BIT(0) 26 #define FREEZE_CSR_CTRL_RESET_REQ BIT(1) 27 #define FREEZE_CSR_CTRL_UNFREEZE_REQ BIT(2) 28 29 #define FREEZE_BRIDGE_NAME "freeze" 30 31 struct altera_freeze_br_data { 32 struct device *dev; 33 void __iomem *base_addr; 34 bool enable; 35 }; 36 37 /* 38 * Poll status until status bit is set or we have a timeout. 39 */ 40 static int altera_freeze_br_req_ack(struct altera_freeze_br_data *priv, 41 u32 timeout, u32 req_ack) 42 { 43 struct device *dev = priv->dev; 44 void __iomem *csr_illegal_req_addr = priv->base_addr + 45 FREEZE_CSR_ILLEGAL_REQ_OFFSET; 46 u32 status, illegal, ctrl; 47 int ret = -ETIMEDOUT; 48 49 do { 50 illegal = readl(csr_illegal_req_addr); 51 if (illegal) { 52 dev_err(dev, "illegal request detected 0x%x", illegal); 53 54 writel(1, csr_illegal_req_addr); 55 56 illegal = readl(csr_illegal_req_addr); 57 if (illegal) 58 dev_err(dev, "illegal request not cleared 0x%x", 59 illegal); 60 61 ret = -EINVAL; 62 break; 63 } 64 65 status = readl(priv->base_addr + FREEZE_CSR_STATUS_OFFSET); 66 dev_dbg(dev, "%s %x %x\n", __func__, status, req_ack); 67 status &= req_ack; 68 if (status) { 69 ctrl = readl(priv->base_addr + FREEZE_CSR_CTRL_OFFSET); 70 dev_dbg(dev, "%s request %x acknowledged %x %x\n", 71 __func__, req_ack, status, ctrl); 72 ret = 0; 73 break; 74 } 75 76 udelay(1); 77 } while (timeout--); 78 79 if (ret == -ETIMEDOUT) 80 dev_err(dev, "%s timeout waiting for 0x%x\n", 81 __func__, req_ack); 82 83 return ret; 84 } 85 86 static int altera_freeze_br_do_freeze(struct altera_freeze_br_data *priv, 87 u32 timeout) 88 { 89 struct device *dev = priv->dev; 90 void __iomem *csr_ctrl_addr = priv->base_addr + 91 FREEZE_CSR_CTRL_OFFSET; 92 u32 status; 93 int ret; 94 95 status = readl(priv->base_addr + FREEZE_CSR_STATUS_OFFSET); 96 97 dev_dbg(dev, "%s %d %d\n", __func__, status, readl(csr_ctrl_addr)); 98 99 if (status & FREEZE_CSR_STATUS_FREEZE_REQ_DONE) { 100 dev_dbg(dev, "%s bridge already disabled %d\n", 101 __func__, status); 102 return 0; 103 } else if (!(status & FREEZE_CSR_STATUS_UNFREEZE_REQ_DONE)) { 104 dev_err(dev, "%s bridge not enabled %d\n", __func__, status); 105 return -EINVAL; 106 } 107 108 writel(FREEZE_CSR_CTRL_FREEZE_REQ, csr_ctrl_addr); 109 110 ret = altera_freeze_br_req_ack(priv, timeout, 111 FREEZE_CSR_STATUS_FREEZE_REQ_DONE); 112 113 if (ret) 114 writel(0, csr_ctrl_addr); 115 else 116 writel(FREEZE_CSR_CTRL_RESET_REQ, csr_ctrl_addr); 117 118 return ret; 119 } 120 121 static int altera_freeze_br_do_unfreeze(struct altera_freeze_br_data *priv, 122 u32 timeout) 123 { 124 struct device *dev = priv->dev; 125 void __iomem *csr_ctrl_addr = priv->base_addr + 126 FREEZE_CSR_CTRL_OFFSET; 127 u32 status; 128 int ret; 129 130 writel(0, csr_ctrl_addr); 131 132 status = readl(priv->base_addr + FREEZE_CSR_STATUS_OFFSET); 133 134 dev_dbg(dev, "%s %d %d\n", __func__, status, readl(csr_ctrl_addr)); 135 136 if (status & FREEZE_CSR_STATUS_UNFREEZE_REQ_DONE) { 137 dev_dbg(dev, "%s bridge already enabled %d\n", 138 __func__, status); 139 return 0; 140 } else if (!(status & FREEZE_CSR_STATUS_FREEZE_REQ_DONE)) { 141 dev_err(dev, "%s bridge not frozen %d\n", __func__, status); 142 return -EINVAL; 143 } 144 145 writel(FREEZE_CSR_CTRL_UNFREEZE_REQ, csr_ctrl_addr); 146 147 ret = altera_freeze_br_req_ack(priv, timeout, 148 FREEZE_CSR_STATUS_UNFREEZE_REQ_DONE); 149 150 status = readl(priv->base_addr + FREEZE_CSR_STATUS_OFFSET); 151 152 dev_dbg(dev, "%s %d %d\n", __func__, status, readl(csr_ctrl_addr)); 153 154 writel(0, csr_ctrl_addr); 155 156 return ret; 157 } 158 159 /* 160 * enable = 1 : allow traffic through the bridge 161 * enable = 0 : disable traffic through the bridge 162 */ 163 static int altera_freeze_br_enable_set(struct fpga_bridge *bridge, 164 bool enable) 165 { 166 struct altera_freeze_br_data *priv = bridge->priv; 167 struct fpga_image_info *info = bridge->info; 168 u32 timeout = 0; 169 int ret; 170 171 if (enable) { 172 if (info) 173 timeout = info->enable_timeout_us; 174 175 ret = altera_freeze_br_do_unfreeze(bridge->priv, timeout); 176 } else { 177 if (info) 178 timeout = info->disable_timeout_us; 179 180 ret = altera_freeze_br_do_freeze(bridge->priv, timeout); 181 } 182 183 if (!ret) 184 priv->enable = enable; 185 186 return ret; 187 } 188 189 static int altera_freeze_br_enable_show(struct fpga_bridge *bridge) 190 { 191 struct altera_freeze_br_data *priv = bridge->priv; 192 193 return priv->enable; 194 } 195 196 static const struct fpga_bridge_ops altera_freeze_br_br_ops = { 197 .enable_set = altera_freeze_br_enable_set, 198 .enable_show = altera_freeze_br_enable_show, 199 }; 200 201 static const struct of_device_id altera_freeze_br_of_match[] = { 202 { .compatible = "altr,freeze-bridge-controller", }, 203 {}, 204 }; 205 MODULE_DEVICE_TABLE(of, altera_freeze_br_of_match); 206 207 static int altera_freeze_br_probe(struct platform_device *pdev) 208 { 209 struct device *dev = &pdev->dev; 210 struct device_node *np = pdev->dev.of_node; 211 void __iomem *base_addr; 212 struct altera_freeze_br_data *priv; 213 struct fpga_bridge *br; 214 struct resource *res; 215 u32 status, revision; 216 217 if (!np) 218 return -ENODEV; 219 220 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 221 base_addr = devm_ioremap_resource(dev, res); 222 if (IS_ERR(base_addr)) 223 return PTR_ERR(base_addr); 224 225 revision = readl(base_addr + FREEZE_CSR_REG_VERSION); 226 if ((revision != FREEZE_CSR_SUPPORTED_VERSION) && 227 (revision != FREEZE_CSR_OFFICIAL_VERSION)) { 228 dev_err(dev, 229 "%s unexpected revision 0x%x != 0x%x != 0x%x\n", 230 __func__, revision, FREEZE_CSR_SUPPORTED_VERSION, 231 FREEZE_CSR_OFFICIAL_VERSION); 232 return -EINVAL; 233 } 234 235 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 236 if (!priv) 237 return -ENOMEM; 238 239 priv->dev = dev; 240 241 status = readl(base_addr + FREEZE_CSR_STATUS_OFFSET); 242 if (status & FREEZE_CSR_STATUS_UNFREEZE_REQ_DONE) 243 priv->enable = 1; 244 245 priv->base_addr = base_addr; 246 247 br = devm_fpga_bridge_create(dev, FREEZE_BRIDGE_NAME, 248 &altera_freeze_br_br_ops, priv); 249 if (!br) 250 return -ENOMEM; 251 252 platform_set_drvdata(pdev, br); 253 254 return fpga_bridge_register(br); 255 } 256 257 static int altera_freeze_br_remove(struct platform_device *pdev) 258 { 259 struct fpga_bridge *br = platform_get_drvdata(pdev); 260 261 fpga_bridge_unregister(br); 262 263 return 0; 264 } 265 266 static struct platform_driver altera_freeze_br_driver = { 267 .probe = altera_freeze_br_probe, 268 .remove = altera_freeze_br_remove, 269 .driver = { 270 .name = "altera_freeze_br", 271 .of_match_table = of_match_ptr(altera_freeze_br_of_match), 272 }, 273 }; 274 275 module_platform_driver(altera_freeze_br_driver); 276 277 MODULE_DESCRIPTION("Altera Freeze Bridge"); 278 MODULE_AUTHOR("Alan Tull <atull@opensource.altera.com>"); 279 MODULE_LICENSE("GPL v2"); 280