开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
xbow.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：49k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

xbow.c：源码内容
  1. /* $Id$
  2.  *
  3.  * This file is subject to the terms and conditions of the GNU General Public
  4.  * License.  See the file "COPYING" in the main directory of this archive
  5.  * for more details.
  6.  *
  7.  * Copyright (C) 1992 - 1997, 2000 Silicon Graphics, Inc.
  8.  * Copyright (C) 2000 by Colin Ngam
  9.  */
  11. #include <linux/types.h>
  12. #include <linux/slab.h>
  13. #include <linux/sched.h>
  14. #include <asm/sn/sgi.h>
  15. #include <asm/sn/iograph.h>
  16. #include <asm/sn/invent.h>
  17. #include <asm/sn/hcl.h>
  18. #include <asm/sn/labelcl.h>
  19. #include <asm/sn/hack.h>
  20. #include <asm/sn/pci/bridge.h>
  21. #include <asm/sn/xtalk/xtalk_private.h>
  23. /* #define DEBUG 1 */
  24. /* #define XBOW_DEBUG 1 */
  27. /*
  28.  * Files needed to get the device driver entry points
  29.  */
  31. #include <asm/sn/xtalk/xbow.h>
  32. #include <asm/sn/xtalk/xtalk.h>
  33. #include <asm/sn/xtalk/xswitch.h>
  34. #include <asm/sn/xtalk/xwidget.h>
  36. #include <asm/sn/prio.h>
  37. #include <asm/sn/hcl_util.h>
  40. #define NEW(ptr) (ptr = kmalloc(sizeof (*(ptr)), GFP_KERNEL))
  41. #define DEL(ptr) (kfree(ptr))
  43. int                     xbow_devflag = D_MP;
  45. /*
  46.  * This file supports the Xbow chip.  Main functions: initializtion,
  47.  * error handling, and GBR.
  48.  */
  50. /*
  51.  * each vertex corresponding to an xbow chip
  52.  * has a "fastinfo" pointer pointing at one
  53.  * of these things.
  54.  */
  55. typedef struct xbow_soft_s *xbow_soft_t;
  57. struct xbow_soft_s {
  58.     devfs_handle_t            conn; /* our connection point */
  59.     devfs_handle_t            vhdl; /* xbow's private vertex */
  60.     devfs_handle_t            busv; /* the xswitch vertex */
  61.     xbow_t                 *base; /* PIO pointer to crossbow chip */
  62.     char                   *name; /* hwgraph name */
  64.     xbow_perf_t             xbow_perfcnt[XBOW_PERF_COUNTERS];
  65.     xbow_perf_link_t        xbow_perflink[MAX_XBOW_PORTS];
  66.     xbow_link_status_t      xbow_link_status[MAX_XBOW_PORTS];
  67.     spinlock_t              xbow_perf_lock;
  68.     int                     link_monitor;
  69.     widget_cfg_t    *wpio[MAX_XBOW_PORTS]; /* cached PIO pointer */
  71.     /* Bandwidth allocation state. Bandwidth values are for the
  72.      * destination port since contention happens there.
  73.      * Implicit mapping from xbow ports (8..f) -> (0..7) array indices.
  74.      */
  75.     spinlock_t     xbow_bw_alloc_lock; /* bw allocation lock */
  76.     unsigned long long     bw_hiwm[MAX_XBOW_PORTS]; /* hiwater mark values */
  77.     unsigned long long      bw_cur_used[MAX_XBOW_PORTS]; /* bw used currently */
  78. };
  80. #define xbow_soft_set(v,i) hwgraph_fastinfo_set((v), (arbitrary_info_t)(i))
  81. #define xbow_soft_get(v) ((xbow_soft_t)hwgraph_fastinfo_get((v)))
  83. /*
  84.  * Function Table of Contents
  85.  */
  87. void                    xbow_mlreset(xbow_t *);
  88. void                    xbow_init(void);
  89. int                     xbow_attach(devfs_handle_t);
  91. int                     xbow_open(devfs_handle_t *, int, int, cred_t *);
  92. int                     xbow_close(devfs_handle_t, int, int, cred_t *);
  94. int                     xbow_map(devfs_handle_t, vhandl_t *, off_t, size_t, uint);
  95. int                     xbow_unmap(devfs_handle_t, vhandl_t *);
  96. int                     xbow_ioctl(devfs_handle_t, int, void *, int, struct cred *, int *);
  98. int                     xbow_widget_present(xbow_t *, int);
  99. static int              xbow_link_alive(xbow_t *, int);
  100. devfs_handle_t            xbow_widget_lookup(devfs_handle_t, int);
  102. #ifdef LATER
  103. static void             xbow_setwidint(xtalk_intr_t);
  104. static void             xbow_errintr_handler(intr_arg_t);
  105. static error_handler_f  xbow_error_handler;
  106. #endif
  107. void                    xbow_intr_preset(void *, int, xwidgetnum_t, iopaddr_t, xtalk_intr_vector_t);
  111. void                    xbow_update_perf_counters(devfs_handle_t);
  112. xbow_perf_link_t       *xbow_get_perf_counters(devfs_handle_t);
  113. int                     xbow_enable_perf_counter(devfs_handle_t, int, int, int);
  114. xbow_link_status_t     *xbow_get_llp_status(devfs_handle_t);
  115. void                    xbow_update_llp_status(devfs_handle_t);
  117. int                     xbow_disable_llp_monitor(devfs_handle_t);
  118. int                     xbow_enable_llp_monitor(devfs_handle_t);
  119. int                     xbow_prio_bw_alloc(devfs_handle_t, xwidgetnum_t, xwidgetnum_t,
  120.                                 unsigned long long, unsigned long long);
  122. xswitch_reset_link_f    xbow_reset_link;
  124. void                    idbg_xbowregs(int64_t);
  126. xswitch_provider_t      xbow_provider =
  127. {
  128.     xbow_reset_link,
  129. };
  131. /*
  132.  *    xbow_mlreset: called at mlreset time if the
  133.  *      platform specific code determines that there is
  134.  *      a crossbow in a critical path that must be
  135.  *      functional before the driver would normally get
  136.  *      the device properly set up.
  137.  *
  138.  *      what do we need to do, that the boot prom can
  139.  *      not be counted on to have already done, that is
  140.  *      generic across all platforms using crossbows?
  141.  */
  142. /*ARGSUSED */
  143. void
  144. xbow_mlreset(xbow_t * xbow)
  145. {
  146. }
  148. /*
  149.  *    xbow_init: called with the rest of the device
  150.  *      driver XXX_init routines. This platform *might*
  151.  *      have a Crossbow chip, or even several, but it
  152.  *      might have none. Register with the crosstalk
  153.  *      generic provider so when we encounter the chip
  154.  *      the right magic happens.
  155.  */
  156. void
  157. xbow_init(void)
  158. {
  160. #if DEBUG && ATTACH_DEBUG
  161.     printf("xbow_initn");
  162. #endif
  164.     xwidget_driver_register(XXBOW_WIDGET_PART_NUM,
  165.     0, /* XXBOW_WIDGET_MFGR_NUM, */
  166.     "xbow_",
  167.     CDL_PRI_HI); /* attach before friends */
  169.     xwidget_driver_register(XBOW_WIDGET_PART_NUM,
  170.     XBOW_WIDGET_MFGR_NUM,
  171.     "xbow_",
  172.     CDL_PRI_HI); /* attach before friends */
  173. }
  175. #ifdef XBRIDGE_REGS_SIM
  176. /*    xbow_set_simulated_regs: sets xbow regs as needed
  177.  * for powering through the boot
  178.  */
  179. void
  180. xbow_set_simulated_regs(xbow_t *xbow, int port)
  181. {
  182.     /*
  183.      * turn on link
  184.      */
  185.     xbow->xb_link(port).link_status = (1<<31);
  186.     /*
  187.      * and give it a live widget too
  188.      */
  189.     xbow->xb_link(port).link_aux_status = XB_AUX_STAT_PRESENT;
  190.     /*
  191.      * zero the link control reg
  192.      */
  193.     xbow->xb_link(port).link_control = 0x0;
  194. }
  195. #endif /* XBRIDGE_REGS_SIM */
  197. /*
  198.  *    xbow_attach: the crosstalk provider has
  199.  *      determined that there is a crossbow widget
  200.  *      present, and has handed us the connection
  201.  *      point for that vertex.
  202.  *
  203.  *      We not only add our own vertex, but add
  204.  *      some "xtalk switch" data to the switch
  205.  *      vertex (at the connect point's parent) if
  206.  *      it does not have any.
  207.  */
  209. /*ARGSUSED */
  210. int
  211. xbow_attach(devfs_handle_t conn)
  212. {
  213.     /*REFERENCED */
  214.     devfs_handle_t            vhdl;
  215.     devfs_handle_t            busv;
  216.     xbow_t                 *xbow;
  217.     xbow_soft_t             soft;
  218.     int                     port;
  219.     xswitch_info_t          info;
  220. #ifdef LATER
  221.     xtalk_intr_t            intr_hdl;
  222.     device_desc_t           dev_desc;
  223. #endif
  224.     char                    devnm[MAXDEVNAME], *s;
  225.     xbowreg_t               id;
  226.     int                     rev;
  227.     int     i;
  228.     int     xbow_num;
  230. #if DEBUG && ATTACH_DEBUG
  231. #if defined(SUPPORT_PRINTING_V_FORMAT
  232.     printk("%v: xbow_attachn", conn);
  233. #else
  234.     printk("0x%x: xbow_attachn", conn);
  235. #endif
  236. #endif
  238.     /*
  239.      * Get a PIO pointer to the base of the crossbow
  240.      * chip.
  241.      */
  242. #ifdef XBRIDGE_REGS_SIM
  243.     printk("xbow_attach: XBRIDGE_REGS_SIM FIXME: allocating %ld bytes for xbow_sn", sizeof(xbow_t));
  244.     xbow = (xbow_t *) kmalloc(sizeof(xbow_t), GFP_KERNEL);
  245.     /*
  246.      * turn on ports e and f like in a real live ibrick
  247.      */
  248.     xbow_set_simulated_regs(xbow, 0xe);
  249.     xbow_set_simulated_regs(xbow, 0xf);
  250. #else
  251.     xbow = (xbow_t *) xtalk_piotrans_addr(conn, 0, 0, sizeof(xbow_t), 0);
  252. #endif /* XBRIDGE_REGS_SIM */
  254.     /*
  255.      * Locate the "switch" vertex: it is the parent
  256.      * of our connection point.
  257.      */
  258.     busv = hwgraph_connectpt_get(conn);
  259. #if DEBUG && ATTACH_DEBUG
  260.     printk("xbow_attach: Bus Vertex 0x%p, conn 0x%p, xbow register 0x%p wid= 0x%xn", busv, conn, xbow, *(volatile u32 *)xbow);
  261. #endif
  263.     ASSERT(busv != GRAPH_VERTEX_NONE);
  265.     /*
  266.      * Create our private vertex, and connect our
  267.      * driver information to it. This makes it possible
  268.      * for diagnostic drivers to open the crossbow
  269.      * vertex for access to registers.
  270.      */
  272.     /*
  273.      * We need to teach xbow drivers to provide the right set of
  274.      * file ops.
  275.      */
  276.     vhdl = NULL;
  277.     vhdl = hwgraph_register(conn, EDGE_LBL_XBOW,
  278.                         0, DEVFS_FL_AUTO_DEVNUM,
  279.                         0, 0,
  280.                         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP, 0, 0,
  281.                         /* &hcl_fops */ (void *)&vhdl, NULL);
  282.     if (!vhdl) {
  283.         printk(KERN_WARNING "xbow_attach: Unable to create char device for xbow conn %pn",
  284.                 conn);
  285.     }
  287.     /*
  288.      * Allocate the soft state structure and attach
  289.      * it to the xbow's vertex
  290.      */
  291.     NEW(soft);
  292.     soft->conn = conn;
  293.     soft->vhdl = vhdl;
  294.     soft->busv = busv;
  295.     soft->base = xbow;
  296.     /* does the universe really need another macro?  */
  297.     /* xbow_soft_set(vhdl, (arbitrary_info_t) soft); */
  298.     hwgraph_fastinfo_set(vhdl, (arbitrary_info_t) soft);
  300. #define XBOW_NUM_SUFFIX_FORMAT "[xbow# %d]"
  302.     /* Add xbow number as a suffix to the hwgraph name of the xbow.
  303.      * This is helpful while looking at the error/warning messages.
  304.      */
  305.     xbow_num = 0;
  307.     /*
  308.      * get the name of this xbow vertex and keep the info.
  309.      * This is needed during errors and interrupts, but as
  310.      * long as we have it, we can use it elsewhere.
  311.      */
  312.     s = dev_to_name(vhdl, devnm, MAXDEVNAME);
  313.     soft->name = kmalloc(strlen(s) + strlen(XBOW_NUM_SUFFIX_FORMAT) + 1, 
  314.     GFP_KERNEL);
  315.     sprintf(soft->name,"%s"XBOW_NUM_SUFFIX_FORMAT, s,xbow_num);
  317. #ifdef XBRIDGE_REGS_SIM
  318.     /* my o200/ibrick has id=0x2d002049, but XXBOW_WIDGET_PART_NUM is defined
  319.      * as 0xd000, so I'm using that for the partnum bitfield.
  320.      */
  321.     printk("xbow_attach: XBRIDGE_REGS_SIM FIXME: need xb_wid_id value!!n");
  322.     id = 0x2d000049;
  323. #else
  324.     id = xbow->xb_wid_id;
  325. #endif /* XBRIDGE_REGS_SIM */
  326.     rev = XWIDGET_PART_REV_NUM(id);
  328.     /*
  329.      * Print the revision if DEBUG, or SHOW_REVS and kdebug,
  330.      * or the xbow is downrev.
  331.      *
  332.      * If xbow is downrev, make it a WARNING that the
  333.      * Crossbow is DOWNREV: these chips are not good
  334.      * to have around, and the operator should be told.
  335.      */
  336. #ifdef LATER
  337. #if !DEBUG
  338.     if (
  339. #if SHOW_REVS
  340.    (kdebug) ||
  341. #endif /* SHOW_REVS */
  342.    (rev < XBOW_REV_1_1))
  343. #endif /* !DEBUG  */
  344. printk("%sCrossbow ASIC: rev %s (code=%d) at %s%s",
  345. (rev < XBOW_REV_1_1) ? "DOWNREV " : "",
  346. (rev == XBOW_REV_1_0) ? "1.0" :
  347. (rev == XBOW_REV_1_1) ? "1.1" :
  348. (rev == XBOW_REV_1_2) ? "1.2" :
  349. (rev == XBOW_REV_1_3) ? "1.3" :
  350. (rev == XBOW_REV_2_0) ? "2.0" :
  351. (rev == XXBOW_PART_REV_1_0) ? "Xbridge 1.0" :
  352. (rev == XXBOW_PART_REV_2_0) ? "Xbridge 2.0" :
  353. "unknown",
  354. rev, soft->name,
  355. (rev < XBOW_REV_1_1) ? "" : "n");
  356. #endif /* LATER */
  357.     mutex_spinlock_init(&soft->xbow_perf_lock);
  358.     soft->xbow_perfcnt[0].xp_perf_reg = &xbow->xb_perf_ctr_a;
  359.     soft->xbow_perfcnt[1].xp_perf_reg = &xbow->xb_perf_ctr_b;
  361.     /* Initialization for GBR bw allocation */
  362.     mutex_spinlock_init(&soft->xbow_bw_alloc_lock);
  364. #define XBOW_8_BIT_PORT_BW_MAX (400 * 1000 * 1000) /* 400 MB/s */
  365. #define XBOW_16_BIT_PORT_BW_MAX (800 * 1000 * 1000) /* 800 MB/s */
  367.     /* Set bandwidth hiwatermark and current values */
  368.     for (i = 0; i < MAX_XBOW_PORTS; i++) {
  369. soft->bw_hiwm[i] = XBOW_16_BIT_PORT_BW_MAX; /* for now */
  370. soft->bw_cur_used[i] = 0;
  371.     }
  373.     /*
  374.      * attach the crossbow error interrupt.
  375.      */
  376. #ifdef LATER
  377.     dev_desc = device_desc_dup(vhdl);
  378.     device_desc_flags_set(dev_desc,
  379.   device_desc_flags_get(dev_desc) | D_INTR_ISERR);
  380.     device_desc_intr_name_set(dev_desc, "Crossbow error");
  382.     intr_hdl = xtalk_intr_alloc(conn, dev_desc, vhdl);
  383.     ASSERT(intr_hdl != NULL);
  385.     xtalk_intr_connect(intr_hdl,
  386.        (intr_func_t) xbow_errintr_handler,
  387.        (intr_arg_t) soft,
  388.        (xtalk_intr_setfunc_t) xbow_setwidint,
  389.        (void *) xbow,
  390.        (void *) 0);
  391.     device_desc_free(dev_desc);
  393.     xwidget_error_register(conn, xbow_error_handler, soft);
  395. #else
  396.     FIXME("xbow_attach: Fixme: we bypassed attaching xbow error interrupt.n");
  397. #endif /* LATER */
  399.     /*
  400.      * Enable xbow error interrupts
  401.      */
  402.     xbow->xb_wid_control = (XB_WID_CTRL_REG_ACC_IE |
  403.     XB_WID_CTRL_XTALK_IE);
  405.     /*
  406.      * take a census of the widgets present,
  407.      * leaving notes at the switch vertex.
  408.      */
  409.     info = xswitch_info_new(busv);
  411.     for (port = MAX_PORT_NUM - MAX_XBOW_PORTS;
  412.  port < MAX_PORT_NUM; ++port) {
  413. if (!xbow_link_alive(xbow, port)) {
  414. #if DEBUG && XBOW_DEBUG
  415.     printk(KERN_INFO "0x%p link %d is not aliven",
  416.     busv, port);
  417. #endif
  418.     continue;
  419. }
  420. if (!xbow_widget_present(xbow, port)) {
  421. #if DEBUG && XBOW_DEBUG
  422.     printk(KERN_INFO "0x%p link %d is alive but no widget is presentn", busv, port);
  423. #endif
  424.     continue;
  425. }
  426. #if DEBUG && XBOW_DEBUG
  427. printk(KERN_INFO "0x%p link %d has a widgetn",
  428. busv, port);
  429. #endif
  431. xswitch_info_link_is_ok(info, port);
  432. /*
  433.  * Turn some error interrupts on
  434.  * and turn others off. The PROM has
  435.  * some things turned on we don't
  436.  * want to see (bandwidth allocation
  437.  * errors for instance); so if it
  438.  * is not listed here, it is not on.
  439.  */
  440. xbow->xb_link(port).link_control =
  441.     ( (xbow->xb_link(port).link_control
  442. /*
  443.  * Turn off these bits; they are non-fatal,
  444.  * but we might want to save some statistics
  445.  * on the frequency of these errors.
  446.  * XXX FIXME XXX
  447.  */
  448.     & ~XB_CTRL_RCV_CNT_OFLOW_IE
  449.     & ~XB_CTRL_XMT_CNT_OFLOW_IE
  450.     & ~XB_CTRL_BNDWDTH_ALLOC_IE
  451.     & ~XB_CTRL_RCV_IE)
  452. /*
  453.  * These are the ones we want to turn on.
  454.  */
  455.     | (XB_CTRL_ILLEGAL_DST_IE
  456.     | XB_CTRL_OALLOC_IBUF_IE
  457.     | XB_CTRL_XMT_MAX_RTRY_IE
  458.     | XB_CTRL_MAXREQ_TOUT_IE
  459.     | XB_CTRL_XMT_RTRY_IE
  460.     | XB_CTRL_SRC_TOUT_IE) );
  461.     }
  463.     xswitch_provider_register(busv, &xbow_provider);
  465.     return 0; /* attach successful */
  466. }
  468. /*ARGSUSED */
  469. int
  470. xbow_open(devfs_handle_t *devp, int oflag, int otyp, cred_t *credp)
  471. {
  472.     return 0;
  474. }
  476. /*ARGSUSED */
  477. int
  478. xbow_close(devfs_handle_t dev, int oflag, int otyp, cred_t *crp)
  479. {
  480.     return 0;
  481. }
  483. /*ARGSUSED */
  484. int
  485. xbow_map(devfs_handle_t dev, vhandl_t *vt, off_t off, size_t len, uint prot)
  486. {
  487.     devfs_handle_t            vhdl = dev_to_vhdl(dev);
  488.     xbow_soft_t             soft = xbow_soft_get(vhdl);
  489.     int                     error;
  491.     ASSERT(soft);
  492.     len = ctob(btoc(len));
  493.     /* XXX- this ignores the offset!!! */
  494.     error = v_mapphys(vt, (void *) soft->base, len);
  495.     return error;
  496. }
  498. /*ARGSUSED */
  499. int
  500. xbow_unmap(devfs_handle_t dev, vhandl_t *vt)
  501. {
  502.     return 0;
  503. }
  505. /* This contains special-case code for grio. There are plans to make
  506.  * this general sometime in the future, but till then this should
  507.  * be good enough.
  508.  */
  509. xwidgetnum_t
  510. xbow_widget_num_get(devfs_handle_t dev)
  511. {
  512. devfs_handle_t tdev;
  513. char devname[MAXDEVNAME];
  514. xwidget_info_t xwidget_info;
  515. int i;
  517. vertex_to_name(dev, devname, MAXDEVNAME);
  519. /* If this is a pci controller vertex, traverse up using
  520.  * the ".." links to get to the widget.
  521.  */
  522. if (strstr(devname, EDGE_LBL_PCI) &&
  523. strstr(devname, EDGE_LBL_CONTROLLER)) {
  524. tdev = dev;
  525. for (i=0; i< 2; i++) {
  526. if (hwgraph_edge_get(tdev,
  527. HWGRAPH_EDGELBL_DOTDOT, &tdev) !=
  528. GRAPH_SUCCESS)
  529. return XWIDGET_NONE;
  530. }
  532. if ((xwidget_info = xwidget_info_chk(tdev)) != NULL) {
  533. return (xwidget_info_id_get(xwidget_info));
  534. } else {
  535. return XWIDGET_NONE;
  536. }
  537. }
  539. return XWIDGET_NONE;
  540. }
  542. int
  543. xbow_ioctl(devfs_handle_t dev,
  544.    int cmd,
  545.    void *arg,
  546.    int flag,
  547.    struct cred *cr,
  548.    int *rvalp)
  549. {
  550.     devfs_handle_t            vhdl;
  551.     int                     error = 0;
  553. #if defined (DEBUG)
  554.     int                     rc;
  555.     devfs_handle_t            conn;
  556.     struct xwidget_info_s  *xwidget_info;
  557.     xbow_soft_t             xbow_soft;
  558. #endif
  559.     *rvalp = 0;
  561.     vhdl = dev_to_vhdl(dev);
  562. #if defined (DEBUG)
  563.     xbow_soft = xbow_soft_get(vhdl);
  564.     conn = xbow_soft->conn;
  566.     xwidget_info = xwidget_info_get(conn);
  567.     ASSERT_ALWAYS(xwidget_info != NULL);
  569.     rc = xwidget_hwid_is_xswitch(&xwidget_info->w_hwid);
  570.     ASSERT_ALWAYS(rc != 0);
  571. #endif
  572.     switch (cmd) {
  573. #ifdef LATER
  574.     case XBOWIOC_PERF_ENABLE:
  575.     case XBOWIOC_PERF_DISABLE:
  576. {
  577.     struct xbow_perfarg_t   xbow_perf_en;
  579.     if (!_CAP_CRABLE(cr, CAP_DEVICE_MGT)) {
  580. error = EPERM;
  581. break;
  582.     }
  583.     if ((flag & FWRITE) == 0) {
  584. error = EBADF;
  585. break;
  586.     }
  587.     if (COPYIN(arg, &xbow_perf_en, sizeof(xbow_perf_en))) {
  588. error = EFAULT;
  589. break;
  590.     }
  591.     if (error = xbow_enable_perf_counter(vhdl,
  592.  xbow_perf_en.link,
  593.  (cmd == XBOWIOC_PERF_DISABLE) ? 0 : xbow_perf_en.mode,
  594.  xbow_perf_en.counter)) {
  595. error = EINVAL;
  596. break;
  597.     }
  598.     break;
  599. }
  600. #endif
  602. #ifdef LATER
  603.     case XBOWIOC_PERF_GET:
  604. {
  605.     xbow_perf_link_t       *xbow_perf_cnt;
  607.     if ((flag & FREAD) == 0) {
  608. error = EBADF;
  609. break;
  610.     }
  611.     xbow_perf_cnt = xbow_get_perf_counters(vhdl);
  612.     ASSERT_ALWAYS(xbow_perf_cnt != NULL);
  614.     if (COPYOUT((void *) xbow_perf_cnt, (void *) arg,
  615. MAX_XBOW_PORTS * sizeof(xbow_perf_link_t))) {
  616. error = EFAULT;
  617. break;
  618.     }
  619.     break;
  620. }
  621. #endif
  623.     case XBOWIOC_LLP_ERROR_ENABLE:
  624. if ((error = xbow_enable_llp_monitor(vhdl)) != 0)
  625.     error = EINVAL;
  627. break;
  629.     case XBOWIOC_LLP_ERROR_DISABLE:
  631. if ((error = xbow_disable_llp_monitor(vhdl)) != 0)
  632.     error = EINVAL;
  634. break;
  636. #ifdef LATER
  637.     case XBOWIOC_LLP_ERROR_GET:
  638. {
  639.     xbow_link_status_t     *xbow_llp_status;
  641.     if ((flag & FREAD) == 0) {
  642. error = EBADF;
  643. break;
  644.     }
  645.     xbow_llp_status = xbow_get_llp_status(vhdl);
  646.     ASSERT_ALWAYS(xbow_llp_status != NULL);
  648.     if (COPYOUT((void *) xbow_llp_status, (void *) arg,
  649. MAX_XBOW_PORTS * sizeof(xbow_link_status_t))) {
  650. error = EFAULT;
  651. break;
  652.     }
  653.     break;
  654. }
  655. #endif
  657. #ifdef LATER
  658.     case GIOCSETBW:
  659. {
  660.     grio_ioctl_info_t info;
  661.     xwidgetnum_t src_widgetnum, dest_widgetnum;
  663.     if (COPYIN(arg, &info, sizeof(grio_ioctl_info_t))) {
  664. error = EFAULT;
  665. break;
  666.     }
  667. #ifdef GRIO_DEBUG
  668.     printf("xbow:: prev_vhdl: %d next_vhdl: %d reqbw: %lldn",
  669. info.prev_vhdl, info.next_vhdl, info.reqbw);
  670. #endif /* GRIO_DEBUG */
  672.     src_widgetnum = xbow_widget_num_get(info.prev_vhdl);
  673.     dest_widgetnum = xbow_widget_num_get(info.next_vhdl);
  675.     /* Bandwidth allocation is bi-directional. Since bandwidth
  676.      * reservations have already been done at an earlier stage,
  677.      * we cannot fail here for lack of bandwidth.
  678.      */
  679.     xbow_prio_bw_alloc(dev, src_widgetnum, dest_widgetnum,
  680. 0, info.reqbw);
  681.     xbow_prio_bw_alloc(dev, dest_widgetnum, src_widgetnum,
  682. 0, info.reqbw);
  684.     break;
  685. }
  687.     case GIOCRELEASEBW:
  688. {
  689.     grio_ioctl_info_t info;
  690.     xwidgetnum_t src_widgetnum, dest_widgetnum;
  692.     if (!cap_able(CAP_DEVICE_MGT)) {
  693. error = EPERM;
  694. break;
  695.     }
  697.     if (COPYIN(arg, &info, sizeof(grio_ioctl_info_t))) {
  698. error = EFAULT;
  699. break;
  700.     }
  701. #ifdef GRIO_DEBUG
  702.     printf("xbow:: prev_vhdl: %d next_vhdl: %d reqbw: %lldn",
  703. info.prev_vhdl, info.next_vhdl, info.reqbw);
  704. #endif /* GRIO_DEBUG */
  706.     src_widgetnum = xbow_widget_num_get(info.prev_vhdl);
  707.     dest_widgetnum = xbow_widget_num_get(info.next_vhdl);
  709.     /* Bandwidth reservation is bi-directional. Hence, remove
  710.      * bandwidth reservations for both directions.
  711.      */
  712.     xbow_prio_bw_alloc(dev, src_widgetnum, dest_widgetnum,
  713. info.reqbw, (-1 * info.reqbw));
  714.     xbow_prio_bw_alloc(dev, dest_widgetnum, src_widgetnum,
  715. info.reqbw, (-1 * info.reqbw));
  717.     break;
  718. }
  719. #endif
  721.     default:
  722. break;
  724.     }
  725.     return error;
  726. }
  728. /*
  729.  * xbow_widget_present: See if a device is present
  730.  * on the specified port of this crossbow.
  731.  */
  732. int
  733. xbow_widget_present(xbow_t * xbow, int port)
  734. {
  735. if ( IS_RUNNING_ON_SIMULATOR() ) {
  736. if ( (port == 14) || (port == 15) ) {
  737. return 1;
  738. }
  739. else {
  740. return 0;
  741. }
  742. }
  743. else {
  744. return xbow->xb_link(port).link_aux_status & XB_AUX_STAT_PRESENT;
  745. }
  746. }
  748. static int
  749. xbow_link_alive(xbow_t * xbow, int port)
  750. {
  751.     xbwX_stat_t             xbow_linkstat;
  753.     xbow_linkstat.linkstatus = xbow->xb_link(port).link_status;
  754.     return (xbow_linkstat.link_alive);
  755. }
  757. /*
  758.  * xbow_widget_lookup
  759.  *      Lookup the edges connected to the xbow specified, and
  760.  *      retrieve the handle corresponding to the widgetnum
  761.  *      specified.
  762.  *      If not found, return 0.
  763.  */
  764. devfs_handle_t
  765. xbow_widget_lookup(devfs_handle_t vhdl,
  766.    int widgetnum)
  767. {
  768.     xswitch_info_t          xswitch_info;
  769.     devfs_handle_t            conn;
  771.     xswitch_info = xswitch_info_get(vhdl);
  772.     conn = xswitch_info_vhdl_get(xswitch_info, widgetnum);
  773.     return conn;
  774. }
  776. /*
  777.  * xbow_setwidint: called when xtalk
  778.  * is establishing or migrating our
  779.  * interrupt service.
  780.  */
  781. #ifdef LATER
  782. static void
  783. xbow_setwidint(xtalk_intr_t intr)
  784. {
  785.     xwidgetnum_t            targ = xtalk_intr_target_get(intr);
  786.     iopaddr_t               addr = xtalk_intr_addr_get(intr);
  787.     xtalk_intr_vector_t     vect = xtalk_intr_vector_get(intr);
  788.     xbow_t                 *xbow = (xbow_t *) xtalk_intr_sfarg_get(intr);
  790.     xbow_intr_preset((void *) xbow, 0, targ, addr, vect);
  791. }
  792. #endif /* LATER */
  794. /*
  795.  * xbow_intr_preset: called during mlreset time
  796.  * if the platform specific code needs to route
  797.  * an xbow interrupt before the xtalk infrastructure
  798.  * is available for use.
  799.  *
  800.  * Also called from xbow_setwidint, so we don't
  801.  * replicate the guts of the routine.
  802.  *
  803.  * XXX- probably should be renamed xbow_wid_intr_set or
  804.  * something to reduce confusion.
  805.  */
  806. /*ARGSUSED3 */
  807. void
  808. xbow_intr_preset(void *which_widget,
  809.  int which_widget_intr,
  810.  xwidgetnum_t targ,
  811.  iopaddr_t addr,
  812.  xtalk_intr_vector_t vect)
  813. {
  814.     xbow_t                 *xbow = (xbow_t *) which_widget;
  816.     xbow->xb_wid_int_upper = ((0xFF000000 & (vect << 24)) |
  817.       (0x000F0000 & (targ << 16)) |
  818.       XTALK_ADDR_TO_UPPER(addr));
  819.     xbow->xb_wid_int_lower = XTALK_ADDR_TO_LOWER(addr);
  820. }
  822. #define XEM_ADD_STR(s) printk("%s", (s))
  823. #define XEM_ADD_NVAR(n,v) printk("t%20s: 0x%xn", (n), (v))
  824. #define XEM_ADD_VAR(v) XEM_ADD_NVAR(#v,(v))
  825. #define XEM_ADD_IOEF(n)  if (IOERROR_FIELDVALID(ioe,n))     
  826.     XEM_ADD_NVAR("ioe." #n,     
  827.  IOERROR_GETVALUE(ioe,n))
  829. #ifdef LATER
  830. static void
  831. xem_add_ioe(ioerror_t *ioe)
  832. {
  833.     XEM_ADD_IOEF(errortype);
  834.     XEM_ADD_IOEF(widgetnum);
  835.     XEM_ADD_IOEF(widgetdev);
  836.     XEM_ADD_IOEF(srccpu);
  837.     XEM_ADD_IOEF(srcnode);
  838.     XEM_ADD_IOEF(errnode);
  839.     XEM_ADD_IOEF(sysioaddr);
  840.     XEM_ADD_IOEF(xtalkaddr);
  841.     XEM_ADD_IOEF(busspace);
  842.     XEM_ADD_IOEF(busaddr);
  843.     XEM_ADD_IOEF(vaddr);
  844.     XEM_ADD_IOEF(memaddr);
  845.     XEM_ADD_IOEF(epc);
  846.     XEM_ADD_IOEF(ef);
  847. }
  849. #define XEM_ADD_IOE() (xem_add_ioe(ioe))
  850. #endif /* LATER */
  852. int                     xbow_xmit_retry_errors = 0;
  854. int
  855. xbow_xmit_retry_error(xbow_soft_t soft,
  856.       int port)
  857. {
  858.     xswitch_info_t          info;
  859.     devfs_handle_t            vhdl;
  860.     widget_cfg_t           *wid;
  861.     widgetreg_t             id;
  862.     int                     part;
  863.     int                     mfgr;
  865.     wid = soft->wpio[port - BASE_XBOW_PORT];
  866.     if (wid == NULL) {
  867. /* If we can't track down a PIO
  868.  * pointer to our widget yet,
  869.  * leave our caller knowing that
  870.  * we are interested in this
  871.  * interrupt if it occurs in
  872.  * the future.
  873.  */
  874. info = xswitch_info_get(soft->busv);
  875. if (!info)
  876.     return 1;
  877. vhdl = xswitch_info_vhdl_get(info, port);
  878. if (vhdl == GRAPH_VERTEX_NONE)
  879.     return 1;
  880. wid = (widget_cfg_t *) xtalk_piotrans_addr
  881.     (vhdl, 0, 0, sizeof *wid, 0);
  882. if (!wid)
  883.     return 1;
  884. soft->wpio[port - BASE_XBOW_PORT] = wid;
  885.     }
  886.     id = wid->w_id;
  887.     part = XWIDGET_PART_NUM(id);
  888.     mfgr = XWIDGET_MFG_NUM(id);
  890.     /* If this thing is not a Bridge,
  891.      * do not activate the WAR, and
  892.      * tell our caller we do not need
  893.      * to be called again.
  894.      */
  895.     if ((part != BRIDGE_WIDGET_PART_NUM) ||
  896. (mfgr != BRIDGE_WIDGET_MFGR_NUM)) {
  897. /* FIXME: add Xbridge to the WAR.
  898.  * Shouldn't hurt anything.  Later need to
  899.  * check if we can remove this.
  900.                  */
  901.      if ((part != XBRIDGE_WIDGET_PART_NUM) ||
  902.     (mfgr != XBRIDGE_WIDGET_MFGR_NUM))
  903. return 0;
  904.     }
  906.     /* count how many times we
  907.      * have picked up after
  908.      * LLP Transmit problems.
  909.      */
  910.     xbow_xmit_retry_errors++;
  912.     /* rewrite the control register
  913.      * to fix things up.
  914.      */
  915.     wid->w_control = wid->w_control;
  916.     wid->w_control;
  918.     return 1;
  919. }
  921. /*
  922.  * xbow_errintr_handler will be called if the xbow
  923.  * sends an interrupt request to report an error.
  924.  */
  926. #ifdef LATER
  927. static void
  928. xbow_errintr_handler(intr_arg_t arg)
  929. {
  930.     ioerror_t               ioe[1];
  931.     xbow_soft_t             soft = (xbow_soft_t) arg;
  932.     xbow_t                 *xbow = soft->base;
  933.     xbowreg_t               wid_control;
  934.     xbowreg_t               wid_stat;
  935.     xbowreg_t               wid_err_cmdword;
  936.     xbowreg_t               wid_err_upper;
  937.     xbowreg_t               wid_err_lower;
  938.     w_err_cmd_word_u        wid_err;
  939.     uint64_t                 wid_err_addr;
  941.     int                     fatal = 0;
  942.     int                     dump_ioe = 0;
  944.     wid_control = xbow->xb_wid_control;
  945.     wid_stat = xbow->xb_wid_stat_clr;
  946.     wid_err_cmdword = xbow->xb_wid_err_cmdword;
  947.     wid_err_upper = xbow->xb_wid_err_upper;
  948.     wid_err_lower = xbow->xb_wid_err_lower;
  949.     xbow->xb_wid_err_cmdword = 0;
  951.     wid_err_addr =
  952. wid_err_lower
  953. | (((iopaddr_t) wid_err_upper
  954.     & WIDGET_ERR_UPPER_ADDR_ONLY)
  955.    << 32);
  957.     if (wid_stat & XB_WID_STAT_LINK_INTR_MASK) {
  958. int                     port;
  960. wid_err.r = wid_err_cmdword;
  962. for (port = MAX_PORT_NUM - MAX_XBOW_PORTS;
  963.      port < MAX_PORT_NUM; port++) {
  964.     if (wid_stat & XB_WID_STAT_LINK_INTR(port)) {
  965. xb_linkregs_t          *link = &(xbow->xb_link(port));
  966. xbowreg_t               link_control = link->link_control;
  967. xbowreg_t               link_status = link->link_status_clr;
  968. xbowreg_t               link_aux_status = link->link_aux_status;
  969. xbowreg_t               link_pend;
  971. link_pend = link_status & link_control &
  972.     (XB_STAT_ILLEGAL_DST_ERR
  973.      | XB_STAT_OALLOC_IBUF_ERR
  974.      | XB_STAT_RCV_CNT_OFLOW_ERR
  975.      | XB_STAT_XMT_CNT_OFLOW_ERR
  976.      | XB_STAT_XMT_MAX_RTRY_ERR
  977.      | XB_STAT_RCV_ERR
  978.      | XB_STAT_XMT_RTRY_ERR
  979.      | XB_STAT_MAXREQ_TOUT_ERR
  980.      | XB_STAT_SRC_TOUT_ERR
  981.     );
  983. if (link_pend & XB_STAT_ILLEGAL_DST_ERR) {
  984.     if (wid_err.f.sidn == port) {
  985. IOERROR_INIT(ioe);
  986. IOERROR_SETVALUE(ioe, widgetnum, port);
  987. IOERROR_SETVALUE(ioe, xtalkaddr, wid_err_addr);
  988. if (IOERROR_HANDLED ==
  989.     xbow_error_handler(soft,
  990.        IOECODE_DMA,
  991.        MODE_DEVERROR,
  992.        ioe)) {
  993.     link_pend &= ~XB_STAT_ILLEGAL_DST_ERR;
  994. } else {
  995.     dump_ioe++;
  996. }
  997.     }
  998. }
  999. /* Xbow/Bridge WAR:
  1000.  * if the bridge signals an LLP Transmitter Retry,
  1001.  * rewrite its control register.
  1002.  * If someone else triggers this interrupt,
  1003.  * ignore (and disable) the interrupt.
  1004.  */
  1005. if (link_pend & XB_STAT_XMT_RTRY_ERR) {
  1006.     if (!xbow_xmit_retry_error(soft, port)) {
  1007. link_control &= ~XB_CTRL_XMT_RTRY_IE;
  1008. link->link_control = link_control;
  1009. link->link_control; /* stall until written */
  1010.     }
  1011.     link_pend &= ~XB_STAT_XMT_RTRY_ERR;
  1012. }
  1013. if (link_pend) {
  1014.     devfs_handle_t xwidget_vhdl;
  1015.     char *xwidget_name;
  1016.     
  1017.     /* Get the widget name corresponding to the current
  1018.      * xbow link.
  1019.      */
  1020.     xwidget_vhdl = xbow_widget_lookup(soft->busv,port);
  1021.     xwidget_name = xwidget_name_get(xwidget_vhdl);
  1023. #ifdef LATER
  1024.     printk("%s port %X[%s] XIO Bus Error",
  1025.     soft->name, port, xwidget_name);
  1026.     if (link_status & XB_STAT_MULTI_ERR)
  1027. XEM_ADD_STR("tMultiple Errorsn");
  1028.     if (link_status & XB_STAT_ILLEGAL_DST_ERR)
  1029. XEM_ADD_STR("tInvalid Packet Destinationn");
  1030.     if (link_status & XB_STAT_OALLOC_IBUF_ERR)
  1031. XEM_ADD_STR("tInput Overallocation Errorn");
  1032.     if (link_status & XB_STAT_RCV_CNT_OFLOW_ERR)
  1033. XEM_ADD_STR("tLLP receive error counter overflown");
  1034.     if (link_status & XB_STAT_XMT_CNT_OFLOW_ERR)
  1035. XEM_ADD_STR("tLLP transmit retry counter overflown");
  1036.     if (link_status & XB_STAT_XMT_MAX_RTRY_ERR)
  1037. XEM_ADD_STR("tLLP Max Transmitter Retryn");
  1038.     if (link_status & XB_STAT_RCV_ERR)
  1039. XEM_ADD_STR("tLLP Receiver errorn");
  1040.     if (link_status & XB_STAT_XMT_RTRY_ERR)
  1041. XEM_ADD_STR("tLLP Transmitter Retryn");
  1042.     if (link_status & XB_STAT_MAXREQ_TOUT_ERR)
  1043. XEM_ADD_STR("tMaximum Request Timeoutn");
  1044.     if (link_status & XB_STAT_SRC_TOUT_ERR)
  1045. XEM_ADD_STR("tSource Timeout Errorn");
  1046. #endif /* LATER */
  1047.     {
  1048. int                     other_port;
  1050. for (other_port = 8; other_port < 16; ++other_port) {
  1051.     if (link_aux_status & (1 << other_port)) {
  1052. /* XXX- need to go to "other_port"
  1053.  * and clean up after the timeout?
  1054.  */
  1055. XEM_ADD_VAR(other_port);
  1056.     }
  1057. }
  1058.     }
  1060. #if !DEBUG
  1061.     if (kdebug) {
  1062. #endif
  1063. XEM_ADD_VAR(link_control);
  1064. XEM_ADD_VAR(link_status);
  1065. XEM_ADD_VAR(link_aux_status);
  1067. if (dump_ioe) {
  1068.     XEM_ADD_IOE();
  1069.     dump_ioe = 0;
  1070. }
  1071. #if !DEBUG
  1072.     }
  1073. #endif
  1074.     fatal++;
  1075. }
  1076.     }
  1077. }
  1078.     }
  1079.     if (wid_stat & wid_control & XB_WID_STAT_WIDGET0_INTR) {
  1080. /* we have a "widget zero" problem */
  1082. if (wid_stat & (XB_WID_STAT_MULTI_ERR
  1083. | XB_WID_STAT_XTALK_ERR
  1084. | XB_WID_STAT_REG_ACC_ERR)) {
  1086.     printk("%s Port 0 XIO Bus Error",
  1087.     soft->name);
  1088.     if (wid_stat & XB_WID_STAT_MULTI_ERR)
  1089. XEM_ADD_STR("tMultiple Errorn");
  1090.     if (wid_stat & XB_WID_STAT_XTALK_ERR)
  1091. XEM_ADD_STR("tXIO Errorn");
  1092.     if (wid_stat & XB_WID_STAT_REG_ACC_ERR)
  1093. XEM_ADD_STR("tRegister Access Errorn");
  1095.     fatal++;
  1096. }
  1097.     }
  1098.     if (fatal) {
  1099. XEM_ADD_VAR(wid_stat);
  1100. XEM_ADD_VAR(wid_control);
  1101. XEM_ADD_VAR(wid_err_cmdword);
  1102. XEM_ADD_VAR(wid_err_upper);
  1103. XEM_ADD_VAR(wid_err_lower);
  1104. XEM_ADD_VAR(wid_err_addr);
  1105. PRINT_PANIC("XIO Bus Error");
  1106.     }
  1107. }
  1108. #endif /* LATER */
  1110. /*
  1111.  * XBOW ERROR Handling routines.
  1112.  * These get invoked as part of walking down the error handling path
  1113.  * from hub/heart towards the I/O device that caused the error.
  1114.  */
  1116. /*
  1117.  * xbow_error_handler
  1118.  *      XBow error handling dispatch routine.
  1119.  *      This is the primary interface used by external world to invoke
  1120.  *      in case of an error related to a xbow.
  1121.  *      Only functionality in this layer is to identify the widget handle
  1122.  *      given the widgetnum. Otherwise, xbow does not gathers any error
  1123.  *      data.
  1124.  */
  1126. #ifdef LATER
  1127. static int
  1128. xbow_error_handler(
  1129.       void *einfo,
  1130.       int error_code,
  1131.       ioerror_mode_t mode,
  1132.       ioerror_t *ioerror)
  1133. {
  1134.     int                     retval = IOERROR_WIDGETLEVEL;
  1136.     xbow_soft_t             soft = (xbow_soft_t) einfo;
  1137.     int                     port;
  1138.     devfs_handle_t            conn;
  1139.     devfs_handle_t            busv;
  1141.     xbow_t                 *xbow = soft->base;
  1142.     xbowreg_t               wid_stat;
  1143.     xbowreg_t               wid_err_cmdword;
  1144.     xbowreg_t               wid_err_upper;
  1145.     xbowreg_t               wid_err_lower;
  1146.     uint64_t                 wid_err_addr;
  1148.     xb_linkregs_t          *link;
  1149.     xbowreg_t               link_control;
  1150.     xbowreg_t               link_status;
  1151.     xbowreg_t               link_aux_status;
  1153.     ASSERT(soft != 0);
  1154.     busv = soft->busv;
  1156. #if DEBUG && ERROR_DEBUG
  1157.     printk("%s: xbow_error_handlern", soft->name, busv);
  1158. #endif
  1160.     port = IOERROR_GETVALUE(ioerror, widgetnum);
  1162.     if (port == 0) {
  1163. /* error during access to xbow:
  1164.  * do NOT attempt to access xbow regs.
  1165.  */
  1166. if (mode == MODE_DEVPROBE)
  1167.     return IOERROR_HANDLED;
  1169. if (error_code & IOECODE_DMA) {
  1170.     PRINT_ALERT("DMA error blamed on Crossbow at %sn"
  1171.     "tbut Crosbow never initiates DMA!",
  1172.     soft->name);
  1173. }
  1174. if (error_code & IOECODE_PIO) {
  1175.     PRINT_ALERt("PIO Error on XIO Bus %sn"
  1176.     "tattempting to access XIO controllern"
  1177.     "twith offset 0x%X",
  1178.     soft->name,
  1179.     IOERROR_GETVALUE(ioerror, xtalkaddr));
  1180. }
  1181. /* caller will dump contents of ioerror
  1182.  * in DEBUG and kdebug kernels.
  1183.  */
  1185. return retval;
  1186.     }
  1187.     /*
  1188.      * error not on port zero:
  1189.      * safe to read xbow registers.
  1190.      */
  1191.     wid_stat = xbow->xb_wid_stat;
  1192.     wid_err_cmdword = xbow->xb_wid_err_cmdword;
  1193.     wid_err_upper = xbow->xb_wid_err_upper;
  1194.     wid_err_lower = xbow->xb_wid_err_lower;
  1196.     wid_err_addr =
  1197. wid_err_lower
  1198. | (((iopaddr_t) wid_err_upper
  1199.     & WIDGET_ERR_UPPER_ADDR_ONLY)
  1200.    << 32);
  1202.     if ((port < BASE_XBOW_PORT) ||
  1203. (port >= MAX_PORT_NUM)) {
  1205. if (mode == MODE_DEVPROBE)
  1206.     return IOERROR_HANDLED;
  1208. if (error_code & IOECODE_DMA) {
  1209.     PRINT_ALERT("DMA error blamed on XIO port at %s/%dn"
  1210.     "tbut Crossbow does not support that port",
  1211.     soft->name, port);
  1212. }
  1213. if (error_code & IOECODE_PIO) {
  1214.     PRINT_ALERT("PIO Error on XIO Bus %sn"
  1215.     "tattempting to access XIO port %dn"
  1216.     "t(which Crossbow does not support)"
  1217.     "twith offset 0x%X",
  1218.     soft->name, port,
  1219.     IOERROR_GETVALUE(ioerror, xtalkaddr));
  1220. }
  1221. #if !DEBUG
  1222. if (kdebug) {
  1223. #endif
  1224.     XEM_ADD_STR("Raw status values for Crossbow:n");
  1225.     XEM_ADD_VAR(wid_stat);
  1226.     XEM_ADD_VAR(wid_err_cmdword);
  1227.     XEM_ADD_VAR(wid_err_upper);
  1228.     XEM_ADD_VAR(wid_err_lower);
  1229.     XEM_ADD_VAR(wid_err_addr);
  1230. #if !DEBUG
  1231. }
  1232. #endif
  1234. /* caller will dump contents of ioerror
  1235.  * in DEBUG and kdebug kernels.
  1236.  */
  1238. return retval;
  1239.     }
  1240.     /* access to valid port:
  1241.      * ok to check port status.
  1242.      */
  1244.     link = &(xbow->xb_link(port));
  1245.     link_control = link->link_control;
  1246.     link_status = link->link_status;
  1247.     link_aux_status = link->link_aux_status;
  1249.     /* Check that there is something present
  1250.      * in that XIO port.
  1251.      */
  1252.     if (!(link_aux_status & XB_AUX_STAT_PRESENT)) {
  1253. /* nobody connected. */
  1254. if (mode == MODE_DEVPROBE)
  1255.     return IOERROR_HANDLED;
  1257. if (error_code & IOECODE_DMA) {
  1258.     PRINT_ALERT("DMA error blamed on XIO port at %s/%dn"
  1259.     "tbut there is no device connected there.",
  1260.     soft->name, port);
  1261. }
  1262. if (error_code & IOECODE_PIO) {
  1263.     PRINT_ALERT("PIO Error on XIO Bus %sn"
  1264.     "tattempting to access XIO port %dn"
  1265.     "t(which has no device connected)"
  1266.     "twith offset 0x%X",
  1267.     soft->name, port,
  1268.     IOERROR_GETVALUE(ioerror, xtalkaddr));
  1269. }
  1270. #if !DEBUG
  1271. if (kdebug) {
  1272. #endif
  1273.     XEM_ADD_STR("Raw status values for Crossbow:n");
  1274.     XEM_ADD_VAR(wid_stat);
  1275.     XEM_ADD_VAR(wid_err_cmdword);
  1276.     XEM_ADD_VAR(wid_err_upper);
  1277.     XEM_ADD_VAR(wid_err_lower);
  1278.     XEM_ADD_VAR(wid_err_addr);
  1279.     XEM_ADD_VAR(port);
  1280.     XEM_ADD_VAR(link_control);
  1281.     XEM_ADD_VAR(link_status);
  1282.     XEM_ADD_VAR(link_aux_status);
  1283. #if !DEBUG
  1284. }
  1285. #endif
  1286. return retval;
  1288.     }
  1289.     /* Check that the link is alive.
  1290.      */
  1291.     if (!(link_status & XB_STAT_LINKALIVE)) {
  1292. /* nobody connected. */
  1293. if (mode == MODE_DEVPROBE)
  1294.     return IOERROR_HANDLED;
  1296. PRINT_ALERT("%s%sError on XIO Bus %s port %d",
  1297. (error_code & IOECODE_DMA) ? "DMA " : "",
  1298. (error_code & IOECODE_PIO) ? "PIO " : "",
  1299. soft->name, port);
  1301. if ((error_code & IOECODE_PIO) &&
  1302.     (IOERROR_FIELDVALID(ioerror, xtalkaddr))) {
  1303.     printk("tAccess attempted to offset 0x%Xn",
  1304.     IOERROR_GETVALUE(ioerror, xtalkaddr));
  1305. }
  1306. if (link_aux_status & XB_AUX_LINKFAIL_RST_BAD)
  1307.     XEM_ADD_STR("tLink never came out of resetn");
  1308. else
  1309.     XEM_ADD_STR("tLink failed while transferring datan");
  1311.     }
  1312.     /* get the connection point for the widget
  1313.      * involved in this error; if it exists and
  1314.      * is not our connectpoint, cycle back through
  1315.      * xtalk_error_handler to deliver control to
  1316.      * the proper handler (or to report a generic
  1317.      * crosstalk error).
  1318.      *
  1319.      * If the downstream handler won't handle
  1320.      * the problem, we let our upstream caller
  1321.      * deal with it, after (in DEBUG and kdebug
  1322.      * kernels) dumping the xbow state for this
  1323.      * port.
  1324.      */
  1325.     conn = xbow_widget_lookup(busv, port);
  1326.     if ((conn != GRAPH_VERTEX_NONE) &&
  1327. (conn != soft->conn)) {
  1328. retval = xtalk_error_handler(conn, error_code, mode, ioerror);
  1329. if (retval == IOERROR_HANDLED)
  1330.     return IOERROR_HANDLED;
  1331.     }
  1332.     if (mode == MODE_DEVPROBE)
  1333. return IOERROR_HANDLED;
  1335.     if (retval == IOERROR_UNHANDLED) {
  1336. retval = IOERROR_PANIC;
  1338. PRINT_ALERT("%s%sError on XIO Bus %s port %d",
  1339. (error_code & IOECODE_DMA) ? "DMA " : "",
  1340. (error_code & IOECODE_PIO) ? "PIO " : "",
  1341. soft->name, port);
  1343. if ((error_code & IOECODE_PIO) &&
  1344.     (IOERROR_FIELDVALID(ioerror, xtalkaddr))) {
  1345.     printk("tAccess attempted to offset 0x%Xn",
  1346.     IOERROR_GETVALUE(ioerror, xtalkaddr));
  1347. }
  1348.     }
  1350. #if !DEBUG
  1351.     if (kdebug) {
  1352. #endif
  1353. XEM_ADD_STR("Raw status values for Crossbow:n");
  1354. XEM_ADD_VAR(wid_stat);
  1355. XEM_ADD_VAR(wid_err_cmdword);
  1356. XEM_ADD_VAR(wid_err_upper);
  1357. XEM_ADD_VAR(wid_err_lower);
  1358. XEM_ADD_VAR(wid_err_addr);
  1359. XEM_ADD_VAR(port);
  1360. XEM_ADD_VAR(link_control);
  1361. XEM_ADD_VAR(link_status);
  1362. XEM_ADD_VAR(link_aux_status);
  1363. #if !DEBUG
  1364.     }
  1365. #endif
  1366.     /* caller will dump raw ioerror data
  1367.      * in DEBUG and kdebug kernels.
  1368.      */
  1370.     return retval;
  1371. }
  1373. #endif /* LATER */
  1375. void
  1376. xbow_update_perf_counters(devfs_handle_t vhdl)
  1377. {
  1378.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1379.     xbow_perf_t            *xbow_perf = xbow_soft->xbow_perfcnt;
  1380.     xbow_perf_link_t       *xbow_plink = xbow_soft->xbow_perflink;
  1381.     xbow_perfcount_t        perf_reg;
  1382.     unsigned long           s;
  1383.     int                     link, i;
  1385.     for (i = 0; i < XBOW_PERF_COUNTERS; i++, xbow_perf++) {
  1386. if (xbow_perf->xp_mode == XBOW_MONITOR_NONE)
  1387.     continue;
  1389. s = mutex_spinlock(&xbow_soft->xbow_perf_lock);
  1391. perf_reg.xb_counter_val = *(xbowreg_t *) xbow_perf->xp_perf_reg;
  1393. link = perf_reg.xb_perf.link_select;
  1395. (xbow_plink + link)->xlp_cumulative[xbow_perf->xp_curmode] +=
  1396.     ((perf_reg.xb_perf.count - xbow_perf->xp_current) & XBOW_COUNTER_MASK);
  1397. xbow_perf->xp_current = perf_reg.xb_perf.count;
  1399. mutex_spinunlock(&xbow_soft->xbow_perf_lock, s);
  1400.     }
  1401.     /* Do port /mode multiplexing here */
  1403. #ifdef LATER
  1404.     (void) timeout(xbow_update_perf_counters,
  1405.    (void *) (__psunsigned_t) vhdl, XBOW_PERF_TIMEOUT);
  1406. #endif
  1408. }
  1410. xbow_perf_link_t       *
  1411. xbow_get_perf_counters(devfs_handle_t vhdl)
  1412. {
  1413.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1414.     xbow_perf_link_t       *xbow_perf_link = xbow_soft->xbow_perflink;
  1416.     return xbow_perf_link;
  1417. }
  1419. int
  1420. xbow_enable_perf_counter(devfs_handle_t vhdl, int link, int mode, int counter)
  1421. {
  1422.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1423.     xbow_perf_t            *xbow_perf = xbow_soft->xbow_perfcnt;
  1424.     xbow_linkctrl_t         xbow_link_ctrl;
  1425.     xbow_t                 *xbow = xbow_soft->base;
  1426.     xbow_perfcount_t        perf_reg;
  1427.     unsigned long           s;
  1428.     int                     i;
  1430.     link -= BASE_XBOW_PORT;
  1431.     if ((link < 0) || (link >= MAX_XBOW_PORTS))
  1432. return -1;
  1434.     if ((mode < XBOW_MONITOR_NONE) || (mode > XBOW_MONITOR_DEST_LINK))
  1435. return -1;
  1437.     if ((counter < 0) || (counter >= XBOW_PERF_COUNTERS))
  1438. return -1;
  1440.     s = mutex_spinlock(&xbow_soft->xbow_perf_lock);
  1442.     if ((xbow_perf + counter)->xp_mode && mode) {
  1443. mutex_spinunlock(&xbow_soft->xbow_perf_lock, s);
  1444. return -1;
  1445.     }
  1446.     for (i = 0; i < XBOW_PERF_COUNTERS; i++) {
  1447. if (i == counter)
  1448.     continue;
  1449. if (((xbow_perf + i)->xp_link == link) &&
  1450.     ((xbow_perf + i)->xp_mode)) {
  1451.     mutex_spinunlock(&xbow_soft->xbow_perf_lock, s);
  1452.     return -1;
  1453. }
  1454.     }
  1455.     xbow_perf += counter;
  1457.     xbow_perf->xp_curlink = xbow_perf->xp_link = link;
  1458.     xbow_perf->xp_curmode = xbow_perf->xp_mode = mode;
  1460.     xbow_link_ctrl.xbl_ctrlword = xbow->xb_link_raw[link].link_control;
  1461.     xbow_link_ctrl.xb_linkcontrol.perf_mode = mode;
  1462.     xbow->xb_link_raw[link].link_control = xbow_link_ctrl.xbl_ctrlword;
  1464.     perf_reg.xb_counter_val = *(xbowreg_t *) xbow_perf->xp_perf_reg;
  1465.     perf_reg.xb_perf.link_select = link;
  1466.     *(xbowreg_t *) xbow_perf->xp_perf_reg = perf_reg.xb_counter_val;
  1467.     xbow_perf->xp_current = perf_reg.xb_perf.count;
  1469. #ifdef LATER
  1470.     (void) timeout(xbow_update_perf_counters,
  1471.    (void *) (__psunsigned_t) vhdl, XBOW_PERF_TIMEOUT);
  1472. #endif
  1474.     mutex_spinunlock(&xbow_soft->xbow_perf_lock, s);
  1476.     return 0;
  1477. }
  1479. xbow_link_status_t     *
  1480. xbow_get_llp_status(devfs_handle_t vhdl)
  1481. {
  1482.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1483.     xbow_link_status_t     *xbow_llp_status = xbow_soft->xbow_link_status;
  1485.     return xbow_llp_status;
  1486. }
  1488. void
  1489. xbow_update_llp_status(devfs_handle_t vhdl)
  1490. {
  1491.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1492.     xbow_link_status_t     *xbow_llp_status = xbow_soft->xbow_link_status;
  1493.     xbow_t                 *xbow;
  1494.     xbwX_stat_t             lnk_sts;
  1495.     xbow_aux_link_status_t  aux_sts;
  1496.     int                     link;
  1497.     devfs_handle_t     xwidget_vhdl;
  1498.     char    *xwidget_name;
  1500.     xbow = (xbow_t *) xbow_soft->base;
  1501.     for (link = 0; link < MAX_XBOW_PORTS; link++, xbow_llp_status++) {
  1502. /* Get the widget name corresponding the current link.
  1503.  * Note : 0 <= link < MAX_XBOW_PORTS(8).
  1504.  *    BASE_XBOW_PORT(0x8) <= xwidget number < MAX_PORT_NUM (0x10)
  1505.  */
  1506. xwidget_vhdl = xbow_widget_lookup(xbow_soft->busv,link+BASE_XBOW_PORT);
  1507. xwidget_name = xwidget_name_get(xwidget_vhdl);
  1508. aux_sts.aux_linkstatus
  1509.     = xbow->xb_link_raw[link].link_aux_status;
  1510. lnk_sts.linkstatus = xbow->xb_link_raw[link].link_status_clr;
  1512. if (lnk_sts.link_alive == 0)
  1513.     continue;
  1515. xbow_llp_status->rx_err_count +=
  1516.     aux_sts.xb_aux_linkstatus.rx_err_cnt;
  1518. xbow_llp_status->tx_retry_count +=
  1519.     aux_sts.xb_aux_linkstatus.tx_retry_cnt;
  1521. if (lnk_sts.linkstatus & ~(XB_STAT_RCV_ERR | XB_STAT_XMT_RTRY_ERR | XB_STAT_LINKALIVE)) {
  1522. #ifdef LATER
  1523.     PRINT_WARNING("link %d[%s]: bad status 0x%xn",
  1524.     link, xwidget_name, lnk_sts.linkstatus);
  1525. #endif
  1526. }
  1527.     }
  1528. #ifdef LATER
  1529.     if (xbow_soft->link_monitor)
  1530. (void) timeout(xbow_update_llp_status,
  1531.        (void *) (__psunsigned_t) vhdl, XBOW_STATS_TIMEOUT);
  1532. #endif
  1533. }
  1535. int
  1536. xbow_disable_llp_monitor(devfs_handle_t vhdl)
  1537. {
  1538.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1539.     int                     port;
  1541.     for (port = 0; port < MAX_XBOW_PORTS; port++) {
  1542. xbow_soft->xbow_link_status[port].rx_err_count = 0;
  1543. xbow_soft->xbow_link_status[port].tx_retry_count = 0;
  1544.     }
  1546.     xbow_soft->link_monitor = 0;
  1547.     return 0;
  1548. }
  1550. int
  1551. xbow_enable_llp_monitor(devfs_handle_t vhdl)
  1552. {
  1553.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1555. #ifdef LATER
  1556.     (void) timeout(xbow_update_llp_status,
  1557.    (void *) (__psunsigned_t) vhdl, XBOW_STATS_TIMEOUT);
  1558. #endif
  1559.     xbow_soft->link_monitor = 1;
  1560.     return 0;
  1561. }
  1564. int
  1565. xbow_reset_link(devfs_handle_t xconn_vhdl)
  1566. {
  1567.     xwidget_info_t          widget_info;
  1568.     xwidgetnum_t            port;
  1569.     xbow_t                 *xbow;
  1570.     xbowreg_t               ctrl;
  1571.     xbwX_stat_t             stat;
  1572.     unsigned                itick;
  1573.     unsigned                dtick;
  1574.     static int              ticks_per_ms = 0;
  1576.     if (!ticks_per_ms) {
  1577. itick = get_timestamp();
  1578. us_delay(1000);
  1579. ticks_per_ms = get_timestamp() - itick;
  1580.     }
  1581.     widget_info = xwidget_info_get(xconn_vhdl);
  1582.     port = xwidget_info_id_get(widget_info);
  1584. #ifdef XBOW_K1PTR /* defined if we only have one xbow ... */
  1585.     xbow = XBOW_K1PTR;
  1586. #else
  1587.     {
  1588. devfs_handle_t            xbow_vhdl;
  1589. xbow_soft_t             xbow_soft;
  1591. hwgraph_traverse(xconn_vhdl, ".master/xtalk/0/xbow", &xbow_vhdl);
  1592. xbow_soft = xbow_soft_get(xbow_vhdl);
  1593. xbow = xbow_soft->base;
  1594.     }
  1595. #endif
  1597.     /*
  1598.      * This requires three PIOs (reset the link, check for the
  1599.      * reset, restore the control register for the link) plus
  1600.      * 10us to wait for the reset. We allow up to 1ms for the
  1601.      * widget to come out of reset before giving up and
  1602.      * returning a failure.
  1603.      */
  1604.     ctrl = xbow->xb_link(port).link_control;
  1605.     xbow->xb_link(port).link_reset = 0;
  1606.     itick = get_timestamp();
  1607.     while (1) {
  1608. stat.linkstatus = xbow->xb_link(port).link_status;
  1609. if (stat.link_alive)
  1610.     break;
  1611. dtick = get_timestamp() - itick;
  1612. if (dtick > ticks_per_ms) {
  1613.     return -1; /* never came out of reset */
  1614. }
  1615. DELAY(2); /* don't beat on link_status */
  1616.     }
  1617.     xbow->xb_link(port).link_control = ctrl;
  1618.     return 0;
  1619. }
  1621. /*
  1622.  * Dump xbow registers.
  1623.  * input parameter is either a pointer to
  1624.  * the xbow chip or the vertex handle for
  1625.  * an xbow vertex.
  1626.  */
  1627. void
  1628. idbg_xbowregs(int64_t regs)
  1629. {
  1630.     xbow_t                 *xbow;
  1631.     int                     i;
  1632.     xb_linkregs_t          *link;
  1634. #ifdef LATER
  1635.     if (dev_is_vertex((devfs_handle_t) regs)) {
  1636. devfs_handle_t            vhdl = (devfs_handle_t) regs;
  1637. xbow_soft_t             soft = xbow_soft_get(vhdl);
  1639. xbow = soft->base;
  1640.     } else
  1641. #endif
  1642.     {
  1643. xbow = (xbow_t *) regs;
  1644.     }
  1646. #ifdef LATER
  1647.     qprintf("Printing xbow registers starting at 0x%xn", xbow);
  1648.     qprintf("wid %x status %x erruppr %x errlower %x control %x timeout %xn",
  1649.     xbow->xb_wid_id, xbow->xb_wid_stat, xbow->xb_wid_err_upper,
  1650.     xbow->xb_wid_err_lower, xbow->xb_wid_control,
  1651.     xbow->xb_wid_req_timeout);
  1652.     qprintf("intr uppr %x lower %x errcmd %x llp ctrl %x arb_reload %xn",
  1653.     xbow->xb_wid_int_upper, xbow->xb_wid_int_lower,
  1654.     xbow->xb_wid_err_cmdword, xbow->xb_wid_llp,
  1655.     xbow->xb_wid_arb_reload);
  1656. #endif
  1658.     for (i = 8; i <= 0xf; i++) {
  1659. link = &xbow->xb_link(i);
  1660. #ifdef LATER
  1661. qprintf("Link %d registersn", i);
  1662. qprintf("tctrl %x stat %x arbuppr %x arblowr %x auxstat %xn",
  1663. link->link_control, link->link_status,
  1664. link->link_arb_upper, link->link_arb_lower,
  1665. link->link_aux_status);
  1666. #endif
  1667.     }
  1668. }
  1671. #define XBOW_ARB_RELOAD_TICKS 25
  1672. /* granularity: 4 MB/s, max: 124 MB/s */
  1673. #define GRANULARITY ((100 * 1000000) / XBOW_ARB_RELOAD_TICKS)
  1675. #define XBOW_BYTES_TO_GBR(BYTES_per_s) (int) (BYTES_per_s / GRANULARITY)
  1677. #define XBOW_GBR_TO_BYTES(cnt) (bandwidth_t) ((cnt) * GRANULARITY)
  1679. #define CEILING_BYTES_TO_GBR(gbr, bytes_per_sec)
  1680. ((XBOW_GBR_TO_BYTES(gbr) < bytes_per_sec) ? gbr+1 : gbr)
  1682. #define XBOW_ARB_GBR_MAX 31
  1684. #define ABS(x) ((x > 0) ? (x) : (-1 * x))
  1685. /* absolute value */
  1687. int
  1688. xbow_bytes_to_gbr(bandwidth_t old_bytes_per_sec, bandwidth_t bytes_per_sec)
  1689. {
  1690.     int                     gbr_granted;
  1691.     int                     new_total_gbr;
  1692.     int                     change_gbr;
  1693.     bandwidth_t             new_total_bw;
  1695. #ifdef GRIO_DEBUG
  1696.     printf("xbow_bytes_to_gbr: old_bytes_per_sec %lld bytes_per_sec %lldn",
  1697. old_bytes_per_sec, bytes_per_sec);
  1698. #endif /* GRIO_DEBUG */
  1700.     gbr_granted = CEILING_BYTES_TO_GBR((XBOW_BYTES_TO_GBR(old_bytes_per_sec)),
  1701. old_bytes_per_sec);
  1702.     new_total_bw = old_bytes_per_sec + bytes_per_sec;
  1703.     new_total_gbr = CEILING_BYTES_TO_GBR((XBOW_BYTES_TO_GBR(new_total_bw)),
  1704. new_total_bw);
  1706.     change_gbr = new_total_gbr - gbr_granted;
  1708. #ifdef GRIO_DEBUG
  1709.     printf("xbow_bytes_to_gbr: gbr_granted %d new_total_gbr %d change_gbr %dn",
  1710. gbr_granted, new_total_gbr, change_gbr);
  1711. #endif /* GRIO_DEBUG */
  1713.     return (change_gbr);
  1714. }
  1716. /* Conversion from GBR to bytes */
  1717. bandwidth_t
  1718. xbow_gbr_to_bytes(int gbr)
  1719. {
  1720.     return (XBOW_GBR_TO_BYTES(gbr));
  1721. }
  1723. /* Given the vhdl for the desired xbow, the src and dest. widget ids
  1724.  * and the req_bw value, this xbow driver entry point accesses the
  1725.  * xbow registers and allocates the desired bandwidth if available.
  1726.  *
  1727.  * If bandwidth allocation is successful, return success else return failure.
  1728.  */
  1729. int
  1730. xbow_prio_bw_alloc(devfs_handle_t vhdl,
  1731. xwidgetnum_t src_wid,
  1732. xwidgetnum_t dest_wid,
  1733. unsigned long long old_alloc_bw,
  1734. unsigned long long req_bw)
  1735. {
  1736.     xbow_soft_t             soft = xbow_soft_get(vhdl);
  1737.     volatile xbowreg_t     *xreg;
  1738.     xbowreg_t               mask;
  1739.     unsigned long           s;
  1740.     int                     error = 0;
  1741.     bandwidth_t             old_bw_BYTES, req_bw_BYTES;
  1742.     xbowreg_t               old_xreg;
  1743.     int                     old_bw_GBR, req_bw_GBR, new_bw_GBR;
  1745. #ifdef GRIO_DEBUG
  1746.     printf("xbow_prio_bw_alloc: vhdl %d src_wid %d dest_wid %d req_bw %lldn",
  1747. (int) vhdl, (int) src_wid, (int) dest_wid, req_bw);
  1748. #endif
  1750.     ASSERT(XBOW_WIDGET_IS_VALID(src_wid));
  1751.     ASSERT(XBOW_WIDGET_IS_VALID(dest_wid));
  1753.     s = mutex_spinlock(&soft->xbow_bw_alloc_lock);
  1755.     /* Get pointer to the correct register */
  1756.     xreg = XBOW_PRIO_ARBREG_PTR(soft->base, dest_wid, src_wid);
  1758.     /* Get mask for GBR count value */
  1759.     mask = XB_ARB_GBR_MSK << XB_ARB_GBR_SHFT(src_wid);
  1761.     req_bw_GBR = xbow_bytes_to_gbr(old_alloc_bw, req_bw);
  1762.     req_bw_BYTES = (req_bw_GBR < 0) ? (-1 * xbow_gbr_to_bytes(ABS(req_bw_GBR)))
  1763. : xbow_gbr_to_bytes(req_bw_GBR);
  1765. #ifdef GRIO_DEBUG
  1766.     printf("req_bw %lld req_bw_BYTES %lld req_bw_GBR %dn",
  1767. req_bw, req_bw_BYTES, req_bw_GBR);
  1768. #endif /* GRIO_DEBUG */
  1770.     old_bw_BYTES = soft->bw_cur_used[(int) dest_wid - MAX_XBOW_PORTS];
  1771.     old_xreg = *xreg;
  1772.     old_bw_GBR = (((*xreg) & mask) >> XB_ARB_GBR_SHFT(src_wid));
  1774. #ifdef GRIO_DEBUG
  1775.     ASSERT(XBOW_BYTES_TO_GBR(old_bw_BYTES) == old_bw_GBR);
  1777.     printf("old_bw_BYTES %lld old_bw_GBR %dn", old_bw_BYTES, old_bw_GBR);
  1779.     printf("req_bw_BYTES %lld old_bw_BYTES %lld soft->bw_hiwm %lldn",
  1780. req_bw_BYTES, old_bw_BYTES,
  1781. soft->bw_hiwm[(int) dest_wid - MAX_XBOW_PORTS]);
  1782.    
  1783. #endif /* GRIO_DEBUG */
  1785.     /* Accept the request only if we don't exceed the destination
  1786.      * port HIWATER_MARK *AND* the max. link GBR arbitration count
  1787.      */
  1788.     if (((old_bw_BYTES + req_bw_BYTES) <=
  1789. soft->bw_hiwm[(int) dest_wid - MAX_XBOW_PORTS]) &&
  1790. (req_bw_GBR + old_bw_GBR <= XBOW_ARB_GBR_MAX)) {
  1792. new_bw_GBR = (old_bw_GBR + req_bw_GBR);
  1794. /* Set this in the xbow link register */
  1795. *xreg = (old_xreg & ~mask) | 
  1796.     (new_bw_GBR << XB_ARB_GBR_SHFT(src_wid) & mask);
  1798. soft->bw_cur_used[(int) dest_wid - MAX_XBOW_PORTS] =
  1799. xbow_gbr_to_bytes(new_bw_GBR);
  1800.     } else {
  1801. error = 1;
  1802.     }
  1804.     mutex_spinunlock(&soft->xbow_bw_alloc_lock, s);
  1806.     return (error);
  1807. }