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