staging: r8188eu: Add files for new driver - part 3 (105981e6) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/staging/rtl8188eu/core/rtw_io.c

0 → 100644

+329 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify it
		* under the terms of version 2 of the GNU General Public License as
		* published by the Free Software Foundation.
		*
		* This program is distributed in the hope that it will be useful, but WITHOUT
		* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
		* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
		* more details.
		*
		* You should have received a copy of the GNU General Public License along with
		* this program; if not, write to the Free Software Foundation, Inc.,
		* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
		*
		*
		******************************************************************************/
		/*

		The purpose of rtw_io.c

		a. provides the API

		b. provides the protocol engine

		c. provides the software interface between caller and the hardware interface


		Compiler Flag Option:

		USB:
		a. USE_ASYNC_IRP: Both sync/async operations are provided.

		Only sync read/rtw_write_mem operations are provided.

		jackson@realtek.com.tw

		*/

		#define _RTW_IO_C_
		#include <osdep_service.h>
		#include <drv_types.h>
		#include <rtw_io.h>
		#include <osdep_intf.h>
		#include <usb_ops.h>

		#define rtw_le16_to_cpu(val) le16_to_cpu(val)
		#define rtw_le32_to_cpu(val) le32_to_cpu(val)
		#define rtw_cpu_to_le16(val) cpu_to_le16(val)
		#define rtw_cpu_to_le32(val) cpu_to_le32(val)


		u8 _rtw_read8(struct adapter *adapter, u32 addr)
		{
		u8 r_val;
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		u8 (_read8)(struct intf_hdl pintfhdl, u32 addr);

		_func_enter_;
		_read8 = pintfhdl->io_ops._read8;
		r_val = _read8(pintfhdl, addr);
		_func_exit_;
		return r_val;
		}

		u16 _rtw_read16(struct adapter *adapter, u32 addr)
		{
		u16 r_val;
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		u16 (_read16)(struct intf_hdl pintfhdl, u32 addr);
		_func_enter_;
		_read16 = pintfhdl->io_ops._read16;

		r_val = _read16(pintfhdl, addr);
		_func_exit_;
		return r_val;
		}

		u32 _rtw_read32(struct adapter *adapter, u32 addr)
		{
		u32 r_val;
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		u32 (_read32)(struct intf_hdl pintfhdl, u32 addr);
		_func_enter_;
		_read32 = pintfhdl->io_ops._read32;

		r_val = _read32(pintfhdl, addr);
		_func_exit_;
		return r_val;
		}

		int _rtw_write8(struct adapter *adapter, u32 addr, u8 val)
		{
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		int (_write8)(struct intf_hdl pintfhdl, u32 addr, u8 val);
		int ret;
		_func_enter_;
		_write8 = pintfhdl->io_ops._write8;

		ret = _write8(pintfhdl, addr, val);
		_func_exit_;

		return RTW_STATUS_CODE(ret);
		}

		int _rtw_write16(struct adapter *adapter, u32 addr, u16 val)
		{
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		int (_write16)(struct intf_hdl pintfhdl, u32 addr, u16 val);
		int ret;
		_func_enter_;
		_write16 = pintfhdl->io_ops._write16;

		ret = _write16(pintfhdl, addr, val);
		_func_exit_;

		return RTW_STATUS_CODE(ret);
		}
		int _rtw_write32(struct adapter *adapter, u32 addr, u32 val)
		{
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		int (_write32)(struct intf_hdl pintfhdl, u32 addr, u32 val);
		int ret;
		_func_enter_;
		_write32 = pintfhdl->io_ops._write32;

		ret = _write32(pintfhdl, addr, val);
		_func_exit_;

		return RTW_STATUS_CODE(ret);
		}

		int _rtw_writeN(struct adapter adapter, u32 addr , u32 length , u8 pdata)
		{
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl pintfhdl = (struct intf_hdl )(&(pio_priv->intf));
		int (_writeN)(struct intf_hdl pintfhdl, u32 addr, u32 length, u8 *pdata);
		int ret;
		_func_enter_;
		_writeN = pintfhdl->io_ops._writeN;

		ret = _writeN(pintfhdl, addr, length, pdata);
		_func_exit_;

		return RTW_STATUS_CODE(ret);
		}
		int _rtw_write8_async(struct adapter *adapter, u32 addr, u8 val)
		{
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		int (_write8_async)(struct intf_hdl pintfhdl, u32 addr, u8 val);
		int ret;
		_func_enter_;
		_write8_async = pintfhdl->io_ops._write8_async;

		ret = _write8_async(pintfhdl, addr, val);
		_func_exit_;

		return RTW_STATUS_CODE(ret);
		}

		int _rtw_write16_async(struct adapter *adapter, u32 addr, u16 val)
		{
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		int (_write16_async)(struct intf_hdl pintfhdl, u32 addr, u16 val);
		int ret;

		_func_enter_;
		_write16_async = pintfhdl->io_ops._write16_async;
		ret = _write16_async(pintfhdl, addr, val);
		_func_exit_;

		return RTW_STATUS_CODE(ret);
		}

		int _rtw_write32_async(struct adapter *adapter, u32 addr, u32 val)
		{
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		int (_write32_async)(struct intf_hdl pintfhdl, u32 addr, u32 val);
		int ret;

		_func_enter_;
		_write32_async = pintfhdl->io_ops._write32_async;
		ret = _write32_async(pintfhdl, addr, val);
		_func_exit_;

		return RTW_STATUS_CODE(ret);
		}

		void _rtw_read_mem(struct adapter adapter, u32 addr, u32 cnt, u8 pmem)
		{
		void (_read_mem)(struct intf_hdl pintfhdl, u32 addr, u32 cnt, u8 *pmem);
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);

		_func_enter_;
		if (adapter->bDriverStopped \|\| adapter->bSurpriseRemoved) {
		RT_TRACE(_module_rtl871x_io_c_, _drv_info_,
		("rtw_read_mem:bDriverStopped(%d) OR bSurpriseRemoved(%d)",
		adapter->bDriverStopped, adapter->bSurpriseRemoved));
		return;
		}
		_read_mem = pintfhdl->io_ops._read_mem;
		_read_mem(pintfhdl, addr, cnt, pmem);
		_func_exit_;
		}

		void _rtw_write_mem(struct adapter adapter, u32 addr, u32 cnt, u8 pmem)
		{
		void (_write_mem)(struct intf_hdl pintfhdl, u32 addr, u32 cnt, u8 *pmem);
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);

		_func_enter_;

		_write_mem = pintfhdl->io_ops._write_mem;

		_write_mem(pintfhdl, addr, cnt, pmem);

		_func_exit_;
		}

		void _rtw_read_port(struct adapter adapter, u32 addr, u32 cnt, u8 pmem)
		{
		u32 (_read_port)(struct intf_hdl pintfhdl, u32 addr, u32 cnt, u8 *pmem);
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);

		_func_enter_;

		if (adapter->bDriverStopped \|\| adapter->bSurpriseRemoved) {
		RT_TRACE(_module_rtl871x_io_c_, _drv_info_,
		("rtw_read_port:bDriverStopped(%d) OR bSurpriseRemoved(%d)",
		adapter->bDriverStopped, adapter->bSurpriseRemoved));
		return;
		}

		_read_port = pintfhdl->io_ops._read_port;

		_read_port(pintfhdl, addr, cnt, pmem);

		_func_exit_;
		}

		void _rtw_read_port_cancel(struct adapter *adapter)
		{
		void (_read_port_cancel)(struct intf_hdl pintfhdl);
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);

		_read_port_cancel = pintfhdl->io_ops._read_port_cancel;

		if (_read_port_cancel)
		_read_port_cancel(pintfhdl);
		}

		u32 _rtw_write_port(struct adapter adapter, u32 addr, u32 cnt, u8 pmem)
		{
		u32 (_write_port)(struct intf_hdl pintfhdl, u32 addr, u32 cnt, u8 *pmem);
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);
		u32 ret = _SUCCESS;

		_func_enter_;

		_write_port = pintfhdl->io_ops._write_port;

		ret = _write_port(pintfhdl, addr, cnt, pmem);

		_func_exit_;

		return ret;
		}

		u32 _rtw_write_port_and_wait(struct adapter adapter, u32 addr, u32 cnt, u8 pmem, int timeout_ms)
		{
		int ret = _SUCCESS;
		struct xmit_buf pxmitbuf = (struct xmit_buf )pmem;
		struct submit_ctx sctx;

		rtw_sctx_init(&sctx, timeout_ms);
		pxmitbuf->sctx = &sctx;

		ret = _rtw_write_port(adapter, addr, cnt, pmem);

		if (ret == _SUCCESS)
		ret = rtw_sctx_wait(&sctx);

		return ret;
		}

		void _rtw_write_port_cancel(struct adapter *adapter)
		{
		void (_write_port_cancel)(struct intf_hdl pintfhdl);
		struct io_priv *pio_priv = &adapter->iopriv;
		struct intf_hdl *pintfhdl = &(pio_priv->intf);

		_write_port_cancel = pintfhdl->io_ops._write_port_cancel;

		if (_write_port_cancel)
		_write_port_cancel(pintfhdl);
		}

		int rtw_init_io_priv(struct adapter padapter, void (set_intf_ops)(struct _io_ops *pops))
		{
		struct io_priv *piopriv = &padapter->iopriv;
		struct intf_hdl *pintf = &piopriv->intf;

		if (set_intf_ops == NULL)
		return _FAIL;

		piopriv->padapter = padapter;
		pintf->padapter = padapter;
		pintf->pintf_dev = adapter_to_dvobj(padapter);

		set_intf_ops(&pintf->io_ops);

		return _SUCCESS;
		}

