xref: /openbmc/qemu/hw/net/can/ctucan_pci.c (revision 7d87775f)
1 /*
2  * CTU CAN FD PCI device emulation
3  * http://canbus.pages.fel.cvut.cz/
4  *
5  * Copyright (c) 2019 Jan Charvat (jancharvat.charvat@gmail.com)
6  *
7  * Based on Kvaser PCI CAN device (SJA1000 based) emulation implemented by
8  * Jin Yang and Pavel Pisa
9  *
10  * Permission is hereby granted, free of charge, to any person obtaining a copy
11  * of this software and associated documentation files (the "Software"), to deal
12  * in the Software without restriction, including without limitation the rights
13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14  * copies of the Software, and to permit persons to whom the Software is
15  * furnished to do so, subject to the following conditions:
16  *
17  * The above copyright notice and this permission notice shall be included in
18  * all copies or substantial portions of the Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26  * THE SOFTWARE.
27  */
28 
29 #include "qemu/osdep.h"
30 #include "qemu/event_notifier.h"
31 #include "qemu/module.h"
32 #include "qemu/thread.h"
33 #include "qemu/sockets.h"
34 #include "qapi/error.h"
35 #include "chardev/char.h"
36 #include "hw/irq.h"
37 #include "hw/pci/pci_device.h"
38 #include "hw/qdev-properties.h"
39 #include "migration/vmstate.h"
40 #include "net/can_emu.h"
41 
42 #include "ctucan_core.h"
43 
44 #define TYPE_CTUCAN_PCI_DEV "ctucan_pci"
45 
46 typedef struct CtuCanPCIState CtuCanPCIState;
47 DECLARE_INSTANCE_CHECKER(CtuCanPCIState, CTUCAN_PCI_DEV,
48                          TYPE_CTUCAN_PCI_DEV)
49 
50 #define CTUCAN_PCI_CORE_COUNT     2
51 #define CTUCAN_PCI_CORE_RANGE     0x10000
52 
53 #define CTUCAN_PCI_BAR_COUNT      2
54 
55 #define CTUCAN_PCI_BYTES_PER_CORE 0x4000
56 
57 #ifndef PCI_VENDOR_ID_TEDIA
58 #define PCI_VENDOR_ID_TEDIA 0x1760
59 #endif
60 
61 #define PCI_DEVICE_ID_TEDIA_CTUCAN_VER21 0xff00
62 
63 #define CTUCAN_BAR0_RANGE 0x8000
64 #define CTUCAN_BAR0_CTUCAN_ID 0x0000
65 #define CTUCAN_BAR0_CRA_BASE  0x4000
66 #define CYCLONE_IV_CRA_A2P_IE (0x0050)
67 
68 #define CTUCAN_WITHOUT_CTUCAN_ID  0
69 #define CTUCAN_WITH_CTUCAN_ID     1
70 
71 struct CtuCanPCIState {
72     /*< private >*/
73     PCIDevice       dev;
74     /*< public >*/
75     MemoryRegion    ctucan_io[CTUCAN_PCI_BAR_COUNT];
76 
77     CtuCanCoreState ctucan_state[CTUCAN_PCI_CORE_COUNT];
78     qemu_irq        irq;
79 
80     char            *model; /* The model that support, only SJA1000 now. */
81     CanBusState     *canbus[CTUCAN_PCI_CORE_COUNT];
82 };
83 
84 static void ctucan_pci_reset(DeviceState *dev)
85 {
86     CtuCanPCIState *d = CTUCAN_PCI_DEV(dev);
87     int i;
88 
89     for (i = 0 ; i < CTUCAN_PCI_CORE_COUNT; i++) {
90         ctucan_hardware_reset(&d->ctucan_state[i]);
91     }
92 }
93 
94 static uint64_t ctucan_pci_id_cra_io_read(void *opaque, hwaddr addr,
95                                           unsigned size)
96 {
97     if (addr >= 4) {
98         return 0;
99     }
100 
101     uint64_t tmp = 0xC0000000 + CTUCAN_PCI_CORE_COUNT;
102     tmp >>= ((addr & 3) << 3);
103     if (size < 8) {
104         tmp &= ((uint64_t)1 << (size << 3)) - 1;
105     }
106     return tmp;
107 }
108 
109 static void ctucan_pci_id_cra_io_write(void *opaque, hwaddr addr, uint64_t data,
110                              unsigned size)
111 {
112 
113 }
114 
115 static uint64_t ctucan_pci_cores_io_read(void *opaque, hwaddr addr,
116                                           unsigned size)
117 {
118     CtuCanPCIState *d = opaque;
119     CtuCanCoreState *s;
120     hwaddr core_num = addr / CTUCAN_PCI_BYTES_PER_CORE;
121 
122     if (core_num >= CTUCAN_PCI_CORE_COUNT) {
123         return 0;
124     }
125 
126     s = &d->ctucan_state[core_num];
127 
128     return ctucan_mem_read(s, addr % CTUCAN_PCI_BYTES_PER_CORE, size);
129 }
130 
131 static void ctucan_pci_cores_io_write(void *opaque, hwaddr addr, uint64_t data,
132                              unsigned size)
133 {
134     CtuCanPCIState *d = opaque;
135     CtuCanCoreState *s;
136     hwaddr core_num = addr / CTUCAN_PCI_BYTES_PER_CORE;
137 
138     if (core_num >= CTUCAN_PCI_CORE_COUNT) {
139         return;
140     }
141 
142     s = &d->ctucan_state[core_num];
143 
144     return ctucan_mem_write(s, addr % CTUCAN_PCI_BYTES_PER_CORE, data, size);
145 }
146 
147 static const MemoryRegionOps ctucan_pci_id_cra_io_ops = {
148     .read = ctucan_pci_id_cra_io_read,
149     .write = ctucan_pci_id_cra_io_write,
150     .endianness = DEVICE_LITTLE_ENDIAN,
151     .impl.min_access_size = 1,
152     .impl.max_access_size = 4,
153     .valid.min_access_size = 1,
154     .valid.max_access_size = 4,
155 };
156 
157 static const MemoryRegionOps ctucan_pci_cores_io_ops = {
158     .read = ctucan_pci_cores_io_read,
159     .write = ctucan_pci_cores_io_write,
160     .endianness = DEVICE_LITTLE_ENDIAN,
161     .impl.min_access_size = 1,
162     .impl.max_access_size = 4,
163     .valid.min_access_size = 1,
164     .valid.max_access_size = 4,
165 };
166 
167 static void ctucan_pci_realize(PCIDevice *pci_dev, Error **errp)
168 {
169     CtuCanPCIState *d = CTUCAN_PCI_DEV(pci_dev);
170     uint8_t *pci_conf;
171     int i;
172 
173     pci_conf = pci_dev->config;
174     pci_conf[PCI_INTERRUPT_PIN] = 0x01; /* interrupt pin A */
175 
176     d->irq = pci_allocate_irq(&d->dev);
177 
178     for (i = 0 ; i < CTUCAN_PCI_CORE_COUNT; i++) {
179         ctucan_init(&d->ctucan_state[i], d->irq);
180     }
181 
182     for (i = 0 ; i < CTUCAN_PCI_CORE_COUNT; i++) {
183         if (ctucan_connect_to_bus(&d->ctucan_state[i], d->canbus[i]) < 0) {
184             error_setg(errp, "ctucan_connect_to_bus failed");
185             return;
186         }
187     }
188 
189     memory_region_init_io(&d->ctucan_io[0], OBJECT(d),
190                           &ctucan_pci_id_cra_io_ops, d,
191                           "ctucan_pci-core0", CTUCAN_BAR0_RANGE);
192     memory_region_init_io(&d->ctucan_io[1], OBJECT(d),
193                           &ctucan_pci_cores_io_ops, d,
194                           "ctucan_pci-core1", CTUCAN_PCI_CORE_RANGE);
195 
196     for (i = 0 ; i < CTUCAN_PCI_BAR_COUNT; i++) {
197         pci_register_bar(&d->dev, i, PCI_BASE_ADDRESS_MEM_MASK & 0,
198                          &d->ctucan_io[i]);
199     }
200 }
201 
202 static void ctucan_pci_exit(PCIDevice *pci_dev)
203 {
204     CtuCanPCIState *d = CTUCAN_PCI_DEV(pci_dev);
205     int i;
206 
207     for (i = 0 ; i < CTUCAN_PCI_CORE_COUNT; i++) {
208         ctucan_disconnect(&d->ctucan_state[i]);
209     }
210 
211     qemu_free_irq(d->irq);
212 }
213 
214 static const VMStateDescription vmstate_ctucan_pci = {
215     .name = "ctucan_pci",
216     .version_id = 1,
217     .minimum_version_id = 1,
218     .fields = (const VMStateField[]) {
219         VMSTATE_PCI_DEVICE(dev, CtuCanPCIState),
220         VMSTATE_STRUCT(ctucan_state[0], CtuCanPCIState, 0, vmstate_ctucan,
221                        CtuCanCoreState),
222 #if CTUCAN_PCI_CORE_COUNT >= 2
223         VMSTATE_STRUCT(ctucan_state[1], CtuCanPCIState, 0, vmstate_ctucan,
224                        CtuCanCoreState),
225 #endif
226         VMSTATE_END_OF_LIST()
227     }
228 };
229 
230 static void ctucan_pci_instance_init(Object *obj)
231 {
232     CtuCanPCIState *d = CTUCAN_PCI_DEV(obj);
233 
234     object_property_add_link(obj, "canbus0", TYPE_CAN_BUS,
235                              (Object **)&d->canbus[0],
236                              qdev_prop_allow_set_link_before_realize, 0);
237 #if CTUCAN_PCI_CORE_COUNT >= 2
238     object_property_add_link(obj, "canbus1", TYPE_CAN_BUS,
239                              (Object **)&d->canbus[1],
240                              qdev_prop_allow_set_link_before_realize, 0);
241 #endif
242 }
243 
244 static void ctucan_pci_class_init(ObjectClass *klass, void *data)
245 {
246     DeviceClass *dc = DEVICE_CLASS(klass);
247     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
248 
249     k->realize = ctucan_pci_realize;
250     k->exit = ctucan_pci_exit;
251     k->vendor_id = PCI_VENDOR_ID_TEDIA;
252     k->device_id = PCI_DEVICE_ID_TEDIA_CTUCAN_VER21;
253     k->revision = 0x00;
254     k->class_id = 0x000c09;
255     k->subsystem_vendor_id = PCI_VENDOR_ID_TEDIA;
256     k->subsystem_id = PCI_DEVICE_ID_TEDIA_CTUCAN_VER21;
257     dc->desc = "CTU CAN PCI";
258     dc->vmsd = &vmstate_ctucan_pci;
259     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
260     device_class_set_legacy_reset(dc, ctucan_pci_reset);
261 }
262 
263 static const TypeInfo ctucan_pci_info = {
264     .name          = TYPE_CTUCAN_PCI_DEV,
265     .parent        = TYPE_PCI_DEVICE,
266     .instance_size = sizeof(CtuCanPCIState),
267     .class_init    = ctucan_pci_class_init,
268     .instance_init = ctucan_pci_instance_init,
269     .interfaces = (InterfaceInfo[]) {
270         { INTERFACE_CONVENTIONAL_PCI_DEVICE },
271         { },
272     },
273 };
274 
275 static void ctucan_pci_register_types(void)
276 {
277     type_register_static(&ctucan_pci_info);
278 }
279 
280 type_init(ctucan_pci_register_types)
281