1 /****************************************************************************** 2 * rtl871x_io.c 3 * 4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved. 5 * Linux device driver for RTL8192SU 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of version 2 of the GNU General Public License as 9 * published by the Free Software Foundation. 10 * 11 * This program is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 14 * more details. 15 * 16 * You should have received a copy of the GNU General Public License along with 17 * this program; if not, write to the Free Software Foundation, Inc., 18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 19 * 20 * Modifications for inclusion into the Linux staging tree are 21 * Copyright(c) 2010 Larry Finger. All rights reserved. 22 * 23 * Contact information: 24 * WLAN FAE <wlanfae@realtek.com> 25 * Larry Finger <Larry.Finger@lwfinger.net> 26 * 27 ******************************************************************************/ 28 /* 29 * 30 * The purpose of rtl871x_io.c 31 * 32 * a. provides the API 33 * b. provides the protocol engine 34 * c. provides the software interface between caller and the hardware interface 35 * 36 * For r8712u, both sync/async operations are provided. 37 * 38 * Only sync read/write_mem operations are provided. 39 * 40 */ 41 42 #define _RTL871X_IO_C_ 43 44 #include "osdep_service.h" 45 #include "drv_types.h" 46 #include "rtl871x_io.h" 47 #include "osdep_intf.h" 48 #include "usb_ops.h" 49 50 static uint _init_intf_hdl(struct _adapter *padapter, 51 struct intf_hdl *pintf_hdl) 52 { 53 struct intf_priv *pintf_priv; 54 void (*set_intf_option)(u32 *poption) = NULL; 55 void (*set_intf_funs)(struct intf_hdl *pintf_hdl); 56 void (*set_intf_ops)(struct _io_ops *pops); 57 uint (*init_intf_priv)(struct intf_priv *pintfpriv); 58 59 set_intf_option = &(r8712_usb_set_intf_option); 60 set_intf_funs = &(r8712_usb_set_intf_funs); 61 set_intf_ops = &r8712_usb_set_intf_ops; 62 init_intf_priv = &r8712_usb_init_intf_priv; 63 pintf_priv = pintf_hdl->pintfpriv = (struct intf_priv *) 64 _malloc(sizeof(struct intf_priv)); 65 if (pintf_priv == NULL) 66 goto _init_intf_hdl_fail; 67 pintf_hdl->adapter = (u8 *)padapter; 68 set_intf_option(&pintf_hdl->intf_option); 69 set_intf_funs(pintf_hdl); 70 set_intf_ops(&pintf_hdl->io_ops); 71 pintf_priv->intf_dev = (u8 *)&(padapter->dvobjpriv); 72 if (init_intf_priv(pintf_priv) == _FAIL) 73 goto _init_intf_hdl_fail; 74 return _SUCCESS; 75 _init_intf_hdl_fail: 76 if (pintf_priv) 77 kfree((u8 *)pintf_priv); 78 return _FAIL; 79 } 80 81 static void _unload_intf_hdl(struct intf_priv *pintfpriv) 82 { 83 void (*unload_intf_priv)(struct intf_priv *pintfpriv); 84 85 unload_intf_priv = &r8712_usb_unload_intf_priv; 86 unload_intf_priv(pintfpriv); 87 if (pintfpriv) 88 kfree((u8 *)pintfpriv); 89 } 90 91 static uint register_intf_hdl(u8 *dev, struct intf_hdl *pintfhdl) 92 { 93 struct _adapter *adapter = (struct _adapter *)dev; 94 95 pintfhdl->intf_option = 0; 96 pintfhdl->adapter = dev; 97 pintfhdl->intf_dev = (u8 *)&(adapter->dvobjpriv); 98 if (_init_intf_hdl(adapter, pintfhdl) == false) 99 goto register_intf_hdl_fail; 100 return _SUCCESS; 101 register_intf_hdl_fail: 102 return false; 103 } 104 105 static void unregister_intf_hdl(struct intf_hdl *pintfhdl) 106 { 107 _unload_intf_hdl(pintfhdl->pintfpriv); 108 memset((u8 *)pintfhdl, 0, sizeof(struct intf_hdl)); 109 } 110 111 uint r8712_alloc_io_queue(struct _adapter *adapter) 112 { 113 u32 i; 114 struct io_queue *pio_queue; 115 struct io_req *pio_req; 116 117 pio_queue = (struct io_queue *)_malloc(sizeof(struct io_queue)); 118 if (pio_queue == NULL) 119 goto alloc_io_queue_fail; 120 _init_listhead(&pio_queue->free_ioreqs); 121 _init_listhead(&pio_queue->processing); 122 _init_listhead(&pio_queue->pending); 123 spin_lock_init(&pio_queue->lock); 124 pio_queue->pallocated_free_ioreqs_buf = (u8 *)_malloc(NUM_IOREQ * 125 (sizeof(struct io_req)) + 4); 126 if ((pio_queue->pallocated_free_ioreqs_buf) == NULL) 127 goto alloc_io_queue_fail; 128 memset(pio_queue->pallocated_free_ioreqs_buf, 0, 129 (NUM_IOREQ * (sizeof(struct io_req)) + 4)); 130 pio_queue->free_ioreqs_buf = pio_queue->pallocated_free_ioreqs_buf + 4 131 - ((addr_t)(pio_queue->pallocated_free_ioreqs_buf) 132 & 3); 133 pio_req = (struct io_req *)(pio_queue->free_ioreqs_buf); 134 for (i = 0; i < NUM_IOREQ; i++) { 135 _init_listhead(&pio_req->list); 136 sema_init(&pio_req->sema, 0); 137 list_insert_tail(&pio_req->list, &pio_queue->free_ioreqs); 138 pio_req++; 139 } 140 if ((register_intf_hdl((u8 *)adapter, &(pio_queue->intf))) == _FAIL) 141 goto alloc_io_queue_fail; 142 adapter->pio_queue = pio_queue; 143 return _SUCCESS; 144 alloc_io_queue_fail: 145 if (pio_queue) { 146 kfree(pio_queue->pallocated_free_ioreqs_buf); 147 kfree((u8 *)pio_queue); 148 } 149 adapter->pio_queue = NULL; 150 return _FAIL; 151 } 152 153 void r8712_free_io_queue(struct _adapter *adapter) 154 { 155 struct io_queue *pio_queue = (struct io_queue *)(adapter->pio_queue); 156 157 if (pio_queue) { 158 kfree(pio_queue->pallocated_free_ioreqs_buf); 159 adapter->pio_queue = NULL; 160 unregister_intf_hdl(&pio_queue->intf); 161 kfree((u8 *)pio_queue); 162 } 163 } 164