~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mips/sgi-ip22/ip22-gio.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #include <linux/export.h>
  2 #include <linux/kernel.h>
  3 #include <linux/init.h>
  4 #include <linux/slab.h>
  5 
  6 #include <asm/addrspace.h>
  7 #include <asm/paccess.h>
  8 #include <asm/gio_device.h>
  9 #include <asm/sgi/gio.h>
 10 #include <asm/sgi/hpc3.h>
 11 #include <asm/sgi/mc.h>
 12 #include <asm/sgi/ip22.h>
 13 
 14 static struct bus_type gio_bus_type;
 15 
 16 static struct {
 17         const char *name;
 18         __u8       id;
 19 } gio_name_table[] = {
 20         { .name = "SGI Impact", .id = 0x10 },
 21         { .name = "Phobos G160", .id = 0x35 },
 22         { .name = "Phobos G130", .id = 0x36 },
 23         { .name = "Phobos G100", .id = 0x37 },
 24         { .name = "Set Engineering GFE", .id = 0x38 },
 25         /* fake IDs */
 26         { .name = "SGI Newport", .id = 0x7e },
 27         { .name = "SGI GR2/GR3", .id = 0x7f },
 28 };
 29 
 30 static void gio_bus_release(struct device *dev)
 31 {
 32         kfree(dev);
 33 }
 34 
 35 static struct device gio_bus = {
 36         .init_name = "gio",
 37         .release = &gio_bus_release,
 38 };
 39 
 40 /**
 41  * gio_match_device - Tell if an of_device structure has a matching
 42  * gio_match structure
 43  * @ids: array of of device match structures to search in
 44  * @dev: the of device structure to match against
 45  *
 46  * Used by a driver to check whether an of_device present in the
 47  * system is in its list of supported devices.
 48  */
 49 const struct gio_device_id *gio_match_device(const struct gio_device_id *match,
 50                      const struct gio_device *dev)
 51 {
 52         const struct gio_device_id *ids;
 53 
 54         for (ids = match; ids->id != 0xff; ids++)
 55                 if (ids->id == dev->id.id)
 56                         return ids;
 57 
 58         return NULL;
 59 }
 60 EXPORT_SYMBOL_GPL(gio_match_device);
 61 
 62 struct gio_device *gio_dev_get(struct gio_device *dev)
 63 {
 64         struct device *tmp;
 65 
 66         if (!dev)
 67                 return NULL;
 68         tmp = get_device(&dev->dev);
 69         if (tmp)
 70                 return to_gio_device(tmp);
 71         else
 72                 return NULL;
 73 }
 74 EXPORT_SYMBOL_GPL(gio_dev_get);
 75 
 76 void gio_dev_put(struct gio_device *dev)
 77 {
 78         if (dev)
 79                 put_device(&dev->dev);
 80 }
 81 EXPORT_SYMBOL_GPL(gio_dev_put);
 82 
 83 /**
 84  * gio_release_dev - free an gio device structure when all users of it are finished.
 85  * @dev: device that's been disconnected
 86  *
 87  * Will be called only by the device core when all users of this gio device are
 88  * done.
 89  */
 90 void gio_release_dev(struct device *dev)
 91 {
 92         struct gio_device *giodev;
 93 
 94         giodev = to_gio_device(dev);
 95         kfree(giodev);
 96 }
 97 EXPORT_SYMBOL_GPL(gio_release_dev);
 98 
 99 int gio_device_register(struct gio_device *giodev)
