1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Microchip PolarFire SoC (MPFS) system controller driver 4 * 5 * Copyright (c) 2020-2021 Microchip Corporation. All rights reserved. 6 * 7 * Author: Conor Dooley <conor.dooley@microchip.com> 8 * 9 */ 10 11 #include <linux/slab.h> 12 #include <linux/kref.h> 13 #include <linux/module.h> 14 #include <linux/interrupt.h> 15 #include <linux/of_platform.h> 16 #include <linux/mailbox_client.h> 17 #include <linux/platform_device.h> 18 #include <soc/microchip/mpfs.h> 19 20 static DEFINE_MUTEX(transaction_lock); 21 22 struct mpfs_sys_controller { 23 struct mbox_client client; 24 struct mbox_chan *chan; 25 struct completion c; 26 struct kref consumers; 27 }; 28 29 int mpfs_blocking_transaction(struct mpfs_sys_controller *sys_controller, struct mpfs_mss_msg *msg) 30 { 31 int ret, err; 32 33 err = mutex_lock_interruptible(&transaction_lock); 34 if (err) 35 return err; 36 37 reinit_completion(&sys_controller->c); 38 39 ret = mbox_send_message(sys_controller->chan, msg); 40 if (ret >= 0) { 41 if (wait_for_completion_timeout(&sys_controller->c, HZ)) { 42 ret = 0; 43 } else { 44 ret = -ETIMEDOUT; 45 dev_warn(sys_controller->client.dev, 46 "MPFS sys controller transaction timeout\n"); 47 } 48 } else { 49 dev_err(sys_controller->client.dev, 50 "mpfs sys controller transaction returned %d\n", ret); 51 } 52 53 mutex_unlock(&transaction_lock); 54 55 return ret; 56 } 57 EXPORT_SYMBOL(mpfs_blocking_transaction); 58 59 static void rx_callback(struct mbox_client *client, void *msg) 60 { 61 struct mpfs_sys_controller *sys_controller = 62 container_of(client, struct mpfs_sys_controller, client); 63 64 complete(&sys_controller->c); 65 } 66 67 static void mpfs_sys_controller_delete(struct kref *kref) 68 { 69 struct mpfs_sys_controller *sys_controller = container_of(kref, struct mpfs_sys_controller, 70 consumers); 71 72 mbox_free_channel(sys_controller->chan); 73 kfree(sys_controller); 74 } 75 76 void mpfs_sys_controller_put(void *data) 77 { 78 struct mpfs_sys_controller *sys_controller = data; 79 80 kref_put(&sys_controller->consumers, mpfs_sys_controller_delete); 81 } 82 EXPORT_SYMBOL(mpfs_sys_controller_put); 83 84 static struct platform_device subdevs[] = { 85 { 86 .name = "mpfs-rng", 87 .id = -1, 88 }, 89 { 90 .name = "mpfs-generic-service", 91 .id = -1, 92 } 93 }; 94 95 static int mpfs_sys_controller_probe(struct platform_device *pdev) 96 { 97 struct device *dev = &pdev->dev; 98 struct mpfs_sys_controller *sys_controller; 99 int i, ret; 100 101 sys_controller = kzalloc(sizeof(*sys_controller), GFP_KERNEL); 102 if (!sys_controller) 103 return -ENOMEM; 104 105 sys_controller->client.dev = dev; 106 sys_controller->client.rx_callback = rx_callback; 107 sys_controller->client.tx_block = 1U; 108 109 sys_controller->chan = mbox_request_channel(&sys_controller->client, 0); 110 if (IS_ERR(sys_controller->chan)) { 111 ret = dev_err_probe(dev, PTR_ERR(sys_controller->chan), 112 "Failed to get mbox channel\n"); 113 kfree(sys_controller); 114 return ret; 115 } 116 117 init_completion(&sys_controller->c); 118 kref_init(&sys_controller->consumers); 119 120 platform_set_drvdata(pdev, sys_controller); 121 122 dev_info(&pdev->dev, "Registered MPFS system controller\n"); 123 124 for (i = 0; i < ARRAY_SIZE(subdevs); i++) { 125 subdevs[i].dev.parent = dev; 126 if (platform_device_register(&subdevs[i])) 127 dev_warn(dev, "Error registering sub device %s\n", subdevs[i].name); 128 } 129 130 return 0; 131 } 132 133 static int mpfs_sys_controller_remove(struct platform_device *pdev) 134 { 135 struct mpfs_sys_controller *sys_controller = platform_get_drvdata(pdev); 136 137 mpfs_sys_controller_put(sys_controller); 138 139 return 0; 140 } 141 142 static const struct of_device_id mpfs_sys_controller_of_match[] = { 143 {.compatible = "microchip,mpfs-sys-controller", }, 144 {}, 145 }; 146 MODULE_DEVICE_TABLE(of, mpfs_sys_controller_of_match); 147 148 struct mpfs_sys_controller *mpfs_sys_controller_get(struct device *dev) 149 { 150 const struct of_device_id *match; 151 struct mpfs_sys_controller *sys_controller; 152 int ret; 153 154 if (!dev->parent) 155 goto err_no_device; 156 157 match = of_match_node(mpfs_sys_controller_of_match, dev->parent->of_node); 158 of_node_put(dev->parent->of_node); 159 if (!match) 160 goto err_no_device; 161 162 sys_controller = dev_get_drvdata(dev->parent); 163 if (!sys_controller) 164 goto err_bad_device; 165 166 if (!kref_get_unless_zero(&sys_controller->consumers)) 167 goto err_bad_device; 168 169 ret = devm_add_action_or_reset(dev, mpfs_sys_controller_put, sys_controller); 170 if (ret) 171 return ERR_PTR(ret); 172 173 return sys_controller; 174 175 err_no_device: 176 dev_dbg(dev, "Parent device was not an MPFS system controller\n"); 177 return ERR_PTR(-ENODEV); 178 179 err_bad_device: 180 dev_dbg(dev, "MPFS system controller found but could not register as a sub device\n"); 181 return ERR_PTR(-EPROBE_DEFER); 182 } 183 EXPORT_SYMBOL(mpfs_sys_controller_get); 184 185 static struct platform_driver mpfs_sys_controller_driver = { 186 .driver = { 187 .name = "mpfs-sys-controller", 188 .of_match_table = mpfs_sys_controller_of_match, 189 }, 190 .probe = mpfs_sys_controller_probe, 191 .remove = mpfs_sys_controller_remove, 192 }; 193 module_platform_driver(mpfs_sys_controller_driver); 194 195 MODULE_LICENSE("GPL v2"); 196 MODULE_AUTHOR("Conor Dooley <conor.dooley@microchip.com>"); 197 MODULE_DESCRIPTION("MPFS system controller driver"); 198