1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2015-2018, Intel Corporation. 4 */ 5 6 #define pr_fmt(fmt) "aspeed-kcs-bmc: " fmt 7 8 #include <linux/atomic.h> 9 #include <linux/errno.h> 10 #include <linux/interrupt.h> 11 #include <linux/io.h> 12 #include <linux/mfd/syscon.h> 13 #include <linux/module.h> 14 #include <linux/of.h> 15 #include <linux/of_address.h> 16 #include <linux/platform_device.h> 17 #include <linux/poll.h> 18 #include <linux/regmap.h> 19 #include <linux/sched.h> 20 #include <linux/slab.h> 21 #include <linux/timer.h> 22 23 #include "kcs_bmc.h" 24 25 26 #define DEVICE_NAME "ast-kcs-bmc" 27 28 #define KCS_CHANNEL_MAX 4 29 30 /* mapped to lpc-bmc@0 IO space */ 31 #define LPC_HICR0 0x000 32 #define LPC_HICR0_LPC3E BIT(7) 33 #define LPC_HICR0_LPC2E BIT(6) 34 #define LPC_HICR0_LPC1E BIT(5) 35 #define LPC_HICR2 0x008 36 #define LPC_HICR2_IBFIF3 BIT(3) 37 #define LPC_HICR2_IBFIF2 BIT(2) 38 #define LPC_HICR2_IBFIF1 BIT(1) 39 #define LPC_HICR4 0x010 40 #define LPC_HICR4_LADR12AS BIT(7) 41 #define LPC_HICR4_KCSENBL BIT(2) 42 #define LPC_LADR3H 0x014 43 #define LPC_LADR3L 0x018 44 #define LPC_LADR12H 0x01C 45 #define LPC_LADR12L 0x020 46 #define LPC_IDR1 0x024 47 #define LPC_IDR2 0x028 48 #define LPC_IDR3 0x02C 49 #define LPC_ODR1 0x030 50 #define LPC_ODR2 0x034 51 #define LPC_ODR3 0x038 52 #define LPC_STR1 0x03C 53 #define LPC_STR2 0x040 54 #define LPC_STR3 0x044 55 56 /* mapped to lpc-host@80 IO space */ 57 #define LPC_HICRB 0x080 58 #define LPC_HICRB_IBFIF4 BIT(1) 59 #define LPC_HICRB_LPC4E BIT(0) 60 #define LPC_LADR4 0x090 61 #define LPC_IDR4 0x094 62 #define LPC_ODR4 0x098 63 #define LPC_STR4 0x09C 64 65 struct aspeed_kcs_bmc { 66 struct regmap *map; 67 }; 68 69 70 static u8 aspeed_kcs_inb(struct kcs_bmc *kcs_bmc, u32 reg) 71 { 72 struct aspeed_kcs_bmc *priv = kcs_bmc_priv(kcs_bmc); 73 u32 val = 0; 74 int rc; 75 76 rc = regmap_read(priv->map, reg, &val); 77 WARN(rc != 0, "regmap_read() failed: %d\n", rc); 78 79 return rc == 0 ? (u8) val : 0; 80 } 81 82 static void aspeed_kcs_outb(struct kcs_bmc *kcs_bmc, u32 reg, u8 data) 83 { 84 struct aspeed_kcs_bmc *priv = kcs_bmc_priv(kcs_bmc); 85 int rc; 86 87 rc = regmap_write(priv->map, reg, data); 88 WARN(rc != 0, "regmap_write() failed: %d\n", rc); 89 } 90 91 92 /* 93 * AST_usrGuide_KCS.pdf 94 * 2. Background: 95 * we note D for Data, and C for Cmd/Status, default rules are 96 * A. KCS1 / KCS2 ( D / C:X / X+4 ) 97 * D / C : CA0h / CA4h 98 * D / C : CA8h / CACh 99 * B. KCS3 ( D / C:XX2h / XX3h ) 100 * D / C : CA2h / CA3h 101 * D / C : CB2h / CB3h 102 * C. KCS4 103 * D / C : CA4h / CA5h 104 */ 105 static void aspeed_kcs_set_address(struct kcs_bmc *kcs_bmc, u16 addr) 106 { 107 struct aspeed_kcs_bmc *priv = kcs_bmc_priv(kcs_bmc); 108 109 switch (kcs_bmc->channel) { 110 case 1: 111 regmap_update_bits(priv->map, LPC_HICR4, 112 LPC_HICR4_LADR12AS, 0); 113 regmap_write(priv->map, LPC_LADR12H, addr >> 8); 114 regmap_write(priv->map, LPC_LADR12L, addr & 0xFF); 115 break; 116 117 case 2: 118 regmap_update_bits(priv->map, LPC_HICR4, 119 LPC_HICR4_LADR12AS, LPC_HICR4_LADR12AS); 120 regmap_write(priv->map, LPC_LADR12H, addr >> 8); 121 regmap_write(priv->map, LPC_LADR12L, addr & 0xFF); 122 break; 123 124 case 3: 125 regmap_write(priv->map, LPC_LADR3H, addr >> 8); 126 regmap_write(priv->map, LPC_LADR3L, addr & 0xFF); 127 break; 128 129 case 4: 130 regmap_write(priv->map, LPC_LADR4, ((addr + 1) << 16) | 131 addr); 132 break; 133 134 default: 135 break; 136 } 137 } 138 139 static void aspeed_kcs_enable_channel(struct kcs_bmc *kcs_bmc, bool enable) 140 { 141 struct aspeed_kcs_bmc *priv = kcs_bmc_priv(kcs_bmc); 142 143 switch (kcs_bmc->channel) { 144 case 1: 145 if (enable) { 146 regmap_update_bits(priv->map, LPC_HICR2, 147 LPC_HICR2_IBFIF1, LPC_HICR2_IBFIF1); 148 regmap_update_bits(priv->map, LPC_HICR0, 149 LPC_HICR0_LPC1E, LPC_HICR0_LPC1E); 150 } else { 151 regmap_update_bits(priv->map, LPC_HICR0, 152 LPC_HICR0_LPC1E, 0); 153 regmap_update_bits(priv->map, LPC_HICR2, 154 LPC_HICR2_IBFIF1, 0); 155 } 156 break; 157 158 case 2: 159 if (enable) { 160 regmap_update_bits(priv->map, LPC_HICR2, 161 LPC_HICR2_IBFIF2, LPC_HICR2_IBFIF2); 162 regmap_update_bits(priv->map, LPC_HICR0, 163 LPC_HICR0_LPC2E, LPC_HICR0_LPC2E); 164 } else { 165 regmap_update_bits(priv->map, LPC_HICR0, 166 LPC_HICR0_LPC2E, 0); 167 regmap_update_bits(priv->map, LPC_HICR2, 168 LPC_HICR2_IBFIF2, 0); 169 } 170 break; 171 172 case 3: 173 if (enable) { 174 regmap_update_bits(priv->map, LPC_HICR2, 175 LPC_HICR2_IBFIF3, LPC_HICR2_IBFIF3); 176 regmap_update_bits(priv->map, LPC_HICR0, 177 LPC_HICR0_LPC3E, LPC_HICR0_LPC3E); 178 regmap_update_bits(priv->map, LPC_HICR4, 179 LPC_HICR4_KCSENBL, LPC_HICR4_KCSENBL); 180 } else { 181 regmap_update_bits(priv->map, LPC_HICR0, 182 LPC_HICR0_LPC3E, 0); 183 regmap_update_bits(priv->map, LPC_HICR4, 184 LPC_HICR4_KCSENBL, 0); 185 regmap_update_bits(priv->map, LPC_HICR2, 186 LPC_HICR2_IBFIF3, 0); 187 } 188 break; 189 190 case 4: 191 if (enable) 192 regmap_update_bits(priv->map, LPC_HICRB, 193 LPC_HICRB_IBFIF4 | LPC_HICRB_LPC4E, 194 LPC_HICRB_IBFIF4 | LPC_HICRB_LPC4E); 195 else 196 regmap_update_bits(priv->map, LPC_HICRB, 197 LPC_HICRB_IBFIF4 | LPC_HICRB_LPC4E, 198 0); 199 break; 200 201 default: 202 break; 203 } 204 } 205 206 static irqreturn_t aspeed_kcs_irq(int irq, void *arg) 207 { 208 struct kcs_bmc *kcs_bmc = arg; 209 210 if (!kcs_bmc_handle_event(kcs_bmc)) 211 return IRQ_HANDLED; 212 213 return IRQ_NONE; 214 } 215 216 static int aspeed_kcs_config_irq(struct kcs_bmc *kcs_bmc, 217 struct platform_device *pdev) 218 { 219 struct device *dev = &pdev->dev; 220 int irq; 221 222 irq = platform_get_irq(pdev, 0); 223 if (irq < 0) 224 return irq; 225 226 return devm_request_irq(dev, irq, aspeed_kcs_irq, IRQF_SHARED, 227 dev_name(dev), kcs_bmc); 228 } 229 230 static const struct kcs_ioreg ast_kcs_bmc_ioregs[KCS_CHANNEL_MAX] = { 231 { .idr = LPC_IDR1, .odr = LPC_ODR1, .str = LPC_STR1 }, 232 { .idr = LPC_IDR2, .odr = LPC_ODR2, .str = LPC_STR2 }, 233 { .idr = LPC_IDR3, .odr = LPC_ODR3, .str = LPC_STR3 }, 234 { .idr = LPC_IDR4, .odr = LPC_ODR4, .str = LPC_STR4 }, 235 }; 236 237 static struct kcs_bmc *aspeed_kcs_probe_of_v1(struct platform_device *pdev) 238 { 239 struct aspeed_kcs_bmc *priv; 240 struct device_node *np; 241 struct kcs_bmc *kcs; 242 u32 channel; 243 u32 slave; 244 int rc; 245 246 np = pdev->dev.of_node; 247 248 rc = of_property_read_u32(np, "kcs_chan", &channel); 249 if ((rc != 0) || (channel == 0 || channel > KCS_CHANNEL_MAX)) { 250 dev_err(&pdev->dev, "no valid 'kcs_chan' configured\n"); 251 return ERR_PTR(-EINVAL); 252 } 253 254 kcs = kcs_bmc_alloc(&pdev->dev, sizeof(struct aspeed_kcs_bmc), channel); 255 if (!kcs) 256 return ERR_PTR(-ENOMEM); 257 258 priv = kcs_bmc_priv(kcs); 259 priv->map = syscon_node_to_regmap(pdev->dev.parent->of_node); 260 if (IS_ERR(priv->map)) { 261 dev_err(&pdev->dev, "Couldn't get regmap\n"); 262 return ERR_PTR(-ENODEV); 263 } 264 265 rc = of_property_read_u32(np, "kcs_addr", &slave); 266 if (rc) { 267 dev_err(&pdev->dev, "no valid 'kcs_addr' configured\n"); 268 return ERR_PTR(-EINVAL); 269 } 270 271 kcs->ioreg = ast_kcs_bmc_ioregs[channel - 1]; 272 aspeed_kcs_set_address(kcs, slave); 273 274 return kcs; 275 } 276 277 static int aspeed_kcs_calculate_channel(const struct kcs_ioreg *regs) 278 { 279 int i; 280 281 for (i = 0; i < ARRAY_SIZE(ast_kcs_bmc_ioregs); i++) { 282 if (!memcmp(&ast_kcs_bmc_ioregs[i], regs, sizeof(*regs))) 283 return i + 1; 284 } 285 286 return -EINVAL; 287 } 288 289 static struct kcs_bmc *aspeed_kcs_probe_of_v2(struct platform_device *pdev) 290 { 291 struct aspeed_kcs_bmc *priv; 292 struct device_node *np; 293 struct kcs_ioreg ioreg; 294 struct kcs_bmc *kcs; 295 const __be32 *reg; 296 int channel; 297 u32 slave; 298 int rc; 299 300 np = pdev->dev.of_node; 301 302 /* Don't translate addresses, we want offsets for the regmaps */ 303 reg = of_get_address(np, 0, NULL, NULL); 304 if (!reg) 305 return ERR_PTR(-EINVAL); 306 ioreg.idr = be32_to_cpup(reg); 307 308 reg = of_get_address(np, 1, NULL, NULL); 309 if (!reg) 310 return ERR_PTR(-EINVAL); 311 ioreg.odr = be32_to_cpup(reg); 312 313 reg = of_get_address(np, 2, NULL, NULL); 314 if (!reg) 315 return ERR_PTR(-EINVAL); 316 ioreg.str = be32_to_cpup(reg); 317 318 channel = aspeed_kcs_calculate_channel(&ioreg); 319 if (channel < 0) 320 return ERR_PTR(channel); 321 322 kcs = kcs_bmc_alloc(&pdev->dev, sizeof(struct aspeed_kcs_bmc), channel); 323 if (!kcs) 324 return ERR_PTR(-ENOMEM); 325 326 kcs->ioreg = ioreg; 327 328 priv = kcs_bmc_priv(kcs); 329 priv->map = syscon_node_to_regmap(pdev->dev.parent->of_node); 330 if (IS_ERR(priv->map)) { 331 dev_err(&pdev->dev, "Couldn't get regmap\n"); 332 return ERR_PTR(-ENODEV); 333 } 334 335 rc = of_property_read_u32(np, "aspeed,lpc-io-reg", &slave); 336 if (rc) 337 return ERR_PTR(rc); 338 339 aspeed_kcs_set_address(kcs, slave); 340 341 return kcs; 342 } 343 344 static int aspeed_kcs_probe(struct platform_device *pdev) 345 { 346 struct device *dev = &pdev->dev; 347 struct kcs_bmc *kcs_bmc; 348 struct device_node *np; 349 int rc; 350 351 np = pdev->dev.of_node; 352 if (of_device_is_compatible(np, "aspeed,ast2400-kcs-bmc") || 353 of_device_is_compatible(np, "aspeed,ast2500-kcs-bmc")) 354 kcs_bmc = aspeed_kcs_probe_of_v1(pdev); 355 else if (of_device_is_compatible(np, "aspeed,ast2400-kcs-bmc-v2") || 356 of_device_is_compatible(np, "aspeed,ast2500-kcs-bmc-v2")) 357 kcs_bmc = aspeed_kcs_probe_of_v2(pdev); 358 else 359 return -EINVAL; 360 361 if (IS_ERR(kcs_bmc)) 362 return PTR_ERR(kcs_bmc); 363 364 kcs_bmc->io_inputb = aspeed_kcs_inb; 365 kcs_bmc->io_outputb = aspeed_kcs_outb; 366 367 rc = aspeed_kcs_config_irq(kcs_bmc, pdev); 368 if (rc) 369 return rc; 370 371 dev_set_drvdata(dev, kcs_bmc); 372 373 aspeed_kcs_enable_channel(kcs_bmc, true); 374 375 rc = misc_register(&kcs_bmc->miscdev); 376 if (rc) { 377 dev_err(dev, "Unable to register device\n"); 378 return rc; 379 } 380 381 dev_dbg(&pdev->dev, 382 "Probed KCS device %d (IDR=0x%x, ODR=0x%x, STR=0x%x)\n", 383 kcs_bmc->channel, kcs_bmc->ioreg.idr, kcs_bmc->ioreg.odr, 384 kcs_bmc->ioreg.str); 385 386 return 0; 387 } 388 389 static int aspeed_kcs_remove(struct platform_device *pdev) 390 { 391 struct kcs_bmc *kcs_bmc = dev_get_drvdata(&pdev->dev); 392 393 misc_deregister(&kcs_bmc->miscdev); 394 395 return 0; 396 } 397 398 static const struct of_device_id ast_kcs_bmc_match[] = { 399 { .compatible = "aspeed,ast2400-kcs-bmc" }, 400 { .compatible = "aspeed,ast2500-kcs-bmc" }, 401 { .compatible = "aspeed,ast2400-kcs-bmc-v2" }, 402 { .compatible = "aspeed,ast2500-kcs-bmc-v2" }, 403 { } 404 }; 405 MODULE_DEVICE_TABLE(of, ast_kcs_bmc_match); 406 407 static struct platform_driver ast_kcs_bmc_driver = { 408 .driver = { 409 .name = DEVICE_NAME, 410 .of_match_table = ast_kcs_bmc_match, 411 }, 412 .probe = aspeed_kcs_probe, 413 .remove = aspeed_kcs_remove, 414 }; 415 module_platform_driver(ast_kcs_bmc_driver); 416 417 MODULE_LICENSE("GPL v2"); 418 MODULE_AUTHOR("Haiyue Wang <haiyue.wang@linux.intel.com>"); 419 MODULE_DESCRIPTION("Aspeed device interface to the KCS BMC device"); 420