1/****************************************************************************** 2 * 3 * Copyright(c) 2003 - 2010 Intel Corporation. All rights reserved. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of version 2 of the GNU General Public License as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 * You should have received a copy of the GNU General Public License along with 15 * this program; if not, write to the Free Software Foundation, Inc., 16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA 17 * 18 * The full GNU General Public License is included in this distribution in the 19 * file called LICENSE. 20 * 21 * Contact Information: 22 * Intel Linux Wireless <ilw@linux.intel.com> 23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497 24 * 25 *****************************************************************************/ 26 27 28#include <linux/kernel.h> 29#include <linux/module.h> 30#include <linux/init.h> 31#include <linux/pci.h> 32#include <linux/dma-mapping.h> 33#include <linux/delay.h> 34#include <linux/skbuff.h> 35#include <linux/netdevice.h> 36#include <linux/wireless.h> 37#include <net/mac80211.h> 38#include <linux/etherdevice.h> 39#include <asm/unaligned.h> 40 41#include "iwl-dev.h" 42#include "iwl-core.h" 43#include "iwl-io.h" 44 45/* default: IWL_LED_BLINK(0) using blinking index table */ 46static int led_mode; 47module_param(led_mode, int, S_IRUGO); 48MODULE_PARM_DESC(led_mode, "led mode: 0=blinking, 1=On(RF On)/Off(RF Off), " 49 "(default 0)"); 50 51 52static const struct { 53 u16 tpt; /* Mb/s */ 54 u8 on_time; 55 u8 off_time; 56} blink_tbl[] = 57{ 58 {300, 25, 25}, 59 {200, 40, 40}, 60 {100, 55, 55}, 61 {70, 65, 65}, 62 {50, 75, 75}, 63 {20, 85, 85}, 64 {10, 95, 95}, 65 {5, 110, 110}, 66 {1, 130, 130}, 67 {0, 167, 167}, 68 /* SOLID_ON */ 69 {-1, IWL_LED_SOLID, 0} 70}; 71 72#define IWL_1MB_RATE (128 * 1024) 73#define IWL_LED_THRESHOLD (16) 74#define IWL_MAX_BLINK_TBL (ARRAY_SIZE(blink_tbl) - 1) /* exclude SOLID_ON */ 75#define IWL_SOLID_BLINK_IDX (ARRAY_SIZE(blink_tbl) - 1) 76 77/* 78 * Adjust led blink rate to compensate on a MAC Clock difference on every HW 79 * Led blink rate analysis showed an average deviation of 0% on 3945, 80 * 5% on 4965 HW and 20% on 5000 series and up. 81 * Need to compensate on the led on/off time per HW according to the deviation 82 * to achieve the desired led frequency 83 * The calculation is: (100-averageDeviation)/100 * blinkTime 84 * For code efficiency the calculation will be: 85 * compensation = (100 - averageDeviation) * 64 / 100 86 * NewBlinkTime = (compensation * BlinkTime) / 64 87 */ 88static inline u8 iwl_blink_compensation(struct iwl_priv *priv, 89 u8 time, u16 compensation) 90{ 91 if (!compensation) { 92 IWL_ERR(priv, "undefined blink compensation: " 93 "use pre-defined blinking time\n"); 94 return time; 95 } 96 97 return (u8)((time * compensation) >> 6); 98} 99 100/* Set led pattern command */ 101static int iwl_led_pattern(struct iwl_priv *priv, unsigned int idx) 102{ 103 struct iwl_led_cmd led_cmd = { 104 .id = IWL_LED_LINK, 105 .interval = IWL_DEF_LED_INTRVL 106 }; 107 108 BUG_ON(idx > IWL_MAX_BLINK_TBL); 109 110 IWL_DEBUG_LED(priv, "Led blink time compensation= %u\n", 111 priv->cfg->led_compensation); 112 led_cmd.on = 113 iwl_blink_compensation(priv, blink_tbl[idx].on_time, 114 priv->cfg->led_compensation); 115 led_cmd.off = 116 iwl_blink_compensation(priv, blink_tbl[idx].off_time, 117 priv->cfg->led_compensation); 118 119 return priv->cfg->ops->led->cmd(priv, &led_cmd); 120} 121 122int iwl_led_start(struct iwl_priv *priv) 123{ 124 return priv->cfg->ops->led->on(priv); 125} 126EXPORT_SYMBOL(iwl_led_start); 127 128int iwl_led_associate(struct iwl_priv *priv) 129{ 130 IWL_DEBUG_LED(priv, "Associated\n"); 131 if (led_mode == IWL_LED_BLINK) 132 priv->allow_blinking = 1; 133 priv->last_blink_time = jiffies; 134 135 return 0; 136} 137 138int iwl_led_disassociate(struct iwl_priv *priv) 139{ 140 priv->allow_blinking = 0; 141 142 return 0; 143} 144 145/* 146 * calculate blink rate according to last second Tx/Rx activities 147 */ 148static int iwl_get_blink_rate(struct iwl_priv *priv) 149{ 150 int i; 151 /* count both tx and rx traffic to be able to 152 * handle traffic in either direction 153 */ 154 u64 current_tpt = priv->tx_stats.data_bytes + 155 priv->rx_stats.data_bytes; 156 s64 tpt = current_tpt - priv->led_tpt; 157 158 if (tpt < 0) /* wraparound */ 159 tpt = -tpt; 160 161 IWL_DEBUG_LED(priv, "tpt %lld current_tpt %llu\n", 162 (long long)tpt, 163 (unsigned long long)current_tpt); 164 priv->led_tpt = current_tpt; 165 166 if (!priv->allow_blinking) 167 i = IWL_MAX_BLINK_TBL; 168 else 169 for (i = 0; i < IWL_MAX_BLINK_TBL; i++) 170 if (tpt > (blink_tbl[i].tpt * IWL_1MB_RATE)) 171 break; 172 173 IWL_DEBUG_LED(priv, "LED BLINK IDX=%d\n", i); 174 return i; 175} 176 177/* 178 * this function called from handler. Since setting Led command can 179 * happen very frequent we postpone led command to be called from 180 * REPLY handler so we know ucode is up 181 */ 182void iwl_leds_background(struct iwl_priv *priv) 183{ 184 u8 blink_idx; 185 186 if (test_bit(STATUS_EXIT_PENDING, &priv->status)) { 187 priv->last_blink_time = 0; 188 return; 189 } 190 if (iwl_is_rfkill(priv)) { 191 priv->last_blink_time = 0; 192 return; 193 } 194 195 if (!priv->allow_blinking) { 196 priv->last_blink_time = 0; 197 if (priv->last_blink_rate != IWL_SOLID_BLINK_IDX) { 198 priv->last_blink_rate = IWL_SOLID_BLINK_IDX; 199 iwl_led_pattern(priv, IWL_SOLID_BLINK_IDX); 200 } 201 return; 202 } 203 if (!priv->last_blink_time || 204 !time_after(jiffies, priv->last_blink_time + 205 msecs_to_jiffies(1000))) 206 return; 207 208 blink_idx = iwl_get_blink_rate(priv); 209 210 /* call only if blink rate change */ 211 if (blink_idx != priv->last_blink_rate) 212 iwl_led_pattern(priv, blink_idx); 213 214 priv->last_blink_time = jiffies; 215 priv->last_blink_rate = blink_idx; 216} 217EXPORT_SYMBOL(iwl_leds_background); 218 219void iwl_leds_init(struct iwl_priv *priv) 220{ 221 priv->last_blink_rate = 0; 222 priv->last_blink_time = 0; 223 priv->allow_blinking = 0; 224} 225EXPORT_SYMBOL(iwl_leds_init); 226