Attachment #169497 for bug #206581

View | Details | Raw Unified | Return to bug 206581
Collapse All | Expand All





    ifmr->ifm_active |= sc->media;

    if (sc->link_vars.duplex == DUPLEX_FULL) {
        ifmr->ifm_active |= IFM_FDX;
    } else {
        ifmr->ifm_active |= IFM_HDX;
    }
}

static int
bxe_ioctl_nvram(struct bxe_softc *sc,
                uint32_t         priv_op,
                struct ifreq     *ifr)
{
    struct bxe_nvram_data nvdata_base;
    struct bxe_nvram_data *nvdata;
    int len;
    int error = 0;

    if ((error = copyin(ifr->ifr_data, &nvdata_base, sizeof(nvdata_base))) != 0
        return error;

    len = (sizeof(struct bxe_nvram_data) +
           nvdata_base.len -
           sizeof(uint32_t));

    if (len > sizeof(struct bxe_nvram_data)) {
        if ((nvdata = (struct bxe_nvram_data *)
                 malloc(len, M_DEVBUF,
                        (M_NOWAIT | M_ZERO))) == NULL) {
            BLOGE(sc, "BXE_IOC_RD_NVRAM malloc failed priv_op 0x%x "
                " len = 0x%x\n", priv_op, len);
            return (1);
        }
        memcpy(nvdata, &nvdata_base, sizeof(struct bxe_nvram_data));
    } else {
        nvdata = &nvdata_base;
    }

    if (priv_op == BXE_IOC_RD_NVRAM) {
        BLOGD(sc, DBG_IOCTL, "IOC_RD_NVRAM 0x%x %d\n",
              nvdata->offset, nvdata->len);
        if ((error = bxe_nvram_read(sc,
                               nvdata->offset,
                               (uint8_t *)nvdata->value,
                               nvdata->len)) != 0) {
            goto bxe_ioctl_nvram_exit;
        }
        error = copyout(nvdata, ifr->ifr_data, len);
    } else { /* BXE_IOC_WR_NVRAM */
        BLOGD(sc, DBG_IOCTL, "IOC_WR_NVRAM 0x%x %d\n",
              nvdata->offset, nvdata->len);
        if ((error = copyin(ifr->ifr_data, nvdata, len)) != 0) {
            goto bxe_ioctl_nvram_exit;
        }
        error = bxe_nvram_write(sc,
                                nvdata->offset,
                                (uint8_t *)nvdata->value,
                                nvdata->len);
    }

    bxe_ioctl_nvram_exit:
    if (len > sizeof(struct bxe_nvram_data)) {
        free(nvdata, M_DEVBUF);
    }

    return (error);
}

static int
bxe_ioctl_stats_show(struct bxe_softc *sc,
                     uint32_t         priv_op,
                     struct ifreq     *ifr)
{
    const size_t str_size   = (BXE_NUM_ETH_STATS * STAT_NAME_LEN);
    const size_t stats_size = (BXE_NUM_ETH_STATS * sizeof(uint64_t));
    caddr_t p_tmp;
    uint32_t *offset;
    int i;

    switch (priv_op)
    {

            BLOGE(sc, "Changing VLAN_HWFILTER is not supported!\n");
            error = EINVAL;
        }

        /* XXX not yet...
         * IFCAP_WOL_MAGIC
         */

        break;

    case SIOCSIFMEDIA:
    case SIOCGIFMEDIA:
        /* set/get interface media */
        BLOGD(sc, DBG_IOCTL,
              "Received SIOCSIFMEDIA/SIOCGIFMEDIA ioctl (cmd=%lu)\n",
              (command & 0xff));
        error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
        break;

    case SIOCGPRIVATE_0:
        if ((error = copyin(ifr->ifr_data, &priv_op, sizeof(priv_op))) != 0)
            break;