100 {
101         giodev->dev.bus = &gio_bus_type;
102         giodev->dev.parent = &gio_bus;
103         return device_register(&giodev->dev);
104 }
105 EXPORT_SYMBOL_GPL(gio_device_register);
106 
107 void gio_device_unregister(struct gio_device *giodev)
108 {
109         device_unregister(&giodev->dev);
110 }
111 EXPORT_SYMBOL_GPL(gio_device_unregister);
112 
113 static int gio_bus_match(struct device *dev, struct device_driver *drv)
114 {
115         struct gio_device *gio_dev = to_gio_device(dev);
116         struct gio_driver *gio_drv = to_gio_driver(drv);
117 
118         return gio_match_device(gio_drv->id_table, gio_dev) != NULL;
119 }
120 
121 static int gio_device_probe(struct device *dev)
122 {
123         int error = -ENODEV;
124         struct gio_driver *drv;
125         struct gio_device *gio_dev;
126         const struct gio_device_id *match;
127 
128         drv = to_gio_driver(dev->driver);
129         gio_dev = to_gio_device(dev);
130 
131         if (!drv->probe)
132                 return error;
133 
134         gio_dev_get(gio_dev);
135 
136         match = gio_match_device(drv->id_table, gio_dev);
137         if (match)
138                 error = drv->probe(gio_dev, match);
139         if (error)
140                 gio_dev_put(gio_dev);
141 
142         return error;
143 }
144 
145 static int gio_device_remove(struct device *dev)
146 {
147         struct gio_device *gio_dev = to_gio_device(dev);
148         struct gio_driver *drv = to_gio_driver(dev->driver);
149 
150         if (dev->driver && drv->remove)
151                 drv->remove(gio_dev);
152         return 0;
153 }
154 
155 static void gio_device_shutdown(struct device *dev)
156 {
157         struct gio_device *gio_dev = to_gio_device(dev);
158         struct gio_driver *drv = to_gio_driver(dev->driver);
159 
160         if (dev->driver && drv->shutdown)
161                 drv->shutdown(gio_dev);
162 }
163 
164 static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
165                              char *buf)
166 {
167         struct gio_device *gio_dev = to_gio_device(dev);
168         int len = snprintf(buf, PAGE_SIZE, "gio:%x\n", gio_dev->id.id);
169 
170         return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
171 }
172 static DEVICE_ATTR_RO(modalias);
173 
174 static ssize_t name_show(struct device *dev,
175                          struct device_attribute *attr, char *buf)
176 {
177         struct gio_device *giodev;
178 
179         giodev = to_gio_device(dev);
180         return sprintf(buf, "%s", giodev->name);
181 }
182 static DEVICE_ATTR_RO(name);
183 
184 static ssize_t id_show(struct device *dev,
185                        struct device_attribute *attr, char *buf)
186 {
187         struct gio_device *giodev;
188 
189         giodev = to_gio_device(dev);
190         return sprintf(buf, "%x", giodev->id.id);
191 }
192 static DEVICE_ATTR_RO(id);
193 
194 static struct attribute *gio_dev_attrs[] = {
195         &dev_attr_modalias.attr,
196         &dev_attr_name.attr,
197         &dev_attr_id.attr,
198         NULL,
199 };
200 ATTRIBUTE_GROUPS(gio_dev);
201 
202 static int gio_device_uevent(struct device *dev, struct kobj_uevent_env *env)
203 {
204         struct gio_device *gio_dev = to_gio_device(dev);
205 
206         add_uevent_var(env, "MODALIAS=gio:%x", gio_dev->id.id);
207         return 0;
208 }
209 
210 int gio_register_driver(struct gio_driver *drv)
211 {
212         /* initialize common driver fields */
213         if (!drv->driver.name)
214                 drv->driver.name = drv->name;
215         if (!drv->driver.owner)
216                 drv->driver.owner = drv->owner;
217         drv->driver.bus = &gio_bus_type;
218 
219         /* register with core */
220         return driver_register(&drv->driver);
221 }
222 EXPORT_SYMBOL_GPL(gio_register_driver);
223 
224 void gio_unregister_driver(struct gio_driver *drv)
225 {
226         driver_unregister(&drv->driver);
227 }
228 EXPORT_SYMBOL_GPL(gio_unregister_driver);
229 
230 void gio_set_master(struct gio_device *dev)
231 {
232         u32 tmp = sgimc->giopar;
233 
234         switch (dev->slotno) {
235         case 0:
236                 tmp |= SGIMC_GIOPAR_MASTERGFX;
237                 break;
238         case 1:
239                 tmp |= SGIMC_GIOPAR_MASTEREXP0;
240                 break;
241         case 2:
242                 tmp |= SGIMC_GIOPAR_MASTEREXP1;
243                 break;
244         }
245         sgimc->giopar = tmp;
246 }
247 EXPORT_SYMBOL_GPL(gio_set_master);
248 
249 void ip22_gio_set_64bit(int slotno)
250 {
251         u32 tmp = sgimc->giopar;
252 
253         switch (slotno) {
254         case 0:
255                 tmp |= SGIMC_GIOPAR_GFX64;
256                 break;
257         case 1:
258                 tmp |= SGIMC_GIOPAR_EXP064;
259                 break;
260         case 2:
261                 tmp |= SGIMC_GIOPAR_EXP164;
262                 break;
263         }
264         sgimc->giopar = tmp;
265 }
266 
267 static int ip22_gio_id(unsigned long addr, u32 *res)
268 {
269         u8 tmp8;
270         u8 tmp16;
271         u32 tmp32;
272         u8 *ptr8;
273         u16 *ptr16;
274         u32 *ptr32;
275 
276         ptr32 = (void *)CKSEG1ADDR(addr);
277         if (!get_dbe(tmp32, ptr32)) {
278                 /*
279                  * We got no DBE, but this doesn't mean anything.
280                  * If GIO is pipelined (which can't be disabled
281                  * for GFX slot) we don't get a DBE, but we see
282                  * the transfer size as data. So we do an 8bit
283                  * and a 16bit access and check whether the common
284                  * data matches
285                  */
286                 ptr8 = (void *)CKSEG1ADDR(addr + 3);
287                 if (get_dbe(tmp8, ptr8)) {
288                         /*
289                          * 32bit access worked, but 8bit doesn't
290                          * so we don't see phantom reads on
291                          * a pipelined bus, but a real card which
292                          * doesn't support 8 bit reads
293                          */
294                         *res = tmp32;
295                         return 1;
296                 }
297                 ptr16 = (void *)CKSEG1ADDR(addr + 2);
298                 get_dbe(tmp16, ptr16);
299                 if (tmp8 == (tmp16 & 0xff) &&
300                     tmp8 == (tmp32 & 0xff) &&
301                     tmp16 == (tmp32 & 0xffff)) {
302                         *res = tmp32;
303                         return 1;
304                 }
305         }
306         return 0; /* nothing here */
307 }
308 
309 #define HQ2_MYSTERY_OFFS       0x6A07C
310 #define NEWPORT_USTATUS_OFFS   0xF133C
311 
312 static int ip22_is_gr2(unsigned long addr)
313 {
314         u32 tmp;
315         u32 *ptr;
316 
317         /* HQ2 only allows 32bit accesses */
318         ptr = (void *)CKSEG1ADDR(addr + HQ2_MYSTERY_OFFS);
319         if (!get_dbe(tmp, ptr)) {
320                 if (tmp == 0xdeadbeef)
321                         return 1;
322         }
323         return 0;
324 }
325 
326 
327 static void ip22_check_gio(int slotno, unsigned long addr, int irq)
328 {
329         const char *name = "Unknown";
330         struct gio_device *gio_dev;
331         u32 tmp;
332         __u8 id;
333         int i;
334 
335         /* first look for GR2/GR3 by checking mystery register */
336         if (ip22_is_gr2(addr))
337                 tmp = 0x7f;
338         else {
339                 if (!ip22_gio_id(addr, &tmp)) {
340                         /*
341                          * no GIO signature at start address of slot
342                          * since Newport doesn't have one, we check if
343                          * user status register is readable
344                          */
345                         if (ip22_gio_id(addr + NEWPORT_USTATUS_OFFS, &tmp))
346                                 tmp = 0x7e;
347                         else
348                                 tmp = 0;
349                 }
350         }
351         if (tmp) {
352                 id = GIO_ID(tmp);
353                 if (tmp & GIO_32BIT_ID) {
354                         if (tmp & GIO_64BIT_IFACE)
355                                 ip22_gio_set_64bit(slotno);
356                 }
357                 for (i = 0; i < ARRAY_SIZE(gio_name_table); i++) {
358                         if (id == gio_name_table[i].id) {
359                                 name = gio_name_table[i].name;
360                                 break;
361                         }
362                 }
363                 printk(KERN_INFO "GIO: slot %d : %s (id %x)\n",
364                        slotno, name, id);
365                 gio_dev = kzalloc(sizeof *gio_dev, GFP_KERNEL);
366                 gio_dev->name = name;
367                 gio_dev->slotno = slotno;
368                 gio_dev->id.id = id;
369                 gio_dev->resource.start = addr;
370                 gio_dev->resource.end = addr + 0x3fffff;
371                 gio_dev->resource.flags = IORESOURCE_MEM;
372                 gio_dev->irq = irq;
373                 dev_set_name(&gio_dev->dev, "%d", slotno);
374                 gio_device_register(gio_dev);
375         } else
376                 printk(KERN_INFO "GIO: slot %d : Empty\n", slotno);
377 }
378 
379 static struct bus_type gio_bus_type = {
380         .name      = "gio",
381         .dev_groups = gio_dev_groups,
382         .match     = gio_bus_match,
383         .probe     = gio_device_probe,
384         .remove    = gio_device_remove,
385         .shutdown  = gio_device_shutdown,
386         .uevent    = gio_device_uevent,
387 };
388 
389 static struct resource gio_bus_resource = {
390         .start = GIO_SLOT_GFX_BASE,
391         .end   = GIO_SLOT_GFX_BASE + 0x9fffff,
392         .name  = "GIO Bus",
393         .flags = IORESOURCE_MEM,
394 };
395 
396 int __init ip22_gio_init(void)
397 {
398         unsigned int pbdma __maybe_unused;
399         int ret;
400 
401         ret = device_register(&gio_bus);
402         if (ret) {
403                 put_device(&gio_bus);
404                 return ret;
405         }
406 
407         ret = bus_register(&gio_bus_type);
408         if (!ret) {
409                 request_resource(&iomem_resource, &gio_bus_resource);
410                 printk(KERN_INFO "GIO: Probing bus...\n");
411 
412                 if (ip22_is_fullhouse()) {
413                         /* Indigo2 */
414                         ip22_check_gio(0, GIO_SLOT_GFX_BASE, SGI_GIO_1_IRQ);
415                         ip22_check_gio(1, GIO_SLOT_EXP0_BASE, SGI_GIO_1_IRQ);
416                 } else {
417                         /* Indy/Challenge S */
418                         if (get_dbe(pbdma, (unsigned int *)&hpc3c1->pbdma[1]))
419                                 ip22_check_gio(0, GIO_SLOT_GFX_BASE,
420                                                SGI_GIO_0_IRQ);
421                         ip22_check_gio(1, GIO_SLOT_EXP0_BASE, SGI_GIOEXP0_IRQ);
422                         ip22_check_gio(2, GIO_SLOT_EXP1_BASE, SGI_GIOEXP1_IRQ);
423                 }
424         } else
425                 device_unregister(&gio_bus);
426 
427         return ret;
428 }
429 
430 subsys_initcall(ip22_gio_init);
431 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp