1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * STi Mailbox 4 * 5 * Copyright (C) 2015 ST Microelectronics 6 * 7 * Author: Lee Jones <lee.jones@linaro.org> for ST Microelectronics 8 * 9 * Based on the original driver written by; 10 * Alexandre Torgue, Olivier Lebreton and Loic Pallardy 11 */ 12 13 #include <linux/err.h> 14 #include <linux/interrupt.h> 15 #include <linux/io.h> 16 #include <linux/kernel.h> 17 #include <linux/mailbox_controller.h> 18 #include <linux/module.h> 19 #include <linux/of.h> 20 #include <linux/platform_device.h> 21 #include <linux/property.h> 22 #include <linux/slab.h> 23 24 #define STI_MBOX_INST_MAX 4 /* RAM saving: Max supported instances */ 25 #define STI_MBOX_CHAN_MAX 20 /* RAM saving: Max supported channels */ 26 27 #define STI_IRQ_VAL_OFFSET 0x04 /* Read interrupt status */ 28 #define STI_IRQ_SET_OFFSET 0x24 /* Generate a Tx channel interrupt */ 29 #define STI_IRQ_CLR_OFFSET 0x44 /* Clear pending Rx interrupts */ 30 #define STI_ENA_VAL_OFFSET 0x64 /* Read enable status */ 31 #define STI_ENA_SET_OFFSET 0x84 /* Enable a channel */ 32 #define STI_ENA_CLR_OFFSET 0xa4 /* Disable a channel */ 33 34 #define MBOX_BASE(mdev, inst) ((mdev)->base + ((inst) * 4)) 35 36 /** 37 * struct sti_mbox_device - STi Mailbox device data 38 * 39 * @dev: Device to which it is attached 40 * @mbox: Representation of a communication channel controller 41 * @base: Base address of the register mapping region 42 * @name: Name of the mailbox 43 * @enabled: Local copy of enabled channels 44 * @lock: Mutex protecting enabled status 45 * 46 * An IP Mailbox is currently composed of 4 instances 47 * Each instance is currently composed of 32 channels 48 * This means that we have 128 channels per Mailbox 49 * A channel an be used for TX or RX 50 */ 51 struct sti_mbox_device { 52 struct device *dev; 53 struct mbox_controller *mbox; 54 void __iomem *base; 55 const char *name; 56 u32 enabled[STI_MBOX_INST_MAX]; 57 spinlock_t lock; 58 }; 59 60 /** 61 * struct sti_mbox_pdata - STi Mailbox platform specific configuration 62 * 63 * @num_inst: Maximum number of instances in one HW Mailbox 64 * @num_chan: Maximum number of channel per instance 65 */ 66 struct sti_mbox_pdata { 67 unsigned int num_inst; 68 unsigned int num_chan; 69 }; 70 71 /** 72 * struct sti_channel - STi Mailbox allocated channel information 73 * 74 * @mdev: Pointer to parent Mailbox device 75 * @instance: Instance number channel resides in 76 * @channel: Channel number pertaining to this container 77 */ 78 struct sti_channel { 79 struct sti_mbox_device *mdev; 80 unsigned int instance; 81 unsigned int channel; 82 }; 83 84 static inline bool sti_mbox_channel_is_enabled(struct mbox_chan *chan) 85 { 86 struct sti_channel *chan_info = chan->con_priv; 87 struct sti_mbox_device *mdev = chan_info->mdev; 88 unsigned int instance = chan_info->instance; 89 unsigned int channel = chan_info->channel; 90 91 return mdev->enabled[instance] & BIT(channel); 92 } 93 94 static inline 95 struct mbox_chan *sti_mbox_to_channel(struct mbox_controller *mbox, 96 unsigned int instance, 97 unsigned int channel) 98 { 99 struct sti_channel *chan_info; 100 int i; 101 102 for (i = 0; i < mbox->num_chans; i++) { 103 chan_info = mbox->chans[i].con_priv; 104 if (chan_info && 105 chan_info->instance == instance && 106 chan_info->channel == channel) 107 return &mbox->chans[i]; 108 } 109 110 dev_err(mbox->dev, 111 "Channel not registered: instance: %d channel: %d\n", 112 instance, channel); 113 114 return NULL; 115 } 116 117 static void sti_mbox_enable_channel(struct mbox_chan *chan) 118 { 119 struct sti_channel *chan_info = chan->con_priv; 120 struct sti_mbox_device *mdev = chan_info->mdev; 121 unsigned int instance = chan_info->instance; 122 unsigned int channel = chan_info->channel; 123 unsigned long flags; 124 void __iomem *base = MBOX_BASE(mdev, instance); 125 126 spin_lock_irqsave(&mdev->lock, flags); 127 mdev->enabled[instance] |= BIT(channel); 128 writel_relaxed(BIT(channel), base + STI_ENA_SET_OFFSET); 129 spin_unlock_irqrestore(&mdev->lock, flags); 130 } 131 132 static void sti_mbox_disable_channel(struct mbox_chan *chan) 133 { 134 struct sti_channel *chan_info = chan->con_priv; 135 struct sti_mbox_device *mdev = chan_info->mdev; 136 unsigned int instance = chan_info->instance; 137 unsigned int channel = chan_info->channel; 138 unsigned long flags; 139 void __iomem *base = MBOX_BASE(mdev, instance); 140 141 spin_lock_irqsave(&mdev->lock, flags); 142 mdev->enabled[instance] &= ~BIT(channel); 143 writel_relaxed(BIT(channel), base + STI_ENA_CLR_OFFSET); 144 spin_unlock_irqrestore(&mdev->lock, flags); 145 } 146 147 static void sti_mbox_clear_irq(struct mbox_chan *chan) 148 { 149 struct sti_channel *chan_info = chan->con_priv; 150 struct sti_mbox_device *mdev = chan_info->mdev; 151 unsigned int instance = chan_info->instance; 152 unsigned int channel = chan_info->channel; 153 void __iomem *base = MBOX_BASE(mdev, instance); 154 155 writel_relaxed(BIT(channel), base + STI_IRQ_CLR_OFFSET); 156 } 157 158 static struct mbox_chan *sti_mbox_irq_to_channel(struct sti_mbox_device *mdev, 159 unsigned int instance) 160 { 161 struct mbox_controller *mbox = mdev->mbox; 162 struct mbox_chan *chan = NULL; 163 unsigned int channel; 164 unsigned long bits; 165 void __iomem *base = MBOX_BASE(mdev, instance); 166 167 bits = readl_relaxed(base + STI_IRQ_VAL_OFFSET); 168 if (!bits) 169 /* No IRQs fired in specified instance */ 170 return NULL; 171 172 /* An IRQ has fired, find the associated channel */ 173 for (channel = 0; bits; channel++) { 174 if (!test_and_clear_bit(channel, &bits)) 175 continue; 176 177 chan = sti_mbox_to_channel(mbox, instance, channel); 178 if (chan) { 179 dev_dbg(mbox->dev, 180 "IRQ fired on instance: %d channel: %d\n", 181 instance, channel); 182 break; 183 } 184 } 185 186 return chan; 187 } 188 189 static irqreturn_t sti_mbox_thread_handler(int irq, void *data) 190 { 191 struct sti_mbox_device *mdev = data; 192 struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev); 193 struct mbox_chan *chan; 194 unsigned int instance; 195 196 for (instance = 0; instance < pdata->num_inst; instance++) { 197 keep_looking: 198 chan = sti_mbox_irq_to_channel(mdev, instance); 199 if (!chan) 200 continue; 201 202 mbox_chan_received_data(chan, NULL); 203 sti_mbox_clear_irq(chan); 204 sti_mbox_enable_channel(chan); 205 goto keep_looking; 206 } 207 208 return IRQ_HANDLED; 209 } 210 211 static irqreturn_t sti_mbox_irq_handler(int irq, void *data) 212 { 213 struct sti_mbox_device *mdev = data; 214 struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev); 215 struct sti_channel *chan_info; 216 struct mbox_chan *chan; 217 unsigned int instance; 218 int ret = IRQ_NONE; 219 220 for (instance = 0; instance < pdata->num_inst; instance++) { 221 chan = sti_mbox_irq_to_channel(mdev, instance); 222 if (!chan) 223 continue; 224 chan_info = chan->con_priv; 225 226 if (!sti_mbox_channel_is_enabled(chan)) { 227 dev_warn(mdev->dev, 228 "Unexpected IRQ: %s\n" 229 " instance: %d: channel: %d [enabled: %x]\n", 230 mdev->name, chan_info->instance, 231 chan_info->channel, mdev->enabled[instance]); 232 233 /* Only handle IRQ if no other valid IRQs were found */ 234 if (ret == IRQ_NONE) 235 ret = IRQ_HANDLED; 236 continue; 237 } 238 239 sti_mbox_disable_channel(chan); 240 ret = IRQ_WAKE_THREAD; 241 } 242 243 if (ret == IRQ_NONE) 244 dev_err(mdev->dev, "Spurious IRQ - was a channel requested?\n"); 245 246 return ret; 247 } 248 249 static bool sti_mbox_tx_is_ready(struct mbox_chan *chan) 250 { 251 struct sti_channel *chan_info = chan->con_priv; 252 struct sti_mbox_device *mdev = chan_info->mdev; 253 unsigned int instance = chan_info->instance; 254 unsigned int channel = chan_info->channel; 255 void __iomem *base = MBOX_BASE(mdev, instance); 256 257 if (!(readl_relaxed(base + STI_ENA_VAL_OFFSET) & BIT(channel))) { 258 dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan: %d disabled\n", 259 mdev->name, instance, channel); 260 return false; 261 } 262 263 if (readl_relaxed(base + STI_IRQ_VAL_OFFSET) & BIT(channel)) { 264 dev_dbg(mdev->dev, "Mbox: %s: inst: %d, chan: %d not ready\n", 265 mdev->name, instance, channel); 266 return false; 267 } 268 269 return true; 270 } 271 272 static int sti_mbox_send_data(struct mbox_chan *chan, void *data) 273 { 274 struct sti_channel *chan_info = chan->con_priv; 275 struct sti_mbox_device *mdev = chan_info->mdev; 276 unsigned int instance = chan_info->instance; 277 unsigned int channel = chan_info->channel; 278 void __iomem *base = MBOX_BASE(mdev, instance); 279 280 /* Send event to co-processor */ 281 writel_relaxed(BIT(channel), base + STI_IRQ_SET_OFFSET); 282 283 dev_dbg(mdev->dev, 284 "Sent via Mailbox %s: instance: %d channel: %d\n", 285 mdev->name, instance, channel); 286 287 return 0; 288 } 289 290 static int sti_mbox_startup_chan(struct mbox_chan *chan) 291 { 292 sti_mbox_clear_irq(chan); 293 sti_mbox_enable_channel(chan); 294 295 return 0; 296 } 297 298 static void sti_mbox_shutdown_chan(struct mbox_chan *chan) 299 { 300 struct sti_channel *chan_info = chan->con_priv; 301 struct mbox_controller *mbox = chan_info->mdev->mbox; 302 int i; 303 304 for (i = 0; i < mbox->num_chans; i++) 305 if (chan == &mbox->chans[i]) 306 break; 307 308 if (mbox->num_chans == i) { 309 dev_warn(mbox->dev, "Request to free non-existent channel\n"); 310 return; 311 } 312 313 /* Reset channel */ 314 sti_mbox_disable_channel(chan); 315 sti_mbox_clear_irq(chan); 316 chan->con_priv = NULL; 317 } 318 319 static struct mbox_chan *sti_mbox_xlate(struct mbox_controller *mbox, 320 const struct of_phandle_args *spec) 321 { 322 struct sti_mbox_device *mdev = dev_get_drvdata(mbox->dev); 323 struct sti_mbox_pdata *pdata = dev_get_platdata(mdev->dev); 324 struct sti_channel *chan_info; 325 struct mbox_chan *chan = NULL; 326 unsigned int instance = spec->args[0]; 327 unsigned int channel = spec->args[1]; 328 int i; 329 330 /* Bounds checking */ 331 if (instance >= pdata->num_inst || channel >= pdata->num_chan) { 332 dev_err(mbox->dev, 333 "Invalid channel requested instance: %d channel: %d\n", 334 instance, channel); 335 return ERR_PTR(-EINVAL); 336 } 337 338 for (i = 0; i < mbox->num_chans; i++) { 339 chan_info = mbox->chans[i].con_priv; 340 341 /* Is requested channel free? */ 342 if (chan_info && 343 mbox->dev == chan_info->mdev->dev && 344 instance == chan_info->instance && 345 channel == chan_info->channel) { 346 347 dev_err(mbox->dev, "Channel in use\n"); 348 return ERR_PTR(-EBUSY); 349 } 350 351 /* 352 * Find the first free slot, then continue checking 353 * to see if requested channel is in use 354 */ 355 if (!chan && !chan_info) 356 chan = &mbox->chans[i]; 357 } 358 359 if (!chan) { 360 dev_err(mbox->dev, "No free channels left\n"); 361 return ERR_PTR(-EBUSY); 362 } 363 364 chan_info = devm_kzalloc(mbox->dev, sizeof(*chan_info), GFP_KERNEL); 365 if (!chan_info) 366 return ERR_PTR(-ENOMEM); 367 368 chan_info->mdev = mdev; 369 chan_info->instance = instance; 370 chan_info->channel = channel; 371 372 chan->con_priv = chan_info; 373 374 dev_info(mbox->dev, 375 "Mbox: %s: Created channel: instance: %d channel: %d\n", 376 mdev->name, instance, channel); 377 378 return chan; 379 } 380 381 static const struct mbox_chan_ops sti_mbox_ops = { 382 .startup = sti_mbox_startup_chan, 383 .shutdown = sti_mbox_shutdown_chan, 384 .send_data = sti_mbox_send_data, 385 .last_tx_done = sti_mbox_tx_is_ready, 386 }; 387 388 static const struct sti_mbox_pdata mbox_stih407_pdata = { 389 .num_inst = 4, 390 .num_chan = 32, 391 }; 392 393 static const struct of_device_id sti_mailbox_match[] = { 394 { 395 .compatible = "st,stih407-mailbox", 396 .data = (void *)&mbox_stih407_pdata 397 }, 398 { } 399 }; 400 MODULE_DEVICE_TABLE(of, sti_mailbox_match); 401 402 static int sti_mbox_probe(struct platform_device *pdev) 403 { 404 struct mbox_controller *mbox; 405 struct sti_mbox_device *mdev; 406 struct device_node *np = pdev->dev.of_node; 407 struct mbox_chan *chans; 408 int irq; 409 int ret; 410 411 pdev->dev.platform_data = (struct sti_mbox_pdata *)device_get_match_data(&pdev->dev); 412 if (!pdev->dev.platform_data) { 413 dev_err(&pdev->dev, "No configuration found\n"); 414 return -ENODEV; 415 } 416 417 mdev = devm_kzalloc(&pdev->dev, sizeof(*mdev), GFP_KERNEL); 418 if (!mdev) 419 return -ENOMEM; 420 421 platform_set_drvdata(pdev, mdev); 422 423 mdev->base = devm_platform_ioremap_resource(pdev, 0); 424 if (IS_ERR(mdev->base)) 425 return PTR_ERR(mdev->base); 426 427 ret = of_property_read_string(np, "mbox-name", &mdev->name); 428 if (ret) 429 mdev->name = np->full_name; 430 431 mbox = devm_kzalloc(&pdev->dev, sizeof(*mbox), GFP_KERNEL); 432 if (!mbox) 433 return -ENOMEM; 434 435 chans = devm_kcalloc(&pdev->dev, 436 STI_MBOX_CHAN_MAX, sizeof(*chans), GFP_KERNEL); 437 if (!chans) 438 return -ENOMEM; 439 440 mdev->dev = &pdev->dev; 441 mdev->mbox = mbox; 442 443 spin_lock_init(&mdev->lock); 444 445 /* STi Mailbox does not have a Tx-Done or Tx-Ready IRQ */ 446 mbox->txdone_irq = false; 447 mbox->txdone_poll = true; 448 mbox->txpoll_period = 100; 449 mbox->ops = &sti_mbox_ops; 450 mbox->dev = mdev->dev; 451 mbox->of_xlate = sti_mbox_xlate; 452 mbox->chans = chans; 453 mbox->num_chans = STI_MBOX_CHAN_MAX; 454 455 ret = devm_mbox_controller_register(&pdev->dev, mbox); 456 if (ret) 457 return ret; 458 459 /* It's okay for Tx Mailboxes to not supply IRQs */ 460 irq = platform_get_irq(pdev, 0); 461 if (irq < 0) { 462 dev_info(&pdev->dev, 463 "%s: Registered Tx only Mailbox\n", mdev->name); 464 return 0; 465 } 466 467 ret = devm_request_threaded_irq(&pdev->dev, irq, 468 sti_mbox_irq_handler, 469 sti_mbox_thread_handler, 470 IRQF_ONESHOT, mdev->name, mdev); 471 if (ret) { 472 dev_err(&pdev->dev, "Can't claim IRQ %d\n", irq); 473 return -EINVAL; 474 } 475 476 dev_info(&pdev->dev, "%s: Registered Tx/Rx Mailbox\n", mdev->name); 477 478 return 0; 479 } 480 481 static struct platform_driver sti_mbox_driver = { 482 .probe = sti_mbox_probe, 483 .driver = { 484 .name = "sti-mailbox", 485 .of_match_table = sti_mailbox_match, 486 }, 487 }; 488 module_platform_driver(sti_mbox_driver); 489 490 MODULE_LICENSE("GPL"); 491 MODULE_DESCRIPTION("STMicroelectronics Mailbox Controller"); 492 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org"); 493 MODULE_ALIAS("platform:mailbox-sti"); 494