[IA64-SGI] Altix only: Remove hubdev SAL call
[linux-2.6.git] / arch / ia64 / sn / kernel / tiocx.c
1 /*
2  * This file is subject to the terms and conditions of the GNU General Public
3  * License.  See the file "COPYING" in the main directory of this archive
4  * for more details.
5  *
6  * Copyright (c) 2005 Silicon Graphics, Inc.  All rights reserved.
7  */
8
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/version.h>
12 #include <linux/slab.h>
13 #include <linux/spinlock.h>
14 #include <linux/proc_fs.h>
15 #include <linux/device.h>
16 #include <linux/delay.h>
17 #include <asm/uaccess.h>
18 #include <asm/sn/sn_sal.h>
19 #include <asm/sn/addrs.h>
20 #include <asm/sn/io.h>
21 #include <asm/sn/types.h>
22 #include <asm/sn/shubio.h>
23 #include <asm/sn/tiocx.h>
24 #include "tio.h"
25 #include "xtalk/xwidgetdev.h"
26 #include "xtalk/hubdev.h"
27
28 #define CX_DEV_NONE 0
29 #define DEVICE_NAME "tiocx"
30 #define WIDGET_ID 0
31 #define TIOCX_DEBUG 0
32
33 #if TIOCX_DEBUG
34 #define DBG(fmt...)    printk(KERN_ALERT fmt)
35 #else
36 #define DBG(fmt...)
37 #endif
38
39 struct device_attribute dev_attr_cxdev_control;
40
41 /**
42  * tiocx_match - Try to match driver id list with device.
43  * @dev: device pointer
44  * @drv: driver pointer
45  *
46  * Returns 1 if match, 0 otherwise.
47  */
48 static int tiocx_match(struct device *dev, struct device_driver *drv)
49 {
50         struct cx_dev *cx_dev = to_cx_dev(dev);
51         struct cx_drv *cx_drv = to_cx_driver(drv);
52         const struct cx_device_id *ids = cx_drv->id_table;
53
54         if (!ids)
55                 return 0;
56
57         while (ids->part_num) {
58                 if (ids->part_num == cx_dev->cx_id.part_num)
59                         return 1;
60                 ids++;
61         }
62         return 0;
63
64 }
65
66 static int tiocx_hotplug(struct device *dev, char **envp, int num_envp,
67                          char *buffer, int buffer_size)
68 {
69         return -ENODEV;
70 }
71
72 static void tiocx_bus_release(struct device *dev)
73 {
74         kfree(to_cx_dev(dev));
75 }
76
77 struct bus_type tiocx_bus_type = {
78         .name = "tiocx",
79         .match = tiocx_match,
80         .hotplug = tiocx_hotplug,
81 };
82
83 /**
84  * cx_device_match - Find cx_device in the id table.
85  * @ids: id table from driver
86  * @cx_device: part/mfg id for the device
87  *
88  */
89 static const struct cx_device_id *cx_device_match(const struct cx_device_id
90                                                   *ids,
91                                                   struct cx_dev *cx_device)
92 {
93         /*
94          * NOTES: We may want to check for CX_ANY_ID too.
95          *        Do we want to match against nasid too?
96          *        CX_DEV_NONE == 0, if the driver tries to register for
97          *        part/mfg == 0 we should return no-match (NULL) here.
98          */
99         while (ids->part_num && ids->mfg_num) {
100                 if (ids->part_num == cx_device->cx_id.part_num &&
101                     ids->mfg_num == cx_device->cx_id.mfg_num)
102                         return ids;
103                 ids++;
104         }
105
106         return NULL;
107 }
108
109 /**
110  * cx_device_probe - Look for matching device.
111  *                      Call driver probe routine if found.
112  * @cx_driver: driver table (cx_drv struct) from driver
113  * @cx_device: part/mfg id for the device
114  */
115 static int cx_device_probe(struct device *dev)
116 {
117         const struct cx_device_id *id;
118         struct cx_drv *cx_drv = to_cx_driver(dev->driver);
119         struct cx_dev *cx_dev = to_cx_dev(dev);
120         int error = 0;
121
122         if (!cx_dev->driver && cx_drv->probe) {
123                 id = cx_device_match(cx_drv->id_table, cx_dev);
124                 if (id) {
125                         if ((error = cx_drv->probe(cx_dev, id)) < 0)
126                                 return error;
127                         else
128                                 cx_dev->driver = cx_drv;
129                 }
130         }
131
132         return error;
133 }
134
135 /**
136  * cx_driver_remove - Remove driver from device struct.
137  * @dev: device
138  */
139 static int cx_driver_remove(struct device *dev)
140 {
141         struct cx_dev *cx_dev = to_cx_dev(dev);
142         struct cx_drv *cx_drv = cx_dev->driver;
143         if (cx_drv->remove)
144                 cx_drv->remove(cx_dev);
145         cx_dev->driver = NULL;
146         return 0;
147 }
148
149 /**
150  * cx_driver_register - Register the driver.
151  * @cx_driver: driver table (cx_drv struct) from driver
152  * 
153  * Called from the driver init routine to register a driver.
154  * The cx_drv struct contains the driver name, a pointer to
155  * a table of part/mfg numbers and a pointer to the driver's
156  * probe/attach routine.
157  */
158 int cx_driver_register(struct cx_drv *cx_driver)
159 {
160         cx_driver->driver.name = cx_driver->name;
161         cx_driver->driver.bus = &tiocx_bus_type;
162         cx_driver->driver.probe = cx_device_probe;
163         cx_driver->driver.remove = cx_driver_remove;
164
165         return driver_register(&cx_driver->driver);
166 }
167
168 /**
169  * cx_driver_unregister - Unregister the driver.
170  * @cx_driver: driver table (cx_drv struct) from driver
171  */
172 int cx_driver_unregister(struct cx_drv *cx_driver)
173 {
174         driver_unregister(&cx_driver->driver);
175         return 0;
176 }
177
178 /**
179  * cx_device_register - Register a device.
180  * @nasid: device's nasid
181  * @part_num: device's part number
182  * @mfg_num: device's manufacturer number
183  * @hubdev: hub info associated with this device
184  *
185  */
186 int
187 cx_device_register(nasid_t nasid, int part_num, int mfg_num,
188                    struct hubdev_info *hubdev)
189 {
190         struct cx_dev *cx_dev;
191
192         cx_dev = kcalloc(1, sizeof(struct cx_dev), GFP_KERNEL);
193         DBG("cx_dev= 0x%p\n", cx_dev);
194         if (cx_dev == NULL)
195                 return -ENOMEM;
196
197         cx_dev->cx_id.part_num = part_num;
198         cx_dev->cx_id.mfg_num = mfg_num;
199         cx_dev->cx_id.nasid = nasid;
200         cx_dev->hubdev = hubdev;
201
202         cx_dev->dev.parent = NULL;
203         cx_dev->dev.bus = &tiocx_bus_type;
204         cx_dev->dev.release = tiocx_bus_release;
205         snprintf(cx_dev->dev.bus_id, BUS_ID_SIZE, "%d.0x%x",
206                  cx_dev->cx_id.nasid, cx_dev->cx_id.part_num);
207         device_register(&cx_dev->dev);
208         get_device(&cx_dev->dev);
209
210         device_create_file(&cx_dev->dev, &dev_attr_cxdev_control);
211
212         return 0;
213 }
214
215 /**
216  * cx_device_unregister - Unregister a device.
217  * @cx_dev: part/mfg id for the device
218  */
219 int cx_device_unregister(struct cx_dev *cx_dev)
220 {
221         put_device(&cx_dev->dev);
222         device_unregister(&cx_dev->dev);
223         return 0;
224 }
225
226 /**
227  * cx_device_reload - Reload the device.
228  * @nasid: device's nasid
229  * @part_num: device's part number
230  * @mfg_num: device's manufacturer number
231  *
232  * Remove the device associated with 'nasid' from device list and then
233  * call device-register with the given part/mfg numbers.
234  */
235 static int cx_device_reload(struct cx_dev *cx_dev)
236 {
237         device_remove_file(&cx_dev->dev, &dev_attr_cxdev_control);
238         cx_device_unregister(cx_dev);
239         return cx_device_register(cx_dev->cx_id.nasid, cx_dev->cx_id.part_num,
240                                   cx_dev->cx_id.mfg_num, cx_dev->hubdev);
241 }
242
243 static inline uint64_t tiocx_intr_alloc(nasid_t nasid, int widget,
244                                         u64 sn_irq_info,
245                                         int req_irq, nasid_t req_nasid,
246                                         int req_slice)
247 {
248         struct ia64_sal_retval rv;
249         rv.status = 0;
250         rv.v0 = 0;
251
252         ia64_sal_oemcall_nolock(&rv, SN_SAL_IOIF_INTERRUPT,
253                                 SAL_INTR_ALLOC, nasid,
254                                 widget, sn_irq_info, req_irq,
255                                 req_nasid, req_slice);
256         return rv.status;
257 }
258
259 static inline void tiocx_intr_free(nasid_t nasid, int widget,
260                                    struct sn_irq_info *sn_irq_info)
261 {
262         struct ia64_sal_retval rv;
263         rv.status = 0;
264         rv.v0 = 0;
265
266         ia64_sal_oemcall_nolock(&rv, SN_SAL_IOIF_INTERRUPT,
267                                 SAL_INTR_FREE, nasid,
268                                 widget, sn_irq_info->irq_irq,
269                                 sn_irq_info->irq_cookie, 0, 0);
270 }
271
272 struct sn_irq_info *tiocx_irq_alloc(nasid_t nasid, int widget, int irq,
273                                     nasid_t req_nasid, int slice)
274 {
275         struct sn_irq_info *sn_irq_info;
276         int status;
277         int sn_irq_size = sizeof(struct sn_irq_info);
278
279         if ((nasid & 1) == 0)
280                 return NULL;
281
282         sn_irq_info = kmalloc(sn_irq_size, GFP_KERNEL);
283         if (sn_irq_info == NULL)
284                 return NULL;
285
286         memset(sn_irq_info, 0x0, sn_irq_size);
287
288         status = tiocx_intr_alloc(nasid, widget, __pa(sn_irq_info), irq,
289                                   req_nasid, slice);
290         if (status) {
291                 kfree(sn_irq_info);
292                 return NULL;
293         } else {
294                 return sn_irq_info;
295         }
296 }
297
298 void tiocx_irq_free(struct sn_irq_info *sn_irq_info)
299 {
300         uint64_t bridge = (uint64_t) sn_irq_info->irq_bridge;
301         nasid_t nasid = NASID_GET(bridge);
302         int widget;
303
304         if (nasid & 1) {
305                 widget = TIO_SWIN_WIDGETNUM(bridge);
306                 tiocx_intr_free(nasid, widget, sn_irq_info);
307                 kfree(sn_irq_info);
308         }
309 }
310
311 uint64_t
312 tiocx_dma_addr(uint64_t addr)
313 {
314         return PHYS_TO_TIODMA(addr);
315 }
316
317 uint64_t
318 tiocx_swin_base(int nasid)
319 {
320         return TIO_SWIN_BASE(nasid, TIOCX_CORELET);
321 }
322
323 EXPORT_SYMBOL(cx_driver_register);
324 EXPORT_SYMBOL(cx_driver_unregister);
325 EXPORT_SYMBOL(cx_device_register);
326 EXPORT_SYMBOL(cx_device_unregister);
327 EXPORT_SYMBOL(tiocx_irq_alloc);
328 EXPORT_SYMBOL(tiocx_irq_free);
329 EXPORT_SYMBOL(tiocx_bus_type);
330 EXPORT_SYMBOL(tiocx_dma_addr);
331 EXPORT_SYMBOL(tiocx_swin_base);
332
333 static void tio_conveyor_set(nasid_t nasid, int enable_flag)
334 {
335         uint64_t ice_frz;
336         uint64_t disable_cb = (1ull << 61);
337
338         if (!(nasid & 1))
339                 return;
340
341         ice_frz = REMOTE_HUB_L(nasid, TIO_ICE_FRZ_CFG);
342         if (enable_flag) {
343                 if (!(ice_frz & disable_cb))    /* already enabled */
344                         return;
345                 ice_frz &= ~disable_cb;
346         } else {
347                 if (ice_frz & disable_cb)       /* already disabled */
348                         return;
349                 ice_frz |= disable_cb;
350         }
351         DBG(KERN_ALERT "TIO_ICE_FRZ_CFG= 0x%lx\n", ice_frz);
352         REMOTE_HUB_S(nasid, TIO_ICE_FRZ_CFG, ice_frz);
353 }
354
355 #define tio_conveyor_enable(nasid) tio_conveyor_set(nasid, 1)
356 #define tio_conveyor_disable(nasid) tio_conveyor_set(nasid, 0)
357
358 static void tio_corelet_reset(nasid_t nasid, int corelet)
359 {
360         if (!(nasid & 1))
361                 return;
362
363         REMOTE_HUB_S(nasid, TIO_ICE_PMI_TX_CFG, 1 << corelet);
364         udelay(2000);
365         REMOTE_HUB_S(nasid, TIO_ICE_PMI_TX_CFG, 0);
366         udelay(2000);
367 }
368
369 static int fpga_attached(nasid_t nasid)
370 {
371         uint64_t cx_credits;
372
373         cx_credits = REMOTE_HUB_L(nasid, TIO_ICE_PMI_TX_DYN_CREDIT_STAT_CB3);
374         cx_credits &= TIO_ICE_PMI_TX_DYN_CREDIT_STAT_CB3_CREDIT_CNT_MASK;
375         DBG("cx_credits= 0x%lx\n", cx_credits);
376
377         return (cx_credits == 0xf) ? 1 : 0;
378 }
379
380 static int tiocx_reload(struct cx_dev *cx_dev)
381 {
382         int part_num = CX_DEV_NONE;
383         int mfg_num = CX_DEV_NONE;
384         nasid_t nasid = cx_dev->cx_id.nasid;
385
386         if (fpga_attached(nasid)) {
387                 uint64_t cx_id;
388
389                 cx_id =
390                     *(volatile int32_t *)(TIO_SWIN_BASE(nasid, TIOCX_CORELET) +
391                                           WIDGET_ID);
392                 part_num = XWIDGET_PART_NUM(cx_id);
393                 mfg_num = XWIDGET_MFG_NUM(cx_id);
394                 DBG("part= 0x%x, mfg= 0x%x\n", part_num, mfg_num);
395                 /* just ignore it if it's a CE */
396                 if (part_num == TIO_CE_ASIC_PARTNUM)
397                         return 0;
398         }
399
400         cx_dev->cx_id.part_num = part_num;
401         cx_dev->cx_id.mfg_num = mfg_num;
402
403         /*
404          * Delete old device and register the new one.  It's ok if
405          * part_num/mfg_num == CX_DEV_NONE.  We want to register
406          * devices in the table even if a bitstream isn't loaded.
407          * That allows use to see that a bitstream isn't loaded via
408          * TIOCX_IOCTL_DEV_LIST.
409          */
410         return cx_device_reload(cx_dev);
411 }
412
413 static ssize_t show_cxdev_control(struct device *dev, char *buf)
414 {
415         struct cx_dev *cx_dev = to_cx_dev(dev);
416
417         return sprintf(buf, "0x%x 0x%x 0x%x\n",
418                        cx_dev->cx_id.nasid,
419                        cx_dev->cx_id.part_num, cx_dev->cx_id.mfg_num);
420 }
421
422 static ssize_t store_cxdev_control(struct device *dev, const char *buf,
423                                    size_t count)
424 {
425         int n;
426         struct cx_dev *cx_dev = to_cx_dev(dev);
427
428         if (!capable(CAP_SYS_ADMIN))
429                 return -EPERM;
430
431         if (count <= 0)
432                 return 0;
433
434         n = simple_strtoul(buf, NULL, 0);
435
436         switch (n) {
437         case 1:
438                 tiocx_reload(cx_dev);
439                 break;
440         case 3:
441                 tio_corelet_reset(cx_dev->cx_id.nasid, TIOCX_CORELET);
442                 break;
443         default:
444                 break;
445         }
446
447         return count;
448 }
449
450 DEVICE_ATTR(cxdev_control, 0644, show_cxdev_control, store_cxdev_control);
451
452 static int __init tiocx_init(void)
453 {
454         cnodeid_t cnodeid;
455         int found_tiocx_device = 0;
456
457         bus_register(&tiocx_bus_type);
458
459         for (cnodeid = 0; cnodeid < MAX_COMPACT_NODES; cnodeid++) {
460                 nasid_t nasid;
461
462                 if ((nasid = cnodeid_to_nasid(cnodeid)) < 0)
463                         break;  /* No more nasids .. bail out of loop */
464
465                 if (nasid & 0x1) {      /* TIO's are always odd */
466                         struct hubdev_info *hubdev;
467                         struct xwidget_info *widgetp;
468
469                         DBG("Found TIO at nasid 0x%x\n", nasid);
470
471                         hubdev =
472                             (struct hubdev_info *)(NODEPDA(cnodeid)->pdinfo);
473
474                         widgetp = &hubdev->hdi_xwidget_info[TIOCX_CORELET];
475
476                         /* The CE hangs off of the CX port but is not an FPGA */
477                         if (widgetp->xwi_hwid.part_num == TIO_CE_ASIC_PARTNUM)
478                                 continue;
479
480                         tio_corelet_reset(nasid, TIOCX_CORELET);
481                         tio_conveyor_enable(nasid);
482
483                         if (cx_device_register
484                             (nasid, widgetp->xwi_hwid.part_num,
485                              widgetp->xwi_hwid.mfg_num, hubdev) < 0)
486                                 return -ENXIO;
487                         else
488                                 found_tiocx_device++;
489                 }
490         }
491
492         /* It's ok if we find zero devices. */
493         DBG("found_tiocx_device= %d\n", found_tiocx_device);
494
495         return 0;
496 }
497
498 static void __exit tiocx_exit(void)
499 {
500         struct device *dev;
501         struct device *tdev;
502
503         DBG("tiocx_exit\n");
504
505         /*
506          * Unregister devices.
507          */
508         list_for_each_entry_safe(dev, tdev, &tiocx_bus_type.devices.list,
509                                  bus_list) {
510                 if (dev) {
511                         struct cx_dev *cx_dev = to_cx_dev(dev);
512                         device_remove_file(dev, &dev_attr_cxdev_control);
513                         cx_device_unregister(cx_dev);
514                 }
515         }
516
517         bus_unregister(&tiocx_bus_type);
518 }
519
520 module_init(tiocx_init);
521 module_exit(tiocx_exit);
522
523 /************************************************************************
524  * Module licensing and description
525  ************************************************************************/
526 MODULE_LICENSE("GPL");
527 MODULE_AUTHOR("Bruce Losure <blosure@sgi.com>");
528 MODULE_DESCRIPTION("TIOCX module");
529 MODULE_SUPPORTED_DEVICE(DEVICE_NAME);