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

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

Linux/Unix编程

开发平台：

Unix_Linux

pcibr_slot.c：源码内容
  1. /*
  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) 2001-2002 Silicon Graphics, Inc. All rights reserved.
  8.  */
  10. #include <linux/types.h>
  11. #include <linux/slab.h>
  12. #include <linux/module.h>
  13. #include <asm/sn/sgi.h>
  14. #include <asm/sn/sn_cpuid.h>
  15. #include <asm/sn/addrs.h>
  16. #include <asm/sn/arch.h>
  17. #include <asm/sn/iograph.h>
  18. #include <asm/sn/invent.h>
  19. #include <asm/sn/hcl.h>
  20. #include <asm/sn/labelcl.h>
  21. #include <asm/sn/xtalk/xwidget.h>
  22. #include <asm/sn/pci/bridge.h>
  23. #include <asm/sn/pci/pciio.h>
  24. #include <asm/sn/pci/pcibr.h>
  25. #include <asm/sn/pci/pcibr_private.h>
  26. #include <asm/sn/pci/pci_defs.h>
  27. #include <asm/sn/prio.h>
  28. #include <asm/sn/xtalk/xbow.h>
  29. #include <asm/sn/ioc3.h>
  30. #include <asm/sn/eeprom.h>
  31. #include <asm/sn/io.h>
  32. #include <asm/sn/sn_private.h>
  34. extern pcibr_info_t     pcibr_info_get(devfs_handle_t);
  35. extern int              pcibr_widget_to_bus(int);
  36. extern pcibr_info_t     pcibr_device_info_new(pcibr_soft_t, pciio_slot_t, pciio_function_t, pciio_vendor_id_t, pciio_device_id_t);
  37. extern void             pcibr_freeblock_sub(iopaddr_t *, iopaddr_t *, iopaddr_t, size_t);
  38. extern int pcibr_slot_initial_rrb_alloc(devfs_handle_t,pciio_slot_t);
  39. #if 0
  40. int pcibr_slot_reset(devfs_handle_t pcibr_vhdl, pciio_slot_t slot);
  41. #endif
  43. int pcibr_slot_info_init(devfs_handle_t pcibr_vhdl, pciio_slot_t slot);
  44. int pcibr_slot_info_free(devfs_handle_t pcibr_vhdl, pciio_slot_t slot);
  45. int pcibr_slot_addr_space_init(devfs_handle_t pcibr_vhdl,  pciio_slot_t slot);
  46. int pcibr_slot_device_init(devfs_handle_t pcibr_vhdl,  pciio_slot_t slot);
  47. int pcibr_slot_guest_info_init(devfs_handle_t pcibr_vhdl,  pciio_slot_t slot);
  48. int pcibr_slot_call_device_attach(devfs_handle_t pcibr_vhdl,
  49.  pciio_slot_t slot, int drv_flags);
  50. int pcibr_slot_call_device_detach(devfs_handle_t pcibr_vhdl,
  51.  pciio_slot_t slot, int drv_flags);
  52. int pcibr_slot_detach(devfs_handle_t pcibr_vhdl, pciio_slot_t slot, int drv_flags);
  53. int pcibr_is_slot_sys_critical(devfs_handle_t pcibr_vhdl, pciio_slot_t slot);
  54. int pcibr_probe_slot(bridge_t *, cfg_p, unsigned int *);
  55. void  pcibr_device_info_free(devfs_handle_t, pciio_slot_t);
  56. extern uint64_t  do_pcibr_config_get(cfg_p, unsigned, unsigned);
  58. #ifdef LATER
  59. int pcibr_slot_attach(devfs_handle_t pcibr_vhdl, pciio_slot_t slot,
  60.                 int drv_flags, char *l1_msg, int *sub_errorp);
  61. int pcibr_slot_pwr(devfs_handle_t, pciio_slot_t, int, char *);
  62. int pcibr_slot_startup(devfs_handle_t, pcibr_slot_req_t);
  63. int pcibr_slot_shutdown(devfs_handle_t, pcibr_slot_req_t);
  64. void pcibr_slot_func_info_return(pcibr_info_h pcibr_infoh, int func,
  65.                  pcibr_slot_func_info_resp_t funcp);
  66. int pcibr_slot_info_return(pcibr_soft_t pcibr_soft, pciio_slot_t slot,
  67.                  pcibr_slot_info_resp_t respp);
  68. int pcibr_slot_query(devfs_handle_t, pcibr_slot_req_t);
  69. #endif /* LATER */
  71. extern devfs_handle_t baseio_pci_vhdl;
  72. int scsi_ctlr_nums_add(devfs_handle_t, devfs_handle_t);
  74. /* For now .... */
  75. /*
  76.  * PCI Hot-Plug Capability Flags
  77.  */
  78. #define D_PCI_HOT_PLUG_ATTACH  0x200  /* Driver supports PCI hot-plug attach */
  79. #define D_PCI_HOT_PLUG_DETACH  0x400  /* Driver supports PCI hot-plug detach */
  82. /*==========================================================================
  83.  * BRIDGE PCI SLOT RELATED IOCTLs
  84.  */
  86. #ifdef LATER
  88. /*
  89.  * pcibr_slot_startup
  90.  * Software start-up the PCI slot.
  91.  */
  92. int
  93. pcibr_slot_startup(devfs_handle_t pcibr_vhdl, pcibr_slot_req_t reqp)
  94. {
  95.     pcibr_soft_t                   pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  96.     pciio_slot_t                   slot = reqp->req_slot;
  97.     int                            error = 0;
  98.     char                           l1_msg[BRL1_QSIZE+1];
  99.     struct pcibr_slot_up_resp_s    tmp_up_resp;
  101.     /* Make sure that we are dealing with a bridge device vertex */
  102.     if (!pcibr_soft) {
  103.         return(PCI_NOT_A_BRIDGE);
  104.     }
  106.     /* Do not allow start-up of a slot in a shoehorn */
  107.     if(nic_vertex_info_match(pcibr_soft->bs_conn, XTALK_PCI_PART_NUM)) {
  108.        return(PCI_SLOT_IN_SHOEHORN);
  109.     }
  110.  
  111.     /* Check for the valid slot */
  112.     if (!PCIBR_VALID_SLOT(slot))
  113.         return(PCI_NOT_A_SLOT);
  115.     /* Acquire update access to the bus */
  116.     mrlock(pcibr_soft->bs_bus_lock, MR_UPDATE, PZERO);
  118.     if (pcibr_soft->bs_slot[slot].slot_status & SLOT_STARTUP_CMPLT) {
  119.         error = PCI_SLOT_ALREADY_UP;
  120.         goto startup_unlock;
  121.     }
  123.     error = pcibr_slot_attach(pcibr_vhdl, slot, D_PCI_HOT_PLUG_ATTACH,
  124.                               l1_msg, &tmp_up_resp.resp_sub_errno);
  126.     strncpy(tmp_up_resp.resp_l1_msg, l1_msg, L1_QSIZE);
  127.     tmp_up_resp.resp_l1_msg[L1_QSIZE] = '';
  129.     if (COPYOUT(&tmp_up_resp, reqp->req_respp.up, reqp->req_size)) {
  130.         return(EFAULT);
  131.     }
  133.     startup_unlock:
  135.     /* Release the bus lock */
  136.     mrunlock(pcibr_soft->bs_bus_lock);
  138.     return(error);
  139. }
  141. /*
  142.  * pcibr_slot_shutdown
  143.  * Software shut-down the PCI slot
  144.  */
  145. int
  146. pcibr_slot_shutdown(devfs_handle_t pcibr_vhdl, pcibr_slot_req_t reqp)
  147. {
  148.     pcibr_soft_t                   pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  149.     bridge_t                      *bridge;
  150.     pciio_slot_t                   slot = reqp->req_slot;
  151.     int                            error = 0;
  152.     char                           l1_msg[BRL1_QSIZE+1];
  153.     struct pcibr_slot_down_resp_s  tmp_down_resp;
  154.     pciio_slot_t                   tmp_slot;
  156.     /* Make sure that we are dealing with a bridge device vertex */
  157.     if (!pcibr_soft) {
  158.         return(PCI_NOT_A_BRIDGE);
  159.     }
  161.     bridge = pcibr_soft->bs_base;
  163.     /* Check for valid slot */
  164.     if (!PCIBR_VALID_SLOT(slot))
  165.         return(PCI_NOT_A_SLOT);
  167.     /* Do not allow shut-down of a slot in a shoehorn */
  168.     if(nic_vertex_info_match(pcibr_soft->bs_conn, XTALK_PCI_PART_NUM)) {
  169.        return(PCI_SLOT_IN_SHOEHORN);
  170.     }
  172.     /* Acquire update access to the bus */
  173.     mrlock(pcibr_soft->bs_bus_lock, MR_UPDATE, PZERO);
  175.     if ((pcibr_soft->bs_slot[slot].slot_status & SLOT_SHUTDOWN_CMPLT) ||
  176.         ((pcibr_soft->bs_slot[slot].slot_status & SLOT_STATUS_MASK) == 0)) {
  177.         error = PCI_SLOT_ALREADY_DOWN;
  178.         /*
  179.          * RJR - Should we invoke an L1 slot power-down command just in case
  180.          *       a previous shut-down failed to power-down the slot?
  181.          */
  182.         goto shutdown_unlock;
  183.     }
  185.     /* Do not allow the last 33 MHz card to be removed */
  186.     if ((bridge->b_wid_control & BRIDGE_CTRL_BUS_SPEED_MASK) ==
  187.          BRIDGE_CTRL_BUS_SPEED_33) {
  188.         for (tmp_slot = pcibr_soft->bs_first_slot;
  189.              tmp_slot <= pcibr_soft->bs_last_slot; tmp_slot++)
  190.             if (tmp_slot != slot)
  191.                 if (pcibr_soft->bs_slot[tmp_slot].slot_status & SLOT_POWER_UP) {
  192.                     error++;
  193.                     break;
  194.                 }
  195.         if (!error) {
  196.             error = PCI_EMPTY_33MHZ;
  197.             goto shutdown_unlock;
  198.         }
  199.     }
  201.     error = pcibr_slot_detach(pcibr_vhdl, slot, D_PCI_HOT_PLUG_DETACH,
  202.                               l1_msg, &tmp_down_resp.resp_sub_errno);
  204.     strncpy(tmp_down_resp.resp_l1_msg, l1_msg, L1_QSIZE);
  205.     tmp_down_resp.resp_l1_msg[L1_QSIZE] = '';
  207.     if (COPYOUT(&tmp_down_resp, reqp->req_respp.down, reqp->req_size)) {
  208.         return(EFAULT);
  209.     }
  211.     shutdown_unlock:
  213.     /* Release the bus lock */
  214.     mrunlock(pcibr_soft->bs_bus_lock);
  216.     return(error);
  217. }
  219. char *pci_space_name[] = {"NONE", 
  220.   "ROM",
  221.   "IO",
  222.   "",
  223.   "MEM",
  224.   "MEM32",
  225.   "MEM64",
  226.   "CFG",
  227.   "WIN0",
  228.   "WIN1",
  229.   "WIN2",
  230.   "WIN3",
  231.   "WIN4",
  232.   "WIN5",
  233.   "",
  234.   "BAD"};
  236. void
  237. pcibr_slot_func_info_return(pcibr_info_h pcibr_infoh,
  238.                             int func,
  239.                             pcibr_slot_func_info_resp_t funcp)
  240. {
  241.     pcibr_info_t                 pcibr_info = pcibr_infoh[func];
  242.     int                          win;
  244.     funcp->resp_f_status = 0;
  246.     if (!pcibr_info) {
  247.         return;
  248.     }
  250.     funcp->resp_f_status |= FUNC_IS_VALID;
  251.     sprintf(funcp->resp_f_slot_name, "%v", pcibr_info->f_vertex);
  253.     if(is_sys_critical_vertex(pcibr_info->f_vertex)) {
  254.         funcp->resp_f_status |= FUNC_IS_SYS_CRITICAL;
  255.     }
  257.     funcp->resp_f_bus = pcibr_info->f_bus;
  258.     funcp->resp_f_slot = pcibr_info->f_slot;
  259.     funcp->resp_f_func = pcibr_info->f_func;
  260.     sprintf(funcp->resp_f_master_name, "%v", pcibr_info->f_master);
  261.     funcp->resp_f_pops = pcibr_info->f_pops;
  262.     funcp->resp_f_efunc = pcibr_info->f_efunc;
  263.     funcp->resp_f_einfo = pcibr_info->f_einfo;
  265.     funcp->resp_f_vendor = pcibr_info->f_vendor;
  266.     funcp->resp_f_device = pcibr_info->f_device;
  268.     for(win = 0 ; win < 6 ; win++) {
  269.         funcp->resp_f_window[win].resp_w_base =
  270.                                   pcibr_info->f_window[win].w_base;
  271.         funcp->resp_f_window[win].resp_w_size =
  272.                                   pcibr_info->f_window[win].w_size;
  273.         sprintf(funcp->resp_f_window[win].resp_w_space,
  274.                 "%s",
  275.                 pci_space_name[pcibr_info->f_window[win].w_space]);
  276.     }
  278.     funcp->resp_f_rbase = pcibr_info->f_rbase;
  279.     funcp->resp_f_rsize = pcibr_info->f_rsize;
  281.     for (win = 0 ; win < 4; win++) {
  282.         funcp->resp_f_ibit[win] = pcibr_info->f_ibit[win];
  283.     }
  285.     funcp->resp_f_att_det_error = pcibr_info->f_att_det_error;
  287. }
  289. int
  290. pcibr_slot_info_return(pcibr_soft_t             pcibr_soft,
  291.                        pciio_slot_t             slot,
  292.                        pcibr_slot_info_resp_t   respp)
  293. {
  294.     pcibr_soft_slot_t            pss;
  295.     int                          func;
  296.     bridge_t                    *bridge = pcibr_soft->bs_base;
  297.     reg_p                        b_respp;
  298.     pcibr_slot_info_resp_t       slotp;
  299.     pcibr_slot_func_info_resp_t  funcp;
  301.     slotp = kmem_zalloc(sizeof(*slotp), KM_SLEEP);
  302.     if (slotp == NULL) {
  303.         return(ENOMEM);
  304.     }
  306.     pss = &pcibr_soft->bs_slot[slot];
  308.     slotp->resp_has_host = pss->has_host;
  309.     slotp->resp_host_slot = pss->host_slot;
  310.     sprintf(slotp->resp_slot_conn_name, "%v", pss->slot_conn);
  311.     slotp->resp_slot_status = pss->slot_status;
  313.     slotp->resp_l1_bus_num = io_path_map_widget(pcibr_soft->bs_vhdl);
  315.     if (is_sys_critical_vertex(pss->slot_conn)) {
  316.         slotp->resp_slot_status |= SLOT_IS_SYS_CRITICAL;
  317.     }
  319.     slotp->resp_bss_ninfo = pss->bss_ninfo;
  321.     for (func = 0; func < pss->bss_ninfo; func++) {
  322.         funcp = &(slotp->resp_func[func]);
  323.         pcibr_slot_func_info_return(pss->bss_infos, func, funcp);
  324.     }
  326.     sprintf(slotp->resp_bss_devio_bssd_space, "%s",
  327.             pci_space_name[pss->bss_devio.bssd_space]);
  328.     slotp->resp_bss_devio_bssd_base = pss->bss_devio.bssd_base;
  329.     slotp->resp_bss_device = pss->bss_device;
  331.     slotp->resp_bss_pmu_uctr = pss->bss_pmu_uctr;
  332.     slotp->resp_bss_d32_uctr = pss->bss_d32_uctr;
  333.     slotp->resp_bss_d64_uctr = pss->bss_d64_uctr;
  335.     slotp->resp_bss_d64_base = pss->bss_d64_base;
  336.     slotp->resp_bss_d64_flags = pss->bss_d64_flags;
  337.     slotp->resp_bss_d32_base = pss->bss_d32_base;
  338.     slotp->resp_bss_d32_flags = pss->bss_d32_flags;
  340.     slotp->resp_bss_ext_ates_active = pss->bss_ext_ates_active;
  342.     slotp->resp_bss_cmd_pointer = pss->bss_cmd_pointer;
  343.     slotp->resp_bss_cmd_shadow = pss->bss_cmd_shadow;
  345.     slotp->resp_bs_rrb_valid = pcibr_soft->bs_rrb_valid[slot];
  346.     slotp->resp_bs_rrb_valid_v = pcibr_soft->bs_rrb_valid[slot +
  347.                                                       PCIBR_RRB_SLOT_VIRTUAL];
  348.     slotp->resp_bs_rrb_res = pcibr_soft->bs_rrb_res[slot];
  350.     if (slot & 1) {
  351.         b_respp = &bridge->b_odd_resp;
  352.     } else {
  353.         b_respp = &bridge->b_even_resp;
  354.     }
  356.     slotp->resp_b_resp = *b_respp;
  358.     slotp->resp_b_wid_control = bridge->b_wid_control;
  359.     slotp->resp_b_int_device = bridge->b_int_device;
  360.     slotp->resp_b_int_enable = bridge->b_int_enable;
  361.     slotp->resp_b_int_host = bridge->b_int_addr[slot].addr;
  363.     if (COPYOUT(slotp, respp, sizeof(*respp))) {
  364.         return(EFAULT);
  365.     }
  367.     kmem_free(slotp, sizeof(*slotp));
  369.     return(0);
  370. }
  372. /*
  373.  * pcibr_slot_query
  374.  * Return information about the PCI slot maintained by the infrastructure.
  375.  * Information is requested in the request structure.
  376.  *
  377.  *      Information returned in the response structure:
  378.  * Slot hwgraph name
  379.  * Vendor/Device info
  380.  * Base register info
  381.  * Interrupt mapping from device pins to the bridge pins
  382.  * Devio register
  383.  * Software RRB info
  384.  * RRB register info
  385.  * Host/Gues info
  386.  * PCI Bus #,slot #, function #
  387.  * Slot provider hwgraph name
  388.  * Provider Functions
  389.  * Error handler
  390.  * DMA mapping usage counters
  391.  * DMA direct translation info
  392.  * External SSRAM workaround info
  393.  */
  394. int
  395. pcibr_slot_query(devfs_handle_t pcibr_vhdl, pcibr_slot_req_t reqp)
  396. {
  397.     pcibr_soft_t            pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  398.     pciio_slot_t            slot = reqp->req_slot;
  399.     pciio_slot_t            tmp_slot;
  400.     pcibr_slot_info_resp_t  respp = reqp->req_respp.query;
  401.     int                     size = reqp->req_size;
  402.     int                     error;
  404.     /* Make sure that we are dealing with a bridge device vertex */
  405.     if (!pcibr_soft) {
  406.         return(PCI_NOT_A_BRIDGE);
  407.     }
  409.     /* Make sure that we have a valid PCI slot number or PCIIO_SLOT_NONE */
  410.     if ((!PCIBR_VALID_SLOT(slot)) && (slot != PCIIO_SLOT_NONE)) {
  411.         return(PCI_NOT_A_SLOT);
  412.     }
  414.     /* Do not allow a query of a slot in a shoehorn */
  415.     if(nic_vertex_info_match(pcibr_soft->bs_conn, XTALK_PCI_PART_NUM)) {
  416.        return(PCI_SLOT_IN_SHOEHORN);
  417.     }
  419.     /* Return information for the requested PCI slot */
  420.     if (slot != PCIIO_SLOT_NONE) {
  421.         if (size < sizeof(*respp)) {
  422.             return(PCI_RESP_AREA_TOO_SMALL);
  423.         }
  425.         /* Acquire read access to the bus */
  426.         mrlock(pcibr_soft->bs_bus_lock, MR_ACCESS, PZERO);
  428.         error = pcibr_slot_info_return(pcibr_soft, slot, respp);
  430.         /* Release the bus lock */
  431.         mrunlock(pcibr_soft->bs_bus_lock);
  433.         return(error);
  434.     }
  436.     /* Return information for all the slots */
  437.     for (tmp_slot = 0; tmp_slot < 8; tmp_slot++) {
  439.         if (size < sizeof(*respp)) {
  440.             return(PCI_RESP_AREA_TOO_SMALL);
  441.         }
  443.         /* Acquire read access to the bus */
  444.         mrlock(pcibr_soft->bs_bus_lock, MR_ACCESS, PZERO);
  446.         error = pcibr_slot_info_return(pcibr_soft, tmp_slot, respp);
  448.         /* Release the bus lock */
  449.         mrunlock(pcibr_soft->bs_bus_lock);
  451.         if (error) {
  452.             return(error);
  453.         }
  455.         ++respp;
  456.         size -= sizeof(*respp);
  457.     }
  459.     return(error);
  460. }
  461. #endif /* LATER */
  463. /* FIXME: there should be a better way to do this.
  464.  * pcibr_attach() needs PCI_ADDR_SPACE_LIMITS_STORE
  465.  */
  467. /* 
  468.  * PCI_ADDR_SPACE_LIMITS_LOAD
  469.  * Gets the current values of 
  470.  * pci io base, 
  471.  * pci io last,
  472.  * pci low memory base,
  473.  * pci low memory last,
  474.  * pci high memory base,
  475.  *  pci high memory last
  476.  */
  477. #define PCI_ADDR_SPACE_LIMITS_LOAD()
  478.     pci_io_fb = pcibr_soft->bs_spinfo.pci_io_base;
  479.     pci_io_fl = pcibr_soft->bs_spinfo.pci_io_last;
  480.     pci_lo_fb = pcibr_soft->bs_spinfo.pci_swin_base;
  481.     pci_lo_fl = pcibr_soft->bs_spinfo.pci_swin_last;
  482.     pci_hi_fb = pcibr_soft->bs_spinfo.pci_mem_base;
  483.     pci_hi_fl = pcibr_soft->bs_spinfo.pci_mem_last;
  484. /*
  485.  * PCI_ADDR_SPACE_LIMITS_STORE
  486.  * Sets the current values of
  487.  * pci io base, 
  488.  * pci io last,
  489.  * pci low memory base,
  490.  * pci low memory last,
  491.  * pci high memory base,
  492.  *  pci high memory last
  493.  */
  494. #define PCI_ADDR_SPACE_LIMITS_STORE()
  495.     pcibr_soft->bs_spinfo.pci_io_base = pci_io_fb;
  496.     pcibr_soft->bs_spinfo.pci_io_last = pci_io_fl;
  497.     pcibr_soft->bs_spinfo.pci_swin_base = pci_lo_fb;
  498.     pcibr_soft->bs_spinfo.pci_swin_last = pci_lo_fl;
  499.     pcibr_soft->bs_spinfo.pci_mem_base = pci_hi_fb;
  500.     pcibr_soft->bs_spinfo.pci_mem_last = pci_hi_fl;
  502. #define PCI_ADDR_SPACE_LIMITS_PRINT()
  503.     printf("+++++++++++++++++++++++n"
  504.    "IO base 0x%x last 0x%xn"
  505.    "SWIN base 0x%x last 0x%xn"
  506.    "MEM base 0x%x last 0x%xn"
  507.    "+++++++++++++++++++++++n",
  508.    pcibr_soft->bs_spinfo.pci_io_base,
  509.    pcibr_soft->bs_spinfo.pci_io_last,
  510.    pcibr_soft->bs_spinfo.pci_swin_base,
  511.    pcibr_soft->bs_spinfo.pci_swin_last,
  512.    pcibr_soft->bs_spinfo.pci_mem_base,
  513.    pcibr_soft->bs_spinfo.pci_mem_last);
  516. /*
  517.  * pcibr_slot_info_init
  518.  * Probe for this slot and see if it is populated.
  519.  * If it is populated initialize the generic PCI infrastructural
  520.  *  information associated with this particular PCI device.
  521.  */
  522. int
  523. pcibr_slot_info_init(devfs_handle_t  pcibr_vhdl,
  524.      pciio_slot_t  slot)
  525. {
  526.     pcibr_soft_t     pcibr_soft;
  527.     pcibr_info_h     pcibr_infoh;
  528.     pcibr_info_t     pcibr_info;
  529.     bridge_t    *bridge;
  530.     cfg_p                   cfgw;
  531.     unsigned                idword;
  532.     unsigned                pfail;
  533.     unsigned                idwords[8];
  534.     pciio_vendor_id_t       vendor;
  535.     pciio_device_id_t       device;
  536.     unsigned                htype;
  537.     cfg_p                   wptr;
  538.     int                     win;
  539.     pciio_space_t           space;
  540.     iopaddr_t     pci_io_fb, pci_io_fl;
  541.     iopaddr_t     pci_lo_fb,  pci_lo_fl;
  542.     iopaddr_t     pci_hi_fb,  pci_hi_fl;
  543.     int     nfunc;
  544.     pciio_function_t     rfunc;
  545.     int     func;
  546.     devfs_handle_t     conn_vhdl;
  547.     pcibr_soft_slot_t     slotp;
  548.     
  549.     /* Get the basic software information required to proceed */
  550.     pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  551.     if (!pcibr_soft)
  552. return(EINVAL);
  554.     bridge = pcibr_soft->bs_base;
  555.     if (!PCIBR_VALID_SLOT(slot))
  556. return(EINVAL);
  558.     /* If we have a host slot (eg:- IOC3 has 2 PCI slots and the initialization
  559.      * is done by the host slot then we are done.
  560.      */
  561.     if (pcibr_soft->bs_slot[slot].has_host) {
  562. return(0);    
  563.     }
  565.     /* Check for a slot with any system critical functions */
  566.     if (pcibr_is_slot_sys_critical(pcibr_vhdl, slot))
  567.         return(EPERM);
  569.     /* Load the current values of allocated PCI address spaces */
  570.     PCI_ADDR_SPACE_LIMITS_LOAD();
  571.     
  572.     /* Try to read the device-id/vendor-id from the config space */
  573.     cfgw = bridge->b_type0_cfg_dev[slot].l;
  575.     if (pcibr_probe_slot(bridge, cfgw, &idword)) 
  576. return(ENODEV);
  578.     slotp = &pcibr_soft->bs_slot[slot];
  579.     slotp->slot_status |= SLOT_POWER_UP;
  581.     vendor = 0xFFFF & idword;
  582.     /* If the vendor id is not valid then the slot is not populated
  583.      * and we are done.
  584.      */
  585.     if (vendor == 0xFFFF) 
  586. return(ENODEV);
  587.     
  588.     device = 0xFFFF & (idword >> 16);
  589.     htype = do_pcibr_config_get(cfgw, PCI_CFG_HEADER_TYPE, 1);
  591.     nfunc = 1;
  592.     rfunc = PCIIO_FUNC_NONE;
  593.     pfail = 0;
  595.     /* NOTE: if a card claims to be multifunction
  596.      * but only responds to config space 0, treat
  597.      * it as a unifunction card.
  598.      */
  600.     if (htype & 0x80) { /* MULTIFUNCTION */
  601. for (func = 1; func < 8; ++func) {
  602.     cfgw = bridge->b_type0_cfg_dev[slot].f[func].l;
  603.     if (pcibr_probe_slot(bridge, cfgw, &idwords[func])) {
  604. pfail |= 1 << func;
  605. continue;
  606.     }
  607.     vendor = 0xFFFF & idwords[func];
  608.     if (vendor == 0xFFFF) {
  609. pfail |= 1 << func;
  610. continue;
  611.     }
  612.     nfunc = func + 1;
  613.     rfunc = 0;
  614. }
  615. cfgw = bridge->b_type0_cfg_dev[slot].l;
  616.     }
  617.     NEWA(pcibr_infoh, nfunc);
  618.     
  619.     pcibr_soft->bs_slot[slot].bss_ninfo = nfunc;
  620.     pcibr_soft->bs_slot[slot].bss_infos = pcibr_infoh;
  622.     for (func = 0; func < nfunc; ++func) {
  623. unsigned                cmd_reg;
  625. if (func) {
  626.     if (pfail & (1 << func))
  627. continue;
  628.     
  629.     idword = idwords[func];
  630.     cfgw = bridge->b_type0_cfg_dev[slot].f[func].l;
  631.     
  632.     device = 0xFFFF & (idword >> 16);
  633.     htype = do_pcibr_config_get(cfgw, PCI_CFG_HEADER_TYPE, 1);
  634.     rfunc = func;
  635. }
  636. htype &= 0x7f;
  637. if (htype != 0x00) {
  638.     printk(KERN_WARNING  "%s pcibr: pci slot %d func %d has strange header type 0x%xn",
  639.     pcibr_soft->bs_name, slot, func, htype);
  640.     continue;
  641. }
  642. #if DEBUG && ATTACH_DEBUG
  643. printk(KERN_NOTICE   
  644. "%s pcibr: pci slot %d func %d: vendor 0x%x device 0x%x",
  645. pcibr_soft->bs_name, slot, func, vendor, device);
  646. #endif
  648. pcibr_info = pcibr_device_info_new
  649.     (pcibr_soft, slot, rfunc, vendor, device);
  650. conn_vhdl = pciio_device_info_register(pcibr_vhdl, &pcibr_info->f_c);
  651. if (func == 0)
  652.     slotp->slot_conn = conn_vhdl;
  654. #ifdef SN1_LITTLE_ENDIAN
  655. cmd_reg = cfgw[(PCI_CFG_COMMAND ^ 4) / 4];
  656. #else
  657. cmd_reg = cfgw[PCI_CFG_COMMAND / 4];
  658. #endif
  660. wptr = cfgw + PCI_CFG_BASE_ADDR_0 / 4;
  662. for (win = 0; win < PCI_CFG_BASE_ADDRS; ++win) {
  663.     iopaddr_t               base, mask, code;
  664.     size_t                  size;
  666.     /*
  667.      * GET THE BASE & SIZE OF THIS WINDOW:
  668.      *
  669.      * The low two or four bits of the BASE register
  670.      * determines which address space we are in; the
  671.      * rest is a base address. BASE registers
  672.      * determine windows that are power-of-two sized
  673.      * and naturally aligned, so we can get the size
  674.      * of a window by writing all-ones to the
  675.      * register, reading it back, and seeing which
  676.      * bits are used for decode; the least
  677.      * significant nonzero bit is also the size of
  678.      * the window.
  679.      *
  680.      * WARNING: someone may already have allocated
  681.      * some PCI space to this window, and in fact
  682.      * PIO may be in process at this very moment
  683.      * from another processor (or even from this
  684.      * one, if we get interrupted)! So, if the BASE
  685.      * already has a nonzero address, be generous
  686.      * and use the LSBit of that address as the
  687.      * size; this could overstate the window size.
  688.      * Usually, when one card is set up, all are set
  689.      * up; so, since we don't bitch about
  690.      * overlapping windows, we are ok.
  691.      *
  692.      * UNFORTUNATELY, some cards do not clear their
  693.      * BASE registers on reset. I have two heuristics
  694.      * that can detect such cards: first, if the
  695.      * decode enable is turned off for the space
  696.      * that the window uses, we can disregard the
  697.      * initial value. second, if the address is
  698.      * outside the range that we use, we can disregard
  699.      * it as well.
  700.      *
  701.      * This is looking very PCI generic. Except for
  702.      * knowing how many slots and where their config
  703.      * spaces are, this window loop and the next one
  704.      * could probably be shared with other PCI host
  705.      * adapters. It would be interesting to see if
  706.      * this could be pushed up into pciio, when we
  707.      * start supporting more PCI providers.
  708.      */
  709. #ifdef SN1_LITTLE_ENDIAN
  710.     base = wptr[((win*4)^4)/4];
  711. #else
  712.     base = wptr[win];
  713. #endif
  715.     if (base & PCI_BA_IO_SPACE) {
  716. /* BASE is in I/O space. */
  717. space = PCIIO_SPACE_IO;
  718. mask = -4;
  719. code = base & 3;
  720. base = base & mask;
  721. if (base == 0) {
  722.     ; /* not assigned */
  723. } else if (!(cmd_reg & PCI_CMD_IO_SPACE)) {
  724.     base = 0; /* decode not enabled */
  725. }
  726.     } else {
  727. /* BASE is in MEM space. */
  728. space = PCIIO_SPACE_MEM;
  729. mask = -16;
  730. code = base & PCI_BA_MEM_LOCATION; /* extract BAR type */
  731. base = base & mask;
  732. if (base == 0) {
  733.     ; /* not assigned */
  734. } else if (!(cmd_reg & PCI_CMD_MEM_SPACE)) {
  735.     base = 0; /* decode not enabled */
  736. } else if (base & 0xC0000000) {
  737.     base = 0; /* outside permissable range */
  738. } else if ((code == PCI_BA_MEM_64BIT) &&
  739. #ifdef SN1_LITTLE_ENDIAN
  740.    (wptr[(((win + 1)*4)^4)/4] != 0)) {
  741. #else 
  742.    (wptr[win + 1] != 0)) {
  743. #endif /* LITTLE_ENDIAN */
  744.     base = 0; /* outside permissable range */
  745. }
  746.     }
  748.     if (base != 0) { /* estimate size */
  749. size = base & -base;
  750.     } else { /* calculate size */
  751. #ifdef SN1_LITTLE_ENDIAN
  752. wptr[((win*4)^4)/4] = ~0; /* turn on all bits */
  753. size = wptr[((win*4)^4)/4]; /* get stored bits */
  754. #else 
  755. wptr[win] = ~0; /* turn on all bits */
  756. size = wptr[win]; /* get stored bits */
  757. #endif /* LITTLE_ENDIAN */
  758. size &= mask; /* keep addr */
  759. size &= -size; /* keep lsbit */
  760. if (size == 0)
  761.     continue;
  762.     }
  764.     pcibr_info->f_window[win].w_space = space;
  765.     pcibr_info->f_window[win].w_base = base;
  766.     pcibr_info->f_window[win].w_size = size;
  768.     /*
  769.      * If this window already has PCI space
  770.      * allocated for it, "subtract" that space from
  771.      * our running freeblocks. Don't worry about
  772.      * overlaps in existing allocated windows; we
  773.      * may be overstating their sizes anyway.
  774.      */
  776.     if (base && size) {
  777. if (space == PCIIO_SPACE_IO) {
  778.     pcibr_freeblock_sub(&pci_io_fb,
  779. &pci_io_fl,
  780. base, size);
  781. } else {
  782.     pcibr_freeblock_sub(&pci_lo_fb,
  783. &pci_lo_fl,
  784. base, size);
  785.     pcibr_freeblock_sub(&pci_hi_fb,
  786. &pci_hi_fl,
  787. base, size);
  788. }
  789.     }
  790. #if defined(IOC3_VENDOR_ID_NUM) && defined(IOC3_DEVICE_ID_NUM)
  791.     /*
  792.      * IOC3 BASE_ADDR* BUG WORKAROUND
  793.      *
  794.      
  795.      * If we write to BASE1 on the IOC3, the
  796.      * data in BASE0 is replaced. The
  797.      * original workaround was to remember
  798.      * the value of BASE0 and restore it
  799.      * when we ran off the end of the BASE
  800.      * registers; however, a later
  801.      * workaround was added (I think it was
  802.      * rev 1.44) to avoid setting up
  803.      * anything but BASE0, with the comment
  804.      * that writing all ones to BASE1 set
  805.      * the enable-parity-error test feature
  806.      * in IOC3's SCR bit 14.
  807.      *
  808.      * So, unless we defer doing any PCI
  809.      * space allocation until drivers
  810.      * attach, and set up a way for drivers
  811.      * (the IOC3 in paricular) to tell us
  812.      * generically to keep our hands off
  813.      * BASE registers, we gotta "know" about
  814.      * the IOC3 here.
  815.      *
  816.      * Too bad the PCI folks didn't reserve the
  817.      * all-zero value for 'no BASE here' (it is a
  818.      * valid code for an uninitialized BASE in
  819.      * 32-bit PCI memory space).
  820.      */
  821.     
  822.     if ((vendor == IOC3_VENDOR_ID_NUM) &&
  823. (device == IOC3_DEVICE_ID_NUM))
  824. break;
  825. #endif
  826.     if (code == PCI_BA_MEM_64BIT) {
  827. win++; /* skip upper half */
  828. #ifdef SN1_LITTLE_ENDIAN
  829. wptr[((win*4)^4)/4] = 0; /* which must be zero */
  830. #else 
  831. wptr[win] = 0; /* which must be zero */
  832. #endif /* LITTLE_ENDIAN */
  833.     }
  834. } /* next win */
  835.     } /* next func */
  837.     /* Store back the values for allocated PCI address spaces */
  838.     PCI_ADDR_SPACE_LIMITS_STORE();
  839.     return(0);
  840. }
  842. /*
  843.  * pcibr_slot_info_free
  844.  * Remove all the PCI infrastructural information associated
  845.  *  with a particular PCI device.
  846.  */
  847. int
  848. pcibr_slot_info_free(devfs_handle_t pcibr_vhdl,
  849.                      pciio_slot_t slot)
  850. {
  851.     pcibr_soft_t pcibr_soft;
  852.     pcibr_info_h pcibr_infoh;
  853.     int nfunc;
  855.     pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  857.     if (!pcibr_soft || !PCIBR_VALID_SLOT(slot))
  858. return(EINVAL);
  860.     nfunc = pcibr_soft->bs_slot[slot].bss_ninfo;
  862.     pcibr_device_info_free(pcibr_vhdl, slot);
  864.     pcibr_infoh = pcibr_soft->bs_slot[slot].bss_infos;
  865.     DELA(pcibr_infoh,nfunc);
  866.     pcibr_soft->bs_slot[slot].bss_ninfo = 0;
  868.     return(0);
  869. }
  871. int as_debug = 0;
  872. /*
  873.  * pcibr_slot_addr_space_init
  874.  * Reserve chunks of PCI address space as required by 
  875.  *  the base registers in the card.
  876.  */
  877. int
  878. pcibr_slot_addr_space_init(devfs_handle_t pcibr_vhdl,
  879.    pciio_slot_t slot)
  880. {
  881.     pcibr_soft_t pcibr_soft;
  882.     pcibr_info_h pcibr_infoh;
  883.     pcibr_info_t pcibr_info;
  884.     bridge_t *bridge;
  885.     iopaddr_t pci_io_fb, pci_io_fl;
  886.     iopaddr_t pci_lo_fb, pci_lo_fl;
  887.     iopaddr_t pci_hi_fb, pci_hi_fl;
  888.     size_t              align;
  889.     iopaddr_t           mask;
  890.     int      nbars;
  891.     int         nfunc;
  892.     int func;
  893.     int win;
  895.     pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  897.     if (!pcibr_soft || !PCIBR_VALID_SLOT(slot))
  898. return(EINVAL);
  900.     bridge = pcibr_soft->bs_base;
  902.     /* Get the current values for the allocated PCI address spaces */
  903.     PCI_ADDR_SPACE_LIMITS_LOAD();
  905.     if (as_debug)
  906. #ifdef LATER
  907.     PCI_ADDR_SPACE_LIMITS_PRINT();
  908. #endif
  910.     /* allocate address space,
  911.      * for windows that have not been
  912.      * previously assigned.
  913.      */
  914.     if (pcibr_soft->bs_slot[slot].has_host) {
  915. return(0);
  916.     }
  918.     nfunc = pcibr_soft->bs_slot[slot].bss_ninfo;
  919.     if (nfunc < 1)
  920. return(EINVAL);
  922.     pcibr_infoh = pcibr_soft->bs_slot[slot].bss_infos;
  923.     if (!pcibr_infoh)
  924. return(EINVAL);
  926.     /*
  927.      * Try to make the DevIO windows not
  928.      * overlap by pushing the "io" and "hi"
  929.      * allocation areas up to the next one
  930.      * or two megabyte bound. This also
  931.      * keeps them from being zero.
  932.      *
  933.      * DO NOT do this with "pci_lo" since
  934.      * the entire "lo" area is only a
  935.      * megabyte, total ...
  936.      */
  937.     align = (slot < 2) ? 0x200000 : 0x100000;
  938.     mask = -align;
  939.     pci_io_fb = (pci_io_fb + align - 1) & mask;
  940.     pci_hi_fb = (pci_hi_fb + align - 1) & mask;
  942.     for (func = 0; func < nfunc; ++func) {
  943. cfg_p                   cfgw;
  944. cfg_p                   wptr;
  945. pciio_space_t           space;
  946. iopaddr_t               base;
  947. size_t                  size;
  948. cfg_p                   pci_cfg_cmd_reg_p;
  949. unsigned                pci_cfg_cmd_reg;
  950. unsigned                pci_cfg_cmd_reg_add = 0;
  952. pcibr_info = pcibr_infoh[func];
  954. if (!pcibr_info)
  955.     continue;
  957. if (pcibr_info->f_vendor == PCIIO_VENDOR_ID_NONE)
  958.     continue;
  960. cfgw = bridge->b_type0_cfg_dev[slot].f[func].l;
  961. wptr = cfgw + PCI_CFG_BASE_ADDR_0 / 4;
  963. nbars = PCI_CFG_BASE_ADDRS;
  965. for (win = 0; win < nbars; ++win) {
  967.     space = pcibr_info->f_window[win].w_space;
  968.     base = pcibr_info->f_window[win].w_base;
  969.     size = pcibr_info->f_window[win].w_size;
  970.     
  971.     if (size < 1)
  972. continue;
  974.     if (base >= size) {
  975. #if DEBUG && PCI_DEBUG
  976. printk("pcibr: slot %d func %d window %d is in %d[0x%x..0x%x], alloc by promn",
  977. slot, func, win, space, base, base + size - 1);
  978. #endif
  979. continue; /* already allocated */
  980.     }
  981.     align = size; /* ie. 0x00001000 */
  982.     if (align < _PAGESZ)
  983. align = _PAGESZ; /* ie. 0x00004000 */
  984.     mask = -align; /* ie. 0xFFFFC000 */
  986.     switch (space) {
  987.     case PCIIO_SPACE_IO:
  988. base = (pci_io_fb + align - 1) & mask;
  989. if ((base + size) > pci_io_fl) {
  990.     base = 0;
  991.     break;
  992. }
  993. pci_io_fb = base + size;
  994. break;
  996.     case PCIIO_SPACE_MEM:
  997. #ifdef SN1_LITTLE_ENDIAN
  998. if ((wptr[((win*4)^4)/4] & PCI_BA_MEM_LOCATION) ==
  999. #else
  1000. if ((wptr[win] & PCI_BA_MEM_LOCATION) ==
  1001. #endif  /* LITTLE_ENDIAN */
  1002.     PCI_BA_MEM_1MEG) {
  1003.     /* allocate from 20-bit PCI space */
  1004.     base = (pci_lo_fb + align - 1) & mask;
  1005.     if ((base + size) > pci_lo_fl) {
  1006. base = 0;
  1007. break;
  1008.     }
  1009.     pci_lo_fb = base + size;
  1010. } else {
  1011.     /* allocate from 32-bit or 64-bit PCI space */
  1012.     base = (pci_hi_fb + align - 1) & mask;
  1013.     if ((base + size) > pci_hi_fl) {
  1014. base = 0;
  1015. break;
  1016.     }
  1017.     pci_hi_fb = base + size;
  1018. }
  1019. break;
  1021.     default:
  1022. base = 0;
  1023. #if DEBUG && PCI_DEBUG
  1024. printk("pcibr: slot %d window %d had bad space code %dn",
  1025. slot, win, space);
  1026. #endif
  1027.     }
  1028.     pcibr_info->f_window[win].w_base = base;
  1029. #ifdef SN1_LITTLE_ENDIAN
  1030.     wptr[((win*4)^4)/4] = base;
  1031. #if DEBUG && PCI_DEBUG
  1032. printk("Setting base address 0x%p base 0x%xn", &(wptr[((win*4)^4)/4]), base);
  1033. #endif
  1034. #else
  1035.     wptr[win] = base;
  1036. #endif  /* LITTLE_ENDIAN */
  1038. #if DEBUG && PCI_DEBUG
  1039.     if (base >= size)
  1040. printk("pcibr: slot %d func %d window %d is in %d [0x%x..0x%x], alloc by pcibrn",
  1041. slot, func, win, space, base, base + size - 1);
  1042.     else
  1043. printk("pcibr: slot %d func %d window %d, unable to alloc 0x%x in 0x%pn",
  1044. slot, func, win, size, space);
  1045. #endif
  1046. } /* next base */
  1048. /*
  1049.  * Allocate space for the EXPANSION ROM
  1050.  * NOTE: DO NOT DO THIS ON AN IOC3,
  1051.  * as it blows the system away.
  1052.  */
  1053. base = size = 0;
  1054. if ((pcibr_soft->bs_slot[slot].bss_vendor_id != IOC3_VENDOR_ID_NUM) ||
  1055.     (pcibr_soft->bs_slot[slot].bss_device_id != IOC3_DEVICE_ID_NUM)) {
  1057.     wptr = cfgw + PCI_EXPANSION_ROM / 4;
  1058. #ifdef SN1_LITTLE_ENDIAN
  1059.     wptr[1] = 0xFFFFF000;
  1060.     mask = wptr[1];
  1061. #else
  1062.     *wptr = 0xFFFFF000;
  1063.     mask = *wptr;
  1064. #endif  /* LITTLE_ENDIAN */
  1065.     if (mask & 0xFFFFF000) {
  1066. size = mask & -mask;
  1067. align = size;
  1068. if (align < _PAGESZ)
  1069.     align = _PAGESZ;
  1070. mask = -align;
  1071. base = (pci_hi_fb + align - 1) & mask;
  1072. if ((base + size) > pci_hi_fl)
  1073.     base = size = 0;
  1074. else {
  1075.     pci_hi_fb = base + size;
  1076. #ifdef SN1_LITTLE_ENDIAN
  1077.     wptr[1] = base;
  1078. #else
  1079.     *wptr = base;
  1080. #endif  /* LITTLE_ENDIAN */
  1081. #if DEBUG && PCI_DEBUG
  1082.     printk("%s/%d ROM in 0x%lx..0x%lx (alloc by pcibr)n",
  1083.     pcibr_soft->bs_name, slot,
  1084.     base, base + size - 1);
  1085. #endif
  1086. }
  1087.     }
  1088. }
  1089. pcibr_info->f_rbase = base;
  1090. pcibr_info->f_rsize = size;
  1092. /*
  1093.  * if necessary, update the board's
  1094.  * command register to enable decoding
  1095.  * in the windows we added.
  1096.  *
  1097.  * There are some bits we always want to
  1098.  * be sure are set.
  1099.  */
  1100. pci_cfg_cmd_reg_add |= PCI_CMD_IO_SPACE;
  1102. /*
  1103.  * The Adaptec 1160 FC Controller WAR #767995:
  1104.  * The part incorrectly ignores the upper 32 bits of a 64 bit
  1105.  * address when decoding references to it's registers so to
  1106.  * keep it from responding to a bus cycle that it shouldn't
  1107.  * we only use I/O space to get at it's registers.  Don't
  1108.  * enable memory space accesses on that PCI device.
  1109.  */
  1110. #define FCADP_VENDID 0x9004 /* Adaptec Vendor ID from fcadp.h */
  1111. #define FCADP_DEVID 0x1160  /* Adaptec 1160 Device ID from fcadp.h */
  1113. if ((pcibr_info->f_vendor != FCADP_VENDID) ||
  1114.     (pcibr_info->f_device != FCADP_DEVID))
  1115.     pci_cfg_cmd_reg_add |= PCI_CMD_MEM_SPACE;
  1117. pci_cfg_cmd_reg_add |= PCI_CMD_BUS_MASTER;
  1119. pci_cfg_cmd_reg_p = cfgw + PCI_CFG_COMMAND / 4;
  1120. pci_cfg_cmd_reg = *pci_cfg_cmd_reg_p;
  1121. #if PCI_FBBE /* XXX- check here to see if dev can do fast-back-to-back */
  1122. if (!((pci_cfg_cmd_reg >> 16) & PCI_STAT_F_BK_BK_CAP))
  1123.     fast_back_to_back_enable = 0;
  1124. #endif
  1125. pci_cfg_cmd_reg &= 0xFFFF;
  1126. if (pci_cfg_cmd_reg_add & ~pci_cfg_cmd_reg)
  1127.     *pci_cfg_cmd_reg_p = pci_cfg_cmd_reg | pci_cfg_cmd_reg_add;
  1129.     } /* next func */
  1131.     /* Now that we have allocated new chunks of PCI address spaces to this
  1132.      * card we need to update the bookkeeping values which indicate
  1133.      * the current PCI address space allocations.
  1134.      */
  1135.     PCI_ADDR_SPACE_LIMITS_STORE();
  1136.     return(0);
  1137. }
  1139. /*
  1140.  * pcibr_slot_device_init
  1141.  *  Setup the device register in the bridge for this PCI slot.
  1142.  */
  1143. int
  1144. pcibr_slot_device_init(devfs_handle_t pcibr_vhdl,
  1145.        pciio_slot_t slot)
  1146. {
  1147.     pcibr_soft_t  pcibr_soft;
  1148.     bridge_t *bridge;
  1149.     bridgereg_t  devreg;
  1151.     pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  1153.     if (!pcibr_soft || !PCIBR_VALID_SLOT(slot))
  1154. return(EINVAL);
  1156.     bridge = pcibr_soft->bs_base;
  1158.     /*
  1159.      * Adjustments to Device(x)
  1160.      * and init of bss_device shadow
  1161.      */
  1162.     devreg = bridge->b_device[slot].reg;
  1163.     devreg &= ~BRIDGE_DEV_PAGE_CHK_DIS;
  1164.     devreg |= BRIDGE_DEV_COH | BRIDGE_DEV_VIRTUAL_EN;
  1165. #ifdef LITTLE_ENDIAN
  1166.     devreg |= BRIDGE_DEV_DEV_SWAP;
  1167. #endif
  1168.     pcibr_soft->bs_slot[slot].bss_device = devreg;
  1169.     bridge->b_device[slot].reg = devreg;
  1171. #if DEBUG && PCI_DEBUG
  1172. printk("pcibr Device(%d): 0x%lxn", slot, bridge->b_device[slot].reg);
  1173. #endif
  1175. #if DEBUG && PCI_DEBUG
  1176.     printk("pcibr: PCI space allocation done.n");
  1177. #endif
  1179.     return(0);
  1180. }
  1182. /*
  1183.  * pcibr_slot_guest_info_init
  1184.  * Setup the host/guest relations for a PCI slot.
  1185.  */
  1186. int
  1187. pcibr_slot_guest_info_init(devfs_handle_t pcibr_vhdl,
  1188.    pciio_slot_t slot)
  1189. {
  1190.     pcibr_soft_t pcibr_soft;
  1191.     pcibr_info_h pcibr_infoh;
  1192.     pcibr_info_t pcibr_info;
  1193.     pcibr_soft_slot_t slotp;
  1195.     pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  1197.     if (!pcibr_soft || !PCIBR_VALID_SLOT(slot))
  1198. return(EINVAL);
  1200.     slotp = &pcibr_soft->bs_slot[slot];
  1202.     /* create info and verticies for guest slots;
  1203.      * for compatibilitiy macros, create info
  1204.      * for even unpopulated slots (but do not
  1205.      * build verticies for them).
  1206.      */
  1207.     if (pcibr_soft->bs_slot[slot].bss_ninfo < 1) {
  1208. NEWA(pcibr_infoh, 1);
  1209. pcibr_soft->bs_slot[slot].bss_ninfo = 1;
  1210. pcibr_soft->bs_slot[slot].bss_infos = pcibr_infoh;
  1212. pcibr_info = pcibr_device_info_new
  1213.     (pcibr_soft, slot, PCIIO_FUNC_NONE,
  1214.      PCIIO_VENDOR_ID_NONE, PCIIO_DEVICE_ID_NONE);
  1216. if (pcibr_soft->bs_slot[slot].has_host) {
  1217.     slotp->slot_conn = pciio_device_info_register
  1218. (pcibr_vhdl, &pcibr_info->f_c);
  1219. }
  1220.     }
  1222.     /* generate host/guest relations
  1223.      */
  1224.     if (pcibr_soft->bs_slot[slot].has_host) {
  1225. int  host = pcibr_soft->bs_slot[slot].host_slot;
  1226. pcibr_soft_slot_t host_slotp = &pcibr_soft->bs_slot[host];
  1228. hwgraph_edge_add(slotp->slot_conn,
  1229.  host_slotp->slot_conn,
  1230.  EDGE_LBL_HOST);
  1232. /* XXX- only gives us one guest edge per
  1233.  * host. If/when we have a host with more than
  1234.  * one guest, we will need to figure out how
  1235.  * the host finds all its guests, and sorts
  1236.  * out which one is which.
  1237.  */
  1238. hwgraph_edge_add(host_slotp->slot_conn,
  1239.  slotp->slot_conn,
  1240.  EDGE_LBL_GUEST);
  1241.     }
  1243.     return(0);
  1244. }
  1247. /*
  1248.  * pcibr_slot_call_device_attach
  1249.  * This calls the associated driver attach routine for the PCI
  1250.  *  card in this slot.
  1251.  */
  1252. int
  1253. pcibr_slot_call_device_attach(devfs_handle_t pcibr_vhdl,
  1254.       pciio_slot_t slot,
  1255.       int          drv_flags)
  1256. {
  1257.     pcibr_soft_t pcibr_soft;
  1258.     pcibr_info_h pcibr_infoh;
  1259.     pcibr_info_t pcibr_info;
  1260.     async_attach_t aa = NULL;
  1261.     int func;
  1262.     devfs_handle_t xconn_vhdl,conn_vhdl;
  1263.     int nfunc;
  1264.     int                 error_func;
  1265.     int                 error_slot = 0;
  1266.     int                 error = ENODEV;
  1268.     pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  1270.     if (!pcibr_soft || !PCIBR_VALID_SLOT(slot))
  1271. return(EINVAL);
  1274.     if (pcibr_soft->bs_slot[slot].has_host) {
  1275.         return(EPERM);
  1276.     }
  1277.     
  1278.     xconn_vhdl = pcibr_soft->bs_conn;
  1279.     aa = async_attach_get_info(xconn_vhdl);
  1281.     nfunc = pcibr_soft->bs_slot[slot].bss_ninfo;
  1282.     pcibr_infoh = pcibr_soft->bs_slot[slot].bss_infos;
  1284.     for (func = 0; func < nfunc; ++func) {
  1286. pcibr_info = pcibr_infoh[func];
  1288. if (!pcibr_info)
  1289.     continue;
  1291. if (pcibr_info->f_vendor == PCIIO_VENDOR_ID_NONE)
  1292.     continue;
  1294. conn_vhdl = pcibr_info->f_vertex;
  1296. #ifdef LATER
  1297. /*
  1298.  * Activate if and when we support cdl.
  1299.  */
  1300. if (aa)
  1301.     async_attach_add_info(conn_vhdl, aa);
  1302. #endif /* LATER */
  1304. error_func = pciio_device_attach(conn_vhdl, drv_flags);
  1306.         pcibr_info->f_att_det_error = error_func;
  1308. if (error_func)
  1309.     error_slot = error_func;
  1311.         error = error_slot;
  1313.     } /* next func */
  1315.     if (error) {
  1316. if ((error != ENODEV) && (error != EUNATCH))
  1317.     pcibr_soft->bs_slot[slot].slot_status |= SLOT_STARTUP_INCMPLT;
  1318.     } else {
  1319.         pcibr_soft->bs_slot[slot].slot_status |= SLOT_STARTUP_CMPLT;
  1320.     }
  1321.         
  1322.     return(error);
  1323. }
  1325. /*
  1326.  * pcibr_slot_call_device_detach
  1327.  * This calls the associated driver detach routine for the PCI
  1328.  *  card in this slot.
  1329.  */
  1330. int
  1331. pcibr_slot_call_device_detach(devfs_handle_t pcibr_vhdl,
  1332.       pciio_slot_t slot,
  1333.       int          drv_flags)
  1334. {
  1335.     pcibr_soft_t pcibr_soft;
  1336.     pcibr_info_h pcibr_infoh;
  1337.     pcibr_info_t pcibr_info;
  1338.     int func;
  1339.     devfs_handle_t conn_vhdl = GRAPH_VERTEX_NONE;
  1340.     int nfunc;
  1341.     int                 error_func;
  1342.     int                 error_slot = 0;
  1343.     int                 error = ENODEV;
  1345.     pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  1347.     if (!pcibr_soft || !PCIBR_VALID_SLOT(slot))
  1348. return(EINVAL);
  1350.     if (pcibr_soft->bs_slot[slot].has_host)
  1351.         return(EPERM);
  1353.     /* Make sure that we do not detach a system critical function vertex */
  1354.     if(pcibr_is_slot_sys_critical(pcibr_vhdl, slot))
  1355.         return(EPERM);
  1357.     nfunc = pcibr_soft->bs_slot[slot].bss_ninfo;
  1358.     pcibr_infoh = pcibr_soft->bs_slot[slot].bss_infos;
  1360.     for (func = 0; func < nfunc; ++func) {
  1362. pcibr_info = pcibr_infoh[func];
  1364. if (!pcibr_info)
  1365.     continue;
  1367. if (pcibr_info->f_vendor == PCIIO_VENDOR_ID_NONE)
  1368.     continue;
  1370. conn_vhdl = pcibr_info->f_vertex;
  1372. error_func = pciio_device_detach(conn_vhdl, drv_flags);
  1374.         pcibr_info->f_att_det_error = error_func;
  1376. if (error_func)
  1377.     error_slot = error_func;
  1379. error = error_slot;
  1381.     } /* next func */
  1383.     pcibr_soft->bs_slot[slot].slot_status &= ~SLOT_STATUS_MASK;
  1385.     if (error) {
  1386. if ((error != ENODEV) && (error != EUNATCH))
  1387.             pcibr_soft->bs_slot[slot].slot_status |= SLOT_SHUTDOWN_INCMPLT;
  1388.     } else {
  1389.         if (conn_vhdl != GRAPH_VERTEX_NONE) 
  1390.             pcibr_device_unregister(conn_vhdl);
  1391.         pcibr_soft->bs_slot[slot].slot_status |= SLOT_SHUTDOWN_CMPLT;
  1392.     }
  1393.         
  1394.     return(error);
  1395. }
  1397. #ifdef LATER
  1399. /*
  1400.  * pcibr_slot_attach
  1401.  * This is a place holder routine to keep track of all the
  1402.  * slot-specific initialization that needs to be done.
  1403.  * This is usually called when we want to initialize a new
  1404.  *  PCI card on the bus.
  1405.  */
  1406. int
  1407. pcibr_slot_attach(devfs_handle_t pcibr_vhdl,
  1408.   pciio_slot_t slot,
  1409.   int          drv_flags,
  1410.   char        *l1_msg,
  1411.                   int         *sub_errorp)
  1412. {
  1413.     pcibr_soft_t  pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  1414.     timespec_t    ts;
  1415.     int   error;
  1417.     if (!(pcibr_soft->bs_slot[slot].slot_status & SLOT_POWER_UP)) { 
  1418.         /* Power-up the slot */
  1419.         error = pcibr_slot_pwr(pcibr_vhdl, slot, L1_REQ_PCI_UP, l1_msg);
  1420.         if (error) {
  1421.             if (sub_errorp)
  1422.                 *sub_errorp = error;
  1423.             return(PCI_L1_ERR);
  1424.         } else {
  1425.             pcibr_soft->bs_slot[slot].slot_status &= ~SLOT_POWER_MASK;
  1426.             pcibr_soft->bs_slot[slot].slot_status |= SLOT_POWER_UP;
  1427.         }
  1429. #ifdef LATER
  1430.         /*
  1431.          * Allow cards like the Alteon Gigabit Ethernet Adapter to complete
  1432.          * on-card initialization following the slot reset
  1433.          */
  1434.          ts.tv_sec = 0;                      /* 0 secs */
  1435.          ts.tv_nsec = 500 * (1000 * 1000);   /* 500 msecs */
  1436.          nano_delay(&ts);
  1437. #else
  1438. #endif
  1439. #if 0
  1440.         /* Reset the slot */
  1441.         error = pcibr_slot_reset(pcibr_vhdl, slot)
  1442.         if (error) {
  1443.             if (sub_errorp)
  1444.                 *sub_errorp = error;
  1445.             return(PCI_SLOT_RESET_ERR);
  1446.         }
  1447. #endif
  1449.         /* Find out what is out there */
  1450.         error = pcibr_slot_info_init(pcibr_vhdl, slot);
  1451.         if (error) {
  1452.             if (sub_errorp)
  1453.                 *sub_errorp = error;
  1454.             return(PCI_SLOT_INFO_INIT_ERR);
  1455.         }
  1457.         /* Set up the address space for this slot in the PCI land */
  1458.         error = pcibr_slot_addr_space_init(pcibr_vhdl, slot);
  1459.         if (error) {
  1460.             if (sub_errorp)
  1461.                 *sub_errorp = error;
  1462.             return(PCI_SLOT_ADDR_INIT_ERR);
  1463.         }
  1465.         /* Setup the device register */
  1466.         error = pcibr_slot_device_init(pcibr_vhdl, slot);
  1467.         if (error) {
  1468.             if (sub_errorp)
  1469.                 *sub_errorp = error;
  1470.             return(PCI_SLOT_DEV_INIT_ERR);
  1471.         }
  1473.         /* Setup host/guest relations */
  1474.         error = pcibr_slot_guest_info_init(pcibr_vhdl, slot);
  1475.         if (error) {
  1476.             if (sub_errorp)
  1477.                 *sub_errorp = error;
  1478.             return(PCI_SLOT_GUEST_INIT_ERR);
  1479.         }
  1481.         /* Initial RRB management */
  1482.         error = pcibr_slot_initial_rrb_alloc(pcibr_vhdl, slot);
  1483.         if (error) {
  1484.             if (sub_errorp)
  1485.                 *sub_errorp = error;
  1486.             return(PCI_SLOT_RRB_ALLOC_ERR);
  1487.         }
  1489.     }
  1491.     /* Call the device attach */
  1492.     error = pcibr_slot_call_device_attach(pcibr_vhdl, slot, drv_flags);
  1493.     if (error) {
  1494.         if (sub_errorp)
  1495.             *sub_errorp = error;
  1496.         if (error == EUNATCH)
  1497.             return(PCI_NO_DRIVER);
  1498.         else
  1499.             return(PCI_SLOT_DRV_ATTACH_ERR);
  1500.     }
  1502.     return(0);
  1503. }
  1504. #endif /* LATER */
  1506. /*
  1507.  * pcibr_slot_detach
  1508.  * This is a place holder routine to keep track of all the
  1509.  * slot-specific freeing that needs to be done.
  1510.  */
  1511. int
  1512. pcibr_slot_detach(devfs_handle_t pcibr_vhdl,
  1513.   pciio_slot_t slot,
  1514.   int          drv_flags)
  1515. {
  1516.     int   error;
  1517.     
  1518.     /* Call the device detach function */
  1519.     error = (pcibr_slot_call_device_detach(pcibr_vhdl, slot, drv_flags));
  1520.     return (error);
  1522. }
  1524. /*
  1525.  * pcibr_is_slot_sys_critical
  1526.  *      Check slot for any functions that are system critical.
  1527.  *      Return 1 if any are system critical or 0 otherwise.
  1528.  *
  1529.  *      This function will always return 0 when called by 
  1530.  *      pcibr_attach() because the system critical vertices 
  1531.  *      have not yet been set in the hwgraph.
  1532.  */
  1533. int
  1534. pcibr_is_slot_sys_critical(devfs_handle_t pcibr_vhdl,
  1535.                       pciio_slot_t slot)
  1536. {
  1537.     pcibr_soft_t        pcibr_soft;
  1538.     pcibr_info_h        pcibr_infoh;
  1539.     pcibr_info_t        pcibr_info;
  1540.     devfs_handle_t        conn_vhdl = GRAPH_VERTEX_NONE;
  1541.     int                 nfunc;
  1542.     int                 func;
  1543.     boolean_t is_sys_critical_vertex(devfs_handle_t);
  1545.     pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  1546.     if (!pcibr_soft || !PCIBR_VALID_SLOT(slot))
  1547.         return(0);
  1549.     nfunc = pcibr_soft->bs_slot[slot].bss_ninfo;
  1550.     pcibr_infoh = pcibr_soft->bs_slot[slot].bss_infos;
  1552.     for (func = 0; func < nfunc; ++func) {
  1554.         pcibr_info = pcibr_infoh[func];
  1555.         if (!pcibr_info)
  1556.             continue;
  1558.         if (pcibr_info->f_vendor == PCIIO_VENDOR_ID_NONE)
  1559.             continue;
  1561.         conn_vhdl = pcibr_info->f_vertex;
  1562.         if (is_sys_critical_vertex(conn_vhdl)) { 
  1563. #if defined(SUPPORT_PRINTING_V_FORMAT)
  1564.             printk(KERN_WARNING  "%v is a system critical device vertexn", conn_vhdl);
  1565. #else
  1566.             printk(KERN_WARNING  "%p is a system critical device vertexn", (void *)conn_vhdl);
  1567. #endif
  1568.             return(1); 
  1569.         }
  1571.     }
  1573.     return(0);
  1574. }
  1576. /*
  1577.  * pcibr_probe_slot: read a config space word
  1578.  * while trapping any errors; reutrn zero if
  1579.  * all went OK, or nonzero if there was an error.
  1580.  * The value read, if any, is passed back
  1581.  * through the valp parameter.
  1582.  */
  1583. int
  1584. pcibr_probe_slot(bridge_t *bridge,
  1585.  cfg_p cfg,
  1586.  unsigned *valp)
  1587. {
  1588.     int                     rv;
  1589.     bridgereg_t             old_enable, new_enable;
  1590.     int badaddr_val(volatile void *, int, volatile void *);
  1592.     old_enable = bridge->b_int_enable;
  1593.     new_enable = old_enable & ~BRIDGE_IMR_PCI_MST_TIMEOUT;
  1595.     bridge->b_int_enable = new_enable;
  1597. /*
  1598.  * The xbridge doesn't clear b_err_int_view unless
  1599.  * multi-err is cleared...
  1600.  */
  1601. if (is_xbridge(bridge))
  1602.     if (bridge->b_err_int_view & BRIDGE_ISR_PCI_MST_TIMEOUT) {
  1603. bridge->b_int_rst_stat = BRIDGE_IRR_MULTI_CLR;
  1604.     }
  1606.     if (bridge->b_int_status & BRIDGE_IRR_PCI_GRP) {
  1607. bridge->b_int_rst_stat = BRIDGE_IRR_PCI_GRP_CLR;
  1608. (void) bridge->b_wid_tflush; /* flushbus */
  1609.     }
  1610.     rv = badaddr_val((void *) cfg, 4, valp);
  1612. /*
  1613.  * The xbridge doesn't set master timeout in b_int_status
  1614.  * here.  Fortunately it's in error_interrupt_view.
  1615.  */
  1616. if (is_xbridge(bridge))
  1617.     if (bridge->b_err_int_view & BRIDGE_ISR_PCI_MST_TIMEOUT) {
  1618. bridge->b_int_rst_stat = BRIDGE_IRR_MULTI_CLR;
  1619. rv = 1; /* unoccupied slot */
  1620.     }
  1622.     bridge->b_int_enable = old_enable;
  1623.     bridge->b_wid_tflush; /* wait until Bridge PIO complete */
  1625.     return rv;
  1626. }
  1628. void
  1629. pcibr_device_info_free(devfs_handle_t pcibr_vhdl, pciio_slot_t slot)
  1630. {
  1631.     pcibr_soft_t pcibr_soft = pcibr_soft_get(pcibr_vhdl);
  1632.     pcibr_info_t pcibr_info;
  1633.     pciio_function_t func;
  1634.     pcibr_soft_slot_t slotp = &pcibr_soft->bs_slot[slot];
  1635.     int nfunc = slotp->bss_ninfo;
  1636.     int                 bar;
  1637.     int                 devio_index;
  1638.     int                 s;
  1641.     for (func = 0; func < nfunc; func++) {
  1642. pcibr_info = slotp->bss_infos[func];
  1644. if (!pcibr_info) 
  1645.     continue;
  1647.         s = pcibr_lock(pcibr_soft);
  1649.         for (bar = 0; bar < PCI_CFG_BASE_ADDRS; bar++) {
  1650.             if (pcibr_info->f_window[bar].w_space == PCIIO_SPACE_NONE)
  1651.                 continue;
  1653.             /* Get index of the DevIO(x) register used to access this BAR */
  1654.             devio_index = pcibr_info->f_window[bar].w_devio_index;
  1656.  
  1657.             /* On last use, clear the DevIO(x) used to access this BAR */
  1658.             if (! --pcibr_soft->bs_slot[devio_index].bss_devio.bssd_ref_cnt) {
  1659.                pcibr_soft->bs_slot[devio_index].bss_devio.bssd_space =
  1660.                                                        PCIIO_SPACE_NONE; 
  1661.                pcibr_soft->bs_slot[devio_index].bss_devio.bssd_base =
  1662.                                                        PCIBR_D32_BASE_UNSET;
  1663.                pcibr_soft->bs_slot[devio_index].bss_device = 0;
  1664.             }
  1665.         }
  1667.         pcibr_unlock(pcibr_soft, s);
  1669. slotp->bss_infos[func] = 0;
  1670. pciio_device_info_unregister(pcibr_vhdl, &pcibr_info->f_c);
  1671. pciio_device_info_free(&pcibr_info->f_c);
  1673. DEL(pcibr_info);
  1674.     }
  1676.     /* Reset the mapping usage counters */
  1677.     slotp->bss_pmu_uctr = 0;
  1678.     slotp->bss_d32_uctr = 0;
  1679.     slotp->bss_d64_uctr = 0;
  1681.     /* Clear the Direct translation info */
  1682.     slotp->bss_d64_base = PCIBR_D64_BASE_UNSET;
  1683.     slotp->bss_d64_flags = 0;
  1684.     slotp->bss_d32_base = PCIBR_D32_BASE_UNSET;
  1685.     slotp->bss_d32_flags = 0;
  1687.     /* Clear out shadow info necessary for the external SSRAM workaround */
  1688.     slotp->bss_ext_ates_active = ATOMIC_INIT(0);
  1689.     slotp->bss_cmd_pointer = 0;
  1690.     slotp->bss_cmd_shadow = 0;
  1692. }