drivers/staging/r8188eu/os_dep/osdep_service.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright(c) 2007 - 2012 Realtek Corporation. */
   3
   4 #define _OSDEP_SERVICE_C_
   5
   6 #include "../include/osdep_service.h"
   7 #include "../include/drv_types.h"
   8 #include "../include/recv_osdep.h"
   9 #include "../include/linux/vmalloc.h"
  10 #include "../include/rtw_ioctl_set.h"
  11
  12 /*
  13 * Translate the OS dependent @param error_code to OS independent RTW_STATUS_CODE
  14 * @return: one of RTW_STATUS_CODE
  15 */
  16 inline int RTW_STATUS_CODE(int error_code)
  17 {
  18         if (error_code >= 0)
  19                 return _SUCCESS;
  20         return _FAIL;
  21 }
  22
  23 u32 rtw_atoi(u8 *s)
  24 {
  25         int num = 0, flag = 0;
  26         int i;
  27         for (i = 0; i <= strlen(s); i++) {
  28                 if (s[i] >= '0' && s[i] <= '9')
  29                         num = num * 10 + s[i] - '0';
  30                 else if (s[0] == '-' && i == 0)
  31                         flag = 1;
  32                 else
  33                         break;
  34         }
  35         if (flag == 1)
  36                 num = num * -1;
  37          return num;
  38 }
  39
  40 inline u8 *_rtw_vmalloc(u32 sz)
  41 {
  42         u8      *pbuf;
  43         pbuf = vmalloc(sz);
  44         return pbuf;
  45 }
  46
  47 inline u8 *_rtw_zvmalloc(u32 sz)
  48 {
  49         u8      *pbuf;
  50         pbuf = _rtw_vmalloc(sz);
  51         if (pbuf)
  52                 memset(pbuf, 0, sz);
  53         return pbuf;
  54 }
  55
  56 void *rtw_malloc2d(int h, int w, int size)
  57 {
  58         int j;
  59
  60         void **a = kzalloc(h * sizeof(void *) + h * w * size, GFP_KERNEL);
  61         if (!a)
  62                 return NULL;
  63
  64         for (j = 0; j < h; j++)
  65                 a[j] = ((char *)(a+h)) + j*w*size;
  66
  67         return a;
  68 }
  69
  70 /*
  71 For the following list_xxx operations,
  72 caller must guarantee the atomic context.
  73 Otherwise, there will be racing condition.
  74 */
  75 /*
  76 Caller must check if the list is empty before calling rtw_list_delete
  77 */
  78
  79 u32 _rtw_down_sema(struct semaphore *sema)
  80 {
  81         if (down_interruptible(sema))
  82                 return _FAIL;
  83         else
  84                 return _SUCCESS;
  85 }
  86
  87 void    _rtw_mutex_init(struct mutex *pmutex)
  88 {
  89         mutex_init(pmutex);
  90 }
  91
  92 void    _rtw_mutex_free(struct mutex *pmutex)
  93 {
  94         mutex_destroy(pmutex);
  95 }
  96
  97 void    _rtw_init_queue(struct __queue *pqueue)
  98 {
  99         INIT_LIST_HEAD(&(pqueue->queue));
 100         spin_lock_init(&(pqueue->lock));
 101 }
 102
 103 inline u32 rtw_systime_to_ms(u32 systime)
 104 {
 105         return systime * 1000 / HZ;
 106 }
 107
 108 inline u32 rtw_ms_to_systime(u32 ms)
 109 {
 110         return ms * HZ / 1000;
 111 }
 112
 113 /*  the input parameter start use the same unit as jiffies */
 114 inline s32 rtw_get_passing_time_ms(u32 start)
 115 {
 116         return rtw_systime_to_ms(jiffies-start);
 117 }
 118
 119 inline s32 rtw_get_time_interval_ms(u32 start, u32 end)
 120 {
 121         return rtw_systime_to_ms(end-start);
 122 }
 123
 124 void rtw_sleep_schedulable(int ms)
 125 {
 126         u32 delta;
 127
 128         delta = (ms * HZ)/1000;/* ms) */
 129         if (delta == 0)
 130                 delta = 1;/*  1 ms */
 131         set_current_state(TASK_INTERRUPTIBLE);
 132         if (schedule_timeout(delta) != 0)
 133                 return;
 134 }
 135
 136 void rtw_msleep_os(int ms)
 137 {
 138         msleep((unsigned int)ms);
 139 }
 140
 141 void rtw_usleep_os(int us)
 142 {
 143         if (1 < (us/1000))
 144                 msleep(1);
 145         else
 146                 msleep((us/1000) + 1);
 147 }
 148
 149 void rtw_mdelay_os(int ms)
 150 {
 151         mdelay((unsigned long)ms);
 152 }
 153
 154 void rtw_udelay_os(int us)
 155 {
 156         udelay((unsigned long)us);
 157 }
 158
 159 void rtw_yield_os(void)
 160 {
 161         yield();
 162 }
 163
 164 #define RTW_SUSPEND_LOCK_NAME "rtw_wifi"
 165
 166 static const struct device_type wlan_type = {
 167         .name = "wlan",
 168 };
 169
 170 struct net_device *rtw_alloc_etherdev_with_old_priv(int sizeof_priv,
 171                                                     void *old_priv)
 172 {
 173         struct net_device *pnetdev;
 174         struct rtw_netdev_priv_indicator *pnpi;
 175
 176         pnetdev = alloc_etherdev_mq(sizeof(struct rtw_netdev_priv_indicator), 4);
 177         if (!pnetdev)
 178                 goto RETURN;
 179
 180         pnetdev->dev.type = &wlan_type;
 181         pnpi = netdev_priv(pnetdev);
 182         pnpi->priv = old_priv;
 183         pnpi->sizeof_priv = sizeof_priv;
 184
 185 RETURN:
 186         return pnetdev;
 187 }
 188
 189 struct net_device *rtw_alloc_etherdev(int sizeof_priv)
 190 {
 191         struct net_device *pnetdev;
 192         struct rtw_netdev_priv_indicator *pnpi;
 193
 194         pnetdev = alloc_etherdev_mq(sizeof(struct rtw_netdev_priv_indicator), 4);
 195         if (!pnetdev)
 196                 goto RETURN;
 197
 198         pnpi = netdev_priv(pnetdev);
 199
 200         pnpi->priv = rtw_zvmalloc(sizeof_priv);
 201         if (!pnpi->priv) {
 202                 free_netdev(pnetdev);
 203                 pnetdev = NULL;
 204                 goto RETURN;
 205         }
 206
 207         pnpi->sizeof_priv = sizeof_priv;
 208 RETURN:
 209         return pnetdev;
 210 }
 211
 212 void rtw_free_netdev(struct net_device *netdev)
 213 {
 214         struct rtw_netdev_priv_indicator *pnpi;
 215
 216         if (!netdev)
 217                 goto RETURN;
 218
 219         pnpi = netdev_priv(netdev);
 220
 221         if (!pnpi->priv)
 222                 goto RETURN;
 223
 224         vfree(pnpi->priv);
 225         free_netdev(netdev);
 226
 227 RETURN:
 228         return;
 229 }
 230
 231 int rtw_change_ifname(struct adapter *padapter, const char *ifname)
 232 {
 233         struct net_device *pnetdev;
 234         struct net_device *cur_pnetdev;
 235         struct rereg_nd_name_data *rereg_priv;
 236         int ret;
 237
 238         if (!padapter)
 239                 goto error;
 240
 241         cur_pnetdev = padapter->pnetdev;
 242         rereg_priv = &padapter->rereg_nd_name_priv;
 243
 244         /* free the old_pnetdev */
 245         if (rereg_priv->old_pnetdev) {
 246                 free_netdev(rereg_priv->old_pnetdev);
 247                 rereg_priv->old_pnetdev = NULL;
 248         }
 249
 250         if (!rtnl_is_locked())
 251                 unregister_netdev(cur_pnetdev);
 252         else
 253                 unregister_netdevice(cur_pnetdev);
 254
 255         rtw_proc_remove_one(cur_pnetdev);
 256
 257         rereg_priv->old_pnetdev = cur_pnetdev;
 258
 259         pnetdev = rtw_init_netdev(padapter);
 260         if (!pnetdev)  {
 261                 ret = -1;
 262                 goto error;
 263         }
 264
 265         SET_NETDEV_DEV(pnetdev, dvobj_to_dev(adapter_to_dvobj(padapter)));
 266
 267         rtw_init_netdev_name(pnetdev, ifname);
 268
 269         memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
 270
 271         if (!rtnl_is_locked())
 272                 ret = register_netdev(pnetdev);
 273         else
 274                 ret = register_netdevice(pnetdev);
 275         if (ret != 0) {
 276                 RT_TRACE(_module_hci_intfs_c_, _drv_err_,
 277                          ("register_netdev() failed\n"));
 278                 goto error;
 279         }
 280         rtw_proc_init_one(pnetdev);
 281         return 0;
 282 error:
 283         return -1;
 284 }
 285
 286 void rtw_buf_update(u8 **buf, u32 *buf_len, u8 *src, u32 src_len)
 287 {
 288         u32 dup_len = 0;
 289         u8 *ori = NULL;
 290         u8 *dup = NULL;
 291
 292         if (!buf || !buf_len)
 293                 return;
 294
 295         if (!src || !src_len)
 296                 goto keep_ori;
 297
 298         /* duplicate src */
 299         dup = kmalloc(src_len, GFP_ATOMIC);
 300         if (dup) {
 301                 dup_len = src_len;
 302                 memcpy(dup, src, dup_len);
 303         }
 304
 305 keep_ori:
 306         ori = *buf;
 307
 308         /* replace buf with dup */
 309         *buf_len = 0;
 310         *buf = dup;
 311         *buf_len = dup_len;
 312
 313         /* free ori */
 314         kfree(ori);
 315 }
 316
 317 /**
 318  * rtw_cbuf_full - test if cbuf is full
 319  * @cbuf: pointer of struct rtw_cbuf
 320  *
 321  * Returns: true if cbuf is full
 322  */
 323 inline bool rtw_cbuf_full(struct rtw_cbuf *cbuf)
 324 {
 325         return (cbuf->write == cbuf->read-1) ? true : false;
 326 }
 327
 328 /**
 329  * rtw_cbuf_empty - test if cbuf is empty
 330  * @cbuf: pointer of struct rtw_cbuf
 331  *
 332  * Returns: true if cbuf is empty
 333  */
 334 inline bool rtw_cbuf_empty(struct rtw_cbuf *cbuf)
 335 {
 336         return (cbuf->write == cbuf->read) ? true : false;
 337 }
 338
 339 /**
 340  * rtw_cbuf_push - push a pointer into cbuf
 341  * @cbuf: pointer of struct rtw_cbuf
 342  * @buf: pointer to push in
 343  *
 344  * Lock free operation, be careful of the use scheme
 345  * Returns: true push success
 346  */
 347 bool rtw_cbuf_push(struct rtw_cbuf *cbuf, void *buf)
 348 {
 349         if (rtw_cbuf_full(cbuf))
 350                 return _FAIL;
 351
 352         if (0)
 353                 DBG_88E("%s on %u\n", __func__, cbuf->write);
 354         cbuf->bufs[cbuf->write] = buf;
 355         cbuf->write = (cbuf->write+1)%cbuf->size;
 356
 357         return _SUCCESS;
 358 }
 359
 360 /**
 361  * rtw_cbuf_pop - pop a pointer from cbuf
 362  * @cbuf: pointer of struct rtw_cbuf
 363  *
 364  * Lock free operation, be careful of the use scheme
 365  * Returns: pointer popped out
 366  */
 367 void *rtw_cbuf_pop(struct rtw_cbuf *cbuf)
 368 {
 369         void *buf;
 370         if (rtw_cbuf_empty(cbuf))
 371                 return NULL;
 372
 373         if (0)
 374                 DBG_88E("%s on %u\n", __func__, cbuf->read);
 375         buf = cbuf->bufs[cbuf->read];
 376         cbuf->read = (cbuf->read+1)%cbuf->size;
 377
 378         return buf;
 379 }
 380
 381 /**
 382  * rtw_cbuf_alloc - allocate a rtw_cbuf with given size and do initialization
 383  * @size: size of pointer
 384  *
 385  * Returns: pointer of srtuct rtw_cbuf, NULL for allocation failure
 386  */
 387 struct rtw_cbuf *rtw_cbuf_alloc(u32 size)
 388 {
 389         struct rtw_cbuf *cbuf;
 390
 391         cbuf = kmalloc(sizeof(*cbuf) + sizeof(void *)*size, GFP_KERNEL);
 392
 393         if (cbuf) {
 394                 cbuf->write = 0;
 395                 cbuf->read = 0;
 396                 cbuf->size = size;
 397         }
 398         return cbuf;
 399 }