        switch (priv_op)
        {
        case BXE_IOC_RD_NVRAM:
        case BXE_IOC_WR_NVRAM:
            nvdata = (struct bxe_nvram_data *)ifr->ifr_data;
            BLOGD(sc, DBG_IOCTL,
                  "Received Private NVRAM ioctl addr=0x%x size=%u\n",
                  nvdata->offset, nvdata->len);
            error = bxe_ioctl_nvram(sc, priv_op, ifr);
            break;

        case BXE_IOC_STATS_SHOW_NUM:
        case BXE_IOC_STATS_SHOW_STR:
        case BXE_IOC_STATS_SHOW_CNT:
            BLOGD(sc, DBG_IOCTL, "Received Private Stats ioctl (%d)\n",
                  priv_op);
            error = bxe_ioctl_stats_show(sc, priv_op, ifr);
            break;


Return to bug 206581

Lines 4422-4498 bxe_ifmedia_status(struct ifnet *ifp, struct ifmediareq Link Here

(-)b/bxe.c (-6 / +13 lines)
4422		4422
4423	ifmr->ifm_active \|= sc->media;	4423	ifmr->ifm_active \|= sc->media;
4424		4424
4425	if (sc->link_vars.duplex == DUPLEX_FULL) {	4425	if (sc->link_vars.duplex == DUPLEX_FULL) {
4426	ifmr->ifm_active \|= IFM_FDX;	4426	ifmr->ifm_active \|= IFM_FDX;
4427	} else {	4427	} else {
4428	ifmr->ifm_active \|= IFM_HDX;	4428	ifmr->ifm_active \|= IFM_HDX;
4429	}	4429	}
4430	}	4430	}
4431		4431
4432	static int	4432	static int
4433	bxe_ioctl_nvram(struct bxe_softc *sc,	4433	bxe_ioctl_nvram(struct bxe_softc *sc,
4434	uint32_t priv_op,	4434	uint32_t priv_op,
4435	struct ifreq *ifr)	4435	struct ifreq *ifr)
4436	{	4436	{
4437	struct bxe_nvram_data nvdata_base;	4437	struct bxe_nvram_data nvdata_base;
4438	struct bxe_nvram_data *nvdata;	4438	struct bxe_nvram_data *nvdata;
4439	int len;	4439	int len;
4440	int error = 0;	4440	int error = 0;
4441		4441
4442	copyin(ifr->ifr_data, &nvdata_base, sizeof(nvdata_base));	4442	if ((error = copyin(ifr->ifr_data, &nvdata_base, sizeof(nvdata_base))) != 0
		4443	return error;
4443		4444
4444	len = (sizeof(struct bxe_nvram_data) +	4445	len = (sizeof(struct bxe_nvram_data) +
4445	nvdata_base.len -	4446	nvdata_base.len -
4446	sizeof(uint32_t));	4447	sizeof(uint32_t));
4447		4448
4448	if (len > sizeof(struct bxe_nvram_data)) {	4449	if (len > sizeof(struct bxe_nvram_data)) {
4449	if ((nvdata = (struct bxe_nvram_data *)	4450	if ((nvdata = (struct bxe_nvram_data *)
4450	malloc(len, M_DEVBUF,	4451	malloc(len, M_DEVBUF,
4451	(M_NOWAIT \| M_ZERO))) == NULL) {	4452	(M_NOWAIT \| M_ZERO))) == NULL) {
4452	BLOGE(sc, "BXE_IOC_RD_NVRAM malloc failed priv_op 0x%x "	4453	BLOGE(sc, "BXE_IOC_RD_NVRAM malloc failed priv_op 0x%x "
4453	" len = 0x%x\n", priv_op, len);	4454	" len = 0x%x\n", priv_op, len);
4454	return (1);	4455	return (1);
4455	}	4456	}
4456	memcpy(nvdata, &nvdata_base, sizeof(struct bxe_nvram_data));	4457	memcpy(nvdata, &nvdata_base, sizeof(struct bxe_nvram_data));
4457	} else {	4458	} else {
4458	nvdata = &nvdata_base;	4459	nvdata = &nvdata_base;
4459	}	4460	}
4460		4461
4461	if (priv_op == BXE_IOC_RD_NVRAM) {	4462	if (priv_op == BXE_IOC_RD_NVRAM) {
4462	BLOGD(sc, DBG_IOCTL, "IOC_RD_NVRAM 0x%x %d\n",	4463	BLOGD(sc, DBG_IOCTL, "IOC_RD_NVRAM 0x%x %d\n",
4463	nvdata->offset, nvdata->len);	4464	nvdata->offset, nvdata->len);
4464	error = bxe_nvram_read(sc,	4465	if ((error = bxe_nvram_read(sc,
4465	nvdata->offset,	4466	nvdata->offset,
4466	(uint8_t *)nvdata->value,	4467	(uint8_t *)nvdata->value,
4467	nvdata->len);	4468	nvdata->len)) != 0) {
4468	copyout(nvdata, ifr->ifr_data, len);	4469	goto bxe_ioctl_nvram_exit;
		4470	}
		4471	error = copyout(nvdata, ifr->ifr_data, len);
4469	} else { /* BXE_IOC_WR_NVRAM */	4472	} else { /* BXE_IOC_WR_NVRAM */
4470	BLOGD(sc, DBG_IOCTL, "IOC_WR_NVRAM 0x%x %d\n",	4473	BLOGD(sc, DBG_IOCTL, "IOC_WR_NVRAM 0x%x %d\n",
4471	nvdata->offset, nvdata->len);	4474	nvdata->offset, nvdata->len);
4472	copyin(ifr->ifr_data, nvdata, len);	4475	if ((error = copyin(ifr->ifr_data, nvdata, len)) != 0) {
		4476	goto bxe_ioctl_nvram_exit;
		4477	}
4473	error = bxe_nvram_write(sc,	4478	error = bxe_nvram_write(sc,
4474	nvdata->offset,	4479	nvdata->offset,
4475	(uint8_t *)nvdata->value,	4480	(uint8_t *)nvdata->value,
4476	nvdata->len);	4481	nvdata->len);
4477	}	4482	}
4478		4483
		4484	bxe_ioctl_nvram_exit:
4479	if (len > sizeof(struct bxe_nvram_data)) {	4485	if (len > sizeof(struct bxe_nvram_data)) {
4480	free(nvdata, M_DEVBUF);	4486	free(nvdata, M_DEVBUF);
4481	}	4487	}
4482		4488
4483	return (error);	4489	return (error);
4484	}	4490	}
4485		4491
4486	static int	4492	static int
4487	bxe_ioctl_stats_show(struct bxe_softc *sc,	4493	bxe_ioctl_stats_show(struct bxe_softc *sc,
4488	uint32_t priv_op,	4494	uint32_t priv_op,
4489	struct ifreq *ifr)	4495	struct ifreq *ifr)
4490	{	4496	{
4491	const size_t str_size = (BXE_NUM_ETH_STATS * STAT_NAME_LEN);	4497	const size_t str_size = (BXE_NUM_ETH_STATS * STAT_NAME_LEN);
4492	const size_t stats_size = (BXE_NUM_ETH_STATS * sizeof(uint64_t));	4498	const size_t stats_size = (BXE_NUM_ETH_STATS * sizeof(uint64_t));
4493	caddr_t p_tmp;	4499	caddr_t p_tmp;
4494	uint32_t *offset;	4500	uint32_t *offset;
4495	int i;	4501	int i;
4496		4502
4497	switch (priv_op)	4503	switch (priv_op)
4498	{	4504	{
Lines 4752-4792 bxe_ioctl(if_t ifp, Link Here
4752	BLOGE(sc, "Changing VLAN_HWFILTER is not supported!\n");	4758	BLOGE(sc, "Changing VLAN_HWFILTER is not supported!\n");
4753	error = EINVAL;	4759	error = EINVAL;
4754	}	4760	}
4755		4761
4756	/* XXX not yet...	4762	/* XXX not yet...
4757	* IFCAP_WOL_MAGIC	4763	* IFCAP_WOL_MAGIC
4758	*/	4764	*/
4759		4765
4760	break;	4766	break;
4761		4767
4762	case SIOCSIFMEDIA:	4768	case SIOCSIFMEDIA:
4763	case SIOCGIFMEDIA:	4769	case SIOCGIFMEDIA:
4764	/* set/get interface media */	4770	/* set/get interface media */
4765	BLOGD(sc, DBG_IOCTL,	4771	BLOGD(sc, DBG_IOCTL,
4766	"Received SIOCSIFMEDIA/SIOCGIFMEDIA ioctl (cmd=%lu)\n",	4772	"Received SIOCSIFMEDIA/SIOCGIFMEDIA ioctl (cmd=%lu)\n",
4767	(command & 0xff));	4773	(command & 0xff));
4768	error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);	4774	error = ifmedia_ioctl(ifp, ifr, &sc->ifmedia, command);
4769	break;	4775	break;
4770		4776
4771	case SIOCGPRIVATE_0:	4777	case SIOCGPRIVATE_0:
4772	copyin(ifr->ifr_data, &priv_op, sizeof(priv_op));	4778	if ((error = copyin(ifr->ifr_data, &priv_op, sizeof(priv_op))) != 0)
		4779	break;
4773		4780
4774	switch (priv_op)	4781	switch (priv_op)
4775	{	4782	{
4776	case BXE_IOC_RD_NVRAM:	4783	case BXE_IOC_RD_NVRAM:
4777	case BXE_IOC_WR_NVRAM:	4784	case BXE_IOC_WR_NVRAM:
4778	nvdata = (struct bxe_nvram_data *)ifr->ifr_data;	4785	nvdata = (struct bxe_nvram_data *)ifr->ifr_data;
4779	BLOGD(sc, DBG_IOCTL,	4786	BLOGD(sc, DBG_IOCTL,
4780	"Received Private NVRAM ioctl addr=0x%x size=%u\n",	4787	"Received Private NVRAM ioctl addr=0x%x size=%u\n",
4781	nvdata->offset, nvdata->len);	4788	nvdata->offset, nvdata->len);
4782	error = bxe_ioctl_nvram(sc, priv_op, ifr);	4789	error = bxe_ioctl_nvram(sc, priv_op, ifr);
4783	break;	4790	break;
4784		4791
4785	case BXE_IOC_STATS_SHOW_NUM:	4792	case BXE_IOC_STATS_SHOW_NUM:
4786	case BXE_IOC_STATS_SHOW_STR:	4793	case BXE_IOC_STATS_SHOW_STR:
4787	case BXE_IOC_STATS_SHOW_CNT:	4794	case BXE_IOC_STATS_SHOW_CNT:
4788	BLOGD(sc, DBG_IOCTL, "Received Private Stats ioctl (%d)\n",	4795	BLOGD(sc, DBG_IOCTL, "Received Private Stats ioctl (%d)\n",
4789	priv_op);	4796	priv_op);
4790	error = bxe_ioctl_stats_show(sc, priv_op, ifr);	4797	error = bxe_ioctl_stats_show(sc, priv_op, ifr);
4791	break;	4798	break;
4792		4799