drivers/staging/rtl8188eu/core/rtw_ioctl_set.c

0 → 100644

+1169 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/rtl8188eu/core/rtw_iol.c

0 → 100644

+209 −0

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify it
		* under the terms of version 2 of the GNU General Public License as
		* published by the Free Software Foundation.
		*
		* This program is distributed in the hope that it will be useful, but WITHOUT
		* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
		* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
		* more details.
		*
		* You should have received a copy of the GNU General Public License along with
		* this program; if not, write to the Free Software Foundation, Inc.,
		* 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
		*
		*
		******************************************************************************/

		#include<rtw_iol.h>

		struct xmit_frame rtw_IOL_accquire_xmit_frame(struct adapter adapter)
		{
		struct xmit_frame *xmit_frame;
		struct xmit_buf *xmitbuf;
		struct pkt_attrib *pattrib;
		struct xmit_priv *pxmitpriv = &(adapter->xmitpriv);

		xmit_frame = rtw_alloc_xmitframe(pxmitpriv);
		if (xmit_frame == NULL) {
		DBG_88E("%s rtw_alloc_xmitframe return null\n", __func__);
		goto exit;
		}

		xmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
		if (xmitbuf == NULL) {
		DBG_88E("%s rtw_alloc_xmitbuf return null\n", __func__);
		rtw_free_xmitframe(pxmitpriv, xmit_frame);
		xmit_frame = NULL;
		goto exit;
		}

		xmit_frame->frame_tag = MGNT_FRAMETAG;
		xmit_frame->pxmitbuf = xmitbuf;
		xmit_frame->buf_addr = xmitbuf->pbuf;
		xmitbuf->priv_data = xmit_frame;

		pattrib = &xmit_frame->attrib;
		update_mgntframe_attrib(adapter, pattrib);
		pattrib->qsel = 0x10;/* Beacon */
		pattrib->subtype = WIFI_BEACON;
		pattrib->pktlen = 0;
		pattrib->last_txcmdsz = 0;
		exit:
		return xmit_frame;
		}

		int rtw_IOL_append_cmds(struct xmit_frame xmit_frame, u8 IOL_cmds, u32 cmd_len)
		{
		struct pkt_attrib *pattrib = &xmit_frame->attrib;
		u16 buf_offset;
		u32 ori_len;

		buf_offset = TXDESC_OFFSET;
		ori_len = buf_offset+pattrib->pktlen;

		/* check if the io_buf can accommodate new cmds */
		if (ori_len + cmd_len + 8 > MAX_XMITBUF_SZ) {
		DBG_88E("%s %u is large than MAX_XMITBUF_SZ:%u, can't accommodate new cmds\n",
		__func__ , ori_len + cmd_len + 8, MAX_XMITBUF_SZ);
		return _FAIL;
		}

		memcpy(xmit_frame->buf_addr + buf_offset + pattrib->pktlen, IOL_cmds, cmd_len);
		pattrib->pktlen += cmd_len;
		pattrib->last_txcmdsz += cmd_len;

		return _SUCCESS;
		}

		bool rtw_IOL_applied(struct adapter *adapter)
		{
		if (1 == adapter->registrypriv.fw_iol)
		return true;

		if ((2 == adapter->registrypriv.fw_iol) && (!adapter_to_dvobj(adapter)->ishighspeed))
		return true;
		return false;
		}

		int rtw_IOL_exec_cmds_sync(struct adapter adapter, struct xmit_frame xmit_frame, u32 max_wating_ms, u32 bndy_cnt)
		{
		return rtw_hal_iol_cmd(adapter, xmit_frame, max_wating_ms, bndy_cnt);
		}

		int rtw_IOL_append_LLT_cmd(struct xmit_frame *xmit_frame, u8 page_boundary)
		{
		return _SUCCESS;
		}

		int _rtw_IOL_append_WB_cmd(struct xmit_frame *xmit_frame, u16 addr, u8 value, u8 mask)
		{
		struct ioreg_cfg cmd = {8, IOREG_CMD_WB_REG, 0x0, 0x0, 0x0};

		cmd.address = cpu_to_le16(addr);
		cmd.data = cpu_to_le32(value);

		if (mask != 0xFF) {
		cmd.length = 12;
		cmd.mask = cpu_to_le32(mask);
		}
		return rtw_IOL_append_cmds(xmit_frame, (u8 *)&cmd, cmd.length);
		}

		int _rtw_IOL_append_WW_cmd(struct xmit_frame *xmit_frame, u16 addr, u16 value, u16 mask)
		{
		struct ioreg_cfg cmd = {8, IOREG_CMD_WW_REG, 0x0, 0x0, 0x0};

		cmd.address = cpu_to_le16(addr);
		cmd.data = cpu_to_le32(value);

		if (mask != 0xFFFF) {
		cmd.length = 12;
		cmd.mask = cpu_to_le32(mask);
		}
		return rtw_IOL_append_cmds(xmit_frame, (u8 *)&cmd, cmd.length);
		}

		int _rtw_IOL_append_WD_cmd(struct xmit_frame *xmit_frame, u16 addr, u32 value, u32 mask)
		{
		struct ioreg_cfg cmd = {8, IOREG_CMD_WD_REG, 0x0, 0x0, 0x0};

		cmd.address = cpu_to_le16(addr);
		cmd.data = cpu_to_le32(value);

		if (mask != 0xFFFFFFFF) {
		cmd.length = 12;
		cmd.mask = cpu_to_le32(mask);
		}
		return rtw_IOL_append_cmds(xmit_frame, (u8 *)&cmd, cmd.length);
		}

		int _rtw_IOL_append_WRF_cmd(struct xmit_frame *xmit_frame, u8 rf_path, u16 addr, u32 value, u32 mask)
		{
		struct ioreg_cfg cmd = {8, IOREG_CMD_W_RF, 0x0, 0x0, 0x0};

		cmd.address = cpu_to_le16((rf_path<<8) \| ((addr) & 0xFF));
		cmd.data = cpu_to_le32(value);

		if (mask != 0x000FFFFF) {
		cmd.length = 12;
		cmd.mask = cpu_to_le32(mask);
		}
		return rtw_IOL_append_cmds(xmit_frame, (u8 *)&cmd, cmd.length);
		}

		int rtw_IOL_append_DELAY_US_cmd(struct xmit_frame *xmit_frame, u16 us)
		{
		struct ioreg_cfg cmd = {4, IOREG_CMD_DELAY_US, 0x0, 0x0, 0x0};
		cmd.address = cpu_to_le16(us);

		return rtw_IOL_append_cmds(xmit_frame, (u8 *)&cmd, 4);
		}

		int rtw_IOL_append_DELAY_MS_cmd(struct xmit_frame *xmit_frame, u16 ms)
		{
		struct ioreg_cfg cmd = {4, IOREG_CMD_DELAY_US, 0x0, 0x0, 0x0};

		cmd.address = cpu_to_le16(ms);
		return rtw_IOL_append_cmds(xmit_frame, (u8 *)&cmd, 4);
		}

		int rtw_IOL_append_END_cmd(struct xmit_frame *xmit_frame)
		{
		struct ioreg_cfg cmd = {4, IOREG_CMD_END, cpu_to_le16(0xFFFF), cpu_to_le32(0xFF), 0x0};

		return rtw_IOL_append_cmds(xmit_frame, (u8 *)&cmd, 4);
		}

		u8 rtw_IOL_cmd_boundary_handle(struct xmit_frame *pxmit_frame)
		{
		u8 is_cmd_bndy = false;
		if (((pxmit_frame->attrib.pktlen+32)%256) + 8 >= 256) {
		rtw_IOL_append_END_cmd(pxmit_frame);
		pxmit_frame->attrib.pktlen = ((((pxmit_frame->attrib.pktlen+32)/256)+1)*256);

		pxmit_frame->attrib.last_txcmdsz = pxmit_frame->attrib.pktlen;
		is_cmd_bndy = true;
		}
		return is_cmd_bndy;
		}

		void rtw_IOL_cmd_buf_dump(struct adapter Adapter, int buf_len, u8 pbuf)
		{
		int i;
		int j = 1;

		pr_info("###### %s ######\n", __func__);
		for (i = 0; i < buf_len; i++) {
		printk("%02x-", *(pbuf+i));

		if (j%32 == 0)
		printk("\n");
		j++;
		}
		printk("\n");
		pr_info("=============ioreg_cmd len=%d===============\n", buf_len);
		}