/*
* Initialize the QuarterDeck. This should be done in BSP driver init routine.
* Since BSP is not combined with QuarterDeck driver, we are doing here.
*/
GT_STATUS qdStart(void) /* devId is used for simulator only */
{
GT_STATUS status;
/*
* Register all the required functions to QuarterDeck Driver.
*/
cfg.BSPFunctions.readMii = ffReadMii;
cfg.BSPFunctions.writeMii = ffWriteMii;
#ifdef USE_SEMAPHORE
cfg.BSPFunctions.semCreate = osSemCreate;
cfg.BSPFunctions.semDelete = osSemDelete;
cfg.BSPFunctions.semTake = osSemWait;
cfg.BSPFunctions.semGive = osSemSignal;
#else /* USE_SEMAPHORE */
cfg.BSPFunctions.semCreate = NULL;
cfg.BSPFunctions.semDelete = NULL;
cfg.BSPFunctions.semTake = NULL;
cfg.BSPFunctions.semGive = NULL;
#endif /* USE_SEMAPHORE */
cfg.initPorts = GT_TRUE;
cfg.cpuPortNum = GT_CPU_SWITCH_PORT;
qd_dev->cpuPortNum = GT_CPU_SWITCH_PORT;
if((status = qdLoadDriver(&cfg, qd_dev)) != GT_OK) {
gtOsPrintf("qdLoadDriver is failed: status = 0x%x\n", status);
return status;
}
/*
* start the QuarterDeck
*/
if (qd_dev->deviceId == GT_88E6063) {
phyPatch(qd_dev);
}
/* to which VID should we set the CPU_PORT? (1 is temporary)*/
if((status = gvlnSetPortVid(qd_dev, GT_CPU_SWITCH_PORT, 5)) != GT_OK) {
gtOsPrintf("gprtSetPortVid returned fail for CPU port.\n");
return status;
}
#ifdef QD_TRAILER_MODE
/* set ingress trailer mode*/
gprtSetIngressMode(qd_dev, GT_CPU_SWITCH_PORT, GT_TRAILER_INGRESS);
/* set egress trailer*/
gprtSetTrailerMode(qd_dev, GT_CPU_SWITCH_PORT, GT_TRUE);
#endif
#ifdef QD_HEADER_MODE
if((status = gprtSetHeaderMode(qd_dev, GT_CPU_SWITCH_PORT, GT_TRUE)) != GT_OK)
{
gtOsPrintf("gprtSetHeaderMode return Failed\n");
return status;
}
#endif
return GT_OK;
}
int mv_switch_load_drv(unsigned int port)
{
int num, scan_mode = 0;
GT_QD_DEV *qd;
printk(" o Loading Switch QuarterDeck driver\n");
memset((char*)&qd_cfg, 0, sizeof(GT_SYS_CONFIG) * BOARD_MAX_CASCADED_SWITCHES);
scan_mode = mvBoardSmiScanModeGet(port);
for (num = 0; num < mvBoardNumSwitchesOnPortGet(port); num++) {
/* init config structure for qd package */
qd_cfg[num].BSPFunctions.readMii = gtwReadMiiWrap;
qd_cfg[num].BSPFunctions.writeMii = gtwWriteMiiWrap;
qd_cfg[num].BSPFunctions.semCreate = NULL;
qd_cfg[num].BSPFunctions.semDelete = NULL;
qd_cfg[num].BSPFunctions.semTake = NULL;
qd_cfg[num].BSPFunctions.semGive = NULL;
qd_cfg[num].initPorts = GT_TRUE;
qd_cfg[num].cpuPortNum = mvBoardSwitchCpuPortGet(port, num);
if (scan_mode == 1) {
qd_cfg[num].mode.baseAddr = 0;
qd_cfg[num].mode.scanMode = SMI_MANUAL_MODE;
} else if (scan_mode == 2) {
qd_cfg[num].mode.baseAddr = mvBoardSwitchSmiAddrGet(port, num);
qd_cfg[num].mode.scanMode = SMI_MULTI_ADDR_MODE;
}
/* load switch sw package */
if (qdLoadDriver(&qd_cfg[num], &qd_dev[num]) != GT_OK) {
printk("qdLoadDriver failed, qd_num = %d\n", num);
return -1;
}
qd = &qd_dev[num];
ETH_DBG( ETH_DBG_LOAD, ("Device ID : 0x%x\n", qd->deviceId));
ETH_DBG( ETH_DBG_LOAD, ("Base Reg Addr : 0x%x\n", qd->baseRegAddr));
ETH_DBG( ETH_DBG_LOAD, ("No. of Ports : %d\n", qd->numOfPorts));
ETH_DBG( ETH_DBG_LOAD, ("CPU Ports : %ld\n", qd->cpuPortNum));
}
return 0;
}
int mv_switch_load(unsigned int port)
{
printk(KERN_ERR " o Loading Switch QuarterDeck driver\n");
if (qd_dev) {
printk(KERN_ERR " o %s: Already initialized\n", __func__);
return 0;
}
memset((char *)&qd_cfg, 0, sizeof(GT_SYS_CONFIG));
spin_lock_init(&switch_lock);
/* init config structure for qd package */
qd_cfg.BSPFunctions.readMii = readMiiWrap;
qd_cfg.BSPFunctions.writeMii = writeMiiWrap;
qd_cfg.BSPFunctions.semCreate = NULL;
qd_cfg.BSPFunctions.semDelete = NULL;
qd_cfg.BSPFunctions.semTake = NULL;
qd_cfg.BSPFunctions.semGive = NULL;
qd_cfg.initPorts = GT_TRUE;
qd_cfg.cpuPortNum = mvBoardSwitchCpuPortGet(port);
if (mvBoardSmiScanModeGet(port) == 1) {
qd_cfg.mode.baseAddr = 0;
qd_cfg.mode.scanMode = SMI_MANUAL_MODE;
}
else if (mvBoardSmiScanModeGet(port) == 2) {
qd_cfg.mode.baseAddr = mvBoardPhyAddrGet(port); /* was 0xA; */
qd_cfg.mode.scanMode = SMI_MULTI_ADDR_MODE;
}
/* load switch sw package */
if (qdLoadDriver(&qd_cfg, &qddev) != GT_OK) {
printk(KERN_ERR "qdLoadDriver failed (mv_switch_load)\n");
return -1;
}
printk("qdLoadDriver OK in %s\n",__func__);
qd_dev = &qddev;
return 0;
}
//#define MULTI_ADDR_MODE 1
GT_STATUS qdStart(int cpuPort)
{
GT_STATUS status;
/*
* Register all the required functions to QuarterDeck Driver.
* */
memset((char*)&cfg,0,sizeof(GT_SYS_CONFIG));
memset((char*)&diagDev,0,sizeof(GT_QD_DEV));
dev = &diagDev;
cfg.BSPFunctions.readMii = switchReadReg;
cfg.BSPFunctions.writeMii = switchWriteReg;
#ifdef GT_RMGMT_ACCESS
cfg.BSPFunctions.hwAccess = gtBspHwAccess;
#endif
#ifdef USE_SEMAPHORE
cfg.BSPFunctions.semCreate = osSemCreate;
cfg.BSPFunctions.semDelete = osSemDelete;
cfg.BSPFunctions.semTake = osSemWait;
cfg.BSPFunctions.semGive = osSemSignal;
#else
cfg.BSPFunctions.semCreate = NULL;
cfg.BSPFunctions.semDelete = NULL;
cfg.BSPFunctions.semTake = NULL;
cfg.BSPFunctions.semGive = NULL;
#endif
gtBspMiiInit(dev);
cfg.initPorts = GT_TRUE; /* Set switch ports to Forwarding mode. If GT_FALSE, use Default Setting. */
cfg.cpuPortNum = cpuPort;
#ifdef MANUAL_MODE /* not defined. this is only for sample */
/* user may want to use this mode when there are two QD switchs on the same MII bus. */
cfg.mode.scanMode = SMI_MANUAL_MODE; /* Use QD located at manually defined base addr */
cfg.mode.baseAddr = 0x10; /* valid value in this case is either 0 or 0x10 */
#else
#ifdef MULTI_ADDR_MODE
cfg.mode.scanMode = SMI_MULTI_ADDR_MODE; /* find a QD in indirect access mode */
cfg.mode.baseAddr = 1; /* this is the phyAddr used by QD family device.
Valid value are 1 ~ 31.*/
#else
cfg.mode.scanMode = SMI_AUTO_SCAN_MODE; /* Scan 0 or 0x10 base address to find the QD */
cfg.mode.baseAddr = 0;
#endif
#endif
if((status=qdLoadDriver(&cfg, dev)) != GT_OK)
{
ERROR(GLOBAL_OUT_GROUP, "qdLoadDriver return Failed\n");
return status;
}
INFO(GLOBAL_OUT_GROUP,"Device ID : 0x%x\n",dev->deviceId);
INFO(GLOBAL_OUT_GROUP,"Base Reg Addr : 0x%x\n",dev->baseRegAddr);
INFO(GLOBAL_OUT_GROUP,"No of Ports : %d\n",(int)dev->numOfPorts);
INFO(GLOBAL_OUT_GROUP,"CPU Ports : %d\n",(int)dev->cpuPortNum);
/*
* * start the QuarterDeck
* */
if((status=sysEnable(dev)) != GT_OK)
{
ERROR(GLOBAL_OUT_GROUP,"sysConfig return Failed\n");
return status;
}
INFO(GLOBAL_OUT_GROUP,"QuarterDeck has been started.\n");
return GT_OK;
}
GT_STATUS RubyStart(int phyAddr, GT_QD_DEV* d)
{
GT_STATUS status = GT_FAIL;
GT_SYS_CONFIG cfg;
memset((char*)&cfg,0,sizeof(GT_SYS_CONFIG));
MSG_PRINT(("Size of GT_QD_DEV %i\n",sizeof(GT_QD_DEV)));
if(d == NULL)
{
MSG_PRINT(("Device Structure is NULL.\n"));
return GT_FAIL;
}
memset((char*)d,0,sizeof(GT_QD_DEV));
cfg.BSPFunctions.readMii = ffReadMii;
cfg.BSPFunctions.writeMii = ffWriteMii;
#ifdef USE_SEMAPHORE
cfg.BSPFunctions.semCreate = osSemCreate;
cfg.BSPFunctions.semDelete = osSemDelete;
cfg.BSPFunctions.semTake = osSemWait;
cfg.BSPFunctions.semGive = osSemSignal;
#else
cfg.BSPFunctions.semCreate = NULL;
cfg.BSPFunctions.semDelete = NULL;
cfg.BSPFunctions.semTake = NULL;
cfg.BSPFunctions.semGive = NULL;
#endif
cfg.initPorts = GT_TRUE; /* Set switch ports to Forwarding mode. If GT_FALSE, use Default Setting. */
cfg.cpuPortNum = 10;
cfg.mode.scanMode = SMI_MULTI_ADDR_MODE;
cfg.mode.baseAddr = phyAddr; /* valid value in this case is either 0 or 0x10 */
if((status=qdLoadDriver(&cfg, d)) != GT_OK)
{
MSG_PRINT(("qdLoadDriver return Failed\n"));
return status;
}
MSG_PRINT(("Device ID : 0x%x\n",d->deviceId));
MSG_PRINT(("PHY Addr : 0x%x\n",d->phyAddr));
MSG_PRINT(("Base Addr : 0x%x\n",d->baseRegAddr));
MSG_PRINT(("CPU Ports : %d\n",d->cpuPortNum));
MSG_PRINT(("N Ports : %d\n",d->numOfPorts));
MSG_PRINT(("Device Group : 0x%x\n",d->devName));
MSG_PRINT(("QDDev : %#x\n",(unsigned long)&d));
/*
* start the QuarterDeck
*/
if((status=sysEnable(d)) != GT_OK)
{
MSG_PRINT(("sysConfig return Failed\n"));
return status;
}
return GT_OK;
}
GT_QD_DEV* loadDev(GT_QD_DEV* dev, int mode, int phyAddr, int cpuPort, unsigned int cfgMode)
{
GT_QD_DEV* d = dev;
GT_STATUS status = GT_FAIL;
GT_SYS_CONFIG cfg;
if((int)dev == -1)
goto printUse;
memset((char*)&cfg,0,sizeof(GT_SYS_CONFIG));
if(d == NULL)
{
d = (GT_QD_DEV*)malloc(sizeof(GT_QD_DEV));
if(d == NULL)
{
MSG_PRINT(("Failed to allocate Device Structure\n"));
return NULL;
}
}
memset((char*)d,0,sizeof(GT_QD_DEV));
cfg.BSPFunctions.readMii = ffReadMii;
cfg.BSPFunctions.writeMii = ffWriteMii;
#ifdef USE_SEMAPHORE
cfg.BSPFunctions.semCreate = osSemCreate;
cfg.BSPFunctions.semDelete = osSemDelete;
cfg.BSPFunctions.semTake = osSemWait;
cfg.BSPFunctions.semGive = osSemSignal;
#else
cfg.BSPFunctions.semCreate = NULL;
cfg.BSPFunctions.semDelete = NULL;
cfg.BSPFunctions.semTake = NULL;
cfg.BSPFunctions.semGive = NULL;
#endif
cfg.initPorts = GT_TRUE; /* Set switch ports to Forwarding mode. If GT_FALSE, use Default Setting. */
cfg.cpuPortNum = cpuPort;
cfg.skipInitSetup = (GT_U32)cfgMode;
switch(mode)
{
case SMI_MANUAL_MODE: /* Use QD located at manually defined base addr */
case SMI_MULTI_ADDR_MODE: /* Use QD in multi chip address mode */
cfg.mode.scanMode = mode;
cfg.mode.baseAddr = phyAddr; /* valid value in this case is either 0 or 0x10 */
break;
case SMI_AUTO_SCAN_MODE: /* Scan 0 or 0x10 base address to find the QD */
cfg.mode.scanMode = mode;
cfg.mode.baseAddr = 0;
break;
default:
MSG_PRINT(("Unknown Mode %i\n",mode));
goto printUse;
}
if((status=qdLoadDriver(&cfg, d)) != GT_OK)
{
MSG_PRINT(("qdLoadDriver return Failed\n"));
goto loadErr;
}
MSG_PRINT(("Device ID : 0x%x\n",d->deviceId));
MSG_PRINT(("PHY Addr : 0x%x\n",d->phyAddr));
MSG_PRINT(("Base Addr : 0x%x\n",d->baseRegAddr));
MSG_PRINT(("CPU Ports : %d\n",d->cpuPortNum));
/*
* start the QuarterDeck
*/
if((status=sysEnable(d)) != GT_OK)
{
MSG_PRINT(("sysConfig return Failed\n"));
goto loadErr;
}
return d;
printUse:
MSG_PRINT(("Usage: loadDev(Dev,mode,phyAddr,cpuPort)\n",SMI_AUTO_SCAN_MODE));
MSG_PRINT(("\tSMI_AUTO_SCAN_MODE : %i\n",SMI_AUTO_SCAN_MODE));
MSG_PRINT(("\tSMI_MANUAL_MODE : %i\n",SMI_MANUAL_MODE));
MSG_PRINT(("\tSMI_MULTI_ADDR_MODE : %i\n",SMI_MULTI_ADDR_MODE));
MSG_PRINT(("Example: loadDev(0,1,0x10,5)\n"));
MSG_PRINT(("for Manual mode, phy base address 0x10, and cpu port 5\n"));
loadErr:
if(dev)
return NULL;
if(d)
free(d);
return NULL;
}
GT_STATUS qdStart(int cpuPort, int useQdSim, int devId) /* devId is used for simulator only */
{
GT_STATUS status;
/*
* Register all the required functions to QuarterDeck Driver.
*/
memset((char*)&cfg,0,sizeof(GT_SYS_CONFIG));
memset((char*)&diagDev,0,sizeof(GT_QD_DEV));
if(useQdSim == 0) /* use EV-96122 */
{
cfg.BSPFunctions.readMii = gtBspReadMii;
cfg.BSPFunctions.writeMii = gtBspWriteMii;
#ifdef GT_RMGMT_ACCESS
cfg.BSPFunctions.hwAccess = gtBspHwAccess;
#endif
#ifdef USE_SEMAPHORE
cfg.BSPFunctions.semCreate = osSemCreate;
cfg.BSPFunctions.semDelete = osSemDelete;
cfg.BSPFunctions.semTake = osSemWait;
cfg.BSPFunctions.semGive = osSemSignal;
#else
cfg.BSPFunctions.semCreate = NULL;
cfg.BSPFunctions.semDelete = NULL;
cfg.BSPFunctions.semTake = NULL;
cfg.BSPFunctions.semGive = NULL;
#endif
gtBspMiiInit(dev);
}
else /* use QuaterDeck Simulator (No QD Device Required.) */
{
cfg.BSPFunctions.readMii = qdSimRead;
cfg.BSPFunctions.writeMii = qdSimWrite;
#ifdef USE_SEMAPHORE
cfg.BSPFunctions.semCreate = osSemCreate;
cfg.BSPFunctions.semDelete = osSemDelete;
cfg.BSPFunctions.semTake = osSemWait;
cfg.BSPFunctions.semGive = osSemSignal;
#else
cfg.BSPFunctions.semCreate = NULL;
cfg.BSPFunctions.semDelete = NULL;
cfg.BSPFunctions.semTake = NULL;
cfg.BSPFunctions.semGive = NULL;
#endif
qdSimInit(devId,0);
}
cfg.initPorts = GT_TRUE; /* Set switch ports to Forwarding mode. If GT_FALSE, use Default Setting. */
cfg.cpuPortNum = cpuPort;
#ifdef MANUAL_MODE /* not defined. this is only for sample */
/* user may want to use this mode when there are two QD switchs on the same MII bus. */
cfg.mode.scanMode = SMI_MANUAL_MODE; /* Use QD located at manually defined base addr */
cfg.mode.baseAddr = 0x10; /* valid value in this case is either 0 or 0x10 */
#else
#ifdef MULTI_ADDR_MODE
cfg.mode.scanMode = SMI_MULTI_ADDR_MODE; /* find a QD in indirect access mode */
cfg.mode.baseAddr = 1; /* this is the phyAddr used by QD family device.
Valid value are 1 ~ 31.*/
#else
cfg.mode.scanMode = SMI_AUTO_SCAN_MODE; /* Scan 0 or 0x10 base address to find the QD */
cfg.mode.baseAddr = 0;
#endif
#endif
if((status=qdLoadDriver(&cfg, dev)) != GT_OK)
{
MSG_PRINT(("qdLoadDriver return Failed\n"));
return status;
}
MSG_PRINT(("Device ID : 0x%x\n",dev->deviceId));
MSG_PRINT(("Base Reg Addr : 0x%x\n",dev->baseRegAddr));
MSG_PRINT(("No of Ports : %d\n",dev->numOfPorts));
MSG_PRINT(("CPU Ports : %d\n",dev->cpuPortNum));
/*
* start the QuarterDeck
*/
if((status=sysEnable(dev)) != GT_OK)
{
MSG_PRINT(("sysConfig return Failed\n"));
return status;
}
MSG_PRINT(("QuarterDeck has been started.\n"));
return GT_OK;
}
int mv_switch_load(unsigned int switch_ports_mask)
{
int p;
GT_STU_ENTRY stuEntry;
printk(KERN_ERR " o Loading Switch QuarterDeck driver\n");
if (qd_dev) {
printk(KERN_ERR " o %s: Already initialized\n", __func__);
return 0;
}
memset((char *)&qd_cfg, 0, sizeof(GT_SYS_CONFIG));
spin_lock_init(&switch_lock);
/* init config structure for qd package */
qd_cfg.BSPFunctions.readMii = mv_switch_mii_read;
qd_cfg.BSPFunctions.writeMii = mv_switch_mii_write;
qd_cfg.BSPFunctions.semCreate = NULL;
qd_cfg.BSPFunctions.semDelete = NULL;
qd_cfg.BSPFunctions.semTake = NULL;
qd_cfg.BSPFunctions.semGive = NULL;
qd_cfg.initPorts = GT_TRUE;
qd_cfg.cpuPortNum = mvBoardSwitchCpuPortGet(MV_SWITCH_DEF_INDEX);
if (mvBoardSmiScanModeGet(MV_SWITCH_DEF_INDEX) == 1) {
qd_cfg.mode.baseAddr = 0;
qd_cfg.mode.scanMode = SMI_MANUAL_MODE;
} else if (mvBoardSmiScanModeGet(MV_SWITCH_DEF_INDEX) == 2) {
qd_cfg.mode.scanMode = SMI_MULTI_ADDR_MODE;
if (mvBoardSwitchConnectedPortGet(MV_ETH_PORT_0) != -1) {
qd_cfg.mode.baseAddr = mvBoardPhyAddrGet(MV_ETH_PORT_0);
} else if (mvBoardSwitchConnectedPortGet(MV_ETH_PORT_1) != -1) {
qd_cfg.mode.baseAddr = mvBoardPhyAddrGet(MV_ETH_PORT_1);
} else {
printk(KERN_ERR "mv_switch_load failed: Wrong SCAN mode\n");
return -1;
}
}
/* load switch sw package */
if (qdLoadDriver(&qd_cfg, &qddev) != GT_OK) {
printk(KERN_ERR "qdLoadDriver failed\n");
return -1;
}
qd_dev = &qddev;
qd_cpu_port = qd_cfg.cpuPortNum;
/* Create entry in STU table */
memset(&stuEntry, 0, sizeof(GT_STU_ENTRY));
stuEntry.sid = 1; /* required: ((sid > 0) && (sid < 0x3F)) */
gstuAddEntry(qd_dev, &stuEntry);
printk(KERN_ERR " o Device ID : 0x%x\n", qd_dev->deviceId);
printk(KERN_ERR " o No. of Ports : %d\n", qd_dev->numOfPorts);
printk(KERN_ERR " o CPU Port : %ld\n", qd_dev->cpuPortNum);
qsgmii_module = mvBoardIsQsgmiiModuleConnected();
if (qsgmii_module)
printk(KERN_ERR " o QSGMII Module Detected\n");
gephy_on_port = mvBoardGePhySwitchPortGet();
if (gephy_on_port >= 0)
printk(KERN_ERR " o Internal GE PHY Connected to Switch Port %d Detected\n", gephy_on_port);
rgmiia_on_port = mvBoardRgmiiASwitchPortGet();
if (rgmiia_on_port >= 0)
printk(KERN_ERR " o RGMII-A Connected to Switch Port %d Detected\n", rgmiia_on_port);
/* disable all disconnected ports */
for (p = 0; p < qd_dev->numOfPorts; p++) {
/* Do nothing for ports that are not part of the given switch_port_mask */
if (!MV_BIT_CHECK(switch_ports_mask, p))
continue;
if (mvBoardSwitchPortMap(MV_SWITCH_DEF_INDEX, p) != -1) {
/* Switch port mapped to connector on the board */
if ((gpcsSetFCValue(qd_dev, p, GT_FALSE) != GT_OK) ||
(gpcsSetForcedFC(qd_dev, p, GT_FALSE) != GT_OK)) {
printk(KERN_ERR "Force Flow Control - Failed\n");
return -1;
}
#if 0
/* TODO - decide if we want to enable auto-negotiation of Flow Control for external ports */
if (qsgmii_module) {
/* TODO - configure ports via QSGMII registers */
} else {
GT_STATUS status;
status = gprtSetPause(qd_dev, p, GT_PHY_PAUSE);
if (status != GT_OK)
printk(KERN_ERR "Failed set pause for switch port #%d: status = %d\n", p, status);
}
#endif
continue;
}
if ((mvBoardSwitchConnectedPortGet(MV_ETH_PORT_0) == p) ||
(mvBoardSwitchConnectedPortGet(MV_ETH_PORT_1) == p)) {
/* Switch port connected to GMAC - force link UP - 1000 Full with FC */
printk(KERN_ERR " o Setting Switch Port #%d connected to GMAC port for 1000 Full with FC\n", p);
if (gpcsSetForceSpeed(qd_dev, p, PORT_FORCE_SPEED_1000_MBPS) != GT_OK) {
printk(KERN_ERR "Force speed 1000mbps - Failed\n");
return -1;
}
if ((gpcsSetDpxValue(qd_dev, p, GT_TRUE) != GT_OK) ||
(gpcsSetForcedDpx(qd_dev, p, GT_TRUE) != GT_OK)) {
printk(KERN_ERR "Force duplex FULL - Failed\n");
return -1;
}
if ((gpcsSetFCValue(qd_dev, p, GT_TRUE) != GT_OK) ||
(gpcsSetForcedFC(qd_dev, p, GT_TRUE) != GT_OK)) {
printk(KERN_ERR "Force Flow Control - Failed\n");
return -1;
}
if ((gpcsSetLinkValue(qd_dev, p, GT_TRUE) != GT_OK) ||
(gpcsSetForcedLink(qd_dev, p, GT_TRUE) != GT_OK)) {
printk(KERN_ERR "Force Link UP - Failed\n");
return -1;
}
continue;
}
printk(KERN_ERR " o Disable disconnected Switch Port #%d and force link down\n", p);
if (gstpSetPortState(qd_dev, p, GT_PORT_DISABLE) != GT_OK) {
printk(KERN_ERR "gstpSetPortState failed\n");
return -1;
}
if ((gpcsSetLinkValue(qd_dev, p, GT_FALSE) != GT_OK) ||
(gpcsSetForcedLink(qd_dev, p, GT_TRUE) != GT_OK)) {
printk(KERN_ERR "Force Link DOWN - Failed\n");
return -1;
}
}
return 0;
}