1 /* 2 * APM X-Gene SLIMpro MailBox Driver 3 * 4 * Copyright (c) 2015, Applied Micro Circuits Corporation 5 * Author: Feng Kan fkan@apm.com 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License as 9 * published by the Free Software Foundation; either version 2 of 10 * the License, or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, see <http://www.gnu.org/licenses/>. 19 * 20 */ 21 #include <linux/acpi.h> 22 #include <linux/delay.h> 23 #include <linux/interrupt.h> 24 #include <linux/io.h> 25 #include <linux/mailbox_controller.h> 26 #include <linux/module.h> 27 #include <linux/of.h> 28 #include <linux/platform_device.h> 29 #include <linux/spinlock.h> 30 31 #define MBOX_CON_NAME "slimpro-mbox" 32 #define MBOX_REG_SET_OFFSET 0x1000 33 #define MBOX_CNT 8 34 #define MBOX_STATUS_AVAIL_MASK BIT(16) 35 #define MBOX_STATUS_ACK_MASK BIT(0) 36 37 /* Configuration and Status Registers */ 38 #define REG_DB_IN 0x00 39 #define REG_DB_DIN0 0x04 40 #define REG_DB_DIN1 0x08 41 #define REG_DB_OUT 0x10 42 #define REG_DB_DOUT0 0x14 43 #define REG_DB_DOUT1 0x18 44 #define REG_DB_STAT 0x20 45 #define REG_DB_STATMASK 0x24 46 47 /** 48 * X-Gene SlimPRO mailbox channel information 49 * 50 * @dev: Device to which it is attached 51 * @chan: Pointer to mailbox communication channel 52 * @reg: Base address to access channel registers 53 * @irq: Interrupt number of the channel 54 * @rx_msg: Received message storage 55 */ 56 struct slimpro_mbox_chan { 57 struct device *dev; 58 struct mbox_chan *chan; 59 void __iomem *reg; 60 int irq; 61 u32 rx_msg[3]; 62 }; 63 64 /** 65 * X-Gene SlimPRO Mailbox controller data 66 * 67 * X-Gene SlimPRO Mailbox controller has 8 commnunication channels. 68 * Each channel has a separate IRQ number assgined to it. 69 * 70 * @mb_ctrl: Representation of the commnunication channel controller 71 * @mc: Array of SlimPRO mailbox channels of the controller 72 * @chans: Array of mailbox communication channels 73 * 74 */ 75 struct slimpro_mbox { 76 struct mbox_controller mb_ctrl; 77 struct slimpro_mbox_chan mc[MBOX_CNT]; 78 struct mbox_chan chans[MBOX_CNT]; 79 }; 80 81 static void mb_chan_send_msg(struct slimpro_mbox_chan *mb_chan, u32 *msg) 82 { 83 writel(msg[1], mb_chan->reg + REG_DB_DOUT0); 84 writel(msg[2], mb_chan->reg + REG_DB_DOUT1); 85 writel(msg[0], mb_chan->reg + REG_DB_OUT); 86 } 87 88 static void mb_chan_recv_msg(struct slimpro_mbox_chan *mb_chan) 89 { 90 mb_chan->rx_msg[1] = readl(mb_chan->reg + REG_DB_DIN0); 91 mb_chan->rx_msg[2] = readl(mb_chan->reg + REG_DB_DIN1); 92 mb_chan->rx_msg[0] = readl(mb_chan->reg + REG_DB_IN); 93 } 94 95 static int mb_chan_status_ack(struct slimpro_mbox_chan *mb_chan) 96 { 97 u32 val = readl(mb_chan->reg + REG_DB_STAT); 98 99 if (val & MBOX_STATUS_ACK_MASK) { 100 writel(MBOX_STATUS_ACK_MASK, mb_chan->reg + REG_DB_STAT); 101 return 1; 102 } 103 return 0; 104 } 105 106 static int mb_chan_status_avail(struct slimpro_mbox_chan *mb_chan) 107 { 108 u32 val = readl(mb_chan->reg + REG_DB_STAT); 109 110 if (val & MBOX_STATUS_AVAIL_MASK) { 111 mb_chan_recv_msg(mb_chan); 112 writel(MBOX_STATUS_AVAIL_MASK, mb_chan->reg + REG_DB_STAT); 113 return 1; 114 } 115 return 0; 116 } 117 118 static irqreturn_t slimpro_mbox_irq(int irq, void *id) 119 { 120 struct slimpro_mbox_chan *mb_chan = id; 121 122 if (mb_chan_status_ack(mb_chan)) 123 mbox_chan_txdone(mb_chan->chan, 0); 124 125 if (mb_chan_status_avail(mb_chan)) 126 mbox_chan_received_data(mb_chan->chan, mb_chan->rx_msg); 127 128 return IRQ_HANDLED; 129 } 130 131 static int slimpro_mbox_send_data(struct mbox_chan *chan, void *msg) 132 { 133 struct slimpro_mbox_chan *mb_chan = chan->con_priv; 134 135 mb_chan_send_msg(mb_chan, msg); 136 return 0; 137 } 138 139 static int slimpro_mbox_startup(struct mbox_chan *chan) 140 { 141 struct slimpro_mbox_chan *mb_chan = chan->con_priv; 142 int rc; 143 u32 val; 144 145 rc = devm_request_irq(mb_chan->dev, mb_chan->irq, slimpro_mbox_irq, 0, 146 MBOX_CON_NAME, mb_chan); 147 if (unlikely(rc)) { 148 dev_err(mb_chan->dev, "failed to register mailbox interrupt %d\n", 149 mb_chan->irq); 150 return rc; 151 } 152 153 /* Enable HW interrupt */ 154 writel(MBOX_STATUS_ACK_MASK | MBOX_STATUS_AVAIL_MASK, 155 mb_chan->reg + REG_DB_STAT); 156 /* Unmask doorbell status interrupt */ 157 val = readl(mb_chan->reg + REG_DB_STATMASK); 158 val &= ~(MBOX_STATUS_ACK_MASK | MBOX_STATUS_AVAIL_MASK); 159 writel(val, mb_chan->reg + REG_DB_STATMASK); 160 161 return 0; 162 } 163 164 static void slimpro_mbox_shutdown(struct mbox_chan *chan) 165 { 166 struct slimpro_mbox_chan *mb_chan = chan->con_priv; 167 u32 val; 168 169 /* Mask doorbell status interrupt */ 170 val = readl(mb_chan->reg + REG_DB_STATMASK); 171 val |= (MBOX_STATUS_ACK_MASK | MBOX_STATUS_AVAIL_MASK); 172 writel(val, mb_chan->reg + REG_DB_STATMASK); 173 174 devm_free_irq(mb_chan->dev, mb_chan->irq, mb_chan); 175 } 176 177 static const struct mbox_chan_ops slimpro_mbox_ops = { 178 .send_data = slimpro_mbox_send_data, 179 .startup = slimpro_mbox_startup, 180 .shutdown = slimpro_mbox_shutdown, 181 }; 182 183 static int slimpro_mbox_probe(struct platform_device *pdev) 184 { 185 struct slimpro_mbox *ctx; 186 struct resource *regs; 187 void __iomem *mb_base; 188 int rc; 189 int i; 190 191 ctx = devm_kzalloc(&pdev->dev, sizeof(struct slimpro_mbox), GFP_KERNEL); 192 if (!ctx) 193 return -ENOMEM; 194 195 platform_set_drvdata(pdev, ctx); 196 197 regs = platform_get_resource(pdev, IORESOURCE_MEM, 0); 198 mb_base = devm_ioremap(&pdev->dev, regs->start, resource_size(regs)); 199 if (!mb_base) 200 return -ENOMEM; 201 202 /* Setup mailbox links */ 203 for (i = 0; i < MBOX_CNT; i++) { 204 ctx->mc[i].irq = platform_get_irq(pdev, i); 205 if (ctx->mc[i].irq < 0) { 206 if (i == 0) { 207 dev_err(&pdev->dev, "no available IRQ\n"); 208 return -EINVAL; 209 } 210 dev_info(&pdev->dev, "no IRQ for channel %d\n", i); 211 break; 212 } 213 214 ctx->mc[i].dev = &pdev->dev; 215 ctx->mc[i].reg = mb_base + i * MBOX_REG_SET_OFFSET; 216 ctx->mc[i].chan = &ctx->chans[i]; 217 ctx->chans[i].con_priv = &ctx->mc[i]; 218 } 219 220 /* Setup mailbox controller */ 221 ctx->mb_ctrl.dev = &pdev->dev; 222 ctx->mb_ctrl.chans = ctx->chans; 223 ctx->mb_ctrl.txdone_irq = true; 224 ctx->mb_ctrl.ops = &slimpro_mbox_ops; 225 ctx->mb_ctrl.num_chans = i; 226 227 rc = mbox_controller_register(&ctx->mb_ctrl); 228 if (rc) { 229 dev_err(&pdev->dev, 230 "APM X-Gene SLIMpro MailBox register failed:%d\n", rc); 231 return rc; 232 } 233 234 dev_info(&pdev->dev, "APM X-Gene SLIMpro MailBox registered\n"); 235 return 0; 236 } 237 238 static int slimpro_mbox_remove(struct platform_device *pdev) 239 { 240 struct slimpro_mbox *smb = platform_get_drvdata(pdev); 241 242 mbox_controller_unregister(&smb->mb_ctrl); 243 return 0; 244 } 245 246 static const struct of_device_id slimpro_of_match[] = { 247 {.compatible = "apm,xgene-slimpro-mbox" }, 248 { }, 249 }; 250 MODULE_DEVICE_TABLE(of, slimpro_of_match); 251 252 #ifdef CONFIG_ACPI 253 static const struct acpi_device_id slimpro_acpi_ids[] = { 254 {"APMC0D01", 0}, 255 {} 256 }; 257 MODULE_DEVICE_TABLE(acpi, slimpro_acpi_ids); 258 #endif 259 260 static struct platform_driver slimpro_mbox_driver = { 261 .probe = slimpro_mbox_probe, 262 .remove = slimpro_mbox_remove, 263 .driver = { 264 .name = "xgene-slimpro-mbox", 265 .of_match_table = of_match_ptr(slimpro_of_match), 266 .acpi_match_table = ACPI_PTR(slimpro_acpi_ids) 267 }, 268 }; 269 270 static int __init slimpro_mbox_init(void) 271 { 272 return platform_driver_register(&slimpro_mbox_driver); 273 } 274 275 static void __exit slimpro_mbox_exit(void) 276 { 277 platform_driver_unregister(&slimpro_mbox_driver); 278 } 279 280 subsys_initcall(slimpro_mbox_init); 281 module_exit(slimpro_mbox_exit); 282 283 MODULE_DESCRIPTION("APM X-Gene SLIMpro Mailbox Driver"); 284 MODULE_LICENSE("GPL"); 285