1dc413a90SLinus Torvalds // SPDX-License-Identifier: GPL-2.0+
2dc413a90SLinus Torvalds /*
3dc413a90SLinus Torvalds * Copyright 2019 Google Inc
4dc413a90SLinus Torvalds *
5dc413a90SLinus Torvalds * This program is free software; you can redistribute it and/or
6dc413a90SLinus Torvalds * modify it under the terms of the GNU General Public License
7dc413a90SLinus Torvalds * as published by the Free Software Foundation; either version
8dc413a90SLinus Torvalds * 2 of the License, or (at your option) any later version.
9dc413a90SLinus Torvalds *
10dc413a90SLinus Torvalds * Provides a simple driver to control the ASPEED P2A interface which allows
11dc413a90SLinus Torvalds * the host to read and write to various regions of the BMC's memory.
12dc413a90SLinus Torvalds */
13dc413a90SLinus Torvalds
14dc413a90SLinus Torvalds #include <linux/fs.h>
15dc413a90SLinus Torvalds #include <linux/io.h>
16dc413a90SLinus Torvalds #include <linux/mfd/syscon.h>
17dc413a90SLinus Torvalds #include <linux/miscdevice.h>
18dc413a90SLinus Torvalds #include <linux/mm.h>
19dc413a90SLinus Torvalds #include <linux/module.h>
20dc413a90SLinus Torvalds #include <linux/mutex.h>
2196b75c9dSRob Herring #include <linux/of.h>
22dc413a90SLinus Torvalds #include <linux/of_address.h>
23dc413a90SLinus Torvalds #include <linux/platform_device.h>
24dc413a90SLinus Torvalds #include <linux/regmap.h>
25dc413a90SLinus Torvalds #include <linux/slab.h>
26dc413a90SLinus Torvalds #include <linux/uaccess.h>
27dc413a90SLinus Torvalds
28dc413a90SLinus Torvalds #include <linux/aspeed-p2a-ctrl.h>
29dc413a90SLinus Torvalds
30dc413a90SLinus Torvalds #define DEVICE_NAME "aspeed-p2a-ctrl"
31dc413a90SLinus Torvalds
32dc413a90SLinus Torvalds /* SCU2C is a Misc. Control Register. */
33dc413a90SLinus Torvalds #define SCU2C 0x2c
34dc413a90SLinus Torvalds /* SCU180 is the PCIe Configuration Setting Control Register. */
35dc413a90SLinus Torvalds #define SCU180 0x180
36dc413a90SLinus Torvalds /* Bit 1 controls the P2A bridge, while bit 0 controls the entire VGA device
37dc413a90SLinus Torvalds * on the PCI bus.
38dc413a90SLinus Torvalds */
39dc413a90SLinus Torvalds #define SCU180_ENP2A BIT(1)
40dc413a90SLinus Torvalds
41dc413a90SLinus Torvalds /* The ast2400/2500 both have six ranges. */
42dc413a90SLinus Torvalds #define P2A_REGION_COUNT 6
43dc413a90SLinus Torvalds
44dc413a90SLinus Torvalds struct region {
45dc413a90SLinus Torvalds u64 min;
46dc413a90SLinus Torvalds u64 max;
47dc413a90SLinus Torvalds u32 bit;
48dc413a90SLinus Torvalds };
49dc413a90SLinus Torvalds
50dc413a90SLinus Torvalds struct aspeed_p2a_model_data {
51dc413a90SLinus Torvalds /* min, max, bit */
52dc413a90SLinus Torvalds struct region regions[P2A_REGION_COUNT];
53dc413a90SLinus Torvalds };
54dc413a90SLinus Torvalds
55dc413a90SLinus Torvalds struct aspeed_p2a_ctrl {
56dc413a90SLinus Torvalds struct miscdevice miscdev;
57dc413a90SLinus Torvalds struct regmap *regmap;
58dc413a90SLinus Torvalds
59dc413a90SLinus Torvalds const struct aspeed_p2a_model_data *config;
60dc413a90SLinus Torvalds
61dc413a90SLinus Torvalds /* Access to these needs to be locked, held via probe, mapping ioctl,
62dc413a90SLinus Torvalds * and release, remove.
63dc413a90SLinus Torvalds */
64dc413a90SLinus Torvalds struct mutex tracking;
65dc413a90SLinus Torvalds u32 readers;
66dc413a90SLinus Torvalds u32 readerwriters[P2A_REGION_COUNT];
67dc413a90SLinus Torvalds
68dc413a90SLinus Torvalds phys_addr_t mem_base;
69dc413a90SLinus Torvalds resource_size_t mem_size;
70dc413a90SLinus Torvalds };
71dc413a90SLinus Torvalds
72dc413a90SLinus Torvalds struct aspeed_p2a_user {
73dc413a90SLinus Torvalds struct file *file;
74dc413a90SLinus Torvalds struct aspeed_p2a_ctrl *parent;
75dc413a90SLinus Torvalds
76dc413a90SLinus Torvalds /* The entire memory space is opened for reading once the bridge is
77dc413a90SLinus Torvalds * enabled, therefore this needs only to be tracked once per user.
78dc413a90SLinus Torvalds * If any user has it open for read, the bridge must stay enabled.
79dc413a90SLinus Torvalds */
80dc413a90SLinus Torvalds u32 read;
81dc413a90SLinus Torvalds
82dc413a90SLinus Torvalds /* Each entry of the array corresponds to a P2A Region. If the user
83dc413a90SLinus Torvalds * opens for read or readwrite, the reference goes up here. On
84dc413a90SLinus Torvalds * release, this array is walked and references adjusted accordingly.
85dc413a90SLinus Torvalds */
86dc413a90SLinus Torvalds u32 readwrite[P2A_REGION_COUNT];
87dc413a90SLinus Torvalds };
88dc413a90SLinus Torvalds
aspeed_p2a_enable_bridge(struct aspeed_p2a_ctrl * p2a_ctrl)89dc413a90SLinus Torvalds static void aspeed_p2a_enable_bridge(struct aspeed_p2a_ctrl *p2a_ctrl)
90dc413a90SLinus Torvalds {
91dc413a90SLinus Torvalds regmap_update_bits(p2a_ctrl->regmap,
92dc413a90SLinus Torvalds SCU180, SCU180_ENP2A, SCU180_ENP2A);
93dc413a90SLinus Torvalds }
94dc413a90SLinus Torvalds
aspeed_p2a_disable_bridge(struct aspeed_p2a_ctrl * p2a_ctrl)95dc413a90SLinus Torvalds static void aspeed_p2a_disable_bridge(struct aspeed_p2a_ctrl *p2a_ctrl)
96dc413a90SLinus Torvalds {
97dc413a90SLinus Torvalds regmap_update_bits(p2a_ctrl->regmap, SCU180, SCU180_ENP2A, 0);
98dc413a90SLinus Torvalds }
99dc413a90SLinus Torvalds
aspeed_p2a_mmap(struct file * file,struct vm_area_struct * vma)100dc413a90SLinus Torvalds static int aspeed_p2a_mmap(struct file *file, struct vm_area_struct *vma)
101dc413a90SLinus Torvalds {
102dc413a90SLinus Torvalds unsigned long vsize;
103dc413a90SLinus Torvalds pgprot_t prot;
104dc413a90SLinus Torvalds struct aspeed_p2a_user *priv = file->private_data;
105dc413a90SLinus Torvalds struct aspeed_p2a_ctrl *ctrl = priv->parent;
106dc413a90SLinus Torvalds
107dc413a90SLinus Torvalds if (ctrl->mem_base == 0 && ctrl->mem_size == 0)
108dc413a90SLinus Torvalds return -EINVAL;
109dc413a90SLinus Torvalds
110dc413a90SLinus Torvalds vsize = vma->vm_end - vma->vm_start;
111dc413a90SLinus Torvalds prot = vma->vm_page_prot;
112dc413a90SLinus Torvalds
1138b07e990SIwona Winiarska if (vma->vm_pgoff + vma_pages(vma) > ctrl->mem_size >> PAGE_SHIFT)
114dc413a90SLinus Torvalds return -EINVAL;
115dc413a90SLinus Torvalds
116dc413a90SLinus Torvalds /* ast2400/2500 AHB accesses are not cache coherent */
117dc413a90SLinus Torvalds prot = pgprot_noncached(prot);
118dc413a90SLinus Torvalds
119dc413a90SLinus Torvalds if (remap_pfn_range(vma, vma->vm_start,
120dc413a90SLinus Torvalds (ctrl->mem_base >> PAGE_SHIFT) + vma->vm_pgoff,
121dc413a90SLinus Torvalds vsize, prot))
122dc413a90SLinus Torvalds return -EAGAIN;
123dc413a90SLinus Torvalds
124dc413a90SLinus Torvalds return 0;
125dc413a90SLinus Torvalds }
126dc413a90SLinus Torvalds
aspeed_p2a_region_acquire(struct aspeed_p2a_user * priv,struct aspeed_p2a_ctrl * ctrl,struct aspeed_p2a_ctrl_mapping * map)127dc413a90SLinus Torvalds static bool aspeed_p2a_region_acquire(struct aspeed_p2a_user *priv,
128dc413a90SLinus Torvalds struct aspeed_p2a_ctrl *ctrl,
129dc413a90SLinus Torvalds struct aspeed_p2a_ctrl_mapping *map)
130dc413a90SLinus Torvalds {
131dc413a90SLinus Torvalds int i;
132dc413a90SLinus Torvalds u64 base, end;
133dc413a90SLinus Torvalds bool matched = false;
134dc413a90SLinus Torvalds
135dc413a90SLinus Torvalds base = map->addr;
136dc413a90SLinus Torvalds end = map->addr + (map->length - 1);
137dc413a90SLinus Torvalds
138dc413a90SLinus Torvalds /* If the value is a legal u32, it will find a match. */
139dc413a90SLinus Torvalds for (i = 0; i < P2A_REGION_COUNT; i++) {
140dc413a90SLinus Torvalds const struct region *curr = &ctrl->config->regions[i];
141dc413a90SLinus Torvalds
142dc413a90SLinus Torvalds /* If the top of this region is lower than your base, skip it.
143dc413a90SLinus Torvalds */
144dc413a90SLinus Torvalds if (curr->max < base)
145dc413a90SLinus Torvalds continue;
146dc413a90SLinus Torvalds
147dc413a90SLinus Torvalds /* If the bottom of this region is higher than your end, bail.
148dc413a90SLinus Torvalds */
149dc413a90SLinus Torvalds if (curr->min > end)
150dc413a90SLinus Torvalds break;
151dc413a90SLinus Torvalds
152dc413a90SLinus Torvalds /* Lock this and update it, therefore it someone else is
153dc413a90SLinus Torvalds * closing their file out, this'll preserve the increment.
154dc413a90SLinus Torvalds */
155dc413a90SLinus Torvalds mutex_lock(&ctrl->tracking);
156dc413a90SLinus Torvalds ctrl->readerwriters[i] += 1;
157dc413a90SLinus Torvalds mutex_unlock(&ctrl->tracking);
158dc413a90SLinus Torvalds
159dc413a90SLinus Torvalds /* Track with the user, so when they close their file, we can
160dc413a90SLinus Torvalds * decrement properly.
161dc413a90SLinus Torvalds */
162dc413a90SLinus Torvalds priv->readwrite[i] += 1;
163dc413a90SLinus Torvalds
164dc413a90SLinus Torvalds /* Enable the region as read-write. */
165dc413a90SLinus Torvalds regmap_update_bits(ctrl->regmap, SCU2C, curr->bit, 0);
166dc413a90SLinus Torvalds matched = true;
167dc413a90SLinus Torvalds }
168dc413a90SLinus Torvalds
169dc413a90SLinus Torvalds return matched;
170dc413a90SLinus Torvalds }
171dc413a90SLinus Torvalds
aspeed_p2a_ioctl(struct file * file,unsigned int cmd,unsigned long data)172dc413a90SLinus Torvalds static long aspeed_p2a_ioctl(struct file *file, unsigned int cmd,
173dc413a90SLinus Torvalds unsigned long data)
174dc413a90SLinus Torvalds {
175dc413a90SLinus Torvalds struct aspeed_p2a_user *priv = file->private_data;
176dc413a90SLinus Torvalds struct aspeed_p2a_ctrl *ctrl = priv->parent;
177dc413a90SLinus Torvalds void __user *arg = (void __user *)data;
178dc413a90SLinus Torvalds struct aspeed_p2a_ctrl_mapping map;
179dc413a90SLinus Torvalds
180dc413a90SLinus Torvalds if (copy_from_user(&map, arg, sizeof(map)))
181dc413a90SLinus Torvalds return -EFAULT;
182dc413a90SLinus Torvalds
183dc413a90SLinus Torvalds switch (cmd) {
184dc413a90SLinus Torvalds case ASPEED_P2A_CTRL_IOCTL_SET_WINDOW:
185dc413a90SLinus Torvalds /* If they want a region to be read-only, since the entire
186dc413a90SLinus Torvalds * region is read-only once enabled, we just need to track this
187dc413a90SLinus Torvalds * user wants to read from the bridge, and if it's not enabled.
188dc413a90SLinus Torvalds * Enable it.
189dc413a90SLinus Torvalds */
190dc413a90SLinus Torvalds if (map.flags == ASPEED_P2A_CTRL_READ_ONLY) {
191dc413a90SLinus Torvalds mutex_lock(&ctrl->tracking);
192dc413a90SLinus Torvalds ctrl->readers += 1;
193dc413a90SLinus Torvalds mutex_unlock(&ctrl->tracking);
194dc413a90SLinus Torvalds
195dc413a90SLinus Torvalds /* Track with the user, so when they close their file,
196dc413a90SLinus Torvalds * we can decrement properly.
197dc413a90SLinus Torvalds */
198dc413a90SLinus Torvalds priv->read += 1;
199dc413a90SLinus Torvalds } else if (map.flags == ASPEED_P2A_CTRL_READWRITE) {
200dc413a90SLinus Torvalds /* If we don't acquire any region return error. */
201dc413a90SLinus Torvalds if (!aspeed_p2a_region_acquire(priv, ctrl, &map)) {
202dc413a90SLinus Torvalds return -EINVAL;
203dc413a90SLinus Torvalds }
204dc413a90SLinus Torvalds } else {
205dc413a90SLinus Torvalds /* Invalid map flags. */
206dc413a90SLinus Torvalds return -EINVAL;
207dc413a90SLinus Torvalds }
208dc413a90SLinus Torvalds
209dc413a90SLinus Torvalds aspeed_p2a_enable_bridge(ctrl);
210dc413a90SLinus Torvalds return 0;
211dc413a90SLinus Torvalds case ASPEED_P2A_CTRL_IOCTL_GET_MEMORY_CONFIG:
212dc413a90SLinus Torvalds /* This is a request for the memory-region and corresponding
213dc413a90SLinus Torvalds * length that is used by the driver for mmap.
214dc413a90SLinus Torvalds */
215dc413a90SLinus Torvalds
216dc413a90SLinus Torvalds map.flags = 0;
217dc413a90SLinus Torvalds map.addr = ctrl->mem_base;
218dc413a90SLinus Torvalds map.length = ctrl->mem_size;
219dc413a90SLinus Torvalds
220dc413a90SLinus Torvalds return copy_to_user(arg, &map, sizeof(map)) ? -EFAULT : 0;
221dc413a90SLinus Torvalds }
222dc413a90SLinus Torvalds
223dc413a90SLinus Torvalds return -EINVAL;
224dc413a90SLinus Torvalds }
225dc413a90SLinus Torvalds
226dc413a90SLinus Torvalds
227dc413a90SLinus Torvalds /*
228dc413a90SLinus Torvalds * When a user opens this file, we create a structure to track their mappings.
229dc413a90SLinus Torvalds *
230dc413a90SLinus Torvalds * A user can map a region as read-only (bridge enabled), or read-write (bit
231dc413a90SLinus Torvalds * flipped, and bridge enabled). Either way, this tracking is used, s.t. when
232dc413a90SLinus Torvalds * they release the device references are handled.
233dc413a90SLinus Torvalds *
234dc413a90SLinus Torvalds * The bridge is not enabled until a user calls an ioctl to map a region,
235dc413a90SLinus Torvalds * simply opening the device does not enable it.
236dc413a90SLinus Torvalds */
aspeed_p2a_open(struct inode * inode,struct file * file)237dc413a90SLinus Torvalds static int aspeed_p2a_open(struct inode *inode, struct file *file)
238dc413a90SLinus Torvalds {
239dc413a90SLinus Torvalds struct aspeed_p2a_user *priv;
240dc413a90SLinus Torvalds
241dc413a90SLinus Torvalds priv = kmalloc(sizeof(*priv), GFP_KERNEL);
242dc413a90SLinus Torvalds if (!priv)
243dc413a90SLinus Torvalds return -ENOMEM;
244dc413a90SLinus Torvalds
245dc413a90SLinus Torvalds priv->file = file;
246dc413a90SLinus Torvalds priv->read = 0;
247dc413a90SLinus Torvalds memset(priv->readwrite, 0, sizeof(priv->readwrite));
248dc413a90SLinus Torvalds
249dc413a90SLinus Torvalds /* The file's private_data is initialized to the p2a_ctrl. */
250dc413a90SLinus Torvalds priv->parent = file->private_data;
251dc413a90SLinus Torvalds
252dc413a90SLinus Torvalds /* Set the file's private_data to the user's data. */
253dc413a90SLinus Torvalds file->private_data = priv;
254dc413a90SLinus Torvalds
255dc413a90SLinus Torvalds return 0;
256dc413a90SLinus Torvalds }
257dc413a90SLinus Torvalds
258dc413a90SLinus Torvalds /*
259dc413a90SLinus Torvalds * This will close the users mappings. It will go through what they had opened
260dc413a90SLinus Torvalds * for readwrite, and decrement those counts. If at the end, this is the last
261dc413a90SLinus Torvalds * user, it'll close the bridge.
262dc413a90SLinus Torvalds */
aspeed_p2a_release(struct inode * inode,struct file * file)263dc413a90SLinus Torvalds static int aspeed_p2a_release(struct inode *inode, struct file *file)
264dc413a90SLinus Torvalds {
265dc413a90SLinus Torvalds int i;
266dc413a90SLinus Torvalds u32 bits = 0;
267dc413a90SLinus Torvalds bool open_regions = false;
268dc413a90SLinus Torvalds struct aspeed_p2a_user *priv = file->private_data;
269dc413a90SLinus Torvalds
270dc413a90SLinus Torvalds /* Lock others from changing these values until everything is updated
271dc413a90SLinus Torvalds * in one pass.
272dc413a90SLinus Torvalds */
273dc413a90SLinus Torvalds mutex_lock(&priv->parent->tracking);
274dc413a90SLinus Torvalds
275dc413a90SLinus Torvalds priv->parent->readers -= priv->read;
276dc413a90SLinus Torvalds
277dc413a90SLinus Torvalds for (i = 0; i < P2A_REGION_COUNT; i++) {
278dc413a90SLinus Torvalds priv->parent->readerwriters[i] -= priv->readwrite[i];
279dc413a90SLinus Torvalds
280dc413a90SLinus Torvalds if (priv->parent->readerwriters[i] > 0)
281dc413a90SLinus Torvalds open_regions = true;
282dc413a90SLinus Torvalds else
283dc413a90SLinus Torvalds bits |= priv->parent->config->regions[i].bit;
284dc413a90SLinus Torvalds }
285dc413a90SLinus Torvalds
286dc413a90SLinus Torvalds /* Setting a bit to 1 disables the region, so let's just OR with the
287dc413a90SLinus Torvalds * above to disable any.
288dc413a90SLinus Torvalds */
289dc413a90SLinus Torvalds
290dc413a90SLinus Torvalds /* Note, if another user is trying to ioctl, they can't grab tracking,
291dc413a90SLinus Torvalds * and therefore can't grab either register mutex.
292dc413a90SLinus Torvalds * If another user is trying to close, they can't grab tracking either.
293dc413a90SLinus Torvalds */
294dc413a90SLinus Torvalds regmap_update_bits(priv->parent->regmap, SCU2C, bits, bits);
295dc413a90SLinus Torvalds
296dc413a90SLinus Torvalds /* If parent->readers is zero and open windows is 0, disable the
297dc413a90SLinus Torvalds * bridge.
298dc413a90SLinus Torvalds */
299dc413a90SLinus Torvalds if (!open_regions && priv->parent->readers == 0)
300dc413a90SLinus Torvalds aspeed_p2a_disable_bridge(priv->parent);
301dc413a90SLinus Torvalds
302dc413a90SLinus Torvalds mutex_unlock(&priv->parent->tracking);
303dc413a90SLinus Torvalds
304dc413a90SLinus Torvalds kfree(priv);
305dc413a90SLinus Torvalds
306dc413a90SLinus Torvalds return 0;
307dc413a90SLinus Torvalds }
308dc413a90SLinus Torvalds
309dc413a90SLinus Torvalds static const struct file_operations aspeed_p2a_ctrl_fops = {
310dc413a90SLinus Torvalds .owner = THIS_MODULE,
311dc413a90SLinus Torvalds .mmap = aspeed_p2a_mmap,
312dc413a90SLinus Torvalds .unlocked_ioctl = aspeed_p2a_ioctl,
313dc413a90SLinus Torvalds .open = aspeed_p2a_open,
314dc413a90SLinus Torvalds .release = aspeed_p2a_release,
315dc413a90SLinus Torvalds };
316dc413a90SLinus Torvalds
317dc413a90SLinus Torvalds /* The regions are controlled by SCU2C */
aspeed_p2a_disable_all(struct aspeed_p2a_ctrl * p2a_ctrl)318dc413a90SLinus Torvalds static void aspeed_p2a_disable_all(struct aspeed_p2a_ctrl *p2a_ctrl)
319dc413a90SLinus Torvalds {
320dc413a90SLinus Torvalds int i;
321dc413a90SLinus Torvalds u32 value = 0;
322dc413a90SLinus Torvalds
323dc413a90SLinus Torvalds for (i = 0; i < P2A_REGION_COUNT; i++)
324dc413a90SLinus Torvalds value |= p2a_ctrl->config->regions[i].bit;
325dc413a90SLinus Torvalds
326dc413a90SLinus Torvalds regmap_update_bits(p2a_ctrl->regmap, SCU2C, value, value);
327dc413a90SLinus Torvalds
328dc413a90SLinus Torvalds /* Disable the bridge. */
329dc413a90SLinus Torvalds aspeed_p2a_disable_bridge(p2a_ctrl);
330dc413a90SLinus Torvalds }
331dc413a90SLinus Torvalds
aspeed_p2a_ctrl_probe(struct platform_device * pdev)332dc413a90SLinus Torvalds static int aspeed_p2a_ctrl_probe(struct platform_device *pdev)
333dc413a90SLinus Torvalds {
334dc413a90SLinus Torvalds struct aspeed_p2a_ctrl *misc_ctrl;
335dc413a90SLinus Torvalds struct device *dev;
336dc413a90SLinus Torvalds struct resource resm;
337dc413a90SLinus Torvalds struct device_node *node;
338dc413a90SLinus Torvalds int rc = 0;
339dc413a90SLinus Torvalds
340dc413a90SLinus Torvalds dev = &pdev->dev;
341dc413a90SLinus Torvalds
342dc413a90SLinus Torvalds misc_ctrl = devm_kzalloc(dev, sizeof(*misc_ctrl), GFP_KERNEL);
343dc413a90SLinus Torvalds if (!misc_ctrl)
344dc413a90SLinus Torvalds return -ENOMEM;
345dc413a90SLinus Torvalds
346dc413a90SLinus Torvalds mutex_init(&misc_ctrl->tracking);
347dc413a90SLinus Torvalds
348dc413a90SLinus Torvalds /* optional. */
349dc413a90SLinus Torvalds node = of_parse_phandle(dev->of_node, "memory-region", 0);
350dc413a90SLinus Torvalds if (node) {
351dc413a90SLinus Torvalds rc = of_address_to_resource(node, 0, &resm);
352dc413a90SLinus Torvalds of_node_put(node);
353dc413a90SLinus Torvalds if (rc) {
354dc413a90SLinus Torvalds dev_err(dev, "Couldn't address to resource for reserved memory\n");
355dc413a90SLinus Torvalds return -ENODEV;
356dc413a90SLinus Torvalds }
357dc413a90SLinus Torvalds
358dc413a90SLinus Torvalds misc_ctrl->mem_size = resource_size(&resm);
359dc413a90SLinus Torvalds misc_ctrl->mem_base = resm.start;
360dc413a90SLinus Torvalds }
361dc413a90SLinus Torvalds
362dc413a90SLinus Torvalds misc_ctrl->regmap = syscon_node_to_regmap(pdev->dev.parent->of_node);
363dc413a90SLinus Torvalds if (IS_ERR(misc_ctrl->regmap)) {
364dc413a90SLinus Torvalds dev_err(dev, "Couldn't get regmap\n");
365dc413a90SLinus Torvalds return -ENODEV;
366dc413a90SLinus Torvalds }
367dc413a90SLinus Torvalds
368dc413a90SLinus Torvalds misc_ctrl->config = of_device_get_match_data(dev);
369dc413a90SLinus Torvalds
370dc413a90SLinus Torvalds dev_set_drvdata(&pdev->dev, misc_ctrl);
371dc413a90SLinus Torvalds
372dc413a90SLinus Torvalds aspeed_p2a_disable_all(misc_ctrl);
373dc413a90SLinus Torvalds
374dc413a90SLinus Torvalds misc_ctrl->miscdev.minor = MISC_DYNAMIC_MINOR;
375dc413a90SLinus Torvalds misc_ctrl->miscdev.name = DEVICE_NAME;
376dc413a90SLinus Torvalds misc_ctrl->miscdev.fops = &aspeed_p2a_ctrl_fops;
377dc413a90SLinus Torvalds misc_ctrl->miscdev.parent = dev;
378dc413a90SLinus Torvalds
379dc413a90SLinus Torvalds rc = misc_register(&misc_ctrl->miscdev);
380dc413a90SLinus Torvalds if (rc)
381dc413a90SLinus Torvalds dev_err(dev, "Unable to register device\n");
382dc413a90SLinus Torvalds
383dc413a90SLinus Torvalds return rc;
384dc413a90SLinus Torvalds }
385dc413a90SLinus Torvalds
aspeed_p2a_ctrl_remove(struct platform_device * pdev)386*0af9e891SUwe Kleine-König static void aspeed_p2a_ctrl_remove(struct platform_device *pdev)
387dc413a90SLinus Torvalds {
388dc413a90SLinus Torvalds struct aspeed_p2a_ctrl *p2a_ctrl = dev_get_drvdata(&pdev->dev);
389dc413a90SLinus Torvalds
390dc413a90SLinus Torvalds misc_deregister(&p2a_ctrl->miscdev);
391dc413a90SLinus Torvalds }
392dc413a90SLinus Torvalds
393dc413a90SLinus Torvalds #define SCU2C_DRAM BIT(25)
394dc413a90SLinus Torvalds #define SCU2C_SPI BIT(24)
395dc413a90SLinus Torvalds #define SCU2C_SOC BIT(23)
396dc413a90SLinus Torvalds #define SCU2C_FLASH BIT(22)
397dc413a90SLinus Torvalds
398dc413a90SLinus Torvalds static const struct aspeed_p2a_model_data ast2400_model_data = {
399dc413a90SLinus Torvalds .regions = {
400dc413a90SLinus Torvalds {0x00000000, 0x17FFFFFF, SCU2C_FLASH},
401dc413a90SLinus Torvalds {0x18000000, 0x1FFFFFFF, SCU2C_SOC},
402dc413a90SLinus Torvalds {0x20000000, 0x2FFFFFFF, SCU2C_FLASH},
403dc413a90SLinus Torvalds {0x30000000, 0x3FFFFFFF, SCU2C_SPI},
404dc413a90SLinus Torvalds {0x40000000, 0x5FFFFFFF, SCU2C_DRAM},
405dc413a90SLinus Torvalds {0x60000000, 0xFFFFFFFF, SCU2C_SOC},
406dc413a90SLinus Torvalds }
407dc413a90SLinus Torvalds };
408dc413a90SLinus Torvalds
409dc413a90SLinus Torvalds static const struct aspeed_p2a_model_data ast2500_model_data = {
410dc413a90SLinus Torvalds .regions = {
411dc413a90SLinus Torvalds {0x00000000, 0x0FFFFFFF, SCU2C_FLASH},
412dc413a90SLinus Torvalds {0x10000000, 0x1FFFFFFF, SCU2C_SOC},
413dc413a90SLinus Torvalds {0x20000000, 0x3FFFFFFF, SCU2C_FLASH},
414dc413a90SLinus Torvalds {0x40000000, 0x5FFFFFFF, SCU2C_SOC},
415dc413a90SLinus Torvalds {0x60000000, 0x7FFFFFFF, SCU2C_SPI},
416dc413a90SLinus Torvalds {0x80000000, 0xFFFFFFFF, SCU2C_DRAM},
417dc413a90SLinus Torvalds }
418dc413a90SLinus Torvalds };
419dc413a90SLinus Torvalds
420dc413a90SLinus Torvalds static const struct of_device_id aspeed_p2a_ctrl_match[] = {
421dc413a90SLinus Torvalds { .compatible = "aspeed,ast2400-p2a-ctrl",
422dc413a90SLinus Torvalds .data = &ast2400_model_data },
423dc413a90SLinus Torvalds { .compatible = "aspeed,ast2500-p2a-ctrl",
424dc413a90SLinus Torvalds .data = &ast2500_model_data },
425dc413a90SLinus Torvalds { },
426dc413a90SLinus Torvalds };
427dc413a90SLinus Torvalds
428dc413a90SLinus Torvalds static struct platform_driver aspeed_p2a_ctrl_driver = {
429dc413a90SLinus Torvalds .driver = {
430dc413a90SLinus Torvalds .name = DEVICE_NAME,
431dc413a90SLinus Torvalds .of_match_table = aspeed_p2a_ctrl_match,
432dc413a90SLinus Torvalds },
433dc413a90SLinus Torvalds .probe = aspeed_p2a_ctrl_probe,
434*0af9e891SUwe Kleine-König .remove_new = aspeed_p2a_ctrl_remove,
435dc413a90SLinus Torvalds };
436dc413a90SLinus Torvalds
437dc413a90SLinus Torvalds module_platform_driver(aspeed_p2a_ctrl_driver);
438dc413a90SLinus Torvalds
439dc413a90SLinus Torvalds MODULE_DEVICE_TABLE(of, aspeed_p2a_ctrl_match);
440dc413a90SLinus Torvalds MODULE_LICENSE("GPL");
441dc413a90SLinus Torvalds MODULE_AUTHOR("Patrick Venture <venture@google.com>");
442dc413a90SLinus Torvalds MODULE_DESCRIPTION("Control for aspeed 2400/2500 P2A VGA HOST to BMC mappings");
443