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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
xbow.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：36k
源码类别：

Linux/Unix编程

开发平台：

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-2001 Silicon Graphics, Inc. All rights reserved.
  8.  */
  10. #include <linux/types.h>
  11. #include <linux/slab.h>
  12. #include <linux/sched.h>
  13. #include <asm/sn/sgi.h>
  14. #include <asm/sn/iograph.h>
  15. #include <asm/sn/invent.h>
  16. #include <asm/sn/hcl.h>
  17. #include <asm/sn/labelcl.h>
  18. #include <asm/sn/hack.h>
  19. #include <asm/sn/pci/bridge.h>
  20. #include <asm/sn/xtalk/xtalk_private.h>
  21. #include <asm/sn/simulator.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. #endif
  106. void                    xbow_intr_preset(void *, int, xwidgetnum_t, iopaddr_t, xtalk_intr_vector_t);
  110. void                    xbow_update_perf_counters(devfs_handle_t);
  111. xbow_perf_link_t       *xbow_get_perf_counters(devfs_handle_t);
  112. int                     xbow_enable_perf_counter(devfs_handle_t, int, int, int);
  113. xbow_link_status_t     *xbow_get_llp_status(devfs_handle_t);
  114. void                    xbow_update_llp_status(devfs_handle_t);
  116. int                     xbow_disable_llp_monitor(devfs_handle_t);
  117. int                     xbow_enable_llp_monitor(devfs_handle_t);
  118. int                     xbow_prio_bw_alloc(devfs_handle_t, xwidgetnum_t, xwidgetnum_t,
  119.                                 unsigned long long, unsigned long long);
  121. xswitch_reset_link_f    xbow_reset_link;
  123. void                    idbg_xbowregs(int64_t);
  125. xswitch_provider_t      xbow_provider =
  126. {
  127.     xbow_reset_link,
  128. };
  130. /*
  131.  *    xbow_mlreset: called at mlreset time if the
  132.  *      platform specific code determines that there is
  133.  *      a crossbow in a critical path that must be
  134.  *      functional before the driver would normally get
  135.  *      the device properly set up.
  136.  *
  137.  *      what do we need to do, that the boot prom can
  138.  *      not be counted on to have already done, that is
  139.  *      generic across all platforms using crossbows?
  140.  */
  141. /*ARGSUSED */
  142. void
  143. xbow_mlreset(xbow_t * xbow)
  144. {
  145. }
  147. /*
  148.  *    xbow_init: called with the rest of the device
  149.  *      driver XXX_init routines. This platform *might*
  150.  *      have a Crossbow chip, or even several, but it
  151.  *      might have none. Register with the crosstalk
  152.  *      generic provider so when we encounter the chip
  153.  *      the right magic happens.
  154.  */
  155. void
  156. xbow_init(void)
  157. {
  159. #if DEBUG && ATTACH_DEBUG
  160.     printf("xbow_initn");
  161. #endif
  163.     xwidget_driver_register(XXBOW_WIDGET_PART_NUM,
  164.     0, /* XXBOW_WIDGET_MFGR_NUM, */
  165.     "xbow_",
  166.     CDL_PRI_HI); /* attach before friends */
  168.     xwidget_driver_register(XBOW_WIDGET_PART_NUM,
  169.     XBOW_WIDGET_MFGR_NUM,
  170.     "xbow_",
  171.     CDL_PRI_HI); /* attach before friends */
  172. }
  174. #ifdef XBRIDGE_REGS_SIM
  175. /*    xbow_set_simulated_regs: sets xbow regs as needed
  176.  * for powering through the boot
  177.  */
  178. void
  179. xbow_set_simulated_regs(xbow_t *xbow, int port)
  180. {
  181.     /*
  182.      * turn on link
  183.      */
  184.     xbow->xb_link(port).link_status = (1<<31);
  185.     /*
  186.      * and give it a live widget too
  187.      */
  188.     xbow->xb_link(port).link_aux_status = XB_AUX_STAT_PRESENT;
  189.     /*
  190.      * zero the link control reg
  191.      */
  192.     xbow->xb_link(port).link_control = 0x0;
  193. }
  194. #endif /* XBRIDGE_REGS_SIM */
  196. /*
  197.  *    xbow_attach: the crosstalk provider has
  198.  *      determined that there is a crossbow widget
  199.  *      present, and has handed us the connection
  200.  *      point for that vertex.
  201.  *
  202.  *      We not only add our own vertex, but add
  203.  *      some "xtalk switch" data to the switch
  204.  *      vertex (at the connect point's parent) if
  205.  *      it does not have any.
  206.  */
  208. /*ARGSUSED */
  209. int
  210. xbow_attach(devfs_handle_t conn)
  211. {
  212.     /*REFERENCED */
  213.     devfs_handle_t            vhdl;
  214.     devfs_handle_t            busv;
  215.     xbow_t                 *xbow;
  216.     xbow_soft_t             soft;
  217.     int                     port;
  218.     xswitch_info_t          info;
  219. #ifdef LATER
  220.     xtalk_intr_t            intr_hdl;
  221.     device_desc_t           dev_desc;
  222. #endif
  223.     char                    devnm[MAXDEVNAME], *s;
  224.     xbowreg_t               id;
  225.     int                     rev;
  226.     int     i;
  227.     int     xbow_num;
  229. #if DEBUG && ATTACH_DEBUG
  230. #if defined(SUPPORT_PRINTING_V_FORMAT
  231.     printk("%v: xbow_attachn", conn);
  232. #else
  233.     printk("0x%x: xbow_attachn", conn);
  234. #endif
  235. #endif
  237.     /*
  238.      * Get a PIO pointer to the base of the crossbow
  239.      * chip.
  240.      */
  241. #ifdef XBRIDGE_REGS_SIM
  242.     printk("xbow_attach: XBRIDGE_REGS_SIM FIXME: allocating %ld bytes for xbow_sn", sizeof(xbow_t));
  243.     xbow = (xbow_t *) kmalloc(sizeof(xbow_t), GFP_KERNEL);
  244.     /*
  245.      * turn on ports e and f like in a real live ibrick
  246.      */
  247.     xbow_set_simulated_regs(xbow, 0xe);
  248.     xbow_set_simulated_regs(xbow, 0xf);
  249. #else
  250.     xbow = (xbow_t *) xtalk_piotrans_addr(conn, 0, 0, sizeof(xbow_t), 0);
  251. #endif /* XBRIDGE_REGS_SIM */
  253.     /*
  254.      * Locate the "switch" vertex: it is the parent
  255.      * of our connection point.
  256.      */
  257.     busv = hwgraph_connectpt_get(conn);
  258. #if DEBUG && ATTACH_DEBUG
  259.     printk("xbow_attach: Bus Vertex 0x%p, conn 0x%p, xbow register 0x%p wid= 0x%xn", busv, conn, xbow, *(volatile u32 *)xbow);
  260. #endif
  262.     ASSERT(busv != GRAPH_VERTEX_NONE);
  264.     /*
  265.      * Create our private vertex, and connect our
  266.      * driver information to it. This makes it possible
  267.      * for diagnostic drivers to open the crossbow
  268.      * vertex for access to registers.
  269.      */
  271.     /*
  272.      * We need to teach xbow drivers to provide the right set of
  273.      * file ops.
  274.      */
  275.     vhdl = NULL;
  276.     vhdl = hwgraph_register(conn, EDGE_LBL_XBOW,
  277.                         0, DEVFS_FL_AUTO_DEVNUM,
  278.                         0, 0,
  279.                         S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP, 0, 0,
  280.                         /* &hcl_fops */ (void *)&vhdl, NULL);
  281.     if (!vhdl) {
  282.         printk(KERN_WARNING "xbow_attach: Unable to create char device for xbow conn %pn",
  283.                 (void *)conn);
  284.     }
  286.     /*
  287.      * Allocate the soft state structure and attach
  288.      * it to the xbow's vertex
  289.      */
  290.     NEW(soft);
  291.     soft->conn = conn;
  292.     soft->vhdl = vhdl;
  293.     soft->busv = busv;
  294.     soft->base = xbow;
  295.     /* does the universe really need another macro?  */
  296.     /* xbow_soft_set(vhdl, (arbitrary_info_t) soft); */
  297.     hwgraph_fastinfo_set(vhdl, (arbitrary_info_t) soft);
  299. #define XBOW_NUM_SUFFIX_FORMAT "[xbow# %d]"
  301.     /* Add xbow number as a suffix to the hwgraph name of the xbow.
  302.      * This is helpful while looking at the error/warning messages.
  303.      */
  304.     xbow_num = 0;
  306.     /*
  307.      * get the name of this xbow vertex and keep the info.
  308.      * This is needed during errors and interupts, but as
  309.      * long as we have it, we can use it elsewhere.
  310.      */
  311.     s = dev_to_name(vhdl, devnm, MAXDEVNAME);
  312.     soft->name = kmalloc(strlen(s) + strlen(XBOW_NUM_SUFFIX_FORMAT) + 1, 
  313.     GFP_KERNEL);
  314.     sprintf(soft->name,"%s"XBOW_NUM_SUFFIX_FORMAT, s,xbow_num);
  316. #ifdef XBRIDGE_REGS_SIM
  317.     /* my o200/ibrick has id=0x2d002049, but XXBOW_WIDGET_PART_NUM is defined
  318.      * as 0xd000, so I'm using that for the partnum bitfield.
  319.      */
  320.     printk("xbow_attach: XBRIDGE_REGS_SIM FIXME: need xb_wid_id value!!n");
  321.     id = 0x2d000049;
  322. #else
  323.     id = xbow->xb_wid_id;
  324. #endif /* XBRIDGE_REGS_SIM */
  325.     rev = XWIDGET_PART_REV_NUM(id);
  327.     /*
  328.      * Print the revision if DEBUG, or SHOW_REVS and kdebug,
  329.      * or the xbow is downrev.
  330.      *
  331.      * If xbow is downrev, make it a WARNING that the
  332.      * Crossbow is DOWNREV: these chips are not good
  333.      * to have around, and the operator should be told.
  334.      */
  335. #ifdef LATER
  336. #if !DEBUG
  337.     if (
  338. #if SHOW_REVS
  339.    (kdebug) ||
  340. #endif /* SHOW_REVS */
  341.    (rev < XBOW_REV_1_1))
  342. #endif /* !DEBUG  */
  343. printk("%sCrossbow ASIC: rev %s (code=%d) at %s%s",
  344. (rev < XBOW_REV_1_1) ? "DOWNREV " : "",
  345. (rev == XBOW_REV_1_0) ? "1.0" :
  346. (rev == XBOW_REV_1_1) ? "1.1" :
  347. (rev == XBOW_REV_1_2) ? "1.2" :
  348. (rev == XBOW_REV_1_3) ? "1.3" :
  349. (rev == XBOW_REV_2_0) ? "2.0" :
  350. (rev == XXBOW_PART_REV_1_0) ? "Xbridge 1.0" :
  351. (rev == XXBOW_PART_REV_2_0) ? "Xbridge 2.0" :
  352. "unknown",
  353. rev, soft->name,
  354. (rev < XBOW_REV_1_1) ? "" : "n");
  355. #endif /* LATER */
  356.     mutex_spinlock_init(&soft->xbow_perf_lock);
  357.     soft->xbow_perfcnt[0].xp_perf_reg = &xbow->xb_perf_ctr_a;
  358.     soft->xbow_perfcnt[1].xp_perf_reg = &xbow->xb_perf_ctr_b;
  360.     /* Initialization for GBR bw allocation */
  361.     mutex_spinlock_init(&soft->xbow_bw_alloc_lock);
  363. #define XBOW_8_BIT_PORT_BW_MAX (400 * 1000 * 1000) /* 400 MB/s */
  364. #define XBOW_16_BIT_PORT_BW_MAX (800 * 1000 * 1000) /* 800 MB/s */
  366.     /* Set bandwidth hiwatermark and current values */
  367.     for (i = 0; i < MAX_XBOW_PORTS; i++) {
  368. soft->bw_hiwm[i] = XBOW_16_BIT_PORT_BW_MAX; /* for now */
  369. soft->bw_cur_used[i] = 0;
  370.     }
  372.     /*
  373.      * Enable xbow error interrupts
  374.      */
  375.     xbow->xb_wid_control = (XB_WID_CTRL_REG_ACC_IE | XB_WID_CTRL_XTALK_IE);
  377.     /*
  378.      * take a census of the widgets present,
  379.      * leaving notes at the switch vertex.
  380.      */
  381.     info = xswitch_info_new(busv);
  383.     for (port = MAX_PORT_NUM - MAX_XBOW_PORTS;
  384.  port < MAX_PORT_NUM; ++port) {
  385. if (!xbow_link_alive(xbow, port)) {
  386. #if DEBUG && XBOW_DEBUG
  387.     printk(KERN_INFO "0x%p link %d is not aliven",
  388.     busv, port);
  389. #endif
  390.     continue;
  391. }
  392. if (!xbow_widget_present(xbow, port)) {
  393. #if DEBUG && XBOW_DEBUG
  394.     printk(KERN_INFO "0x%p link %d is alive but no widget is presentn", busv, port);
  395. #endif
  396.     continue;
  397. }
  398. #if DEBUG && XBOW_DEBUG
  399. printk(KERN_INFO "0x%p link %d has a widgetn",
  400. busv, port);
  401. #endif
  403. xswitch_info_link_is_ok(info, port);
  404. /*
  405.  * Turn some error interrupts on
  406.  * and turn others off. The PROM has
  407.  * some things turned on we don't
  408.  * want to see (bandwidth allocation
  409.  * errors for instance); so if it
  410.  * is not listed here, it is not on.
  411.  */
  412. xbow->xb_link(port).link_control =
  413.     ( (xbow->xb_link(port).link_control
  414. /*
  415.  * Turn off these bits; they are non-fatal,
  416.  * but we might want to save some statistics
  417.  * on the frequency of these errors.
  418.  * XXX FIXME XXX
  419.  */
  420.     & ~XB_CTRL_RCV_CNT_OFLOW_IE
  421.     & ~XB_CTRL_XMT_CNT_OFLOW_IE
  422.     & ~XB_CTRL_BNDWDTH_ALLOC_IE
  423.     & ~XB_CTRL_RCV_IE)
  424. /*
  425.  * These are the ones we want to turn on.
  426.  */
  427.     | (XB_CTRL_ILLEGAL_DST_IE
  428.     | XB_CTRL_OALLOC_IBUF_IE
  429.     | XB_CTRL_XMT_MAX_RTRY_IE
  430.     | XB_CTRL_MAXREQ_TOUT_IE
  431.     | XB_CTRL_XMT_RTRY_IE
  432.     | XB_CTRL_SRC_TOUT_IE) );
  433.     }
  435.     xswitch_provider_register(busv, &xbow_provider);
  437.     return 0; /* attach successful */
  438. }
  440. /*ARGSUSED */
  441. int
  442. xbow_open(devfs_handle_t *devp, int oflag, int otyp, cred_t *credp)
  443. {
  444.     return 0;
  446. }
  448. /*ARGSUSED */
  449. int
  450. xbow_close(devfs_handle_t dev, int oflag, int otyp, cred_t *crp)
  451. {
  452.     return 0;
  453. }
  455. /*ARGSUSED */
  456. int
  457. xbow_map(devfs_handle_t dev, vhandl_t *vt, off_t off, size_t len, uint prot)
  458. {
  459.     devfs_handle_t            vhdl = dev_to_vhdl(dev);
  460.     xbow_soft_t             soft = xbow_soft_get(vhdl);
  461.     int                     error;
  463.     ASSERT(soft);
  464.     len = ctob(btoc(len));
  465.     /* XXX- this ignores the offset!!! */
  466.     error = v_mapphys(vt, (void *) soft->base, len);
  467.     return error;
  468. }
  470. /*ARGSUSED */
  471. int
  472. xbow_unmap(devfs_handle_t dev, vhandl_t *vt)
  473. {
  474.     return 0;
  475. }
  477. /* This contains special-case code for grio. There are plans to make
  478.  * this general sometime in the future, but till then this should
  479.  * be good enough.
  480.  */
  481. xwidgetnum_t
  482. xbow_widget_num_get(devfs_handle_t dev)
  483. {
  484. devfs_handle_t tdev;
  485. char devname[MAXDEVNAME];
  486. xwidget_info_t xwidget_info;
  487. int i;
  489. vertex_to_name(dev, devname, MAXDEVNAME);
  491. /* If this is a pci controller vertex, traverse up using
  492.  * the ".." links to get to the widget.
  493.  */
  494. if (strstr(devname, EDGE_LBL_PCI) &&
  495. strstr(devname, EDGE_LBL_CONTROLLER)) {
  496. tdev = dev;
  497. for (i=0; i< 2; i++) {
  498. if (hwgraph_edge_get(tdev,
  499. HWGRAPH_EDGELBL_DOTDOT, &tdev) !=
  500. GRAPH_SUCCESS)
  501. return XWIDGET_NONE;
  502. }
  504. if ((xwidget_info = xwidget_info_chk(tdev)) != NULL) {
  505. return (xwidget_info_id_get(xwidget_info));
  506. } else {
  507. return XWIDGET_NONE;
  508. }
  509. }
  511. return XWIDGET_NONE;
  512. }
  514. int
  515. xbow_ioctl(devfs_handle_t dev,
  516.    int cmd,
  517.    void *arg,
  518.    int flag,
  519.    struct cred *cr,
  520.    int *rvalp)
  521. {
  522.     devfs_handle_t            vhdl;
  523.     int                     error = 0;
  525. #if defined (DEBUG)
  526.     int                     rc;
  527.     devfs_handle_t            conn;
  528.     struct xwidget_info_s  *xwidget_info;
  529.     xbow_soft_t             xbow_soft;
  530. #endif
  531.     *rvalp = 0;
  533.     vhdl = dev_to_vhdl(dev);
  534. #if defined (DEBUG)
  535.     xbow_soft = xbow_soft_get(vhdl);
  536.     conn = xbow_soft->conn;
  538.     xwidget_info = xwidget_info_get(conn);
  539.     ASSERT_ALWAYS(xwidget_info != NULL);
  541.     rc = xwidget_hwid_is_xswitch(&xwidget_info->w_hwid);
  542.     ASSERT_ALWAYS(rc != 0);
  543. #endif
  544.     switch (cmd) {
  545. #ifdef LATER
  546.     case XBOWIOC_PERF_ENABLE:
  547.     case XBOWIOC_PERF_DISABLE:
  548. {
  549.     struct xbow_perfarg_t   xbow_perf_en;
  551.     if (!_CAP_CRABLE(cr, CAP_DEVICE_MGT)) {
  552. error = EPERM;
  553. break;
  554.     }
  555.     if ((flag & FWRITE) == 0) {
  556. error = EBADF;
  557. break;
  558.     }
  559.     if (COPYIN(arg, &xbow_perf_en, sizeof(xbow_perf_en))) {
  560. error = EFAULT;
  561. break;
  562.     }
  563.     if (error = xbow_enable_perf_counter(vhdl,
  564.  xbow_perf_en.link,
  565.  (cmd == XBOWIOC_PERF_DISABLE) ? 0 : xbow_perf_en.mode,
  566.  xbow_perf_en.counter)) {
  567. error = EINVAL;
  568. break;
  569.     }
  570.     break;
  571. }
  572. #endif
  574. #ifdef LATER
  575.     case XBOWIOC_PERF_GET:
  576. {
  577.     xbow_perf_link_t       *xbow_perf_cnt;
  579.     if ((flag & FREAD) == 0) {
  580. error = EBADF;
  581. break;
  582.     }
  583.     xbow_perf_cnt = xbow_get_perf_counters(vhdl);
  584.     ASSERT_ALWAYS(xbow_perf_cnt != NULL);
  586.     if (COPYOUT((void *) xbow_perf_cnt, (void *) arg,
  587. MAX_XBOW_PORTS * sizeof(xbow_perf_link_t))) {
  588. error = EFAULT;
  589. break;
  590.     }
  591.     break;
  592. }
  593. #endif
  595.     case XBOWIOC_LLP_ERROR_ENABLE:
  596. if ((error = xbow_enable_llp_monitor(vhdl)) != 0)
  597.     error = EINVAL;
  599. break;
  601.     case XBOWIOC_LLP_ERROR_DISABLE:
  603. if ((error = xbow_disable_llp_monitor(vhdl)) != 0)
  604.     error = EINVAL;
  606. break;
  608. #ifdef LATER
  609.     case XBOWIOC_LLP_ERROR_GET:
  610. {
  611.     xbow_link_status_t     *xbow_llp_status;
  613.     if ((flag & FREAD) == 0) {
  614. error = EBADF;
  615. break;
  616.     }
  617.     xbow_llp_status = xbow_get_llp_status(vhdl);
  618.     ASSERT_ALWAYS(xbow_llp_status != NULL);
  620.     if (COPYOUT((void *) xbow_llp_status, (void *) arg,
  621. MAX_XBOW_PORTS * sizeof(xbow_link_status_t))) {
  622. error = EFAULT;
  623. break;
  624.     }
  625.     break;
  626. }
  627. #endif
  629. #ifdef LATER
  630.     case GIOCSETBW:
  631. {
  632.     grio_ioctl_info_t info;
  633.     xwidgetnum_t src_widgetnum, dest_widgetnum;
  635.     if (COPYIN(arg, &info, sizeof(grio_ioctl_info_t))) {
  636. error = EFAULT;
  637. break;
  638.     }
  639. #ifdef GRIO_DEBUG
  640.     printf("xbow:: prev_vhdl: %d next_vhdl: %d reqbw: %lldn",
  641. info.prev_vhdl, info.next_vhdl, info.reqbw);
  642. #endif /* GRIO_DEBUG */
  644.     src_widgetnum = xbow_widget_num_get(info.prev_vhdl);
  645.     dest_widgetnum = xbow_widget_num_get(info.next_vhdl);
  647.     /* Bandwidth allocation is bi-directional. Since bandwidth
  648.      * reservations have already been done at an earlier stage,
  649.      * we cannot fail here for lack of bandwidth.
  650.      */
  651.     xbow_prio_bw_alloc(dev, src_widgetnum, dest_widgetnum,
  652. 0, info.reqbw);
  653.     xbow_prio_bw_alloc(dev, dest_widgetnum, src_widgetnum,
  654. 0, info.reqbw);
  656.     break;
  657. }
  659.     case GIOCRELEASEBW:
  660. {
  661.     grio_ioctl_info_t info;
  662.     xwidgetnum_t src_widgetnum, dest_widgetnum;
  664.     if (!cap_able(CAP_DEVICE_MGT)) {
  665. error = EPERM;
  666. break;
  667.     }
  669.     if (COPYIN(arg, &info, sizeof(grio_ioctl_info_t))) {
  670. error = EFAULT;
  671. break;
  672.     }
  673. #ifdef GRIO_DEBUG
  674.     printf("xbow:: prev_vhdl: %d next_vhdl: %d reqbw: %lldn",
  675. info.prev_vhdl, info.next_vhdl, info.reqbw);
  676. #endif /* GRIO_DEBUG */
  678.     src_widgetnum = xbow_widget_num_get(info.prev_vhdl);
  679.     dest_widgetnum = xbow_widget_num_get(info.next_vhdl);
  681.     /* Bandwidth reservation is bi-directional. Hence, remove
  682.      * bandwidth reservations for both directions.
  683.      */
  684.     xbow_prio_bw_alloc(dev, src_widgetnum, dest_widgetnum,
  685. info.reqbw, (-1 * info.reqbw));
  686.     xbow_prio_bw_alloc(dev, dest_widgetnum, src_widgetnum,
  687. info.reqbw, (-1 * info.reqbw));
  689.     break;
  690. }
  691. #endif
  693.     default:
  694. break;
  696.     }
  697.     return error;
  698. }
  700. /*
  701.  * xbow_widget_present: See if a device is present
  702.  * on the specified port of this crossbow.
  703.  */
  704. int
  705. xbow_widget_present(xbow_t * xbow, int port)
  706. {
  707. if ( IS_RUNNING_ON_SIMULATOR() ) {
  708. if ( (port == 14) || (port == 15) ) {
  709. return 1;
  710. }
  711. else {
  712. return 0;
  713. }
  714. }
  715. else {
  716. return xbow->xb_link(port).link_aux_status & XB_AUX_STAT_PRESENT;
  717. }
  718. }
  720. static int
  721. xbow_link_alive(xbow_t * xbow, int port)
  722. {
  723.     xbwX_stat_t             xbow_linkstat;
  725.     xbow_linkstat.linkstatus = xbow->xb_link(port).link_status;
  726.     return (xbow_linkstat.link_alive);
  727. }
  729. /*
  730.  * xbow_widget_lookup
  731.  *      Lookup the edges connected to the xbow specified, and
  732.  *      retrieve the handle corresponding to the widgetnum
  733.  *      specified.
  734.  *      If not found, return 0.
  735.  */
  736. devfs_handle_t
  737. xbow_widget_lookup(devfs_handle_t vhdl,
  738.    int widgetnum)
  739. {
  740.     xswitch_info_t          xswitch_info;
  741.     devfs_handle_t            conn;
  743.     xswitch_info = xswitch_info_get(vhdl);
  744.     conn = xswitch_info_vhdl_get(xswitch_info, widgetnum);
  745.     return conn;
  746. }
  748. /*
  749.  * xbow_setwidint: called when xtalk
  750.  * is establishing or migrating our
  751.  * interrupt service.
  752.  */
  753. #ifdef LATER
  754. static void
  755. xbow_setwidint(xtalk_intr_t intr)
  756. {
  757.     xwidgetnum_t            targ = xtalk_intr_target_get(intr);
  758.     iopaddr_t               addr = xtalk_intr_addr_get(intr);
  759.     xtalk_intr_vector_t     vect = xtalk_intr_vector_get(intr);
  760.     xbow_t                 *xbow = (xbow_t *) xtalk_intr_sfarg_get(intr);
  762.     xbow_intr_preset((void *) xbow, 0, targ, addr, vect);
  763. }
  764. #endif /* LATER */
  766. /*
  767.  * xbow_intr_preset: called during mlreset time
  768.  * if the platform specific code needs to route
  769.  * an xbow interrupt before the xtalk infrastructure
  770.  * is available for use.
  771.  *
  772.  * Also called from xbow_setwidint, so we don't
  773.  * replicate the guts of the routine.
  774.  *
  775.  * XXX- probably should be renamed xbow_wid_intr_set or
  776.  * something to reduce confusion.
  777.  */
  778. /*ARGSUSED3 */
  779. void
  780. xbow_intr_preset(void *which_widget,
  781.  int which_widget_intr,
  782.  xwidgetnum_t targ,
  783.  iopaddr_t addr,
  784.  xtalk_intr_vector_t vect)
  785. {
  786.     xbow_t                 *xbow = (xbow_t *) which_widget;
  788.     xbow->xb_wid_int_upper = ((0xFF000000 & (vect << 24)) |
  789.       (0x000F0000 & (targ << 16)) |
  790.       XTALK_ADDR_TO_UPPER(addr));
  791.     xbow->xb_wid_int_lower = XTALK_ADDR_TO_LOWER(addr);
  792. }
  794. #define XEM_ADD_STR(s) printk("%s", (s))
  795. #define XEM_ADD_NVAR(n,v) printk("t%20s: 0x%xn", (n), (v))
  796. #define XEM_ADD_VAR(v) XEM_ADD_NVAR(#v,(v))
  797. #define XEM_ADD_IOEF(n)  if (IOERROR_FIELDVALID(ioe,n))     
  798.     XEM_ADD_NVAR("ioe." #n,     
  799.  IOERROR_GETVALUE(ioe,n))
  801. #ifdef LATER
  802. static void
  803. xem_add_ioe(ioerror_t *ioe)
  804. {
  805.     XEM_ADD_IOEF(errortype);
  806.     XEM_ADD_IOEF(widgetnum);
  807.     XEM_ADD_IOEF(widgetdev);
  808.     XEM_ADD_IOEF(srccpu);
  809.     XEM_ADD_IOEF(srcnode);
  810.     XEM_ADD_IOEF(errnode);
  811.     XEM_ADD_IOEF(sysioaddr);
  812.     XEM_ADD_IOEF(xtalkaddr);
  813.     XEM_ADD_IOEF(busspace);
  814.     XEM_ADD_IOEF(busaddr);
  815.     XEM_ADD_IOEF(vaddr);
  816.     XEM_ADD_IOEF(memaddr);
  817.     XEM_ADD_IOEF(epc);
  818.     XEM_ADD_IOEF(ef);
  819. }
  821. #define XEM_ADD_IOE() (xem_add_ioe(ioe))
  822. #endif /* LATER */
  824. int                     xbow_xmit_retry_errors = 0;
  826. int
  827. xbow_xmit_retry_error(xbow_soft_t soft,
  828.       int port)
  829. {
  830.     xswitch_info_t          info;
  831.     devfs_handle_t            vhdl;
  832.     widget_cfg_t           *wid;
  833.     widgetreg_t             id;
  834.     int                     part;
  835.     int                     mfgr;
  837.     wid = soft->wpio[port - BASE_XBOW_PORT];
  838.     if (wid == NULL) {
  839. /* If we can't track down a PIO
  840.  * pointer to our widget yet,
  841.  * leave our caller knowing that
  842.  * we are interested in this
  843.  * interrupt if it occurs in
  844.  * the future.
  845.  */
  846. info = xswitch_info_get(soft->busv);
  847. if (!info)
  848.     return 1;
  849. vhdl = xswitch_info_vhdl_get(info, port);
  850. if (vhdl == GRAPH_VERTEX_NONE)
  851.     return 1;
  852. wid = (widget_cfg_t *) xtalk_piotrans_addr
  853.     (vhdl, 0, 0, sizeof *wid, 0);
  854. if (!wid)
  855.     return 1;
  856. soft->wpio[port - BASE_XBOW_PORT] = wid;
  857.     }
  858.     id = wid->w_id;
  859.     part = XWIDGET_PART_NUM(id);
  860.     mfgr = XWIDGET_MFG_NUM(id);
  862.     /* If this thing is not a Bridge,
  863.      * do not activate the WAR, and
  864.      * tell our caller we do not need
  865.      * to be called again.
  866.      */
  867.     if ((part != BRIDGE_WIDGET_PART_NUM) ||
  868. (mfgr != BRIDGE_WIDGET_MFGR_NUM)) {
  869. /* FIXME: add Xbridge to the WAR.
  870.  * Shouldn't hurt anything.  Later need to
  871.  * check if we can remove this.
  872.                  */
  873.      if ((part != XBRIDGE_WIDGET_PART_NUM) ||
  874.     (mfgr != XBRIDGE_WIDGET_MFGR_NUM))
  875. return 0;
  876.     }
  878.     /* count how many times we
  879.      * have picked up after
  880.      * LLP Transmit problems.
  881.      */
  882.     xbow_xmit_retry_errors++;
  884.     /* rewrite the control register
  885.      * to fix things up.
  886.      */
  887.     wid->w_control = wid->w_control;
  888.     wid->w_control;
  890.     return 1;
  891. }
  893. void
  894. xbow_update_perf_counters(devfs_handle_t vhdl)
  895. {
  896.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  897.     xbow_perf_t            *xbow_perf = xbow_soft->xbow_perfcnt;
  898.     xbow_perf_link_t       *xbow_plink = xbow_soft->xbow_perflink;
  899.     xbow_perfcount_t        perf_reg;
  900.     unsigned long           s;
  901.     int                     link, i;
  903.     for (i = 0; i < XBOW_PERF_COUNTERS; i++, xbow_perf++) {
  904. if (xbow_perf->xp_mode == XBOW_MONITOR_NONE)
  905.     continue;
  907. s = mutex_spinlock(&xbow_soft->xbow_perf_lock);
  909. perf_reg.xb_counter_val = *(xbowreg_t *) xbow_perf->xp_perf_reg;
  911. link = perf_reg.xb_perf.link_select;
  913. (xbow_plink + link)->xlp_cumulative[xbow_perf->xp_curmode] +=
  914.     ((perf_reg.xb_perf.count - xbow_perf->xp_current) & XBOW_COUNTER_MASK);
  915. xbow_perf->xp_current = perf_reg.xb_perf.count;
  917. mutex_spinunlock(&xbow_soft->xbow_perf_lock, s);
  918.     }
  919.     /* Do port /mode multiplexing here */
  921. #ifdef LATER
  922.     (void) timeout(xbow_update_perf_counters,
  923.    (void *) (__psunsigned_t) vhdl, XBOW_PERF_TIMEOUT);
  924. #endif
  926. }
  928. xbow_perf_link_t       *
  929. xbow_get_perf_counters(devfs_handle_t vhdl)
  930. {
  931.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  932.     xbow_perf_link_t       *xbow_perf_link = xbow_soft->xbow_perflink;
  934.     return xbow_perf_link;
  935. }
  937. int
  938. xbow_enable_perf_counter(devfs_handle_t vhdl, int link, int mode, int counter)
  939. {
  940.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  941.     xbow_perf_t            *xbow_perf = xbow_soft->xbow_perfcnt;
  942.     xbow_linkctrl_t         xbow_link_ctrl;
  943.     xbow_t                 *xbow = xbow_soft->base;
  944.     xbow_perfcount_t        perf_reg;
  945.     unsigned long           s;
  946.     int                     i;
  948.     link -= BASE_XBOW_PORT;
  949.     if ((link < 0) || (link >= MAX_XBOW_PORTS))
  950. return -1;
  952.     if ((mode < XBOW_MONITOR_NONE) || (mode > XBOW_MONITOR_DEST_LINK))
  953. return -1;
  955.     if ((counter < 0) || (counter >= XBOW_PERF_COUNTERS))
  956. return -1;
  958.     s = mutex_spinlock(&xbow_soft->xbow_perf_lock);
  960.     if ((xbow_perf + counter)->xp_mode && mode) {
  961. mutex_spinunlock(&xbow_soft->xbow_perf_lock, s);
  962. return -1;
  963.     }
  964.     for (i = 0; i < XBOW_PERF_COUNTERS; i++) {
  965. if (i == counter)
  966.     continue;
  967. if (((xbow_perf + i)->xp_link == link) &&
  968.     ((xbow_perf + i)->xp_mode)) {
  969.     mutex_spinunlock(&xbow_soft->xbow_perf_lock, s);
  970.     return -1;
  971. }
  972.     }
  973.     xbow_perf += counter;
  975.     xbow_perf->xp_curlink = xbow_perf->xp_link = link;
  976.     xbow_perf->xp_curmode = xbow_perf->xp_mode = mode;
  978.     xbow_link_ctrl.xbl_ctrlword = xbow->xb_link_raw[link].link_control;
  979.     xbow_link_ctrl.xb_linkcontrol.perf_mode = mode;
  980.     xbow->xb_link_raw[link].link_control = xbow_link_ctrl.xbl_ctrlword;
  982.     perf_reg.xb_counter_val = *(xbowreg_t *) xbow_perf->xp_perf_reg;
  983.     perf_reg.xb_perf.link_select = link;
  984.     *(xbowreg_t *) xbow_perf->xp_perf_reg = perf_reg.xb_counter_val;
  985.     xbow_perf->xp_current = perf_reg.xb_perf.count;
  987. #ifdef LATER
  988.     (void) timeout(xbow_update_perf_counters,
  989.    (void *) (__psunsigned_t) vhdl, XBOW_PERF_TIMEOUT);
  990. #endif
  992.     mutex_spinunlock(&xbow_soft->xbow_perf_lock, s);
  994.     return 0;
  995. }
  997. xbow_link_status_t     *
  998. xbow_get_llp_status(devfs_handle_t vhdl)
  999. {
  1000.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1001.     xbow_link_status_t     *xbow_llp_status = xbow_soft->xbow_link_status;
  1003.     return xbow_llp_status;
  1004. }
  1006. void
  1007. xbow_update_llp_status(devfs_handle_t vhdl)
  1008. {
  1009.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1010.     xbow_link_status_t     *xbow_llp_status = xbow_soft->xbow_link_status;
  1011.     xbow_t                 *xbow;
  1012.     xbwX_stat_t             lnk_sts;
  1013.     xbow_aux_link_status_t  aux_sts;
  1014.     int                     link;
  1015.     devfs_handle_t     xwidget_vhdl;
  1016.     char    *xwidget_name;
  1018.     xbow = (xbow_t *) xbow_soft->base;
  1019.     for (link = 0; link < MAX_XBOW_PORTS; link++, xbow_llp_status++) {
  1020. /* Get the widget name corresponding the current link.
  1021.  * Note : 0 <= link < MAX_XBOW_PORTS(8).
  1022.  *    BASE_XBOW_PORT(0x8) <= xwidget number < MAX_PORT_NUM (0x10)
  1023.  */
  1024. xwidget_vhdl = xbow_widget_lookup(xbow_soft->busv,link+BASE_XBOW_PORT);
  1025. xwidget_name = xwidget_name_get(xwidget_vhdl);
  1026. aux_sts.aux_linkstatus
  1027.     = xbow->xb_link_raw[link].link_aux_status;
  1028. lnk_sts.linkstatus = xbow->xb_link_raw[link].link_status_clr;
  1030. if (lnk_sts.link_alive == 0)
  1031.     continue;
  1033. xbow_llp_status->rx_err_count +=
  1034.     aux_sts.xb_aux_linkstatus.rx_err_cnt;
  1036. xbow_llp_status->tx_retry_count +=
  1037.     aux_sts.xb_aux_linkstatus.tx_retry_cnt;
  1039. if (lnk_sts.linkstatus & ~(XB_STAT_RCV_ERR | XB_STAT_XMT_RTRY_ERR | XB_STAT_LINKALIVE)) {
  1040. #ifdef LATER
  1041.     printk(KERN_WARNING  "link %d[%s]: bad status 0x%xn",
  1042.     link, xwidget_name, lnk_sts.linkstatus);
  1043. #endif
  1044. }
  1045.     }
  1046. #ifdef LATER
  1047.     if (xbow_soft->link_monitor)
  1048. (void) timeout(xbow_update_llp_status,
  1049.        (void *) (__psunsigned_t) vhdl, XBOW_STATS_TIMEOUT);
  1050. #endif
  1051. }
  1053. int
  1054. xbow_disable_llp_monitor(devfs_handle_t vhdl)
  1055. {
  1056.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1057.     int                     port;
  1059.     for (port = 0; port < MAX_XBOW_PORTS; port++) {
  1060. xbow_soft->xbow_link_status[port].rx_err_count = 0;
  1061. xbow_soft->xbow_link_status[port].tx_retry_count = 0;
  1062.     }
  1064.     xbow_soft->link_monitor = 0;
  1065.     return 0;
  1066. }
  1068. int
  1069. xbow_enable_llp_monitor(devfs_handle_t vhdl)
  1070. {
  1071.     xbow_soft_t             xbow_soft = xbow_soft_get(vhdl);
  1073. #ifdef LATER
  1074.     (void) timeout(xbow_update_llp_status,
  1075.    (void *) (__psunsigned_t) vhdl, XBOW_STATS_TIMEOUT);
  1076. #endif
  1077.     xbow_soft->link_monitor = 1;
  1078.     return 0;
  1079. }
  1082. int
  1083. xbow_reset_link(devfs_handle_t xconn_vhdl)
  1084. {
  1085.     xwidget_info_t          widget_info;
  1086.     xwidgetnum_t            port;
  1087.     xbow_t                 *xbow;
  1088.     xbowreg_t               ctrl;
  1089.     xbwX_stat_t             stat;
  1090.     unsigned                itick;
  1091.     unsigned                dtick;
  1092.     static int              ticks_per_ms = 0;
  1094.     if (!ticks_per_ms) {
  1095. itick = get_timestamp();
  1096. us_delay(1000);
  1097. ticks_per_ms = get_timestamp() - itick;
  1098.     }
  1099.     widget_info = xwidget_info_get(xconn_vhdl);
  1100.     port = xwidget_info_id_get(widget_info);
  1102. #ifdef XBOW_K1PTR /* defined if we only have one xbow ... */
  1103.     xbow = XBOW_K1PTR;
  1104. #else
  1105.     {
  1106. devfs_handle_t            xbow_vhdl;
  1107. xbow_soft_t             xbow_soft;
  1109. hwgraph_traverse(xconn_vhdl, ".master/xtalk/0/xbow", &xbow_vhdl);
  1110. xbow_soft = xbow_soft_get(xbow_vhdl);
  1111. xbow = xbow_soft->base;
  1112.     }
  1113. #endif
  1115.     /*
  1116.      * This requires three PIOs (reset the link, check for the
  1117.      * reset, restore the control register for the link) plus
  1118.      * 10us to wait for the reset. We allow up to 1ms for the
  1119.      * widget to come out of reset before giving up and
  1120.      * returning a failure.
  1121.      */
  1122.     ctrl = xbow->xb_link(port).link_control;
  1123.     xbow->xb_link(port).link_reset = 0;
  1124.     itick = get_timestamp();
  1125.     while (1) {
  1126. stat.linkstatus = xbow->xb_link(port).link_status;
  1127. if (stat.link_alive)
  1128.     break;
  1129. dtick = get_timestamp() - itick;
  1130. if (dtick > ticks_per_ms) {
  1131.     return -1; /* never came out of reset */
  1132. }
  1133. DELAY(2); /* don't beat on link_status */
  1134.     }
  1135.     xbow->xb_link(port).link_control = ctrl;
  1136.     return 0;
  1137. }
  1139. /*
  1140.  * Dump xbow registers.
  1141.  * input parameter is either a pointer to
  1142.  * the xbow chip or the vertex handle for
  1143.  * an xbow vertex.
  1144.  */
  1145. void
  1146. idbg_xbowregs(int64_t regs)
  1147. {
  1148.     xbow_t                 *xbow;
  1149.     int                     i;
  1150.     xb_linkregs_t          *link;
  1152. #ifdef LATER
  1153.     if (dev_is_vertex((devfs_handle_t) regs)) {
  1154. devfs_handle_t            vhdl = (devfs_handle_t) regs;
  1155. xbow_soft_t             soft = xbow_soft_get(vhdl);
  1157. xbow = soft->base;
  1158.     } else
  1159. #endif
  1160.     {
  1161. xbow = (xbow_t *) regs;
  1162.     }
  1164. #ifdef LATER
  1165.     qprintf("Printing xbow registers starting at 0x%xn", xbow);
  1166.     qprintf("wid %x status %x erruppr %x errlower %x control %x timeout %xn",
  1167.     xbow->xb_wid_id, xbow->xb_wid_stat, xbow->xb_wid_err_upper,
  1168.     xbow->xb_wid_err_lower, xbow->xb_wid_control,
  1169.     xbow->xb_wid_req_timeout);
  1170.     qprintf("intr uppr %x lower %x errcmd %x llp ctrl %x arb_reload %xn",
  1171.     xbow->xb_wid_int_upper, xbow->xb_wid_int_lower,
  1172.     xbow->xb_wid_err_cmdword, xbow->xb_wid_llp,
  1173.     xbow->xb_wid_arb_reload);
  1174. #endif
  1176.     for (i = 8; i <= 0xf; i++) {
  1177. link = &xbow->xb_link(i);
  1178. #ifdef LATER
  1179. qprintf("Link %d registersn", i);
  1180. qprintf("tctrl %x stat %x arbuppr %x arblowr %x auxstat %xn",
  1181. link->link_control, link->link_status,
  1182. link->link_arb_upper, link->link_arb_lower,
  1183. link->link_aux_status);
  1184. #endif
  1185.     }
  1186. }
  1189. #define XBOW_ARB_RELOAD_TICKS 25
  1190. /* granularity: 4 MB/s, max: 124 MB/s */
  1191. #define GRANULARITY ((100 * 1000000) / XBOW_ARB_RELOAD_TICKS)
  1193. #define XBOW_BYTES_TO_GBR(BYTES_per_s) (int) (BYTES_per_s / GRANULARITY)
  1195. #define XBOW_GBR_TO_BYTES(cnt) (bandwidth_t) ((cnt) * GRANULARITY)
  1197. #define CEILING_BYTES_TO_GBR(gbr, bytes_per_sec)
  1198. ((XBOW_GBR_TO_BYTES(gbr) < bytes_per_sec) ? gbr+1 : gbr)
  1200. #define XBOW_ARB_GBR_MAX 31
  1202. #define ABS(x) ((x > 0) ? (x) : (-1 * x))
  1203. /* absolute value */
  1205. int
  1206. xbow_bytes_to_gbr(bandwidth_t old_bytes_per_sec, bandwidth_t bytes_per_sec)
  1207. {
  1208.     int                     gbr_granted;
  1209.     int                     new_total_gbr;
  1210.     int                     change_gbr;
  1211.     bandwidth_t             new_total_bw;
  1213. #ifdef GRIO_DEBUG
  1214.     printf("xbow_bytes_to_gbr: old_bytes_per_sec %lld bytes_per_sec %lldn",
  1215. old_bytes_per_sec, bytes_per_sec);
  1216. #endif /* GRIO_DEBUG */
  1218.     gbr_granted = CEILING_BYTES_TO_GBR((XBOW_BYTES_TO_GBR(old_bytes_per_sec)),
  1219. old_bytes_per_sec);
  1220.     new_total_bw = old_bytes_per_sec + bytes_per_sec;
  1221.     new_total_gbr = CEILING_BYTES_TO_GBR((XBOW_BYTES_TO_GBR(new_total_bw)),
  1222. new_total_bw);
  1224.     change_gbr = new_total_gbr - gbr_granted;
  1226. #ifdef GRIO_DEBUG
  1227.     printf("xbow_bytes_to_gbr: gbr_granted %d new_total_gbr %d change_gbr %dn",
  1228. gbr_granted, new_total_gbr, change_gbr);
  1229. #endif /* GRIO_DEBUG */
  1231.     return (change_gbr);
  1232. }
  1234. /* Conversion from GBR to bytes */
  1235. bandwidth_t
  1236. xbow_gbr_to_bytes(int gbr)
  1237. {
  1238.     return (XBOW_GBR_TO_BYTES(gbr));
  1239. }
  1241. /* Given the vhdl for the desired xbow, the src and dest. widget ids
  1242.  * and the req_bw value, this xbow driver entry point accesses the
  1243.  * xbow registers and allocates the desired bandwidth if available.
  1244.  *
  1245.  * If bandwidth allocation is successful, return success else return failure.
  1246.  */
  1247. int
  1248. xbow_prio_bw_alloc(devfs_handle_t vhdl,
  1249. xwidgetnum_t src_wid,
  1250. xwidgetnum_t dest_wid,
  1251. unsigned long long old_alloc_bw,
  1252. unsigned long long req_bw)
  1253. {
  1254.     xbow_soft_t             soft = xbow_soft_get(vhdl);
  1255.     volatile xbowreg_t     *xreg;
  1256.     xbowreg_t               mask;
  1257.     unsigned long           s;
  1258.     int                     error = 0;
  1259.     bandwidth_t             old_bw_BYTES, req_bw_BYTES;
  1260.     xbowreg_t               old_xreg;
  1261.     int                     old_bw_GBR, req_bw_GBR, new_bw_GBR;
  1263. #ifdef GRIO_DEBUG
  1264.     printf("xbow_prio_bw_alloc: vhdl %d src_wid %d dest_wid %d req_bw %lldn",
  1265. (int) vhdl, (int) src_wid, (int) dest_wid, req_bw);
  1266. #endif
  1268.     ASSERT(XBOW_WIDGET_IS_VALID(src_wid));
  1269.     ASSERT(XBOW_WIDGET_IS_VALID(dest_wid));
  1271.     s = mutex_spinlock(&soft->xbow_bw_alloc_lock);
  1273.     /* Get pointer to the correct register */
  1274.     xreg = XBOW_PRIO_ARBREG_PTR(soft->base, dest_wid, src_wid);
  1276.     /* Get mask for GBR count value */
  1277.     mask = XB_ARB_GBR_MSK << XB_ARB_GBR_SHFT(src_wid);
  1279.     req_bw_GBR = xbow_bytes_to_gbr(old_alloc_bw, req_bw);
  1280.     req_bw_BYTES = (req_bw_GBR < 0) ? (-1 * xbow_gbr_to_bytes(ABS(req_bw_GBR)))
  1281. : xbow_gbr_to_bytes(req_bw_GBR);
  1283. #ifdef GRIO_DEBUG
  1284.     printf("req_bw %lld req_bw_BYTES %lld req_bw_GBR %dn",
  1285. req_bw, req_bw_BYTES, req_bw_GBR);
  1286. #endif /* GRIO_DEBUG */
  1288.     old_bw_BYTES = soft->bw_cur_used[(int) dest_wid - MAX_XBOW_PORTS];
  1289.     old_xreg = *xreg;
  1290.     old_bw_GBR = (((*xreg) & mask) >> XB_ARB_GBR_SHFT(src_wid));
  1292. #ifdef GRIO_DEBUG
  1293.     ASSERT(XBOW_BYTES_TO_GBR(old_bw_BYTES) == old_bw_GBR);
  1295.     printf("old_bw_BYTES %lld old_bw_GBR %dn", old_bw_BYTES, old_bw_GBR);
  1297.     printf("req_bw_BYTES %lld old_bw_BYTES %lld soft->bw_hiwm %lldn",
  1298. req_bw_BYTES, old_bw_BYTES,
  1299. soft->bw_hiwm[(int) dest_wid - MAX_XBOW_PORTS]);
  1300.    
  1301. #endif /* GRIO_DEBUG */
  1303.     /* Accept the request only if we don't exceed the destination
  1304.      * port HIWATER_MARK *AND* the max. link GBR arbitration count
  1305.      */
  1306.     if (((old_bw_BYTES + req_bw_BYTES) <=
  1307. soft->bw_hiwm[(int) dest_wid - MAX_XBOW_PORTS]) &&
  1308. (req_bw_GBR + old_bw_GBR <= XBOW_ARB_GBR_MAX)) {
  1310. new_bw_GBR = (old_bw_GBR + req_bw_GBR);
  1312. /* Set this in the xbow link register */
  1313. *xreg = (old_xreg & ~mask) | 
  1314.     (new_bw_GBR << XB_ARB_GBR_SHFT(src_wid) & mask);
  1316. soft->bw_cur_used[(int) dest_wid - MAX_XBOW_PORTS] =
  1317. xbow_gbr_to_bytes(new_bw_GBR);
  1318.     } else {
  1319. error = 1;
  1320.     }
  1322.     mutex_spinunlock(&soft->xbow_bw_alloc_lock, s);
  1324.     return (error);
  1325. }