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 static 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 83 static struct platform_device subdevs[] = { 84 { 85 .name = "mpfs-rng", 86 .id = -1, 87 }, 88 { 89 .name = "mpfs-generic-service", 90 .id = -1, 91 } 92 }; 93 94 static int mpfs_sys_controller_probe(struct platform_device *pdev) 95 { 96 struct device *dev = &pdev->dev; 97 struct mpfs_sys_controller *sys_controller; 98 int i, ret; 99 100 sys_controller = kzalloc(sizeof(*sys_controller), GFP_KERNEL); 101 if (!sys_controller) 102 return -ENOMEM; 103 104 sys_controller->client.dev = dev; 105 sys_controller->client.rx_callback = rx_callback; 106 sys_controller->client.tx_block = 1U; 107 108 sys_controller->chan = mbox_request_channel(&sys_controller->client, 0); 109 if (IS_ERR(sys_controller->chan)) { 110 ret = dev_err_probe(dev, PTR_ERR(sys_controller->chan), 111 "Failed to get mbox channel\n"); 112 kfree(sys_controller); 113 return ret; 114 } 115 116 init_completion(&sys_controller->c); 117 kref_init(&sys_controller->consumers); 118 119 platform_set_drvdata(pdev, sys_controller); 120 121 dev_info(&pdev->dev, "Registered MPFS system controller\n"); 122 123 for (i = 0; i < ARRAY_SIZE(subdevs); i++) { 124 subdevs[i].dev.parent = dev; 125 if (platform_device_register(&subdevs[i])) 126 dev_warn(dev, "Error registering sub device %s\n", subdevs[i].name); 127 } 128 129 return 0; 130 } 131 132 static int mpfs_sys_controller_remove(struct platform_device *pdev) 133 { 134 struct mpfs_sys_controller *sys_controller = platform_get_drvdata(pdev); 135 136 mpfs_sys_controller_put(sys_controller); 137 138 return 0; 139 } 140 141 static const struct of_device_id mpfs_sys_controller_of_match[] = { 142 {.compatible = "microchip,mpfs-sys-controller", }, 143 {}, 144 }; 145 MODULE_DEVICE_TABLE(of, mpfs_sys_controller_of_match); 146 147 struct mpfs_sys_controller *mpfs_sys_controller_get(struct device *dev) 148 { 149 const struct of_device_id *match; 150 struct mpfs_sys_controller *sys_controller; 151 int ret; 152 153 if (!dev->parent) 154 goto err_no_device; 155 156 match = of_match_node(mpfs_sys_controller_of_match, dev->parent->of_node); 157 of_node_put(dev->parent->of_node); 158 if (!match) 159 goto err_no_device; 160 161 sys_controller = dev_get_drvdata(dev->parent); 162 if (!sys_controller) 163 goto err_bad_device; 164 165 if (!kref_get_unless_zero(&sys_controller->consumers)) 166 goto err_bad_device; 167 168 ret = devm_add_action_or_reset(dev, mpfs_sys_controller_put, sys_controller); 169 if (ret) 170 return ERR_PTR(ret); 171 172 return sys_controller; 173 174 err_no_device: 175 dev_dbg(dev, "Parent device was not an MPFS system controller\n"); 176 return ERR_PTR(-ENODEV); 177 178 err_bad_device: 179 dev_dbg(dev, "MPFS system controller found but could not register as a sub device\n"); 180 return ERR_PTR(-EPROBE_DEFER); 181 } 182 EXPORT_SYMBOL(mpfs_sys_controller_get); 183 184 static struct platform_driver mpfs_sys_controller_driver = { 185 .driver = { 186 .name = "mpfs-sys-controller", 187 .of_match_table = mpfs_sys_controller_of_match, 188 }, 189 .probe = mpfs_sys_controller_probe, 190 .remove = mpfs_sys_controller_remove, 191 }; 192 module_platform_driver(mpfs_sys_controller_driver); 193 194 MODULE_LICENSE("GPL v2"); 195 MODULE_AUTHOR("Conor Dooley <conor.dooley@microchip.com>"); 196 MODULE_DESCRIPTION("MPFS system controller driver"); 197