+13 -8

drivers/bluetooth/hci_usb.h

reviewed

··· 70 70 { 71 71 unsigned long flags; 72 72 spin_lock_irqsave(&q->lock, flags); 73 73 - list_add(&_urb->list, &q->head); _urb->queue = q; 73 73 + /* _urb_unlink needs to know which spinlock to use, thus mb(). */ 74 74 + _urb->queue = q; mb(); list_add(&_urb->list, &q->head); 74 75 spin_unlock_irqrestore(&q->lock, flags); 75 76 } 76 77 ··· 79 78 { 80 79 unsigned long flags; 81 80 spin_lock_irqsave(&q->lock, flags); 82 82 - list_add_tail(&_urb->list, &q->head); _urb->queue = q; 81 81 + /* _urb_unlink needs to know which spinlock to use, thus mb(). */ 82 82 + _urb->queue = q; mb(); list_add_tail(&_urb->list, &q->head); 83 83 spin_unlock_irqrestore(&q->lock, flags); 84 84 } 85 85 86 86 static inline void _urb_unlink(struct _urb *_urb) 87 87 { 88 88 - struct _urb_queue *q = _urb->queue; 88 88 + struct _urb_queue *q; 89 89 unsigned long flags; 90 90 - if (q) { 91 91 - spin_lock_irqsave(&q->lock, flags); 92 92 - list_del(&_urb->list); _urb->queue = NULL; 93 93 - spin_unlock_irqrestore(&q->lock, flags); 94 94 - } 90 90 + 91 91 + mb(); 92 92 + q = _urb->queue; 93 93 + /* If q is NULL, it will die at easy-to-debug NULL pointer dereference. 94 94 + No need to BUG(). */ 95 95 + spin_lock_irqsave(&q->lock, flags); 96 96 + list_del(&_urb->list); _urb->queue = NULL; 97 97 + spin_unlock_irqrestore(&q->lock, flags); 95 98 } 96 99 97 100 struct hci_usb {

+1 -1

drivers/net/8390.c

reviewed

··· 34 34 35 35 void NS8390_init(struct net_device *dev, int startp) 36 36 { 37 37 - return __NS8390_init(dev, startp); 37 37 + __NS8390_init(dev, startp); 38 38 } 39 39 40 40 EXPORT_SYMBOL(ei_open);

+25 -18

drivers/net/bnx2.c

reviewed

··· 56 56 57 57 #define DRV_MODULE_NAME "bnx2" 58 58 #define PFX DRV_MODULE_NAME ": " 59 59 - #define DRV_MODULE_VERSION "1.7.4" 60 60 - #define DRV_MODULE_RELDATE "February 18, 2008" 59 59 + #define DRV_MODULE_VERSION "1.7.5" 60 60 + #define DRV_MODULE_RELDATE "April 29, 2008" 61 61 62 62 #define RUN_AT(x) (jiffies + (x)) 63 63 ··· 1631 1631 static void 1632 1632 bnx2_set_default_link(struct bnx2 *bp) 1633 1633 { 1634 1634 - if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) 1635 1635 - return bnx2_set_default_remote_link(bp); 1634 1634 + if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) { 1635 1635 + bnx2_set_default_remote_link(bp); 1636 1636 + return; 1637 1637 + } 1636 1638 1637 1639 bp->autoneg = AUTONEG_SPEED | AUTONEG_FLOW_CTRL; 1638 1640 bp->req_line_speed = 0; ··· 1717 1715 break; 1718 1716 } 1719 1717 1720 1720 - spin_lock(&bp->phy_lock); 1721 1718 bp->flow_ctrl = 0; 1722 1719 if ((bp->autoneg & (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) != 1723 1720 (AUTONEG_SPEED | AUTONEG_FLOW_CTRL)) { ··· 1738 1737 if (old_port != bp->phy_port) 1739 1738 bnx2_set_default_link(bp); 1740 1739 1741 1741 - spin_unlock(&bp->phy_lock); 1742 1740 } 1743 1741 if (bp->link_up != link_up) 1744 1742 bnx2_report_link(bp); ··· 2222 2222 for (i = 0; i < bp->ctx_pages; i++) { 2223 2223 int j; 2224 2224 2225 2225 + if (bp->ctx_blk[i]) 2226 2226 + memset(bp->ctx_blk[i], 0, BCM_PAGE_SIZE); 2227 2227 + else 2228 2228 + return -ENOMEM; 2229 2229 + 2225 2230 REG_WR(bp, BNX2_CTX_HOST_PAGE_TBL_DATA0, 2226 2231 (bp->ctx_blk_mapping[i] & 0xffffffff) | 2227 2232 BNX2_CTX_HOST_PAGE_TBL_DATA0_VALID); ··· 2450 2445 static void 2451 2446 bnx2_phy_int(struct bnx2 *bp, struct bnx2_napi *bnapi) 2452 2447 { 2453 2453 - if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_LINK_STATE)) { 2454 2454 - spin_lock(&bp->phy_lock); 2448 2448 + spin_lock(&bp->phy_lock); 2449 2449 + 2450 2450 + if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_LINK_STATE)) 2455 2451 bnx2_set_link(bp); 2456 2456 - spin_unlock(&bp->phy_lock); 2457 2457 - } 2458 2452 if (bnx2_phy_event_is_set(bp, bnapi, STATUS_ATTN_BITS_TIMER_ABORT)) 2459 2453 bnx2_set_remote_link(bp); 2454 2454 + 2455 2455 + spin_unlock(&bp->phy_lock); 2460 2456 2461 2457 } 2462 2458 ··· 3180 3174 int i; 3181 3175 u32 val; 3182 3176 3177 3177 + if (rv2p_proc == RV2P_PROC2 && CHIP_NUM(bp) == CHIP_NUM_5709) { 3178 3178 + val = le32_to_cpu(rv2p_code[XI_RV2P_PROC2_MAX_BD_PAGE_LOC]); 3179 3179 + val &= ~XI_RV2P_PROC2_BD_PAGE_SIZE_MSK; 3180 3180 + val |= XI_RV2P_PROC2_BD_PAGE_SIZE; 3181 3181 + rv2p_code[XI_RV2P_PROC2_MAX_BD_PAGE_LOC] = cpu_to_le32(val); 3182 3182 + } 3183 3183 3184 3184 for (i = 0; i < rv2p_code_len; i += 8) { 3185 3185 REG_WR(bp, BNX2_RV2P_INSTR_HIGH, le32_to_cpu(*rv2p_code)); ··· 4227 4215 if (netif_running(bp->dev)) { 4228 4216 u32 sig; 4229 4217 4230 4230 - if (val & BNX2_LINK_STATUS_LINK_UP) { 4231 4231 - bp->link_up = 1; 4232 4232 - netif_carrier_on(bp->dev); 4233 4233 - } else { 4234 4234 - bp->link_up = 0; 4235 4235 - netif_carrier_off(bp->dev); 4236 4236 - } 4237 4218 sig = BNX2_DRV_ACK_CAP_SIGNATURE | 4238 4219 BNX2_FW_CAP_REMOTE_PHY_CAPABLE; 4239 4220 bnx2_shmem_wr(bp, BNX2_DRV_ACK_CAP_MB, sig); ··· 4883 4878 spin_lock_bh(&bp->phy_lock); 4884 4879 bnx2_init_phy(bp); 4885 4880 bnx2_set_link(bp); 4881 4881 + if (bp->phy_flags & BNX2_PHY_FLAG_REMOTE_PHY_CAP) 4882 4882 + bnx2_remote_phy_event(bp); 4886 4883 spin_unlock_bh(&bp->phy_lock); 4887 4884 return 0; 4888 4885 } ··· 4927 4920 { 0x0c08, BNX2_FL_NOT_5709, 0x0f0ff073, 0x00000000 }, 4928 4921 4929 4922 { 0x1000, 0, 0x00000000, 0x00000001 }, 4930 4930 - { 0x1004, 0, 0x00000000, 0x000f0001 }, 4923 4923 + { 0x1004, BNX2_FL_NOT_5709, 0x00000000, 0x000f0001 }, 4931 4924 4932 4925 { 0x1408, 0, 0x01c00800, 0x00000000 }, 4933 4926 { 0x149c, 0, 0x8000ffff, 0x00000000 },

+259 -243

drivers/net/bnx2_fw2.h

reviewed

··· 3173 3173 }; 3174 3174 3175 3175 static u8 bnx2_xi_rv2p_proc1[] = { 3176 3176 - /* Date: 01/14/2008 15:44 */ 3177 3177 - 0xc5, 0x56, 0xcd, 0x6b, 0x13, 0x51, 0x10, 0x9f, 0xdd, 0x7c, 0x6c, 0x9a, 3178 3178 - 0x6c, 0xb2, 0xa1, 0x6a, 0x09, 0x35, 0xd2, 0x58, 0x7a, 0x30, 0x6d, 0xc4, 3179 3179 - 0x56, 0x3d, 0x78, 0x28, 0x54, 0x7a, 0x11, 0xac, 0xa7, 0x1e, 0x44, 0xc4, 3180 3180 - 0xcf, 0x20, 0x05, 0xf5, 0x8f, 0x70, 0x51, 0xab, 0x20, 0x78, 0x28, 0x68, 3181 3181 - 0xb4, 0x7e, 0xa0, 0x27, 0x15, 0xf1, 0x90, 0x1c, 0x04, 0x05, 0x45, 0x50, 3182 3182 - 0xf0, 0xa4, 0x37, 0x41, 0xbd, 0x54, 0xc5, 0x0f, 0xf0, 0xe2, 0x45, 0x8f, 3183 3183 - 0xda, 0xf8, 0xde, 0xcc, 0xef, 0xd9, 0xdd, 0x4d, 0xd2, 0x14, 0x0f, 0x1a, 3184 3184 - 0x68, 0x7f, 0xec, 0xdb, 0xdf, 0x9b, 0x37, 0xf3, 0x9b, 0x79, 0x33, 0x9b, 3185 3185 - 0x27, 0x22, 0x9b, 0xfc, 0xc6, 0x80, 0x42, 0x72, 0xad, 0x58, 0x4a, 0x81, 3186 3186 - 0x45, 0x74, 0xcf, 0x65, 0xf4, 0x37, 0x91, 0xfc, 0x46, 0x04, 0xfc, 0x91, 3187 3187 - 0xbc, 0xfa, 0xff, 0x9d, 0x26, 0x4a, 0x1a, 0x63, 0x34, 0xb1, 0x5e, 0xe3, 3188 3188 - 0x24, 0x3d, 0x29, 0x15, 0x14, 0xfe, 0x6a, 0x92, 0xaf, 0x9f, 0x87, 0xea, 3189 3189 - 0x0f, 0x1a, 0x19, 0xb6, 0xfb, 0x0e, 0xfb, 0xdf, 0xc4, 0x04, 0xb7, 0x55, 3190 3190 - 0x52, 0x62, 0x07, 0x48, 0x1b, 0xf3, 0x0c, 0xaf, 0xe6, 0xf4, 0x73, 0xd1, 3191 3191 - 0xf2, 0x37, 0xe2, 0x7c, 0x5b, 0xd6, 0x17, 0xe6, 0x3c, 0xbd, 0x4e, 0xef, 3192 3192 - 0x27, 0xf5, 0xb3, 0x97, 0x3e, 0xdd, 0x48, 0xb1, 0x5d, 0x79, 0xdf, 0x9b, 3193 3193 - 0x3e, 0xcd, 0xfb, 0x5c, 0x4b, 0xec, 0xa9, 0x3f, 0xde, 0xbf, 0x55, 0xd9, 3194 3194 - 0x81, 0xdf, 0x24, 0x76, 0x0e, 0x96, 0xf4, 0xfa, 0x76, 0xf0, 0xc6, 0xc1, 3195 3195 - 0x2b, 0xb6, 0xf0, 0x16, 0xe6, 0x34, 0x3a, 0x54, 0xad, 0xe8, 0x78, 0x06, 3196 3196 - 0x49, 0xe2, 0x49, 0xd0, 0x4c, 0xca, 0x15, 0x9d, 0x06, 0x84, 0xfd, 0x6e, 3197 3197 - 0x58, 0xef, 0x57, 0xbe, 0x0d, 0x6b, 0xde, 0x82, 0x8a, 0xdb, 0xc4, 0x1b, 3198 3198 - 0xe6, 0x39, 0x15, 0x63, 0x57, 0xf3, 0xde, 0x2a, 0x9e, 0x89, 0x2f, 0x18, 3199 3199 - 0x57, 0x26, 0x10, 0x57, 0x24, 0xde, 0x96, 0xf8, 0x82, 0x7a, 0xa5, 0xda, 3200 3200 - 0xf8, 0xaf, 0xcf, 0x51, 0xbe, 0xf0, 0x39, 0x49, 0xe8, 0x9c, 0x8c, 0xec, 3201 3201 - 0x4b, 0x76, 0x88, 0xfb, 0x93, 0x35, 0xb3, 0x21, 0xec, 0x3f, 0x91, 0xb6, 3202 3202 - 0xf7, 0x54, 0xf9, 0x8d, 0xf5, 0x72, 0x3b, 0x1d, 0x12, 0xd0, 0xe1, 0x31, 3203 3203 - 0xe2, 0x9b, 0xa2, 0x21, 0xbb, 0xc0, 0xef, 0xe3, 0xbc, 0x7f, 0xad, 0xf2, 3204 3204 - 0x47, 0xe3, 0x3a, 0xe0, 0x7a, 0xe0, 0x01, 0xe0, 0x7e, 0xe0, 0x1a, 0xe0, 3205 3205 - 0x6a, 0xe0, 0x2a, 0x60, 0x2f, 0xf0, 0x32, 0x30, 0x0f, 0xf4, 0x80, 0x39, 3206 3206 - 0xe0, 0x05, 0xa0, 0x0b, 0xcc, 0x00, 0x6b, 0xc0, 0xab, 0xc0, 0x14, 0xf0, 3207 3207 - 0x28, 0xf0, 0x21, 0xf0, 0x31, 0xf0, 0x0b, 0xf0, 0x1c, 0xd0, 0xb1, 0x60, 3208 3208 - 0x0f, 0xa8, 0x7e, 0x3e, 0xee, 0x47, 0x48, 0xa7, 0xeb, 0xa8, 0x7f, 0xad, 3209 3209 - 0x33, 0xde, 0x97, 0x0d, 0x0f, 0xf9, 0x65, 0x9d, 0x2e, 0x83, 0xd7, 0x5b, 3210 3210 - 0xbf, 0x19, 0xb9, 0x27, 0xa5, 0xae, 0xf7, 0x23, 0x9a, 0x37, 0x8f, 0xe3, 3211 3211 - 0x39, 0xb4, 0xc3, 0xe3, 0x73, 0x72, 0x49, 0x59, 0x37, 0x6e, 0xed, 0xf1, 3212 3212 - 0x04, 0x8f, 0xa4, 0x05, 0x3f, 0xa7, 0x7b, 0xd4, 0xff, 0x66, 0x73, 0x26, 3213 3213 - 0x23, 0xcf, 0x87, 0xb3, 0x46, 0x67, 0x63, 0xc7, 0xf8, 0xd3, 0xcd, 0x8f, 3214 3214 - 0x4e, 0xe7, 0x19, 0xbf, 0xba, 0x9d, 0x2b, 0x58, 0xb5, 0xc3, 0xf1, 0x5f, 3215 3215 - 0x19, 0x15, 0x8c, 0x8f, 0x31, 0x54, 0xdc, 0x64, 0x5c, 0xe3, 0x56, 0xf7, 3216 3216 - 0xb9, 0x39, 0x47, 0xa3, 0x5b, 0xa8, 0xf1, 0x7d, 0x89, 0x53, 0x2d, 0xa9, 3217 3217 - 0xed, 0xfe, 0x6c, 0x9e, 0x17, 0x5e, 0xff, 0xe1, 0x97, 0x8c, 0x85, 0x2b, 3218 3218 - 0x2f, 0x84, 0xff, 0xba, 0xe4, 0x32, 0xee, 0x1e, 0xa1, 0xc8, 0xcf, 0xbc, 3219 3219 - 0x97, 0xfb, 0xe8, 0xb3, 0xdf, 0x3f, 0x2c, 0xbf, 0x61, 0xce, 0xc1, 0xbe, 3220 3220 - 0xe3, 0x26, 0x8f, 0x79, 0xf6, 0x73, 0x90, 0xe4, 0x79, 0xba, 0x2c, 0xef, 3221 3221 - 0xa7, 0xcb, 0xb8, 0xcf, 0x83, 0xe1, 0x7a, 0x90, 0x7b, 0x11, 0x43, 0xbe, 3222 3222 - 0xf7, 0xe2, 0x5e, 0x44, 0xef, 0x71, 0xaa, 0x7e, 0x73, 0x2e, 0x58, 0x2f, 3223 3223 - 0x05, 0xaa, 0x8e, 0xc1, 0x9f, 0x96, 0x3c, 0x9b, 0xbe, 0x6c, 0xea, 0x9d, 3224 3224 - 0x97, 0xeb, 0x7e, 0x2c, 0xa4, 0xdf, 0x76, 0xaa, 0x04, 0xf3, 0x64, 0xb5, 3225 3225 - 0xa9, 0x97, 0x6e, 0xe7, 0x84, 0xec, 0xe5, 0x54, 0x06, 0xa8, 0xb5, 0x8e, 3226 3226 - 0x1d, 0xc4, 0x35, 0x81, 0x3a, 0x5e, 0xdb, 0x52, 0xc7, 0xa6, 0xdf, 0x4b, 3227 3227 - 0x3d, 0x77, 0xea, 0x5f, 0x7f, 0xdf, 0xa7, 0x85, 0xe7, 0x07, 0xea, 0xd3, 3228 3228 - 0xf4, 0x43, 0xe8, 0xe4, 0x30, 0xaf, 0xb8, 0x70, 0x5f, 0xf2, 0x26, 0xfd, 3229 3229 - 0x5c, 0x15, 0xa3, 0x1f, 0xf6, 0xd3, 0x31, 0xf1, 0x0d, 0x04, 0xfb, 0xe7, 3230 3230 - 0x50, 0x87, 0x7c, 0x05, 0xfb, 0x6e, 0x54, 0x97, 0x70, 0xdd, 0x4b, 0xfe, 3231 3231 - 0xd3, 0xd0, 0xa9, 0xbf, 0x4b, 0x5f, 0xe8, 0x01, 0x6f, 0xcd, 0x32, 0x3c, 3232 3232 - 0xb1, 0x3b, 0x59, 0x0e, 0xf6, 0x11, 0xaf, 0x89, 0xfe, 0x87, 0x7d, 0x7d, 3233 3233 - 0xf5, 0x47, 0x1d, 0xf2, 0x30, 0xfe, 0x7f, 0xf3, 0x80, 0xf9, 0x52, 0xb4, 3234 3234 - 0x24, 0x0f, 0x09, 0x5a, 0x99, 0xbe, 0x84, 0xf8, 0xa9, 0x83, 0xbe, 0x49, 3235 3235 - 0xe8, 0xf0, 0x6d, 0x71, 0x79, 0x7d, 0x33, 0xe0, 0x7d, 0x0d, 0xf0, 0xb8, 3236 3236 - 0x2e, 0xc6, 0xe5, 0xfe, 0x39, 0xd5, 0x2f, 0x11, 0xdd, 0xc6, 0x2a, 0xba, 3237 3237 - 0xaf, 0x9c, 0xa0, 0x06, 0xe2, 0x7a, 0x1b, 0x8a, 0x2f, 0xab, 0xfc, 0x93, 3238 3238 - 0xef, 0x84, 0x3b, 0x0d, 0xa3, 0x83, 0xbc, 0x2e, 0x55, 0x04, 0x6f, 0x33, 3239 3239 - 0x3f, 0x1f, 0xd0, 0x23, 0xac, 0x9b, 0xe8, 0x91, 0xa7, 0x5b, 0x7f, 0xfa, 3240 3240 - 0x8d, 0xc7, 0xf6, 0x46, 0xd1, 0xaf, 0x0f, 0xa1, 0x6f, 0x7e, 0x48, 0x4b, 3241 3241 - 0x5f, 0xae, 0x4e, 0x71, 0xff, 0xa4, 0x3e, 0xf4, 0xcf, 0x6a, 0x56, 0x9e, 3242 3242 - 0xfb, 0xb3, 0xf2, 0x1d, 0x36, 0xea, 0xb8, 0xcc, 0xeb, 0xcf, 0x0a, 0xf6, 3243 3243 - 0x65, 0xf4, 0xbe, 0x02, 0x7d, 0xdc, 0xc5, 0xf4, 0xca, 0xbc, 0x2b, 0x7d, 3244 3244 - 0x74, 0xfe, 0x05, 0xfa, 0xba, 0x67, 0x74, 0x42, 0xbc, 0x5b, 0xf4, 0x7a, 3245 3245 - 0x1f, 0x7f, 0xf2, 0x2c, 0xe9, 0xab, 0x38, 0xc3, 0xe2, 0xdf, 0x0d, 0x78, 3246 3246 - 0x5f, 0x32, 0xfb, 0x06, 0xb4, 0x9e, 0x4f, 0x16, 0xcd, 0xdc, 0x18, 0xdc, 3247 3247 - 0xa1, 0xfd, 0xf1, 0x28, 0xe7, 0x48, 0x3e, 0x05, 0x15, 0xcf, 0x76, 0xf4, 3248 3248 - 0xb6, 0xe2, 0xac, 0x2d, 0xcf, 0xb3, 0x27, 0xd9, 0xcc, 0xae, 0x59, 0xb3, 3249 3249 - 0x3e, 0xc9, 0x05, 0x3a, 0x7d, 0xf7, 0x19, 0xaf, 0xe7, 0x1a, 0x31, 0x59, 3250 3250 - 0x77, 0xa6, 0x8c, 0x1e, 0x1e, 0xc7, 0x57, 0x13, 0x3d, 0xf6, 0x5d, 0x14, 3251 3251 - 0xdc, 0x4b, 0x3b, 0x19, 0xd3, 0x35, 0x57, 0xe6, 0xca, 0xbc, 0x9b, 0x62, 3252 3252 - 0x24, 0xd6, 0xc3, 0xde, 0x2c, 0xf3, 0x21, 0x81, 0xbe, 0xde, 0x13, 0xc8, 3253 3253 - 0x53, 0x74, 0xde, 0xae, 0x34, 0x5f, 0xc1, 0x39, 0x60, 0xe6, 0x43, 0xb4, 3254 3254 - 0xdf, 0x67, 0x51, 0x67, 0xd7, 0xba, 0xd4, 0xa3, 0xe9, 0x9f, 0x97, 0x16, 3255 3255 - 0xe5, 0x1e, 0xb4, 0x9b, 0xb3, 0x1a, 0x73, 0x1d, 0xbe, 0x0f, 0x8a, 0xa8, 3256 3256 - 0x3f, 0x33, 0x0f, 0xdb, 0x7d, 0x07, 0x08, 0x7f, 0x65, 0xf3, 0x3f, 0xdf, 3257 3257 - 0x61, 0xfe, 0xff, 0xb3, 0x39, 0x5f, 0x58, 0xca, 0xa3, 0xa9, 0xd3, 0x60, 3258 3258 - 0x1e, 0x83, 0xf5, 0x1a, 0x9d, 0xc3, 0xcb, 0xcd, 0xdf, 0x1c, 0x74, 0x3e, 3259 3259 - 0x06, 0x9d, 0xe3, 0x94, 0x88, 0xb1, 0x30, 0x6e, 0xfc, 0x14, 0xdb, 0xb5, 3260 3260 - 0x67, 0x6d, 0xa6, 0xbb, 0x89, 0x33, 0x96, 0xc6, 0x9c, 0x7b, 0x46, 0x78, 3261 3261 - 0x71, 0x59, 0x2f, 0x18, 0x3c, 0x7b, 0x4a, 0xbe, 0xfb, 0x6c, 0xfa, 0x0d, 3262 3262 - 0x6d, 0x29, 0x98, 0xe1, 0x30, 0x0d, 0x00, 0x00, 0x00 }; 3176 3176 + /* Date: 04/25/2008 22:02 */ 3177 3177 + 0xbd, 0x56, 0x4f, 0x68, 0x1c, 0x55, 0x18, 0xff, 0x76, 0x76, 0x77, 0x66, 3178 3178 + 0x33, 0x3b, 0xbb, 0xb3, 0xd8, 0x34, 0x4c, 0xb7, 0x2b, 0x59, 0x83, 0x97, 3179 3179 + 0xdd, 0x6c, 0x69, 0xa2, 0x15, 0x04, 0x53, 0x5a, 0x72, 0x09, 0xd8, 0x9e, 3180 3180 + 0x02, 0xb5, 0x52, 0x84, 0xb6, 0x8b, 0xf4, 0x52, 0x5a, 0x28, 0x78, 0x11, 3181 3181 + 0x84, 0x0e, 0x6d, 0x93, 0x82, 0xe8, 0x61, 0xc1, 0x06, 0x12, 0x44, 0xa3, 3182 3182 + 0x07, 0x95, 0x60, 0x61, 0x07, 0x3c, 0x78, 0x10, 0x14, 0x15, 0x11, 0x6c, 3183 3183 + 0x0f, 0x85, 0x88, 0xf6, 0xd2, 0x54, 0x4b, 0x0b, 0x1e, 0x5b, 0x3c, 0xd6, 3184 3184 + 0x8c, 0xef, 0xfb, 0xf3, 0x92, 0x99, 0x97, 0x9d, 0x24, 0xa7, 0x2e, 0xb4, 3185 3185 + 0x3f, 0xbe, 0x37, 0xdf, 0xbf, 0xf7, 0xfd, 0xf9, 0xbd, 0xd4, 0x00, 0xc0, 3186 3186 + 0x82, 0x30, 0x1a, 0x55, 0x08, 0x65, 0x2b, 0x5f, 0x52, 0x90, 0x03, 0xf8, 3187 3187 + 0x1a, 0xf8, 0x57, 0xf4, 0x48, 0x0e, 0x0f, 0x8a, 0x3c, 0xce, 0x10, 0x8e, 3188 3188 + 0xd7, 0xd4, 0xff, 0x17, 0xe0, 0x48, 0x13, 0x31, 0x0f, 0x47, 0x5e, 0x40, 3189 3189 + 0x3c, 0x0c, 0xdf, 0x37, 0x03, 0x85, 0xff, 0xc5, 0x10, 0xa2, 0x3c, 0xdc, 3190 3190 + 0xff, 0x36, 0x2a, 0x93, 0xff, 0x35, 0xb1, 0xff, 0x33, 0xcf, 0xf8, 0x6a, 3191 3191 + 0xa7, 0xc4, 0x7e, 0x04, 0xe1, 0x40, 0x8d, 0x60, 0xb5, 0x87, 0xf2, 0x89, 3192 3192 + 0x13, 0x60, 0xa3, 0x9f, 0x4f, 0x94, 0x02, 0xca, 0x8d, 0x5c, 0x78, 0x40, 3193 3193 + 0xf2, 0xb2, 0x58, 0xef, 0x5e, 0xcf, 0xc7, 0x73, 0xb8, 0x3f, 0x8d, 0xf2, 3194 3194 + 0x3e, 0xf7, 0x5a, 0x0f, 0x31, 0x80, 0x73, 0x25, 0x8f, 0xef, 0x33, 0xca, 3195 3195 + 0x6e, 0xd7, 0xda, 0x68, 0xa7, 0x74, 0xdb, 0xe2, 0xb7, 0x88, 0x7e, 0xff, 3196 3196 + 0x89, 0xd9, 0x2f, 0xfa, 0x4b, 0xfa, 0x69, 0x28, 0x3f, 0x78, 0x6e, 0x4b, 3197 3197 + 0x5e, 0xb6, 0x91, 0x97, 0xad, 0xf2, 0x90, 0x3a, 0x80, 0xce, 0x03, 0x71, 3198 3198 + 0xaf, 0x8a, 0x8b, 0x7e, 0x1f, 0xcb, 0xbd, 0x01, 0x4e, 0x37, 0xc5, 0x7f, 3199 3199 + 0x84, 0xe8, 0xe5, 0xd8, 0x9f, 0xfa, 0x27, 0xf7, 0xd8, 0xea, 0x47, 0xd7, 3200 3200 + 0x29, 0x9d, 0xbf, 0xd3, 0xd1, 0xdf, 0x75, 0x3f, 0x30, 0xce, 0x1d, 0x15, 3201 3201 + 0x27, 0xa9, 0x0f, 0x3b, 0xe8, 0xff, 0xa6, 0xf4, 0xd3, 0x7e, 0xf9, 0xfc, 3202 3202 + 0xd7, 0xcd, 0xf3, 0xd6, 0xa0, 0xba, 0x15, 0x8d, 0xba, 0xfd, 0x28, 0x75, 3203 3203 + 0x9b, 0x81, 0x17, 0xad, 0x80, 0xf4, 0x0a, 0x80, 0xb8, 0x5f, 0x25, 0x80, 3204 3204 + 0xf8, 0xbc, 0xe0, 0x45, 0xc1, 0xcf, 0x04, 0x97, 0x05, 0xf7, 0x0a, 0x0e, 3205 3205 + 0x0b, 0xee, 0x11, 0x7c, 0x4e, 0xf0, 0x6f, 0xc1, 0x9a, 0xa0, 0x2f, 0x58, 3206 3206 + 0x15, 0xbc, 0x27, 0xe8, 0x09, 0x96, 0x0d, 0x7f, 0x75, 0xc1, 0x92, 0x60, 3207 3207 + 0x24, 0xf8, 0x9a, 0x61, 0xef, 0xe6, 0x18, 0x57, 0x45, 0x3e, 0x28, 0xf2, 3208 3208 + 0x49, 0x91, 0xb1, 0xa0, 0x32, 0xf7, 0xa9, 0x7a, 0x7d, 0xbe, 0xd1, 0xdf, 3209 3209 + 0xd5, 0x9e, 0x7c, 0x6f, 0x69, 0xbd, 0x12, 0xd5, 0x0f, 0xda, 0x49, 0xfd, 3210 3210 + 0x8f, 0xb7, 0xd1, 0x67, 0xb5, 0xe9, 0xd6, 0x20, 0xbb, 0x1b, 0x31, 0xe7, 3211 3211 + 0xf1, 0x91, 0xd8, 0x07, 0xfd, 0xef, 0x32, 0xf6, 0x68, 0xaa, 0x63, 0xce, 3212 3212 + 0xd7, 0xa0, 0x3d, 0x7a, 0x45, 0xf6, 0xe8, 0xd0, 0x96, 0xf9, 0xe5, 0x39, 3213 3213 + 0x3d, 0x2a, 0xf6, 0x53, 0x32, 0x9f, 0x8d, 0x0c, 0xbd, 0x30, 0xb1, 0xaf, 3214 3214 + 0x14, 0x2f, 0x63, 0x1f, 0x6e, 0xe6, 0xba, 0x1d, 0x8c, 0x5b, 0x94, 0xb8, 3215 3215 + 0x59, 0xf9, 0xa1, 0xbd, 0xcc, 0x6f, 0x4b, 0xcf, 0x71, 0x7a, 0x7e, 0x79, 3216 3216 + 0x0e, 0x6d, 0x63, 0x0e, 0x2f, 0xed, 0xd0, 0x87, 0xb2, 0x51, 0xcf, 0xf3, 3217 3217 + 0x4a, 0x9f, 0x45, 0xcb, 0x62, 0x5c, 0x62, 0xec, 0x78, 0x76, 0x01, 0xf1, 3218 3218 + 0x90, 0xf7, 0x0b, 0xfb, 0x1b, 0xa5, 0x7b, 0x78, 0xc1, 0x02, 0xed, 0x6d, 3219 3219 + 0x01, 0x16, 0xec, 0x21, 0x85, 0x4f, 0xe3, 0x0f, 0x59, 0xaf, 0x5e, 0xbc, 3220 3220 + 0x4d, 0x18, 0x2c, 0xdd, 0x62, 0xfd, 0x3f, 0x9a, 0x9c, 0xf7, 0x1b, 0xe3, 3221 3221 + 0x60, 0xfc, 0xf4, 0x77, 0xd9, 0x77, 0x1f, 0xe5, 0x7f, 0x73, 0x61, 0xa4, 3222 3222 + 0xe3, 0x88, 0xdd, 0x79, 0xbd, 0x47, 0xfc, 0xbb, 0x62, 0xd7, 0xa8, 0x6e, 3223 3223 + 0xef, 0x47, 0x24, 0x0e, 0x7b, 0xf3, 0xcc, 0xaf, 0x1f, 0x44, 0xfa, 0x3e, 3224 3224 + 0xc2, 0x2b, 0x6d, 0xb6, 0xab, 0x50, 0x9c, 0x3d, 0xfd, 0x65, 0x63, 0x3e, 3225 3225 + 0x9a, 0xbb, 0xe2, 0xd7, 0x27, 0xf1, 0x26, 0xbf, 0x26, 0xef, 0xaf, 0xf9, 3226 3226 + 0xb5, 0x04, 0x67, 0x66, 0x7c, 0x8a, 0x57, 0xb5, 0xd9, 0xcd, 0x9b, 0x3e, 3227 3227 + 0xe3, 0xdb, 0x2e, 0xe3, 0x43, 0x17, 0xeb, 0x13, 0xc7, 0xe7, 0xca, 0x2c, 3228 3228 + 0x9f, 0xad, 0xe8, 0xbd, 0xd6, 0xf6, 0x3a, 0xaf, 0xed, 0xf2, 0xc1, 0xf8, 3229 3229 + 0x3a, 0x8e, 0xce, 0x43, 0xc7, 0x4b, 0xcf, 0x43, 0x76, 0x5c, 0xc6, 0xae, 3230 3230 + 0x95, 0xae, 0xc3, 0xd2, 0x04, 0x63, 0x61, 0x12, 0xf3, 0xfa, 0x21, 0xde, 3231 3231 + 0xd8, 0xeb, 0x56, 0x8d, 0xf4, 0xc6, 0x80, 0xe5, 0x59, 0x99, 0xbf, 0x59, 3232 3232 + 0xda, 0x47, 0xc5, 0x37, 0x16, 0x62, 0x1d, 0x42, 0x7a, 0x6f, 0x2c, 0xf7, 3233 3233 + 0x67, 0x9a, 0x87, 0xbc, 0x9c, 0xab, 0xfa, 0x8f, 0xa5, 0xf7, 0x78, 0x8d, 3234 3234 + 0xe7, 0xad, 0x94, 0x9e, 0xd3, 0x46, 0x3c, 0x78, 0xfe, 0xdd, 0xfe, 0x72, 3235 3235 + 0x6f, 0x50, 0x3f, 0x74, 0x7e, 0x01, 0x74, 0x27, 0xb3, 0xde, 0x09, 0xfd, 3236 3236 + 0x3e, 0x6b, 0x9e, 0xa4, 0xe3, 0x7e, 0x98, 0x4f, 0xdd, 0xfb, 0x28, 0x74, 3237 3237 + 0x06, 0xf9, 0xff, 0x46, 0xbf, 0x7b, 0x03, 0xf6, 0x76, 0xa7, 0xb8, 0x29, 3238 3238 + 0xff, 0x55, 0xb5, 0x39, 0xb0, 0x75, 0xef, 0x1c, 0x63, 0x4f, 0x9f, 0xae, 3239 3239 + 0xf3, 0x9e, 0x36, 0xb6, 0xcc, 0xa7, 0xe6, 0xaf, 0xe6, 0xb6, 0xfc, 0xf5, 3240 3240 + 0xac, 0xf8, 0xca, 0x02, 0xe6, 0x2b, 0x7c, 0x4f, 0xd2, 0x79, 0x3a, 0xfa, 3241 3241 + 0x9e, 0x06, 0x2f, 0xf1, 0xfd, 0xee, 0xaf, 0xef, 0x8e, 0xdf, 0x92, 0x75, 3242 3242 + 0x1a, 0xc4, 0x6f, 0xae, 0xc1, 0x57, 0xbf, 0xaf, 0x6f, 0xf2, 0x1b, 0x7e, 3243 3243 + 0x5f, 0x59, 0xe1, 0xfe, 0xbd, 0x97, 0x98, 0xdf, 0x64, 0xdd, 0x87, 0xa4, 3244 3244 + 0xee, 0x4a, 0x8f, 0xec, 0x6f, 0x1b, 0xf6, 0xba, 0xff, 0xef, 0x08, 0x6f, 3245 3245 + 0x5a, 0x53, 0x3c, 0x7f, 0x4e, 0xf7, 0x91, 0xd1, 0x97, 0xc9, 0x0e, 0xee, 3246 3246 + 0xd5, 0x65, 0x88, 0xa4, 0x6e, 0x77, 0x53, 0xf5, 0xab, 0x08, 0x4f, 0x38, 3247 3247 + 0xf0, 0x55, 0xa4, 0xeb, 0xac, 0xfb, 0xc8, 0xf8, 0x25, 0xe9, 0xd7, 0x76, 3248 3248 + 0xa8, 0x77, 0x0d, 0xbe, 0xd8, 0xe0, 0x41, 0x9f, 0xfc, 0x4d, 0x08, 0xaf, 3249 3249 + 0x9c, 0x91, 0xfd, 0xfe, 0xcb, 0x65, 0xfe, 0xe8, 0x1e, 0xa3, 0x3d, 0x87, 3250 3250 + 0x11, 0xd9, 0xf3, 0x6e, 0x85, 0xe5, 0x7a, 0x85, 0x79, 0x71, 0xc2, 0xf1, 3251 3251 + 0x48, 0xaf, 0x5e, 0x61, 0x1c, 0x29, 0xa3, 0x5d, 0x00, 0x0f, 0x8e, 0x93, 3252 3252 + 0x7a, 0x67, 0xd1, 0x63, 0x7e, 0x5f, 0xbc, 0x25, 0xfc, 0xe3, 0xeb, 0xfa, 3253 3253 + 0xc9, 0x7d, 0x5f, 0xc6, 0xf3, 0x11, 0xb5, 0xcf, 0xc9, 0x7e, 0x28, 0x9d, 3254 3254 + 0x36, 0xe7, 0xf7, 0xa9, 0x64, 0xdf, 0xf4, 0x93, 0xf5, 0xd6, 0xf3, 0xbd, 3255 3255 + 0x9c, 0xd1, 0xa7, 0x99, 0x58, 0xf3, 0xdf, 0xd8, 0x0c, 0xe6, 0xeb, 0x43, 3256 3256 + 0xd5, 0xe1, 0xf9, 0x60, 0x54, 0x7e, 0x2c, 0x07, 0xcd, 0x1a, 0x73, 0xc2, 3257 3257 + 0x27, 0x73, 0x57, 0xc8, 0xcd, 0xf1, 0x39, 0x7d, 0x3e, 0x4d, 0x0b, 0x32, 3258 3258 + 0xbb, 0xf2, 0x13, 0x9d, 0x57, 0xa3, 0x3c, 0x9f, 0x3b, 0xc7, 0x74, 0xbd, 3259 3259 + 0x7c, 0xba, 0xff, 0x02, 0xd7, 0xeb, 0xad, 0x1b, 0x8c, 0xa7, 0xe0, 0x75, 3260 3260 + 0x42, 0x77, 0xc1, 0x63, 0x7e, 0x5c, 0xf4, 0x4a, 0x84, 0x40, 0xf5, 0xb2, 3261 3261 + 0x5e, 0xe2, 0x77, 0xad, 0x28, 0xef, 0xd1, 0x50, 0xa2, 0x8f, 0xe6, 0xfb, 3262 3262 + 0xb1, 0xdb, 0x7e, 0x26, 0xf9, 0x54, 0xbf, 0x6b, 0x39, 0xe3, 0xef, 0xc8, 3263 3263 + 0x8a, 0x31, 0x9f, 0xef, 0x66, 0xcc, 0x67, 0x33, 0x63, 0xbe, 0x4d, 0x5e, 3264 3264 + 0xb9, 0x24, 0x7b, 0x57, 0x80, 0x62, 0x9e, 0x1e, 0x26, 0xaf, 0x70, 0x95, 3265 3265 + 0xfa, 0x6b, 0xcd, 0xf1, 0xbb, 0xee, 0x15, 0xe7, 0x73, 0x54, 0x37, 0x6f, 3266 3266 + 0x9e, 0xf5, 0x0a, 0x7c, 0x1e, 0x68, 0xbc, 0x7e, 0x95, 0xdf, 0x4f, 0x0b, 3267 3267 + 0xfe, 0x07, 0x89, 0x6e, 0x1e, 0x13, 0x00, 0x0d, 0x00, 0x00, 0x00 }; 3263 3268 3264 3269 static u8 bnx2_xi_rv2p_proc2[] = { 3265 3265 - /* Date: 01/14/2008 15:44 */ 3266 3266 - 0xad, 0x58, 0x5d, 0x6c, 0xd3, 0x55, 0x14, 0xbf, 0xfd, 0x58, 0xdb, 0x75, 3267 3267 - 0xff, 0xb6, 0x63, 0x9b, 0xdd, 0xa7, 0x6e, 0x6e, 0x61, 0x6c, 0xd8, 0xcd, 3268 3268 - 0xd1, 0x8d, 0x4f, 0x4d, 0x5c, 0x86, 0x19, 0x20, 0x26, 0x8c, 0x61, 0xd4, 3269 3269 - 0x37, 0xd8, 0x90, 0xb2, 0xb2, 0x8d, 0x2c, 0x8c, 0xf0, 0xc0, 0x8b, 0x0d, 3270 3270 - 0xd3, 0xf1, 0xd2, 0x07, 0x47, 0xb2, 0x0d, 0x8d, 0xc1, 0x45, 0x7d, 0x40, 3271 3271 - 0x9f, 0xec, 0x83, 0x52, 0x30, 0xc6, 0xc4, 0xe8, 0x42, 0xf0, 0x01, 0x48, 3272 3272 - 0x30, 0xc6, 0x68, 0x48, 0x08, 0xea, 0x32, 0x10, 0x75, 0x0c, 0xfb, 0x64, 3273 3273 - 0x98, 0xf7, 0x9e, 0xdf, 0xb9, 0xff, 0xfe, 0xff, 0x5d, 0x27, 0x18, 0xec, 3274 3274 - 0x43, 0x4f, 0xef, 0xbd, 0xe7, 0x9e, 0x7b, 0x3e, 0x7e, 0xe7, 0x9c, 0x7b, 3275 3275 - 0x5b, 0x2c, 0x84, 0x70, 0x8a, 0x44, 0xaa, 0x56, 0x52, 0x61, 0x38, 0x5c, 3276 3276 - 0x02, 0x9f, 0xb5, 0xc5, 0x44, 0xae, 0xa5, 0x7c, 0xf2, 0xbb, 0x40, 0xbc, 3277 3277 - 0xe4, 0xac, 0xa0, 0xb1, 0x5b, 0x28, 0x1a, 0x12, 0x22, 0x61, 0xa5, 0xa5, 3278 3278 - 0x4c, 0xaf, 0x32, 0xfd, 0x9d, 0xe9, 0xe3, 0x0e, 0xd0, 0x2b, 0x3c, 0xde, 3279 3279 - 0xc2, 0xe3, 0x6b, 0x3c, 0xfe, 0x91, 0xe9, 0x46, 0x9e, 0xdf, 0xcc, 0x34, 3280 3280 - 0xc9, 0x74, 0x3b, 0xaf, 0xa7, 0x99, 0xca, 0x4f, 0xc2, 0x90, 0x5f, 0x72, 3281 3281 - 0xb9, 0x59, 0xeb, 0x69, 0x60, 0xba, 0x19, 0xfa, 0xee, 0xa9, 0x53, 0x7c, 3282 3282 - 0xf3, 0x4b, 0x59, 0x3e, 0xcc, 0x5f, 0x9f, 0x00, 0xad, 0xc5, 0xae, 0x8f, 3283 3283 - 0x13, 0x4f, 0xeb, 0xfd, 0x20, 0x7d, 0x01, 0xd0, 0x7e, 0xb6, 0xbf, 0x33, 3284 3284 - 0x42, 0x24, 0xb9, 0xdf, 0x89, 0x71, 0x77, 0xa3, 0xf2, 0x43, 0x89, 0x70, 3285 3285 - 0x3b, 0x95, 0x9c, 0x56, 0x9f, 0xe7, 0x3c, 0xe6, 0x5f, 0x0d, 0x81, 0xbe, 3286 3286 - 0xe6, 0x07, 0xfd, 0xc5, 0x5f, 0x28, 0xbf, 0x97, 0x96, 0x62, 0x45, 0x2c, 3287 3287 - 0xdf, 0x60, 0xb5, 0x8b, 0xb0, 0x7f, 0xd6, 0x80, 0x1e, 0x2f, 0xd7, 0x41, 3288 3288 - 0xbf, 0xef, 0x9f, 0x52, 0xf3, 0x2e, 0x91, 0x60, 0x39, 0x42, 0x68, 0x3d, 3289 3289 - 0x79, 0x7d, 0x10, 0xfb, 0x56, 0xad, 0xc1, 0xea, 0x5b, 0x31, 0x8c, 0xab, 3290 3290 - 0x3f, 0x28, 0xa6, 0xb8, 0x9c, 0x4e, 0x69, 0xfe, 0x7c, 0x72, 0xdd, 0x52, 3291 3291 - 0x2e, 0xe4, 0x8b, 0x7a, 0x1f, 0x29, 0x93, 0x88, 0x80, 0x8a, 0x96, 0xdc, 3292 3292 - 0x73, 0x20, 0x7f, 0x6a, 0xb5, 0x9a, 0x77, 0x8a, 0x5e, 0x97, 0x9a, 0xf7, 3293 3293 - 0x88, 0xde, 0xb8, 0xf6, 0x2f, 0xd6, 0x63, 0x1e, 0x22, 0x15, 0x7d, 0xe3, 3294 3294 - 0xca, 0xce, 0x90, 0xd8, 0xe7, 0x0c, 0x11, 0x3f, 0xfc, 0xe2, 0xf2, 0x19, 3295 3295 - 0x9f, 0x81, 0xff, 0xcb, 0x5a, 0x83, 0x6c, 0x89, 0xb5, 0x63, 0x5f, 0x59, 3296 3296 - 0x14, 0x74, 0x32, 0x5a, 0xa0, 0x48, 0x24, 0x36, 0x4a, 0xc3, 0xd6, 0x9b, 3297 3297 - 0xeb, 0x7c, 0xc4, 0x97, 0x68, 0xd1, 0xf1, 0xd3, 0xf1, 0x52, 0x71, 0xfc, 3298 3298 - 0x44, 0xc6, 0x91, 0xdd, 0xd2, 0x00, 0xbf, 0xfe, 0xba, 0x5a, 0xf1, 0x4b, 3299 3299 - 0xe7, 0xd6, 0xe3, 0x9c, 0xac, 0x7e, 0xd6, 0xf8, 0x7f, 0xf4, 0x1f, 0xe2, 3300 3300 - 0xaf, 0xe4, 0x75, 0xb2, 0x5f, 0xea, 0xa4, 0x5f, 0x14, 0xad, 0x71, 0x24, 3301 3301 - 0x5a, 0xec, 0xf1, 0xb8, 0x3e, 0x11, 0xa2, 0xdf, 0xb7, 0xba, 0x8a, 0xc9, 3302 3302 - 0xaf, 0xbb, 0x30, 0x7f, 0xaa, 0xfb, 0x1c, 0xe2, 0xb1, 0x83, 0xec, 0x17, 3303 3303 - 0xfe, 0x37, 0x3e, 0xc5, 0xae, 0xbe, 0x80, 0x1a, 0xbf, 0xd2, 0x11, 0xbb, 3304 3304 - 0x80, 0xf5, 0x82, 0x31, 0xf8, 0x75, 0x17, 0x4b, 0xdd, 0xe1, 0x72, 0x28, 3305 3305 - 0x92, 0xf4, 0x8c, 0xd1, 0xd0, 0x98, 0xa5, 0x75, 0x43, 0x9c, 0x4c, 0x61, 3306 3306 - 0xfd, 0x70, 0x91, 0x1a, 0xef, 0x8a, 0xcc, 0x63, 0x1c, 0x89, 0x8f, 0xf3, 3307 3307 - 0x46, 0x27, 0xfc, 0x70, 0xcb, 0x09, 0x79, 0x0c, 0x2f, 0xbf, 0x9b, 0xe2, 3308 3308 - 0xe0, 0x10, 0x46, 0x37, 0xe8, 0x9b, 0xb4, 0xfe, 0xb7, 0x23, 0x49, 0x76, 3309 3309 - 0x77, 0x07, 0xdd, 0xe7, 0xc0, 0xc8, 0xb8, 0x36, 0x71, 0xab, 0x71, 0xff, 3310 3310 - 0xb0, 0xf8, 0x1d, 0x37, 0x34, 0x5e, 0xd9, 0xff, 0xec, 0xdf, 0xf7, 0x44, 3311 3311 - 0x2e, 0x4e, 0x41, 0xbb, 0x1b, 0x41, 0x3d, 0x0d, 0xb9, 0x78, 0xd5, 0xf8, 3312 3312 - 0xb4, 0xfb, 0x99, 0xe3, 0x63, 0xc1, 0x0b, 0x11, 0x89, 0x13, 0x1b, 0x6e, 3313 3313 - 0x18, 0xa7, 0x95, 0xd2, 0x5f, 0x3a, 0xfe, 0x4a, 0x90, 0x57, 0x0c, 0xb2, 3314 3314 - 0xbc, 0x38, 0xdb, 0x35, 0xc4, 0x76, 0xdd, 0xf1, 0x6b, 0xbf, 0x6a, 0x7b, 3315 3315 - 0x40, 0x4f, 0xda, 0xec, 0x71, 0x48, 0x3c, 0xd9, 0x71, 0xc8, 0xfa, 0x24, 3316 3316 - 0xbf, 0xa9, 0xc7, 0x8f, 0xea, 0x06, 0x50, 0xd3, 0xce, 0x46, 0xc5, 0xe7, 3317 3317 - 0x89, 0x4e, 0xa7, 0xec, 0x38, 0xd4, 0xf9, 0xb8, 0xa7, 0x4e, 0xcb, 0x57, 3318 3318 - 0xb8, 0xcc, 0x48, 0x5c, 0x22, 0x6e, 0xa7, 0x53, 0xd6, 0xfc, 0xac, 0xca, 3319 3319 - 0x93, 0x9f, 0xf6, 0xbc, 0xd0, 0x7e, 0x39, 0x1c, 0xa0, 0x02, 0xd5, 0x71, 3320 3320 - 0x79, 0xce, 0x7e, 0x1e, 0xf0, 0xed, 0x35, 0xf1, 0x53, 0xb6, 0x81, 0xfd, 3321 3321 - 0xc7, 0x34, 0xbc, 0x51, 0xc9, 0xeb, 0x61, 0xf9, 0x6d, 0x2c, 0xdf, 0xb0, 3322 3322 - 0xe4, 0x9d, 0xd2, 0xaf, 0xcb, 0xcc, 0x37, 0x1d, 0xb7, 0x6c, 0xde, 0x69, 3323 3323 - 0xff, 0xd1, 0xf9, 0x91, 0xcb, 0x73, 0x6a, 0x7f, 0xf5, 0x03, 0xf2, 0x70, 3324 3324 - 0x93, 0x29, 0xef, 0x3b, 0x33, 0xdf, 0xd4, 0x7a, 0x91, 0x78, 0x8e, 0x87, 3325 3325 - 0xf6, 0x7a, 0xf2, 0xa7, 0xac, 0x27, 0x64, 0x87, 0xcf, 0x38, 0xc7, 0xf5, 3326 3326 - 0x63, 0x54, 0x9d, 0x53, 0xc1, 0x7a, 0x57, 0xb0, 0xde, 0xb2, 0x5f, 0xb5, 3327 3327 - 0x70, 0x9d, 0xd9, 0x6b, 0xad, 0x17, 0x6b, 0x2d, 0x79, 0xaf, 0xc6, 0x4d, 3328 3328 - 0x4b, 0xcb, 0xfb, 0x85, 0xcd, 0x9f, 0x09, 0x41, 0xfe, 0xf7, 0x72, 0x7c, 3329 3329 - 0x3c, 0x79, 0xfa, 0x8b, 0xe6, 0x07, 0xbe, 0xb6, 0x11, 0xbf, 0xcf, 0xc4, 3330 3330 - 0xbf, 0xdd, 0xde, 0xaa, 0x3c, 0x75, 0x27, 0xd7, 0x7e, 0xf8, 0xb3, 0xcf, 3331 3331 - 0x19, 0x20, 0xbe, 0x1b, 0x23, 0x6a, 0xdf, 0x49, 0x87, 0xf6, 0x53, 0x27, 3332 3332 - 0xea, 0x90, 0x03, 0xf6, 0xd6, 0xb0, 0xbd, 0x72, 0xb9, 0x85, 0xf0, 0xef, 3333 3333 - 0xbb, 0x31, 0x62, 0xb5, 0xd7, 0xf8, 0x97, 0xf3, 0xec, 0xb8, 0x19, 0xe1, 3334 3334 - 0x3e, 0xd6, 0x8f, 0xbc, 0xf0, 0xed, 0xff, 0x5c, 0xeb, 0xc3, 0xe7, 0x86, 3335 3335 - 0xf4, 0xf9, 0x4a, 0x5e, 0xb5, 0x98, 0x1b, 0x55, 0xfb, 0x1f, 0x13, 0x0c, 3336 3336 - 0x33, 0x31, 0xdc, 0x84, 0xfa, 0x77, 0xe7, 0x00, 0xf4, 0x1f, 0x6e, 0xd4, 3337 3337 - 0x7d, 0x1c, 0x38, 0x16, 0x5c, 0xff, 0xbf, 0x9e, 0xc8, 0xe7, 0x97, 0x41, 3338 3338 - 0x07, 0xf8, 0xca, 0xd8, 0xae, 0x62, 0xb6, 0x2b, 0x22, 0x72, 0xeb, 0xec, 3339 3339 - 0x5e, 0xca, 0x97, 0x4e, 0xe6, 0x7b, 0x56, 0xd7, 0xe3, 0x65, 0x7c, 0xb0, 3340 3340 - 0xbf, 0x80, 0xcf, 0xcf, 0xe7, 0xaf, 0x7c, 0x72, 0xd3, 0x8c, 0xa3, 0x01, 3341 3341 - 0xe6, 0x73, 0xe7, 0xa9, 0xf3, 0x18, 0x65, 0xd6, 0x50, 0x9d, 0x3f, 0x73, 3342 3342 - 0x3c, 0xad, 0xf8, 0x02, 0x26, 0xce, 0xed, 0x76, 0xfd, 0x74, 0xff, 0xd1, 3343 3343 - 0xfd, 0xaf, 0xf8, 0xc2, 0xe2, 0x60, 0x70, 0x25, 0x3f, 0xbb, 0xd5, 0xf4, 3344 3344 - 0xcc, 0x42, 0x5a, 0xc7, 0xc9, 0x20, 0x3b, 0xe7, 0x46, 0xd5, 0xf9, 0x1f, 3345 3345 - 0xe6, 0xf8, 0xdf, 0x69, 0xf1, 0x3f, 0xf8, 0x9f, 0x88, 0x3c, 0xaa, 0xdf, 3346 3346 - 0xf3, 0xf5, 0xe5, 0x2f, 0xee, 0x2f, 0xcf, 0x13, 0x35, 0x7f, 0xe1, 0xa1, 3347 3347 - 0xfd, 0xb1, 0xbb, 0xdd, 0x6a, 0x7f, 0x83, 0x98, 0x4d, 0x21, 0xbf, 0x7a, 3348 3348 - 0x18, 0x87, 0xfb, 0xb8, 0x5e, 0xdf, 0xf0, 0xab, 0x09, 0x9f, 0xe8, 0xdf, 3349 3349 - 0x49, 0xfe, 0x10, 0xe1, 0x22, 0xf8, 0xa7, 0xff, 0x45, 0xed, 0x4f, 0xcc, 3350 3350 - 0x57, 0x51, 0xbf, 0x75, 0x89, 0x1e, 0xaf, 0x41, 0xfc, 0x55, 0x01, 0xd0, 3351 3351 - 0x30, 0xd7, 0xf9, 0x59, 0xb3, 0x8f, 0x81, 0x9e, 0xf6, 0xe8, 0xba, 0x8c, 3352 3352 - 0x7e, 0xfe, 0x95, 0x47, 0x31, 0xc8, 0x20, 0x35, 0xa3, 0x3e, 0x77, 0x35, 3353 3353 - 0x1a, 0xb4, 0xde, 0xdb, 0x0c, 0x3c, 0x89, 0x7a, 0xdd, 0xe7, 0xf0, 0xe1, 3354 3354 - 0x3e, 0x50, 0x95, 0xed, 0x77, 0xd6, 0x7e, 0x58, 0x68, 0xe9, 0x07, 0xfa, 3355 3355 - 0x3c, 0xed, 0x47, 0x2d, 0x97, 0x86, 0xb2, 0xaf, 0x58, 0xfb, 0xa1, 0xee, 3356 3356 - 0x13, 0x8b, 0xdc, 0x27, 0x4a, 0xc5, 0xc5, 0x14, 0xec, 0x9a, 0x4d, 0xe5, 3357 3357 - 0xe2, 0x4f, 0x9f, 0xa7, 0xe5, 0x41, 0x6f, 0x6d, 0x47, 0x56, 0x3e, 0xce, 3358 3358 - 0x3f, 0xc0, 0x7a, 0xfe, 0x4c, 0xf7, 0xd8, 0x30, 0xdb, 0xa3, 0xe4, 0x62, 3359 3359 - 0x7e, 0x3b, 0xf7, 0xe7, 0x84, 0x39, 0xb6, 0xf7, 0xd5, 0x1e, 0xd2, 0xab, 3360 3360 - 0x84, 0xf1, 0x16, 0xb6, 0xe4, 0x03, 0xf8, 0xcb, 0xda, 0x40, 0x27, 0xdb, 3361 3361 - 0x74, 0x1c, 0x74, 0xbc, 0x74, 0x7c, 0x10, 0xc7, 0xf0, 0x3a, 0x62, 0xeb, 3362 3362 - 0xe8, 0x5f, 0x47, 0x7d, 0xa4, 0xad, 0x7f, 0x41, 0xe3, 0x0f, 0xfb, 0x77, 3363 3363 - 0x47, 0x14, 0xff, 0xeb, 0xe2, 0x2a, 0xe1, 0x50, 0x88, 0x1f, 0x98, 0x66, 3364 3364 - 0xfb, 0x15, 0x07, 0xc0, 0xcc, 0x57, 0x8e, 0x5f, 0x01, 0x4f, 0xb7, 0xeb, 3365 3365 - 0x7a, 0xae, 0xe3, 0x65, 0xcd, 0xd7, 0xd8, 0x32, 0xdc, 0x66, 0xeb, 0xb2, 3366 3366 - 0xb6, 0x53, 0xf1, 0x47, 0x18, 0x8f, 0x3e, 0xd1, 0xb5, 0x0d, 0xf7, 0xdc, 3367 3367 - 0xa0, 0x17, 0x75, 0x3f, 0xe8, 0xb5, 0xc6, 0x4b, 0xe2, 0xa2, 0xd0, 0xab, 3368 3368 - 0x86, 0x35, 0x25, 0x85, 0x64, 0xcf, 0xa9, 0x4b, 0xdf, 0xd2, 0xf2, 0xfb, 3369 3369 - 0xd3, 0x45, 0x98, 0x2f, 0xdf, 0x19, 0x22, 0x7f, 0x4c, 0x01, 0xcf, 0xef, 3370 3370 - 0x4e, 0x82, 0xbe, 0x23, 0x5e, 0xc0, 0xfe, 0x92, 0x13, 0x74, 0x0f, 0xf4, 3371 3371 - 0x95, 0x33, 0x3e, 0x2b, 0x50, 0x27, 0x92, 0xd3, 0x74, 0x2f, 0x59, 0x5a, 3372 3372 - 0x12, 0x01, 0x45, 0x3d, 0x66, 0xbf, 0x01, 0x3e, 0xdd, 0x96, 0x38, 0x3f, 3373 3373 - 0x08, 0xaf, 0x74, 0xaf, 0x94, 0x78, 0xc4, 0x76, 0xc6, 0xad, 0x2f, 0x17, 3374 3374 - 0xb7, 0xda, 0x1f, 0x15, 0xce, 0xbc, 0x38, 0xdd, 0x60, 0xc7, 0xa9, 0x87, 3375 3375 - 0x71, 0x7a, 0xcf, 0xec, 0xef, 0xcb, 0xe5, 0xa2, 0xcf, 0x5f, 0xfc, 0xdf, 3376 3376 - 0x70, 0x0b, 0xba, 0xbd, 0x41, 0x9d, 0x5f, 0xbe, 0xac, 0x1e, 0xd7, 0xda, 3377 3377 - 0xe2, 0xdc, 0x7c, 0x5f, 0xeb, 0x75, 0xc2, 0x63, 0x5d, 0x6f, 0x31, 0xfb, 3378 3378 - 0xd9, 0x11, 0x7e, 0xe7, 0x65, 0x0c, 0xfa, 0x11, 0xbd, 0x93, 0xa4, 0xa1, 3379 3379 - 0x51, 0x79, 0x56, 0xf1, 0x35, 0x45, 0x8f, 0x70, 0xbd, 0xbd, 0xe4, 0x42, 3380 3380 - 0xbd, 0x19, 0x38, 0x80, 0xf1, 0x65, 0xae, 0x1f, 0x77, 0xd7, 0x50, 0x5d, 3381 3381 - 0x8e, 0x1e, 0x39, 0xaf, 0xe5, 0x91, 0x1c, 0x23, 0xc3, 0x75, 0xfd, 0x79, 3382 3382 - 0x17, 0xd7, 0x5b, 0xf2, 0x9b, 0x3b, 0xfa, 0x07, 0xdd, 0x67, 0xdc, 0xa2, 3383 3383 - 0xeb, 0x49, 0x45, 0x2b, 0x65, 0xfd, 0xe6, 0xf3, 0x9f, 0x01, 0xed, 0xf5, 3384 3384 - 0x82, 0x8a, 0x66, 0x7b, 0x3c, 0x84, 0x69, 0x17, 0x46, 0x9e, 0x7a, 0x96, 3385 3385 - 0xd3, 0x87, 0xb1, 0x97, 0xef, 0x65, 0xd3, 0xec, 0xa7, 0x20, 0xf9, 0xa3, 3386 3386 - 0x58, 0xda, 0xa9, 0x68, 0x28, 0x3a, 0x9a, 0x86, 0xfe, 0x43, 0x5b, 0x61, 3387 3387 - 0xdf, 0x22, 0xdb, 0xcd, 0x34, 0xf8, 0xf6, 0x18, 0xe1, 0x2f, 0x38, 0x8e, 3388 3388 - 0x77, 0x48, 0xd0, 0x33, 0x06, 0x3b, 0x86, 0x32, 0x18, 0x2f, 0x6e, 0x06, 3389 3389 - 0xfd, 0x6b, 0x0b, 0xf6, 0x1d, 0x3d, 0xce, 0xfe, 0xd8, 0x9a, 0x7f, 0xdf, 3390 3390 - 0xc0, 0x3d, 0xf0, 0x0d, 0x37, 0xa9, 0xf3, 0x07, 0x67, 0xf8, 0xfd, 0x22, 3391 3391 - 0xe2, 0x2e, 0x35, 0x8e, 0x1b, 0x19, 0x1e, 0x1f, 0xe2, 0xfa, 0x7e, 0x9b, 3392 3392 - 0xdf, 0x1b, 0x43, 0x39, 0xef, 0x8d, 0x79, 0xdc, 0x33, 0x67, 0x32, 0x49, 3393 3393 - 0xe0, 0x22, 0x51, 0x98, 0xfb, 0x5e, 0x55, 0xe3, 0x9a, 0x68, 0x39, 0xc7, 3394 3394 - 0xa9, 0x6c, 0x3d, 0xe8, 0xe4, 0x7a, 0xbc, 0x13, 0x86, 0x8e, 0xb1, 0x5f, 3395 3395 - 0x3a, 0x28, 0x4e, 0xad, 0x0b, 0xe9, 0x95, 0xde, 0xc9, 0xe0, 0x9b, 0xe2, 3396 3396 - 0x73, 0xc3, 0xdc, 0x4f, 0xc2, 0xc8, 0x3f, 0x51, 0x91, 0xe4, 0x77, 0xcb, 3397 3397 - 0x04, 0xee, 0x9d, 0x53, 0x06, 0x68, 0x38, 0xa0, 0xf5, 0x45, 0x3e, 0x26, 3398 3398 - 0x52, 0xc8, 0x3b, 0xac, 0x3b, 0x2c, 0xeb, 0x7c, 0x1f, 0x59, 0xf6, 0xce, 3399 3399 - 0x51, 0x74, 0xd1, 0x51, 0xea, 0xd0, 0x76, 0x62, 0xb5, 0x3f, 0xa0, 0xf0, 3400 3400 - 0x7b, 0xd3, 0xcc, 0xab, 0x79, 0xf2, 0x5b, 0xf5, 0x4c, 0x86, 0xf4, 0xaf, 3401 3401 - 0x12, 0xa5, 0xd4, 0x87, 0x2b, 0x83, 0x0b, 0xf0, 0x63, 0x74, 0x9a, 0xfd, 3402 3402 - 0x3f, 0xb2, 0x09, 0xf4, 0x18, 0xe3, 0x4f, 0xe3, 0xea, 0xca, 0x46, 0x83, 3403 3403 - 0xf6, 0xcd, 0x8d, 0xe2, 0x1c, 0x7d, 0x8f, 0xc8, 0x7d, 0x8f, 0x6b, 0x3c, 3404 3404 - 0x56, 0xb6, 0xa3, 0x90, 0x0e, 0x1c, 0x55, 0xe7, 0x04, 0x24, 0x8e, 0x94, 3405 3405 - 0xfe, 0xd2, 0x27, 0x9c, 0x8f, 0x76, 0x9c, 0x2a, 0x1c, 0xeb, 0xfc, 0xb0, 3406 3406 - 0xe2, 0x3b, 0x37, 0xdf, 0xb3, 0x78, 0x0d, 0xd2, 0xbd, 0x5c, 0x16, 0xb9, 3407 3407 - 0x04, 0xbf, 0x9b, 0xf8, 0x7e, 0xb0, 0x52, 0xfc, 0xde, 0x46, 0xfc, 0xa2, 3408 3408 - 0xac, 0xb7, 0x11, 0x1f, 0x43, 0x5f, 0x1c, 0x67, 0x1c, 0xcd, 0x37, 0xf1, 3409 3409 - 0xfd, 0x87, 0xf5, 0xfb, 0x8d, 0xdf, 0x67, 0xc0, 0x9b, 0xd7, 0x88, 0xa5, 3410 3410 - 0x19, 0x5f, 0x8c, 0xfb, 0x43, 0x6c, 0xf7, 0x6d, 0xd8, 0x6d, 0x68, 0xbb, 3411 3411 - 0xe3, 0xa6, 0xdd, 0xfa, 0x7e, 0x65, 0x95, 0x53, 0x22, 0x71, 0xab, 0xe8, 3412 3412 - 0x2a, 0xe3, 0x0a, 0xd5, 0xb3, 0x02, 0xb6, 0x53, 0xf2, 0xb5, 0x2b, 0x7b, 3413 3413 - 0x82, 0x6c, 0x4f, 0x40, 0x1c, 0x6c, 0xb5, 0xee, 0x2b, 0xe2, 0x7d, 0x7e, 3414 3414 - 0xb9, 0x0f, 0xf3, 0xa8, 0x0b, 0xc6, 0x0a, 0xfe, 0x54, 0x7e, 0xd3, 0x72, 3415 3415 - 0x73, 0xf3, 0xde, 0xea, 0x3f, 0xba, 0x91, 0xd2, 0x07, 0xf5, 0x4d, 0xc6, 3416 3416 - 0xa9, 0x05, 0xff, 0x1f, 0xe8, 0xfa, 0x76, 0x97, 0xee, 0xaf, 0xfe, 0x33, 3417 3417 - 0xc3, 0xa8, 0x4f, 0x67, 0x86, 0xcf, 0xf2, 0xbb, 0x83, 0xfd, 0xd2, 0x43, 3418 3418 - 0xff, 0x5b, 0xc8, 0xd8, 0xd5, 0xdb, 0xeb, 0x9b, 0x5d, 0x8f, 0x6a, 0x8b, 3419 3419 - 0x1e, 0xfa, 0xdc, 0x7f, 0x00, 0x5a, 0x33, 0xe6, 0xc0, 0x30, 0x14, 0x00, 3420 3420 - 0x00, 0x00 }; 3270 3270 + /* Date: 04/25/2008 22:02 */ 3271 3271 + #define XI_RV2P_PROC2_MAX_BD_PAGE_LOC 5 3272 3272 + #define XI_RV2P_PROC2_BD_PAGE_SIZE_MSK 0xffff 3273 3273 + #define XI_RV2P_PROC2_BD_PAGE_SIZE ((PAGE_SIZE / 16) - 1) 3274 3274 + 0xad, 0x58, 0x5b, 0x6c, 0x54, 0x55, 0x14, 0x3d, 0xf3, 0xe8, 0xcc, 0xed, 3275 3275 + 0xcc, 0x9d, 0x99, 0xd2, 0xd6, 0xe9, 0x8b, 0x48, 0x69, 0xa5, 0x74, 0x70, 3276 3276 + 0x0a, 0x65, 0x5a, 0x1e, 0x3e, 0x12, 0x49, 0xd1, 0x02, 0x3e, 0x42, 0xa9, 3277 3277 + 0x86, 0x98, 0x18, 0x03, 0x9d, 0x4a, 0xe9, 0x40, 0x4b, 0x2a, 0x25, 0x7c, 3278 3278 + 0xf0, 0xe3, 0x84, 0x62, 0xf9, 0x99, 0x44, 0x4b, 0x80, 0x16, 0x63, 0x48, 3279 3279 + 0x23, 0x3f, 0xc4, 0xbf, 0x26, 0x28, 0x45, 0x3f, 0x4c, 0x88, 0x36, 0x04, 3280 3280 + 0x3e, 0xc0, 0x44, 0x63, 0xfc, 0x21, 0x12, 0xc4, 0x5a, 0xa0, 0xc1, 0x82, 3281 3281 + 0x36, 0xc6, 0x48, 0xeb, 0x3d, 0x7b, 0xed, 0x73, 0xe7, 0xde, 0xe9, 0x2d, 3282 3282 + 0x8f, 0x48, 0x3f, 0x58, 0x9c, 0x73, 0xf7, 0x39, 0x67, 0xef, 0xb5, 0x1f, 3283 3283 + 0x67, 0x9f, 0x29, 0x10, 0x42, 0x78, 0x45, 0x7a, 0x64, 0x91, 0x81, 0x22, 3284 3284 + 0xe8, 0xf6, 0x68, 0x06, 0xcc, 0x0a, 0x91, 0x57, 0x2a, 0xc7, 0xc2, 0x2d, 3285 3285 + 0xf8, 0x6f, 0x59, 0x01, 0xc1, 0x0f, 0x23, 0xf2, 0xbb, 0x5f, 0xbc, 0xe5, 3286 3286 + 0xc6, 0x77, 0xaf, 0x90, 0x18, 0x11, 0x22, 0x2d, 0xb1, 0x80, 0x31, 0xc6, 3287 3287 + 0xe8, 0x72, 0x01, 0x4b, 0x18, 0x5f, 0x61, 0x14, 0x8c, 0xba, 0x1b, 0xe8, 3288 3288 + 0x66, 0xf4, 0xaa, 0x79, 0x5e, 0xaf, 0xf1, 0x7c, 0x3b, 0xe3, 0x76, 0x9e, 3289 3289 + 0xff, 0xdd, 0x40, 0xa5, 0x97, 0x1c, 0x4f, 0xce, 0x8a, 0xb4, 0x8e, 0x6d, 3290 3290 + 0x63, 0x6a, 0x5e, 0x27, 0x48, 0xc7, 0xa0, 0xf7, 0x9b, 0x95, 0xb4, 0xce, 3291 3291 + 0x41, 0x4e, 0xce, 0xdf, 0x98, 0x55, 0xfb, 0x1d, 0xf4, 0xc8, 0xf1, 0x2f, 3292 3292 + 0xc6, 0xd8, 0x25, 0x87, 0xc5, 0x51, 0x6c, 0x53, 0x5c, 0x9a, 0x91, 0xfb, 3293 3293 + 0x78, 0xc4, 0xd0, 0x80, 0x46, 0xac, 0x1c, 0xd7, 0x31, 0x4e, 0x13, 0x1f, 3294 3294 + 0x2e, 0x63, 0xcc, 0xfb, 0x31, 0x96, 0x85, 0x70, 0xee, 0xd6, 0x4a, 0x9c, 3295 3295 + 0xf7, 0xd3, 0xb3, 0x90, 0x4b, 0x47, 0x14, 0xa1, 0xf8, 0xbe, 0x48, 0xf0, 3296 3296 + 0xf7, 0xdd, 0x72, 0x3c, 0xe5, 0x2a, 0x72, 0x81, 0x57, 0xbf, 0x50, 0x7a, 3297 3297 + 0x42, 0xee, 0xea, 0x40, 0xae, 0x3c, 0x0d, 0x3f, 0x4f, 0xaf, 0x50, 0x76, 3298 3298 + 0x00, 0xda, 0x42, 0xc0, 0xa4, 0x07, 0xb8, 0x2e, 0x4e, 0x90, 0x69, 0x67, 3299 3299 + 0x47, 0x36, 0xd7, 0x48, 0x3d, 0x0a, 0x85, 0xd7, 0x2d, 0xf7, 0x5b, 0xa1, 3300 3300 + 0xf9, 0xce, 0x61, 0xfe, 0x6d, 0xd6, 0xeb, 0xbd, 0x00, 0xf0, 0x46, 0x20, 3301 3301 + 0xdf, 0xf8, 0x77, 0x76, 0xb6, 0x23, 0x68, 0xb7, 0x2b, 0x1d, 0xc4, 0xfa, 3302 3302 + 0x31, 0xdd, 0xc9, 0x3e, 0xcf, 0x03, 0xec, 0xc3, 0xba, 0x05, 0x4b, 0xf1, 3303 3303 + 0xf5, 0xe3, 0x0e, 0x8c, 0x2b, 0x4e, 0x49, 0x39, 0x9f, 0x18, 0x1a, 0x71, 3304 3304 + 0xe2, 0x23, 0x77, 0x7f, 0x23, 0x4e, 0x23, 0x38, 0x47, 0x54, 0x69, 0xa4, 3305 3305 + 0x54, 0x3a, 0x0e, 0x14, 0x75, 0x8e, 0xfc, 0x88, 0xe3, 0x4b, 0xe4, 0xbc, 3306 3306 + 0x5b, 0xb4, 0x7a, 0x74, 0x3a, 0xa7, 0x35, 0xa5, 0xe2, 0x02, 0xdf, 0x3b, 3307 3307 + 0x7c, 0x04, 0xa5, 0x6d, 0xfd, 0xd2, 0xde, 0x88, 0xd8, 0xee, 0x8e, 0x90, 3308 3308 + 0x3c, 0xf8, 0xf1, 0x68, 0xfa, 0x97, 0x90, 0xff, 0x66, 0x91, 0x4e, 0x36, 3309 3309 + 0x75, 0x34, 0x60, 0x5d, 0x71, 0x02, 0x78, 0x2c, 0x91, 0x27, 0x21, 0xde, 3310 3310 + 0xd1, 0x4b, 0xc3, 0xe5, 0xd7, 0x57, 0x6a, 0x24, 0x97, 0xae, 0x53, 0x71, 3311 3311 + 0xa7, 0xfc, 0x27, 0xfd, 0x3a, 0x64, 0xc6, 0x99, 0xa8, 0x06, 0xbf, 0xbf, 3312 3312 + 0x2d, 0x91, 0xf2, 0x06, 0xc9, 0x55, 0x38, 0x27, 0xab, 0x9f, 0x35, 0x6e, 3313 3313 + 0x07, 0x2c, 0x71, 0xfb, 0x78, 0xf1, 0xb0, 0x8e, 0xf8, 0x59, 0xc7, 0x3c, 3314 3314 + 0x55, 0x1a, 0x3c, 0x49, 0x5c, 0xe8, 0x4a, 0xd7, 0xd9, 0xfd, 0x74, 0x75, 3315 3315 + 0x20, 0x42, 0xff, 0xbf, 0xd9, 0x54, 0x40, 0x3c, 0x6f, 0xc6, 0xfc, 0x91, 3316 3316 + 0xe6, 0xb3, 0xf0, 0xd3, 0x26, 0xe2, 0x43, 0x04, 0x0e, 0x7d, 0x81, 0x55, 3317 3317 + 0x6d, 0x14, 0xdf, 0xdd, 0x8d, 0x1d, 0x5f, 0x61, 0x9c, 0xf4, 0xc8, 0xf1, 3318 3318 + 0x6e, 0xbd, 0x7d, 0x14, 0xf2, 0x79, 0x7d, 0xe0, 0x7d, 0x33, 0x9f, 0xb2, 3319 3319 + 0xc9, 0x43, 0xf9, 0x94, 0xf1, 0xf5, 0xd1, 0x50, 0x1f, 0xa3, 0xef, 0x05, 3320 3320 + 0xe2, 0xf0, 0x08, 0xbe, 0xef, 0x09, 0x4a, 0x3b, 0xdf, 0x37, 0xf3, 0x2e, 3321 3321 + 0xe5, 0xc3, 0xfa, 0xcc, 0x00, 0xf2, 0x66, 0xe2, 0x8c, 0x1c, 0x6f, 0x8b, 3322 3322 + 0x4f, 0x40, 0x3e, 0x9e, 0xea, 0xe7, 0x8d, 0xdd, 0xe0, 0xf1, 0xa6, 0x1b, 3323 3323 + 0xf2, 0x1c, 0xa6, 0x01, 0x2f, 0xf9, 0xd1, 0x25, 0xf4, 0x66, 0xe0, 0x87, 3324 3324 + 0xf4, 0xfd, 0x5f, 0x57, 0x86, 0x78, 0xdb, 0x1a, 0xf6, 0x9e, 0x55, 0xfc, 3325 3325 + 0x30, 0x46, 0x94, 0x5d, 0xc0, 0x47, 0xcd, 0x83, 0xfe, 0x79, 0xf3, 0x80, 3326 3326 + 0xfd, 0x19, 0x7b, 0x58, 0x1e, 0x00, 0x9b, 0x6b, 0x80, 0xbe, 0x6a, 0x29, 3327 3327 + 0x9f, 0xff, 0x18, 0xf9, 0xc0, 0x7a, 0xcd, 0xc9, 0x37, 0xcc, 0x66, 0xe3, 3328 3328 + 0x94, 0xc0, 0x88, 0x4f, 0x5b, 0xbc, 0x72, 0x7e, 0x2c, 0x36, 0xfc, 0xa0, 3329 3329 + 0xe2, 0x4e, 0x6e, 0xe8, 0x17, 0xbb, 0x79, 0xdf, 0x14, 0xf3, 0xd1, 0xc5, 3330 3330 + 0x7c, 0x4c, 0x32, 0xee, 0x09, 0x2a, 0x1e, 0x80, 0x87, 0x75, 0x9c, 0xdb, 3331 3331 + 0x9a, 0x92, 0x7e, 0x5c, 0xeb, 0x50, 0x3f, 0x55, 0x9d, 0x84, 0x9f, 0x86, 3332 3332 + 0xd8, 0xaf, 0x27, 0xcc, 0x7a, 0xa9, 0xf8, 0x9d, 0xaf, 0x6e, 0xda, 0xf3, 3333 3333 + 0x29, 0xc7, 0xce, 0xcc, 0x77, 0x55, 0x58, 0x5e, 0x58, 0x0d, 0x34, 0xf9, 3334 3334 + 0xad, 0xa1, 0x3c, 0x0e, 0x97, 0x8c, 0x2a, 0xfb, 0xa4, 0x7e, 0xb7, 0x55, 3335 3335 + 0x1e, 0x86, 0x07, 0x0f, 0x12, 0x06, 0x0a, 0x4f, 0xc9, 0x73, 0xca, 0x1d, 3336 3336 + 0xea, 0x8a, 0x3d, 0x9f, 0x73, 0xf9, 0xdd, 0x13, 0xa2, 0x42, 0xdb, 0x78, 3337 3337 + 0x79, 0xdc, 0x9e, 0xb7, 0xc8, 0x4f, 0xbf, 0x19, 0xdf, 0xc5, 0xab, 0xd9, 3338 3338 + 0x0f, 0x8c, 0xd1, 0x35, 0x72, 0xdf, 0x16, 0x3e, 0xa7, 0x9e, 0xcf, 0xd1, 3339 3339 + 0x2d, 0x75, 0x43, 0xea, 0x59, 0x68, 0xd6, 0x0b, 0x15, 0x1f, 0xd9, 0xba, 3340 3340 + 0xa1, 0xfc, 0x40, 0xe7, 0xc7, 0x2f, 0x8f, 0xcb, 0xf5, 0x15, 0x0f, 0xa9, 3341 3341 + 0x23, 0x9a, 0xb9, 0xdf, 0x8f, 0x66, 0x9d, 0x90, 0xdf, 0x83, 0xe2, 0x25, 3342 3342 + 0x1e, 0xda, 0xeb, 0xe1, 0x1f, 0x46, 0x3d, 0x24, 0x3b, 0x34, 0xfd, 0x2c, 3343 3343 + 0xd7, 0xbf, 0x5e, 0x79, 0x4e, 0x29, 0xeb, 0x5d, 0xca, 0x7a, 0x1b, 0xd7, 3344 3344 + 0x73, 0x1d, 0xd7, 0xc9, 0x6d, 0xd6, 0x7a, 0xf7, 0xcf, 0x4c, 0xb6, 0x6e, 3345 3345 + 0xc9, 0xf1, 0xdf, 0x33, 0x73, 0xef, 0x5f, 0x47, 0x5e, 0xd3, 0x22, 0x82, 3346 3346 + 0x3e, 0x23, 0x1d, 0x51, 0x7d, 0x41, 0x6e, 0xfd, 0xcb, 0xb5, 0x03, 0xbc, 3347 3347 + 0xb4, 0xb9, 0x43, 0x24, 0x77, 0xad, 0xc7, 0xde, 0x27, 0xa0, 0x0e, 0x56, 3348 3348 + 0xba, 0xa0, 0xf7, 0x42, 0xd6, 0xdb, 0xd8, 0xaf, 0x8e, 0xf2, 0x41, 0xbb, 3349 3349 + 0xd6, 0x63, 0xd5, 0xfb, 0xfa, 0xcc, 0xfc, 0xe7, 0x39, 0xc7, 0x41, 0x0f, 3350 3350 + 0xdf, 0xaf, 0x49, 0xc4, 0xb1, 0xd6, 0xfe, 0xb5, 0xd2, 0x8b, 0xcf, 0x8f, 3351 3351 + 0x28, 0x3d, 0x74, 0xf2, 0xd3, 0x78, 0xaf, 0xdc, 0xa7, 0x48, 0x70, 0xd8, 3352 3352 + 0x88, 0xee, 0x5a, 0xd4, 0xdf, 0xc9, 0x1d, 0xb0, 0xa3, 0xbb, 0x46, 0xea, 3353 3353 + 0x61, 0x78, 0x25, 0x8d, 0x3c, 0x17, 0x7c, 0x1f, 0x7d, 0x3b, 0xe0, 0xe4, 3354 3354 + 0xd7, 0x4b, 0x2c, 0x57, 0xcc, 0xf6, 0x15, 0xb0, 0x7d, 0x71, 0x91, 0x5b, 3355 3355 + 0xe7, 0xb7, 0x55, 0xd2, 0x7d, 0xc0, 0x72, 0x2f, 0xaa, 0xfb, 0xc0, 0x90, 3356 3356 + 0x93, 0xfb, 0xe4, 0xf1, 0x3e, 0x4e, 0x3c, 0x39, 0xed, 0x33, 0xca, 0x71, 3357 3357 + 0xd0, 0xc9, 0x72, 0x5e, 0x87, 0x7b, 0x05, 0xa3, 0xe9, 0xa5, 0x74, 0xaf, 3358 3358 + 0x9c, 0x3c, 0x40, 0xf7, 0x43, 0xc8, 0x8c, 0x53, 0xbb, 0x1d, 0x67, 0x9e, 3359 3359 + 0x20, 0xef, 0x52, 0x3e, 0x2a, 0x76, 0x86, 0xe7, 0xe3, 0xd7, 0x2b, 0xa7, 3360 3360 + 0x87, 0xa7, 0x46, 0x95, 0x7f, 0x74, 0xb2, 0x77, 0xbc, 0x57, 0xf5, 0xb1, 3361 3361 + 0x56, 0xde, 0xdd, 0x16, 0xde, 0x21, 0xff, 0x74, 0xfc, 0xff, 0xf2, 0xed, 3362 3362 + 0xd4, 0x1f, 0x1c, 0x9d, 0x31, 0xfb, 0x50, 0x9f, 0x53, 0xfd, 0x5f, 0x61, 3363 3363 + 0xc6, 0xcb, 0x5e, 0xee, 0xef, 0xa6, 0x75, 0xfa, 0x4f, 0x62, 0x32, 0x43, 3364 3364 + 0x43, 0xbd, 0xec, 0xb4, 0x94, 0x5b, 0x96, 0xd8, 0xcb, 0x76, 0x5d, 0xf4, 3365 3365 + 0xc0, 0xee, 0xce, 0x1d, 0x18, 0x5f, 0xe6, 0x7a, 0x7d, 0x97, 0xeb, 0xe3, 3366 3366 + 0x16, 0x0d, 0x38, 0x59, 0x4b, 0x7c, 0x24, 0xf6, 0x9e, 0x53, 0xfb, 0xd3, 3367 3367 + 0xbe, 0xfa, 0x34, 0xf3, 0xf9, 0xb2, 0x87, 0xed, 0xac, 0x22, 0x3f, 0x26, 3368 3368 + 0xee, 0x50, 0x3d, 0xf0, 0x8a, 0xa6, 0xc5, 0x12, 0xcb, 0x0c, 0xde, 0x58, 3369 3369 + 0x9f, 0x17, 0x80, 0xad, 0x7e, 0xa6, 0x21, 0x96, 0xeb, 0x67, 0x4c, 0xfb, 3370 3370 + 0xaa, 0x78, 0x7d, 0x1b, 0xc6, 0x7e, 0xae, 0x67, 0x83, 0xac, 0xd7, 0xd1, 3371 3371 + 0x5a, 0x60, 0x38, 0x86, 0x3e, 0x61, 0x9c, 0xee, 0x85, 0x48, 0xa2, 0x77, 3372 3372 + 0x14, 0xf6, 0x74, 0xad, 0x87, 0xbd, 0xf7, 0x98, 0x07, 0xc6, 0xf0, 0x89, 3373 3373 + 0x3e, 0xba, 0x77, 0xc2, 0xfd, 0xe8, 0x33, 0xc2, 0xbe, 0x3e, 0xd8, 0xd1, 3374 3374 + 0x35, 0x8d, 0xf1, 0xbd, 0xe7, 0x80, 0x7f, 0x3d, 0x8f, 0x75, 0xfb, 0x0e, 3375 3375 + 0x30, 0x3f, 0xeb, 0x9d, 0xd7, 0x75, 0xfe, 0x09, 0xb9, 0xee, 0x5a, 0x79, 3376 3376 + 0xfe, 0xbb, 0xc3, 0xdc, 0x7f, 0x88, 0x14, 0xf5, 0x3b, 0xef, 0xe8, 0xd3, 3377 3377 + 0x3c, 0xde, 0xc5, 0xf7, 0xe2, 0x2d, 0xee, 0x17, 0xba, 0x72, 0xfa, 0x85, 3378 3378 + 0x09, 0xd4, 0xe9, 0xe1, 0xe9, 0x8c, 0x9c, 0x30, 0xea, 0x65, 0xbe, 0x93, 3379 3379 + 0x7f, 0xf5, 0x44, 0x09, 0xfb, 0xad, 0x78, 0x15, 0xf0, 0xd8, 0x2a, 0xdc, 3380 3380 + 0xd7, 0x5d, 0xfb, 0x99, 0x9f, 0x46, 0xf2, 0xd3, 0xf2, 0xa9, 0xd1, 0xdc, 3381 3381 + 0xf5, 0x32, 0x7e, 0x3a, 0x8d, 0xf8, 0x51, 0xe7, 0x40, 0x3e, 0x19, 0x92, 3382 3382 + 0xf3, 0xf7, 0xcc, 0xba, 0x3f, 0x41, 0x7a, 0x57, 0x0c, 0x4f, 0xd3, 0xfa, 3383 3383 + 0x72, 0x51, 0x44, 0xf1, 0x57, 0x16, 0x9e, 0x82, 0x1d, 0x89, 0x41, 0xb6, 3384 3384 + 0xbf, 0x67, 0x2d, 0x70, 0x3f, 0xfb, 0x5f, 0xf9, 0xf5, 0xca, 0x1a, 0x9d, 3385 3385 + 0xd6, 0x8d, 0xf7, 0xe2, 0x1c, 0x95, 0x3f, 0xb9, 0xfd, 0xb0, 0x8a, 0x87, 3386 3386 + 0xb2, 0x06, 0x1a, 0x8b, 0xce, 0x7d, 0xf2, 0x9c, 0x90, 0xe1, 0x47, 0x19, 3387 3387 + 0x47, 0x06, 0x47, 0x7c, 0x5f, 0xdb, 0xe3, 0x44, 0xc6, 0x91, 0x8a, 0x57, 3388 3388 + 0x6b, 0x7c, 0x59, 0xe3, 0xc7, 0x1e, 0x37, 0x61, 0xba, 0x57, 0x8c, 0x22, 3389 3389 + 0x90, 0xa6, 0x77, 0x44, 0x62, 0x70, 0xe0, 0xc1, 0xfc, 0x9d, 0x00, 0x7f, 3390 3390 + 0x09, 0xd6, 0x5b, 0x4f, 0x51, 0x1f, 0xfa, 0x94, 0xe8, 0x67, 0x3f, 0x4e, 3391 3391 + 0xd4, 0x72, 0xde, 0x57, 0xc1, 0x8f, 0x3d, 0xcf, 0x40, 0x9f, 0x1e, 0xce, 3392 3392 + 0x9f, 0xdb, 0xdc, 0x5f, 0xc0, 0xff, 0x7e, 0xbd, 0x63, 0x94, 0xfd, 0xcd, 3393 3393 + 0x71, 0xb8, 0x8b, 0x79, 0xb8, 0x05, 0x1e, 0x74, 0xc5, 0x43, 0xca, 0xe4, 3394 3394 + 0x41, 0xd5, 0x19, 0xeb, 0x3e, 0x85, 0x46, 0x1c, 0x49, 0x5c, 0xa0, 0x5f, 3395 3395 + 0xa1, 0x3e, 0x2c, 0x8f, 0xed, 0x36, 0xe4, 0x1a, 0xa4, 0x7d, 0x61, 0xb6, 3396 3396 + 0x2f, 0x24, 0x76, 0x2e, 0xb7, 0xae, 0x0b, 0xf2, 0xba, 0x80, 0xb1, 0x0e, 3397 3397 + 0xf3, 0xc8, 0x53, 0x7d, 0x1e, 0x7e, 0x25, 0x8f, 0x6a, 0xdf, 0xdc, 0x7c, 3398 3398 + 0xb4, 0xf2, 0x49, 0x15, 0x9a, 0xfe, 0x50, 0x87, 0x0c, 0xbf, 0x51, 0xbd, 3399 3399 + 0xd2, 0xcd, 0xfa, 0x73, 0x97, 0xea, 0x79, 0xe0, 0x64, 0x37, 0xea, 0xc5, 3400 3400 + 0xc9, 0xee, 0xd3, 0x7c, 0xff, 0x32, 0x2f, 0x2d, 0xf4, 0x6e, 0x30, 0xb8, 3401 3401 + 0xab, 0xb2, 0xd7, 0x1f, 0xbb, 0x1e, 0x15, 0x16, 0x3d, 0xd4, 0xb9, 0x0f, 3402 3402 + 0xeb, 0x0f, 0xd0, 0x9f, 0x6e, 0xa0, 0xfe, 0x40, 0x33, 0xfb, 0x6c, 0xfb, 3403 3403 + 0x3d, 0x72, 0xeb, 0xfe, 0xe3, 0xde, 0x23, 0x5b, 0x1a, 0xac, 0xe7, 0xc5, 3404 3404 + 0xc4, 0xd8, 0x08, 0xce, 0x69, 0xe1, 0x7b, 0x7b, 0x3b, 0xe7, 0xf7, 0xb5, 3405 3405 + 0x40, 0x84, 0xce, 0x4d, 0xbe, 0x46, 0xf6, 0x8a, 0x68, 0x10, 0xf6, 0x25, 3406 3406 + 0x5f, 0xc7, 0xf7, 0x64, 0x08, 0xf3, 0xe5, 0x21, 0xfc, 0x3e, 0xd0, 0xe2, 3407 3407 + 0xd7, 0x49, 0xbe, 0x3c, 0x04, 0x8c, 0x72, 0x5d, 0x18, 0x33, 0xdf, 0x11, 3408 3408 + 0xc0, 0x21, 0xdf, 0x7c, 0xef, 0x08, 0xbc, 0xc7, 0xce, 0xfb, 0x50, 0x37, 3409 3409 + 0x44, 0x0c, 0xfd, 0x73, 0x53, 0x8d, 0x4e, 0xdf, 0x5b, 0x63, 0xb8, 0x9f, 3410 3410 + 0x51, 0x97, 0xe7, 0xda, 0x55, 0x81, 0x78, 0x2d, 0xcf, 0xbe, 0x37, 0xac, 3411 3411 + 0xef, 0x12, 0x3d, 0x31, 0x68, 0xf6, 0xfd, 0x76, 0x3d, 0x90, 0x67, 0x72, 3412 3412 + 0x7f, 0x1a, 0x1a, 0xfd, 0xf5, 0xa3, 0xbc, 0x47, 0x3c, 0xdc, 0xaf, 0xdd, 3413 3413 + 0x99, 0x45, 0xbc, 0x16, 0x89, 0x0b, 0x23, 0xe0, 0x61, 0x6c, 0xc4, 0x29, 3414 3414 + 0x8f, 0xa5, 0x1e, 0xea, 0x1c, 0xd8, 0xa5, 0xec, 0xcc, 0x9e, 0x0b, 0xbd, 3415 3415 + 0x76, 0xb0, 0xfe, 0xbf, 0xd2, 0xef, 0x17, 0x51, 0xb6, 0x57, 0xee, 0x8b, 3416 3416 + 0xf9, 0x8d, 0xf4, 0x6e, 0xca, 0x13, 0x69, 0x73, 0x6c, 0x7f, 0xcf, 0xb4, 3417 3417 + 0x90, 0x5e, 0x85, 0x7c, 0xaf, 0x47, 0x2d, 0xfd, 0x07, 0xe4, 0x8b, 0xeb, 3418 3418 + 0x81, 0xc7, 0xea, 0x95, 0xdf, 0x94, 0x7f, 0x95, 0x3f, 0xe1, 0xf7, 0xe8, 3419 3419 + 0x4a, 0x12, 0x6b, 0x4c, 0xae, 0xa4, 0x84, 0xaf, 0x4f, 0x4e, 0xa9, 0x7b, 3420 3420 + 0x1e, 0xeb, 0xb7, 0xc4, 0xa5, 0xfc, 0x07, 0xe2, 0xfb, 0x38, 0x2e, 0xd6, 3421 3421 + 0x9f, 0x19, 0xb3, 0xfd, 0xbd, 0xe0, 0x3f, 0xeb, 0x3b, 0xc1, 0x23, 0xce, 3422 3422 + 0xe7, 0xf1, 0x74, 0x83, 0xea, 0x7b, 0xe7, 0x7b, 0xef, 0x48, 0x3b, 0x3e, 3423 3423 + 0xba, 0x9f, 0xdb, 0x47, 0x67, 0xfb, 0x60, 0x65, 0xaf, 0x5c, 0x57, 0xcf, 3424 3424 + 0x71, 0xac, 0x89, 0xa6, 0x0d, 0xf8, 0x7d, 0x23, 0xec, 0x47, 0xde, 0x84, 3425 3425 + 0xfd, 0x4e, 0xef, 0x52, 0x23, 0x8e, 0xf2, 0xa9, 0x60, 0x2c, 0x2c, 0xcc, 3426 3426 + 0x27, 0xfb, 0x8e, 0x5c, 0xbc, 0x44, 0x62, 0x9f, 0x0d, 0x06, 0x31, 0x5f, 3427 3427 + 0xd2, 0x84, 0x63, 0xbc, 0x14, 0xf7, 0x1e, 0x71, 0x08, 0x79, 0xf1, 0xe9, 3428 3428 + 0x31, 0xe0, 0x27, 0xe2, 0x55, 0xec, 0x53, 0x78, 0x90, 0xee, 0x53, 0xad, 3429 3429 + 0x04, 0x34, 0x67, 0x06, 0x39, 0xde, 0x4b, 0xdd, 0xf4, 0xfb, 0xe2, 0xac, 3430 3430 + 0x08, 0x49, 0xf4, 0x99, 0xf9, 0x8b, 0xb8, 0xf6, 0x5a, 0xfc, 0xff, 0xa8, 3431 3431 + 0x71, 0x4e, 0xf5, 0xc9, 0x88, 0x63, 0x6c, 0xc3, 0xf1, 0xae, 0xe5, 0xc6, 3432 3432 + 0xbb, 0xe2, 0xa9, 0xd4, 0xed, 0x18, 0xdf, 0xab, 0xe7, 0xc6, 0xb7, 0xd2, 3433 3433 + 0x4f, 0xf2, 0x7d, 0xd7, 0xbc, 0x3f, 0xe7, 0xee, 0x8f, 0xf7, 0xd3, 0x85, 3434 3434 + 0x27, 0x16, 0xdf, 0xc0, 0x8d, 0xd5, 0xf2, 0xfc, 0x92, 0x39, 0x7d, 0x72, 3435 3435 + 0x6e, 0xfe, 0xa1, 0xde, 0xbd, 0x61, 0xc4, 0xc3, 0x7f, 0x69, 0x4a, 0x77, 3436 3436 + 0x8f, 0xc8, 0x15, 0x00, 0x00, 0x00 }; 3421 3437 3422 3438 static u8 bnx2_TPAT_b09FwText[] = { 3423 3439 0xbd, 0x58, 0x5d, 0x6c, 0x1c, 0xd5, 0x15, 0x3e, 0x73, 0x67, 0xd6, 0x3b,

+113 -36

drivers/net/tg3.c

reviewed

··· 64 64 65 65 #define DRV_MODULE_NAME "tg3" 66 66 #define PFX DRV_MODULE_NAME ": " 67 67 - #define DRV_MODULE_VERSION "3.91" 68 68 - #define DRV_MODULE_RELDATE "April 18, 2008" 67 67 + #define DRV_MODULE_VERSION "3.92" 68 68 + #define DRV_MODULE_RELDATE "May 2, 2008" 69 69 70 70 #define TG3_DEF_MAC_MODE 0 71 71 #define TG3_DEF_RX_MODE 0 ··· 1656 1656 return 0; 1657 1657 } 1658 1658 1659 1659 + /* tp->lock is held. */ 1660 1660 + static void tg3_wait_for_event_ack(struct tg3 *tp) 1661 1661 + { 1662 1662 + int i; 1663 1663 + 1664 1664 + /* Wait for up to 2.5 milliseconds */ 1665 1665 + for (i = 0; i < 250000; i++) { 1666 1666 + if (!(tr32(GRC_RX_CPU_EVENT) & GRC_RX_CPU_DRIVER_EVENT)) 1667 1667 + break; 1668 1668 + udelay(10); 1669 1669 + } 1670 1670 + } 1671 1671 + 1672 1672 + /* tp->lock is held. */ 1673 1673 + static void tg3_ump_link_report(struct tg3 *tp) 1674 1674 + { 1675 1675 + u32 reg; 1676 1676 + u32 val; 1677 1677 + 1678 1678 + if (!(tp->tg3_flags2 & TG3_FLG2_5780_CLASS) || 1679 1679 + !(tp->tg3_flags & TG3_FLAG_ENABLE_ASF)) 1680 1680 + return; 1681 1681 + 1682 1682 + tg3_wait_for_event_ack(tp); 1683 1683 + 1684 1684 + tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_LINK_UPDATE); 1685 1685 + 1686 1686 + tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 14); 1687 1687 + 1688 1688 + val = 0; 1689 1689 + if (!tg3_readphy(tp, MII_BMCR, &reg)) 1690 1690 + val = reg << 16; 1691 1691 + if (!tg3_readphy(tp, MII_BMSR, &reg)) 1692 1692 + val |= (reg & 0xffff); 1693 1693 + tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX, val); 1694 1694 + 1695 1695 + val = 0; 1696 1696 + if (!tg3_readphy(tp, MII_ADVERTISE, &reg)) 1697 1697 + val = reg << 16; 1698 1698 + if (!tg3_readphy(tp, MII_LPA, &reg)) 1699 1699 + val |= (reg & 0xffff); 1700 1700 + tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 4, val); 1701 1701 + 1702 1702 + val = 0; 1703 1703 + if (!(tp->tg3_flags2 & TG3_FLG2_MII_SERDES)) { 1704 1704 + if (!tg3_readphy(tp, MII_CTRL1000, &reg)) 1705 1705 + val = reg << 16; 1706 1706 + if (!tg3_readphy(tp, MII_STAT1000, &reg)) 1707 1707 + val |= (reg & 0xffff); 1708 1708 + } 1709 1709 + tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 8, val); 1710 1710 + 1711 1711 + if (!tg3_readphy(tp, MII_PHYADDR, &reg)) 1712 1712 + val = reg << 16; 1713 1713 + else 1714 1714 + val = 0; 1715 1715 + tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX + 12, val); 1716 1716 + 1717 1717 + val = tr32(GRC_RX_CPU_EVENT); 1718 1718 + val |= GRC_RX_CPU_DRIVER_EVENT; 1719 1719 + tw32_f(GRC_RX_CPU_EVENT, val); 1720 1720 + } 1721 1721 + 1659 1722 static void tg3_link_report(struct tg3 *tp) 1660 1723 { 1661 1724 if (!netif_carrier_ok(tp->dev)) { 1662 1725 if (netif_msg_link(tp)) 1663 1726 printk(KERN_INFO PFX "%s: Link is down.\n", 1664 1727 tp->dev->name); 1728 1728 + tg3_ump_link_report(tp); 1665 1729 } else if (netif_msg_link(tp)) { 1666 1730 printk(KERN_INFO PFX "%s: Link is up at %d Mbps, %s duplex.\n", 1667 1731 tp->dev->name, ··· 1743 1679 "on" : "off", 1744 1680 (tp->link_config.active_flowctrl & TG3_FLOW_CTRL_RX) ? 1745 1681 "on" : "off"); 1682 1682 + tg3_ump_link_report(tp); 1746 1683 } 1747 1684 } 1748 1685 ··· 2162 2097 MAC_STATUS_LNKSTATE_CHANGED)); 2163 2098 udelay(40); 2164 2099 2165 2165 - tp->mi_mode = MAC_MI_MODE_BASE; 2166 2166 - tw32_f(MAC_MI_MODE, tp->mi_mode); 2167 2167 - udelay(80); 2100 2100 + if ((tp->mi_mode & MAC_MI_MODE_AUTO_POLL) != 0) { 2101 2101 + tw32_f(MAC_MI_MODE, 2102 2102 + (tp->mi_mode & ~MAC_MI_MODE_AUTO_POLL)); 2103 2103 + udelay(80); 2104 2104 + } 2168 2105 2169 2106 tg3_writephy(tp, MII_TG3_AUX_CTRL, 0x02); 2170 2107 ··· 5565 5498 if ((tp->tg3_flags & TG3_FLAG_ENABLE_ASF) && 5566 5499 !(tp->tg3_flags3 & TG3_FLG3_ENABLE_APE)) { 5567 5500 u32 val; 5568 5568 - int i; 5501 5501 + 5502 5502 + /* Wait for RX cpu to ACK the previous event. */ 5503 5503 + tg3_wait_for_event_ack(tp); 5569 5504 5570 5505 tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, FWCMD_NICDRV_PAUSE_FW); 5571 5506 val = tr32(GRC_RX_CPU_EVENT); 5572 5572 - val |= (1 << 14); 5507 5507 + val |= GRC_RX_CPU_DRIVER_EVENT; 5573 5508 tw32(GRC_RX_CPU_EVENT, val); 5574 5509 5575 5575 - /* Wait for RX cpu to ACK the event. */ 5576 5576 - for (i = 0; i < 100; i++) { 5577 5577 - if (!(tr32(GRC_RX_CPU_EVENT) & (1 << 14))) 5578 5578 - break; 5579 5579 - udelay(1); 5580 5580 - } 5510 5510 + /* Wait for RX cpu to ACK this event. */ 5511 5511 + tg3_wait_for_event_ack(tp); 5581 5512 } 5582 5513 } 5583 5514 ··· 7167 7102 tp->link_config.autoneg = tp->link_config.orig_autoneg; 7168 7103 } 7169 7104 7170 7170 - tp->mi_mode = MAC_MI_MODE_BASE; 7105 7105 + tp->mi_mode &= ~MAC_MI_MODE_AUTO_POLL; 7171 7106 tw32_f(MAC_MI_MODE, tp->mi_mode); 7172 7107 udelay(80); 7173 7108 ··· 7465 7400 if (tp->tg3_flags & TG3_FLAG_ENABLE_ASF) { 7466 7401 u32 val; 7467 7402 7403 7403 + tg3_wait_for_event_ack(tp); 7404 7404 + 7468 7405 tg3_write_mem(tp, NIC_SRAM_FW_CMD_MBOX, 7469 7406 FWCMD_NICDRV_ALIVE3); 7470 7407 tg3_write_mem(tp, NIC_SRAM_FW_CMD_LEN_MBOX, 4); 7471 7408 /* 5 seconds timeout */ 7472 7409 tg3_write_mem(tp, NIC_SRAM_FW_CMD_DATA_MBOX, 5); 7473 7410 val = tr32(GRC_RX_CPU_EVENT); 7474 7474 - val |= (1 << 14); 7475 7475 - tw32(GRC_RX_CPU_EVENT, val); 7411 7411 + val |= GRC_RX_CPU_DRIVER_EVENT; 7412 7412 + tw32_f(GRC_RX_CPU_EVENT, val); 7476 7413 } 7477 7414 tp->asf_counter = tp->asf_multiplier; 7478 7415 } ··· 9635 9568 9636 9569 /* Turn off link-based power management. */ 9637 9570 cpmuctrl = tr32(TG3_CPMU_CTRL); 9638 9638 - if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 || 9639 9639 - GET_CHIP_REV(tp->pci_chip_rev_id) == CHIPREV_5761_AX) 9640 9640 - tw32(TG3_CPMU_CTRL, 9641 9641 - cpmuctrl & ~(CPMU_CTRL_LINK_SPEED_MODE | 9642 9642 - CPMU_CTRL_LINK_AWARE_MODE)); 9643 9643 - else 9644 9644 - tw32(TG3_CPMU_CTRL, 9645 9645 - cpmuctrl & ~CPMU_CTRL_LINK_AWARE_MODE); 9571 9571 + tw32(TG3_CPMU_CTRL, 9572 9572 + cpmuctrl & ~(CPMU_CTRL_LINK_SPEED_MODE | 9573 9573 + CPMU_CTRL_LINK_AWARE_MODE)); 9646 9574 } 9647 9575 9648 9576 if (tg3_run_loopback(tp, TG3_MAC_LOOPBACK)) ··· 9954 9892 return; 9955 9893 } 9956 9894 } 9957 9957 - tp->nvram_size = 0x80000; 9895 9895 + tp->nvram_size = TG3_NVRAM_SIZE_512KB; 9958 9896 } 9959 9897 9960 9898 static void __devinit tg3_get_nvram_info(struct tg3 *tp) ··· 10095 10033 tp->nvram_pagesize = 264; 10096 10034 if (nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_1 || 10097 10035 nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_5) 10098 10098 - tp->nvram_size = (protect ? 0x3e200 : 0x80000); 10036 10036 + tp->nvram_size = (protect ? 0x3e200 : 10037 10037 + TG3_NVRAM_SIZE_512KB); 10099 10038 else if (nvcfg1 == FLASH_5755VENDOR_ATMEL_FLASH_2) 10100 10100 - tp->nvram_size = (protect ? 0x1f200 : 0x40000); 10039 10039 + tp->nvram_size = (protect ? 0x1f200 : 10040 10040 + TG3_NVRAM_SIZE_256KB); 10101 10041 else 10102 10102 - tp->nvram_size = (protect ? 0x1f200 : 0x20000); 10042 10042 + tp->nvram_size = (protect ? 0x1f200 : 10043 10043 + TG3_NVRAM_SIZE_128KB); 10103 10044 break; 10104 10045 case FLASH_5752VENDOR_ST_M45PE10: 10105 10046 case FLASH_5752VENDOR_ST_M45PE20: ··· 10112 10047 tp->tg3_flags2 |= TG3_FLG2_FLASH; 10113 10048 tp->nvram_pagesize = 256; 10114 10049 if (nvcfg1 == FLASH_5752VENDOR_ST_M45PE10) 10115 10115 - tp->nvram_size = (protect ? 0x10000 : 0x20000); 10050 10050 + tp->nvram_size = (protect ? 10051 10051 + TG3_NVRAM_SIZE_64KB : 10052 10052 + TG3_NVRAM_SIZE_128KB); 10116 10053 else if (nvcfg1 == FLASH_5752VENDOR_ST_M45PE20) 10117 10117 - tp->nvram_size = (protect ? 0x10000 : 0x40000); 10054 10054 + tp->nvram_size = (protect ? 10055 10055 + TG3_NVRAM_SIZE_64KB : 10056 10056 + TG3_NVRAM_SIZE_256KB); 10118 10057 else 10119 10119 - tp->nvram_size = (protect ? 0x20000 : 0x80000); 10058 10058 + tp->nvram_size = (protect ? 10059 10059 + TG3_NVRAM_SIZE_128KB : 10060 10060 + TG3_NVRAM_SIZE_512KB); 10120 10061 break; 10121 10062 } 10122 10063 } ··· 10216 10145 case FLASH_5761VENDOR_ATMEL_MDB161D: 10217 10146 case FLASH_5761VENDOR_ST_A_M45PE16: 10218 10147 case FLASH_5761VENDOR_ST_M_M45PE16: 10219 10219 - tp->nvram_size = 0x100000; 10148 10148 + tp->nvram_size = TG3_NVRAM_SIZE_2MB; 10220 10149 break; 10221 10150 case FLASH_5761VENDOR_ATMEL_ADB081D: 10222 10151 case FLASH_5761VENDOR_ATMEL_MDB081D: 10223 10152 case FLASH_5761VENDOR_ST_A_M45PE80: 10224 10153 case FLASH_5761VENDOR_ST_M_M45PE80: 10225 10225 - tp->nvram_size = 0x80000; 10154 10154 + tp->nvram_size = TG3_NVRAM_SIZE_1MB; 10226 10155 break; 10227 10156 case FLASH_5761VENDOR_ATMEL_ADB041D: 10228 10157 case FLASH_5761VENDOR_ATMEL_MDB041D: 10229 10158 case FLASH_5761VENDOR_ST_A_M45PE40: 10230 10159 case FLASH_5761VENDOR_ST_M_M45PE40: 10231 10231 - tp->nvram_size = 0x40000; 10160 10160 + tp->nvram_size = TG3_NVRAM_SIZE_512KB; 10232 10161 break; 10233 10162 case FLASH_5761VENDOR_ATMEL_ADB021D: 10234 10163 case FLASH_5761VENDOR_ATMEL_MDB021D: 10235 10164 case FLASH_5761VENDOR_ST_A_M45PE20: 10236 10165 case FLASH_5761VENDOR_ST_M_M45PE20: 10237 10237 - tp->nvram_size = 0x20000; 10166 10166 + tp->nvram_size = TG3_NVRAM_SIZE_256KB; 10238 10167 break; 10239 10168 } 10240 10169 } ··· 11835 11764 tp->phy_otp = TG3_OTP_DEFAULT; 11836 11765 } 11837 11766 11767 11767 + if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5784 || 11768 11768 + GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5761) 11769 11769 + tp->mi_mode = MAC_MI_MODE_500KHZ_CONST; 11770 11770 + else 11771 11771 + tp->mi_mode = MAC_MI_MODE_BASE; 11772 11772 + 11838 11773 tp->coalesce_mode = 0; 11839 11774 if (GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_AX && 11840 11775 GET_CHIP_REV(tp->pci_chip_rev_id) != CHIPREV_5700_BX) ··· 12769 12692 tp->mac_mode = TG3_DEF_MAC_MODE; 12770 12693 tp->rx_mode = TG3_DEF_RX_MODE; 12771 12694 tp->tx_mode = TG3_DEF_TX_MODE; 12772 12772 - tp->mi_mode = MAC_MI_MODE_BASE; 12695 12695 + 12773 12696 if (tg3_debug > 0) 12774 12697 tp->msg_enable = tg3_debug; 12775 12698 else

+12 -3

drivers/net/tg3.h

reviewed

··· 415 415 #define MAC_MI_MODE_CLK_10MHZ 0x00000001 416 416 #define MAC_MI_MODE_SHORT_PREAMBLE 0x00000002 417 417 #define MAC_MI_MODE_AUTO_POLL 0x00000010 418 418 - #define MAC_MI_MODE_CORE_CLK_62MHZ 0x00008000 418 418 + #define MAC_MI_MODE_500KHZ_CONST 0x00008000 419 419 #define MAC_MI_MODE_BASE 0x000c0000 /* XXX magic values XXX */ 420 420 #define MAC_AUTO_POLL_STATUS 0x00000458 421 421 #define MAC_AUTO_POLL_ERROR 0x00000001 ··· 1429 1429 #define GRC_LCLCTRL_AUTO_SEEPROM 0x01000000 1430 1430 #define GRC_TIMER 0x0000680c 1431 1431 #define GRC_RX_CPU_EVENT 0x00006810 1432 1432 + #define GRC_RX_CPU_DRIVER_EVENT 0x00004000 1432 1433 #define GRC_RX_TIMER_REF 0x00006814 1433 1434 #define GRC_RX_CPU_SEM 0x00006818 1434 1435 #define GRC_REMOTE_RX_CPU_ATTN 0x0000681c ··· 1677 1676 #define FWCMD_NICDRV_IPV6ADDR_CHG 0x00000004 1678 1677 #define FWCMD_NICDRV_FIX_DMAR 0x00000005 1679 1678 #define FWCMD_NICDRV_FIX_DMAW 0x00000006 1679 1679 + #define FWCMD_NICDRV_LINK_UPDATE 0x0000000c 1680 1680 #define FWCMD_NICDRV_ALIVE2 0x0000000d 1681 1681 #define FWCMD_NICDRV_ALIVE3 0x0000000e 1682 1682 #define NIC_SRAM_FW_CMD_LEN_MBOX 0x00000b7c ··· 2578 2576 2579 2577 int nvram_lock_cnt; 2580 2578 u32 nvram_size; 2579 2579 + #define TG3_NVRAM_SIZE_64KB 0x00010000 2580 2580 + #define TG3_NVRAM_SIZE_128KB 0x00020000 2581 2581 + #define TG3_NVRAM_SIZE_256KB 0x00040000 2582 2582 + #define TG3_NVRAM_SIZE_512KB 0x00080000 2583 2583 + #define TG3_NVRAM_SIZE_1MB 0x00100000 2584 2584 + #define TG3_NVRAM_SIZE_2MB 0x00200000 2585 2585 + 2581 2586 u32 nvram_pagesize; 2582 2587 u32 nvram_jedecnum; 2583 2588 ··· 2593 2584 #define JEDEC_SAIFUN 0x4f 2594 2585 #define JEDEC_SST 0xbf 2595 2586 2596 2596 - #define ATMEL_AT24C64_CHIP_SIZE (64 * 1024) 2587 2587 + #define ATMEL_AT24C64_CHIP_SIZE TG3_NVRAM_SIZE_64KB 2597 2588 #define ATMEL_AT24C64_PAGE_SIZE (32) 2598 2589 2599 2599 - #define ATMEL_AT24C512_CHIP_SIZE (512 * 1024) 2590 2590 + #define ATMEL_AT24C512_CHIP_SIZE TG3_NVRAM_SIZE_512KB 2600 2591 #define ATMEL_AT24C512_PAGE_SIZE (128) 2601 2592 2602 2593 #define ATMEL_AT45DB0X1B_PAGE_POS 9

+4

drivers/net/wireless/b43/b43.h

reviewed

··· 691 691 692 692 struct mutex mutex; 693 693 spinlock_t irq_lock; 694 694 + /* R/W lock for data transmission. 695 695 + * Transmissions on 2+ queues can run concurrently, but somebody else 696 696 + * might sync with TX by write_lock_irqsave()'ing. */ 697 697 + rwlock_t tx_lock; 694 698 /* Lock for LEDs access. */ 695 699 spinlock_t leds_lock; 696 700 /* Lock for SHM access. */

+37 -14

drivers/net/wireless/b43/main.c

reviewed

··· 729 729 */ 730 730 void b43_dummy_transmission(struct b43_wldev *dev) 731 731 { 732 732 + struct b43_wl *wl = dev->wl; 732 733 struct b43_phy *phy = &dev->phy; 733 734 unsigned int i, max_loop; 734 735 u16 value; ··· 755 754 B43_WARN_ON(1); 756 755 return; 757 756 } 757 757 + 758 758 + spin_lock_irq(&wl->irq_lock); 759 759 + write_lock(&wl->tx_lock); 758 760 759 761 for (i = 0; i < 5; i++) 760 762 b43_ram_write(dev, i * 4, buffer[i]); ··· 799 795 } 800 796 if (phy->radio_ver == 0x2050 && phy->radio_rev <= 0x5) 801 797 b43_radio_write16(dev, 0x0051, 0x0037); 798 798 + 799 799 + write_unlock(&wl->tx_lock); 800 800 + spin_unlock_irq(&wl->irq_lock); 802 801 } 803 802 804 803 static void key_write(struct b43_wldev *dev, ··· 2847 2840 { 2848 2841 struct b43_wl *wl = hw_to_b43_wl(hw); 2849 2842 struct b43_wldev *dev = wl->current_dev; 2850 2850 - int err = -ENODEV; 2843 2843 + unsigned long flags; 2844 2844 + int err; 2851 2845 2852 2846 if (unlikely(skb->len < 2 + 2 + 6)) { 2853 2847 /* Too short, this can't be a valid frame. */ 2854 2854 - return -EINVAL; 2848 2848 + dev_kfree_skb_any(skb); 2849 2849 + return NETDEV_TX_OK; 2855 2850 } 2856 2851 B43_WARN_ON(skb_shinfo(skb)->nr_frags); 2857 2857 - 2858 2852 if (unlikely(!dev)) 2859 2859 - goto out; 2860 2860 - if (unlikely(b43_status(dev) < B43_STAT_STARTED)) 2861 2861 - goto out; 2862 2862 - /* TX is done without a global lock. */ 2863 2863 - if (b43_using_pio_transfers(dev)) 2864 2864 - err = b43_pio_tx(dev, skb, ctl); 2865 2865 - else 2866 2866 - err = b43_dma_tx(dev, skb, ctl); 2867 2867 - out: 2853 2853 + return NETDEV_TX_BUSY; 2854 2854 + 2855 2855 + /* Transmissions on seperate queues can run concurrently. */ 2856 2856 + read_lock_irqsave(&wl->tx_lock, flags); 2857 2857 + 2858 2858 + err = -ENODEV; 2859 2859 + if (likely(b43_status(dev) >= B43_STAT_STARTED)) { 2860 2860 + if (b43_using_pio_transfers(dev)) 2861 2861 + err = b43_pio_tx(dev, skb, ctl); 2862 2862 + else 2863 2863 + err = b43_dma_tx(dev, skb, ctl); 2864 2864 + } 2865 2865 + 2866 2866 + read_unlock_irqrestore(&wl->tx_lock, flags); 2867 2867 + 2868 2868 if (unlikely(err)) 2869 2869 return NETDEV_TX_BUSY; 2870 2870 return NETDEV_TX_OK; ··· 3490 3476 spin_unlock_irqrestore(&wl->irq_lock, flags); 3491 3477 b43_synchronize_irq(dev); 3492 3478 3479 3479 + write_lock_irqsave(&wl->tx_lock, flags); 3493 3480 b43_set_status(dev, B43_STAT_INITIALIZED); 3481 3481 + write_unlock_irqrestore(&wl->tx_lock, flags); 3494 3482 3495 3483 b43_pio_stop(dev); 3496 3484 mutex_unlock(&wl->mutex); ··· 3500 3484 * Cancel the possibly running self-rearming periodic work. */ 3501 3485 cancel_delayed_work_sync(&dev->periodic_work); 3502 3486 mutex_lock(&wl->mutex); 3503 3503 - 3504 3504 - ieee80211_stop_queues(wl->hw); //FIXME this could cause a deadlock, as mac80211 seems buggy. 3505 3487 3506 3488 b43_mac_suspend(dev); 3507 3489 free_irq(dev->dev->irq, dev); ··· 4340 4326 err = -EOPNOTSUPP; 4341 4327 goto err_powerdown; 4342 4328 } 4329 4329 + if (1 /* disable A-PHY */) { 4330 4330 + /* FIXME: For now we disable the A-PHY on multi-PHY devices. */ 4331 4331 + if (dev->phy.type != B43_PHYTYPE_N) { 4332 4332 + have_2ghz_phy = 1; 4333 4333 + have_5ghz_phy = 0; 4334 4334 + } 4335 4335 + } 4336 4336 + 4343 4337 dev->phy.gmode = have_2ghz_phy; 4344 4338 tmp = dev->phy.gmode ? B43_TMSLOW_GMODE : 0; 4345 4339 b43_wireless_core_reset(dev, tmp); ··· 4512 4490 memset(wl, 0, sizeof(*wl)); 4513 4491 wl->hw = hw; 4514 4492 spin_lock_init(&wl->irq_lock); 4493 4493 + rwlock_init(&wl->tx_lock); 4515 4494 spin_lock_init(&wl->leds_lock); 4516 4495 spin_lock_init(&wl->shm_lock); 4517 4496 mutex_init(&wl->mutex);

-1

drivers/net/wireless/iwlwifi/iwl-3945.h

reviewed

··· 742 742 u8 direct_ssid_len; 743 743 u8 direct_ssid[IW_ESSID_MAX_SIZE]; 744 744 struct iwl3945_scan_cmd *scan; 745 745 - u8 only_active_channel; 746 745 747 746 /* spinlock */ 748 747 spinlock_t lock; /* protect general shared data */

-1

drivers/net/wireless/iwlwifi/iwl-4965.h

reviewed

··· 996 996 u8 direct_ssid_len; 997 997 u8 direct_ssid[IW_ESSID_MAX_SIZE]; 998 998 struct iwl4965_scan_cmd *scan; 999 999 - u8 only_active_channel; 1000 999 1001 1000 /* spinlock */ 1002 1001 spinlock_t lock; /* protect general shared data */

+8 -21

drivers/net/wireless/iwlwifi/iwl3945-base.c

reviewed

··· 4968 4968 if (channels[i].flags & IEEE80211_CHAN_DISABLED) 4969 4969 continue; 4970 4970 4971 4971 - if (channels[i].hw_value == 4972 4972 - le16_to_cpu(priv->active_rxon.channel)) { 4973 4973 - if (iwl3945_is_associated(priv)) { 4974 4974 - IWL_DEBUG_SCAN 4975 4975 - ("Skipping current channel %d\n", 4976 4976 - le16_to_cpu(priv->active_rxon.channel)); 4977 4977 - continue; 4978 4978 - } 4979 4979 - } else if (priv->only_active_channel) 4980 4980 - continue; 4981 4981 - 4982 4971 scan_ch->channel = channels[i].hw_value; 4983 4972 4984 4973 ch_info = iwl3945_get_channel_info(priv, band, scan_ch->channel); ··· 6292 6303 priv->direct_ssid, priv->direct_ssid_len); 6293 6304 direct_mask = 1; 6294 6305 } else if (!iwl3945_is_associated(priv) && priv->essid_len) { 6306 6306 + IWL_DEBUG_SCAN 6307 6307 + ("Kicking off one direct scan for '%s' when not associated\n", 6308 6308 + iwl3945_escape_essid(priv->essid, priv->essid_len)); 6295 6309 scan->direct_scan[0].id = WLAN_EID_SSID; 6296 6310 scan->direct_scan[0].len = priv->essid_len; 6297 6311 memcpy(scan->direct_scan[0].ssid, priv->essid, priv->essid_len); 6298 6312 direct_mask = 1; 6299 6299 - } else 6313 6313 + } else { 6314 6314 + IWL_DEBUG_SCAN("Kicking off one indirect scan.\n"); 6300 6315 direct_mask = 0; 6316 6316 + } 6301 6317 6302 6318 /* We don't build a direct scan probe request; the uCode will do 6303 6319 * that based on the direct_mask added to each channel entry */ ··· 6340 6346 if (priv->iw_mode == IEEE80211_IF_TYPE_MNTR) 6341 6347 scan->filter_flags = RXON_FILTER_PROMISC_MSK; 6342 6348 6343 6343 - if (direct_mask) { 6344 6344 - IWL_DEBUG_SCAN 6345 6345 - ("Initiating direct scan for %s.\n", 6346 6346 - iwl3945_escape_essid(priv->essid, priv->essid_len)); 6349 6349 + if (direct_mask) 6347 6350 scan->channel_count = 6348 6351 iwl3945_get_channels_for_scan( 6349 6352 priv, band, 1, /* active */ 6350 6353 direct_mask, 6351 6354 (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]); 6352 6352 - } else { 6353 6353 - IWL_DEBUG_SCAN("Initiating indirect scan.\n"); 6355 6355 + else 6354 6356 scan->channel_count = 6355 6357 iwl3945_get_channels_for_scan( 6356 6358 priv, band, 0, /* passive */ 6357 6359 direct_mask, 6358 6360 (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]); 6359 6359 - } 6360 6361 6361 6362 cmd.len += le16_to_cpu(scan->tx_cmd.len) + 6362 6363 scan->channel_count * sizeof(struct iwl3945_scan_channel); ··· 7302 7313 mutex_unlock(&priv->mutex); 7303 7314 return; 7304 7315 } 7305 7305 - 7306 7306 - priv->only_active_channel = 0; 7307 7316 7308 7317 iwl3945_set_rate(priv); 7309 7318

+6 -20

drivers/net/wireless/iwlwifi/iwl4965-base.c

reviewed

··· 4633 4633 if (channels[i].flags & IEEE80211_CHAN_DISABLED) 4634 4634 continue; 4635 4635 4636 4636 - if (ieee80211_frequency_to_channel(channels[i].center_freq) == 4637 4637 - le16_to_cpu(priv->active_rxon.channel)) { 4638 4638 - if (iwl_is_associated(priv)) { 4639 4639 - IWL_DEBUG_SCAN 4640 4640 - ("Skipping current channel %d\n", 4641 4641 - le16_to_cpu(priv->active_rxon.channel)); 4642 4642 - continue; 4643 4643 - } 4644 4644 - } else if (priv->only_active_channel) 4645 4645 - continue; 4646 4646 - 4647 4636 scan_ch->channel = ieee80211_frequency_to_channel(channels[i].center_freq); 4648 4637 4649 4638 ch_info = iwl_get_channel_info(priv, band, ··· 5813 5824 priv->direct_ssid, priv->direct_ssid_len); 5814 5825 direct_mask = 1; 5815 5826 } else if (!iwl_is_associated(priv) && priv->essid_len) { 5827 5827 + IWL_DEBUG_SCAN 5828 5828 + ("Kicking off one direct scan for '%s' when not associated\n", 5829 5829 + iwl4965_escape_essid(priv->essid, priv->essid_len)); 5816 5830 scan->direct_scan[0].id = WLAN_EID_SSID; 5817 5831 scan->direct_scan[0].len = priv->essid_len; 5818 5832 memcpy(scan->direct_scan[0].ssid, priv->essid, priv->essid_len); 5819 5833 direct_mask = 1; 5820 5834 } else { 5835 5835 + IWL_DEBUG_SCAN("Kicking off one indirect scan.\n"); 5821 5836 direct_mask = 0; 5822 5837 } 5823 5838 ··· 5874 5881 if (priv->iw_mode == IEEE80211_IF_TYPE_MNTR) 5875 5882 scan->filter_flags = RXON_FILTER_PROMISC_MSK; 5876 5883 5877 5877 - if (direct_mask) { 5878 5878 - IWL_DEBUG_SCAN 5879 5879 - ("Initiating direct scan for %s.\n", 5880 5880 - iwl4965_escape_essid(priv->essid, priv->essid_len)); 5884 5884 + if (direct_mask) 5881 5885 scan->channel_count = 5882 5886 iwl4965_get_channels_for_scan( 5883 5887 priv, band, 1, /* active */ 5884 5888 direct_mask, 5885 5889 (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]); 5886 5886 - } else { 5887 5887 - IWL_DEBUG_SCAN("Initiating indirect scan.\n"); 5890 5890 + else 5888 5891 scan->channel_count = 5889 5892 iwl4965_get_channels_for_scan( 5890 5893 priv, band, 0, /* passive */ 5891 5894 direct_mask, 5892 5895 (void *)&scan->data[le16_to_cpu(scan->tx_cmd.len)]); 5893 5893 - } 5894 5896 5895 5897 cmd.len += le16_to_cpu(scan->tx_cmd.len) + 5896 5898 scan->channel_count * sizeof(struct iwl4965_scan_channel); ··· 7048 7060 mutex_unlock(&priv->mutex); 7049 7061 return; 7050 7062 } 7051 7051 - 7052 7052 - priv->only_active_channel = 0; 7053 7063 7054 7064 iwl4965_set_rate(priv); 7055 7065

+2 -1

drivers/net/wireless/libertas/scan.c

reviewed

··· 298 298 uint8_t *tlv; /* pointer into our current, growing TLV storage area */ 299 299 300 300 lbs_deb_enter_args(LBS_DEB_SCAN, "bsstype %d, chanlist[].chan %d, chan_count %d", 301 301 - bsstype, chan_list[0].channumber, chan_count); 301 301 + bsstype, chan_list ? chan_list[0].channumber : -1, 302 302 + chan_count); 302 303 303 304 /* create the fixed part for scan command */ 304 305 scan_cmd = kzalloc(MAX_SCAN_CFG_ALLOC, GFP_KERNEL);

+2 -2

drivers/net/wireless/rt2x00/rt2400pci.c

reviewed

··· 363 363 rt2x00pci_register_write(rt2x00dev, TXCSR1, reg); 364 364 365 365 rt2x00pci_register_read(rt2x00dev, ARCSR2, &reg); 366 366 - rt2x00_set_field32(&reg, ARCSR2_SIGNAL, 0x00 | preamble_mask); 366 366 + rt2x00_set_field32(&reg, ARCSR2_SIGNAL, 0x00); 367 367 rt2x00_set_field32(&reg, ARCSR2_SERVICE, 0x04); 368 368 rt2x00_set_field32(&reg, ARCSR2_LENGTH, get_duration(ACK_SIZE, 10)); 369 369 rt2x00pci_register_write(rt2x00dev, ARCSR2, reg); ··· 1308 1308 1309 1309 if (value == LED_MODE_TXRX_ACTIVITY) { 1310 1310 rt2x00dev->led_qual.rt2x00dev = rt2x00dev; 1311 1311 - rt2x00dev->led_radio.type = LED_TYPE_ACTIVITY; 1311 1311 + rt2x00dev->led_qual.type = LED_TYPE_ACTIVITY; 1312 1312 rt2x00dev->led_qual.led_dev.brightness_set = 1313 1313 rt2400pci_brightness_set; 1314 1314 rt2x00dev->led_qual.led_dev.blink_set =

+2 -2

drivers/net/wireless/rt2x00/rt2500pci.c

reviewed

··· 370 370 rt2x00pci_register_write(rt2x00dev, TXCSR1, reg); 371 371 372 372 rt2x00pci_register_read(rt2x00dev, ARCSR2, &reg); 373 373 - rt2x00_set_field32(&reg, ARCSR2_SIGNAL, 0x00 | preamble_mask); 373 373 + rt2x00_set_field32(&reg, ARCSR2_SIGNAL, 0x00); 374 374 rt2x00_set_field32(&reg, ARCSR2_SERVICE, 0x04); 375 375 rt2x00_set_field32(&reg, ARCSR2_LENGTH, get_duration(ACK_SIZE, 10)); 376 376 rt2x00pci_register_write(rt2x00dev, ARCSR2, reg); ··· 1485 1485 1486 1486 if (value == LED_MODE_TXRX_ACTIVITY) { 1487 1487 rt2x00dev->led_qual.rt2x00dev = rt2x00dev; 1488 1488 - rt2x00dev->led_radio.type = LED_TYPE_ACTIVITY; 1488 1488 + rt2x00dev->led_qual.type = LED_TYPE_ACTIVITY; 1489 1489 rt2x00dev->led_qual.led_dev.brightness_set = 1490 1490 rt2500pci_brightness_set; 1491 1491 rt2x00dev->led_qual.led_dev.blink_set =

+1 -1

drivers/net/wireless/rt2x00/rt2500usb.c

reviewed

··· 1394 1394 1395 1395 if (value == LED_MODE_TXRX_ACTIVITY) { 1396 1396 rt2x00dev->led_qual.rt2x00dev = rt2x00dev; 1397 1397 - rt2x00dev->led_radio.type = LED_TYPE_ACTIVITY; 1397 1397 + rt2x00dev->led_qual.type = LED_TYPE_ACTIVITY; 1398 1398 rt2x00dev->led_qual.led_dev.brightness_set = 1399 1399 rt2500usb_brightness_set; 1400 1400 rt2x00dev->led_qual.led_dev.blink_set =

+2

drivers/net/wireless/rt2x00/rt2x00dev.c

reviewed

··· 114 114 return status; 115 115 116 116 rt2x00leds_led_radio(rt2x00dev, true); 117 117 + rt2x00led_led_activity(rt2x00dev, true); 117 118 118 119 __set_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags); 119 120 ··· 158 157 * Disable radio. 159 158 */ 160 159 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF); 160 160 + rt2x00led_led_activity(rt2x00dev, false); 161 161 rt2x00leds_led_radio(rt2x00dev, false); 162 162 } 163 163

+15

drivers/net/wireless/rt2x00/rt2x00leds.c

reviewed

··· 72 72 } 73 73 } 74 74 75 75 + void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, bool enabled) 76 76 + { 77 77 + struct rt2x00_led *led = &rt2x00dev->led_qual; 78 78 + unsigned int brightness; 79 79 + 80 80 + if ((led->type != LED_TYPE_ACTIVITY) || !(led->flags & LED_REGISTERED)) 81 81 + return; 82 82 + 83 83 + brightness = enabled ? LED_FULL : LED_OFF; 84 84 + if (brightness != led->led_dev.brightness) { 85 85 + led->led_dev.brightness_set(&led->led_dev, brightness); 86 86 + led->led_dev.brightness = brightness; 87 87 + } 88 88 + } 89 89 + 75 90 void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled) 76 91 { 77 92 struct rt2x00_led *led = &rt2x00dev->led_assoc;

+6

drivers/net/wireless/rt2x00/rt2x00lib.h

reviewed

··· 185 185 */ 186 186 #ifdef CONFIG_RT2X00_LIB_LEDS 187 187 void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, int rssi); 188 188 + void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, bool enabled); 188 189 void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled); 189 190 void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled); 190 191 void rt2x00leds_register(struct rt2x00_dev *rt2x00dev); ··· 195 194 #else 196 195 static inline void rt2x00leds_led_quality(struct rt2x00_dev *rt2x00dev, 197 196 int rssi) 197 197 + { 198 198 + } 199 199 + 200 200 + static inline void rt2x00led_led_activity(struct rt2x00_dev *rt2x00dev, 201 201 + bool enabled) 198 202 { 199 203 } 200 204

+1 -1

drivers/net/wireless/rt2x00/rt61pci.c

reviewed

··· 2087 2087 2088 2088 if (value == LED_MODE_SIGNAL_STRENGTH) { 2089 2089 rt2x00dev->led_qual.rt2x00dev = rt2x00dev; 2090 2090 - rt2x00dev->led_radio.type = LED_TYPE_QUALITY; 2090 2090 + rt2x00dev->led_qual.type = LED_TYPE_QUALITY; 2091 2091 rt2x00dev->led_qual.led_dev.brightness_set = 2092 2092 rt61pci_brightness_set; 2093 2093 rt2x00dev->led_qual.led_dev.blink_set =

+1 -1

drivers/net/wireless/rt2x00/rt73usb.c

reviewed

··· 1647 1647 1648 1648 if (value == LED_MODE_SIGNAL_STRENGTH) { 1649 1649 rt2x00dev->led_qual.rt2x00dev = rt2x00dev; 1650 1650 - rt2x00dev->led_radio.type = LED_TYPE_QUALITY; 1650 1650 + rt2x00dev->led_qual.type = LED_TYPE_QUALITY; 1651 1651 rt2x00dev->led_qual.led_dev.brightness_set = 1652 1652 rt73usb_brightness_set; 1653 1653 rt2x00dev->led_qual.led_dev.blink_set =

+1 -1

drivers/net/xen-netfront.c

reviewed

··· 1803 1803 if (is_initial_xendomain()) 1804 1804 return; 1805 1805 1806 1806 - return xenbus_unregister_driver(&netfront); 1806 1806 + xenbus_unregister_driver(&netfront); 1807 1807 } 1808 1808 module_exit(netif_exit); 1809 1809

+17

fs/proc/generic.c

reviewed

··· 641 641 return ent; 642 642 } 643 643 644 644 + struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name, 645 645 + struct proc_dir_entry *parent) 646 646 + { 647 647 + struct proc_dir_entry *ent; 648 648 + 649 649 + ent = __proc_create(&parent, name, S_IFDIR | S_IRUGO | S_IXUGO, 2); 650 650 + if (ent) { 651 651 + ent->data = net; 652 652 + if (proc_register(parent, ent) < 0) { 653 653 + kfree(ent); 654 654 + ent = NULL; 655 655 + } 656 656 + } 657 657 + return ent; 658 658 + } 659 659 + EXPORT_SYMBOL_GPL(proc_net_mkdir); 660 660 + 644 661 struct proc_dir_entry *proc_mkdir(const char *name, 645 662 struct proc_dir_entry *parent) 646 663 {

-11

fs/proc/proc_net.c

reviewed

··· 159 159 } 160 160 EXPORT_SYMBOL_GPL(get_proc_net); 161 161 162 162 - struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name, 163 163 - struct proc_dir_entry *parent) 164 164 - { 165 165 - struct proc_dir_entry *pde; 166 166 - pde = proc_mkdir_mode(name, S_IRUGO | S_IXUGO, parent); 167 167 - if (pde != NULL) 168 168 - pde->data = net; 169 169 - return pde; 170 170 - } 171 171 - EXPORT_SYMBOL_GPL(proc_net_mkdir); 172 172 - 173 162 static __net_init int proc_net_ns_init(struct net *net) 174 163 { 175 164 struct proc_dir_entry *netd, *net_statd;

+1 -1

include/linux/ieee80211.h

reviewed

··· 113 113 struct ieee80211s_hdr { 114 114 u8 flags; 115 115 u8 ttl; 116 116 - u8 seqnum[3]; 116 116 + __le32 seqnum; 117 117 u8 eaddr1[6]; 118 118 u8 eaddr2[6]; 119 119 u8 eaddr3[6];

+3 -1

include/linux/if_bridge.h

reviewed

··· 97 97 __u8 port_no; 98 98 __u8 is_local; 99 99 __u32 ageing_timer_value; 100 100 - __u32 unused; 100 100 + __u8 port_hi; 101 101 + __u8 pad0; 102 102 + __u16 unused; 101 103 }; 102 104 103 105 #ifdef __KERNEL__

+1 -6

include/linux/wireless.h

reviewed

··· 69 69 70 70 /***************************** INCLUDES *****************************/ 71 71 72 72 - /* This header is used in user-space, therefore need to be sanitised 73 73 - * for that purpose. Those includes are usually not compatible with glibc. 74 74 - * To know which includes to use in user-space, check iwlib.h. */ 75 75 - #ifdef __KERNEL__ 76 76 - #include <linux/types.h> /* for "caddr_t" et al */ 72 72 + #include <linux/types.h> /* for __u* and __s* typedefs */ 77 73 #include <linux/socket.h> /* for "struct sockaddr" et al */ 78 74 #include <linux/if.h> /* for IFNAMSIZ and co... */ 79 79 - #endif /* __KERNEL__ */ 80 75 81 76 /***************************** VERSION *****************************/ 82 77 /*

+3 -4

net/8021q/vlanproc.c

reviewed

··· 176 176 struct vlan_dev_info *dev_info = vlan_dev_info(vlandev); 177 177 struct vlan_net *vn = net_generic(dev_net(vlandev), vlan_net_id); 178 178 179 179 - dev_info->dent = proc_create(vlandev->name, S_IFREG|S_IRUSR|S_IWUSR, 180 180 - vn->proc_vlan_dir, &vlandev_fops); 179 179 + dev_info->dent = 180 180 + proc_create_data(vlandev->name, S_IFREG|S_IRUSR|S_IWUSR, 181 181 + vn->proc_vlan_dir, &vlandev_fops, vlandev); 181 182 if (!dev_info->dent) 182 183 return -ENOBUFS; 183 183 - 184 184 - dev_info->dent->data = vlandev; 185 184 return 0; 186 185 } 187 186

+2 -4

net/atm/proc.c

reviewed

··· 417 417 goto err_out; 418 418 sprintf(dev->proc_name,"%s:%d",dev->type, dev->number); 419 419 420 420 - dev->proc_entry = proc_create(dev->proc_name, 0, atm_proc_root, 421 421 - &proc_atm_dev_ops); 420 420 + dev->proc_entry = proc_create_data(dev->proc_name, 0, atm_proc_root, 421 421 + &proc_atm_dev_ops, dev); 422 422 if (!dev->proc_entry) 423 423 goto err_free_name; 424 424 - dev->proc_entry->data = dev; 425 425 - dev->proc_entry->owner = THIS_MODULE; 426 424 return 0; 427 425 err_free_name: 428 426 kfree(dev->proc_name);

+4 -4

net/bluetooth/bnep/core.c

reviewed

··· 135 135 if (len < 2) 136 136 return -EILSEQ; 137 137 138 138 - n = ntohs(get_unaligned(data)); 138 138 + n = get_unaligned_be16(data); 139 139 data++; len -= 2; 140 140 141 141 if (len < n) ··· 150 150 int i; 151 151 152 152 for (i = 0; i < n; i++) { 153 153 - f[i].start = ntohs(get_unaligned(data++)); 154 154 - f[i].end = ntohs(get_unaligned(data++)); 153 153 + f[i].start = get_unaligned_be16(data++); 154 154 + f[i].end = get_unaligned_be16(data++); 155 155 156 156 BT_DBG("proto filter start %d end %d", 157 157 f[i].start, f[i].end); ··· 180 180 if (len < 2) 181 181 return -EILSEQ; 182 182 183 183 - n = ntohs(get_unaligned((__be16 *) data)); 183 183 + n = get_unaligned_be16(data); 184 184 data += 2; len -= 2; 185 185 186 186 if (len < n)

+4 -5

net/bluetooth/hci_event.c

reviewed

··· 129 129 130 130 conn = hci_conn_hash_lookup_handle(hdev, __le16_to_cpu(rp->handle)); 131 131 if (conn) { 132 132 - __le16 policy = get_unaligned((__le16 *) (sent + 2)); 133 133 - conn->link_policy = __le16_to_cpu(policy); 132 132 + conn->link_policy = get_unaligned_le16(sent + 2); 134 133 } 135 134 136 135 hci_dev_unlock(hdev); ··· 312 313 return; 313 314 314 315 if (!status) { 315 315 - __u16 setting = __le16_to_cpu(get_unaligned((__le16 *) sent)); 316 316 + __u16 setting = get_unaligned_le16(sent); 316 317 317 318 if (hdev->voice_setting != setting) { 318 319 hdev->voice_setting = setting; ··· 1151 1152 struct hci_conn *conn; 1152 1153 __u16 handle, count; 1153 1154 1154 1154 - handle = __le16_to_cpu(get_unaligned(ptr++)); 1155 1155 - count = __le16_to_cpu(get_unaligned(ptr++)); 1155 1155 + handle = get_unaligned_le16(ptr++); 1156 1156 + count = get_unaligned_le16(ptr++); 1156 1157 1157 1158 conn = hci_conn_hash_lookup_handle(hdev, handle); 1158 1159 if (conn) {

+1 -1

net/bluetooth/hci_sock.c

reviewed

··· 440 440 skb->dev = (void *) hdev; 441 441 442 442 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) { 443 443 - u16 opcode = __le16_to_cpu(get_unaligned((__le16 *) skb->data)); 443 443 + u16 opcode = get_unaligned_le16(skb->data); 444 444 u16 ogf = hci_opcode_ogf(opcode); 445 445 u16 ocf = hci_opcode_ocf(opcode); 446 446

+1 -1

net/bluetooth/l2cap.c

reviewed

··· 1827 1827 del_timer(&conn->info_timer); 1828 1828 1829 1829 if (type == L2CAP_IT_FEAT_MASK) 1830 1830 - conn->feat_mask = __le32_to_cpu(get_unaligned((__le32 *) rsp->data)); 1830 1830 + conn->feat_mask = get_unaligned_le32(rsp->data); 1831 1831 1832 1832 l2cap_conn_start(conn); 1833 1833

+4

net/bridge/br_fdb.c

reviewed

··· 285 285 286 286 /* convert from internal format to API */ 287 287 memcpy(fe->mac_addr, f->addr.addr, ETH_ALEN); 288 288 + 289 289 + /* due to ABI compat need to split into hi/lo */ 288 290 fe->port_no = f->dst->port_no; 291 291 + fe->port_hi = f->dst->port_no >> 8; 292 292 + 289 293 fe->is_local = f->is_local; 290 294 if (!f->is_static) 291 295 fe->ageing_timer_value = jiffies_to_clock_t(jiffies - f->ageing_timer);

+2 -2

net/bridge/br_stp_bpdu.c

reviewed

··· 58 58 { 59 59 unsigned long ticks = (STP_HZ * j)/ HZ; 60 60 61 61 - put_unaligned(htons(ticks), (__be16 *)dest); 61 61 + put_unaligned_be16(ticks, dest); 62 62 } 63 63 64 64 static inline int br_get_ticks(const unsigned char *src) 65 65 { 66 66 - unsigned long ticks = ntohs(get_unaligned((__be16 *)src)); 66 66 + unsigned long ticks = get_unaligned_be16(src); 67 67 68 68 return DIV_ROUND_UP(ticks * HZ, STP_HZ); 69 69 }

+14 -5

net/core/dev.c

reviewed

··· 162 162 struct dma_client client; 163 163 spinlock_t lock; 164 164 cpumask_t channel_mask; 165 165 - struct dma_chan *channels[NR_CPUS]; 165 165 + struct dma_chan **channels; 166 166 }; 167 167 168 168 static enum dma_state_client ··· 2444 2444 { 2445 2445 struct netif_rx_stats *rc = NULL; 2446 2446 2447 2447 - while (*pos < NR_CPUS) 2447 2447 + while (*pos < nr_cpu_ids) 2448 2448 if (cpu_online(*pos)) { 2449 2449 rc = &per_cpu(netdev_rx_stat, *pos); 2450 2450 break; ··· 3776 3776 } 3777 3777 } 3778 3778 3779 3779 + netdev_initialize_kobject(dev); 3779 3780 ret = netdev_register_kobject(dev); 3780 3781 if (ret) 3781 3782 goto err_uninit; ··· 4209 4208 } 4210 4209 4211 4210 /* Fixup kobjects */ 4212 4212 - err = device_rename(&dev->dev, dev->name); 4211 4211 + netdev_unregister_kobject(dev); 4212 4212 + err = netdev_register_kobject(dev); 4213 4213 WARN_ON(err); 4214 4214 4215 4215 /* Add the device back in the hashes */ ··· 4326 4324 spin_lock(&net_dma->lock); 4327 4325 switch (state) { 4328 4326 case DMA_RESOURCE_AVAILABLE: 4329 4329 - for (i = 0; i < NR_CPUS; i++) 4327 4327 + for (i = 0; i < nr_cpu_ids; i++) 4330 4328 if (net_dma->channels[i] == chan) { 4331 4329 found = 1; 4332 4330 break; ··· 4341 4339 } 4342 4340 break; 4343 4341 case DMA_RESOURCE_REMOVED: 4344 4344 - for (i = 0; i < NR_CPUS; i++) 4342 4342 + for (i = 0; i < nr_cpu_ids; i++) 4345 4343 if (net_dma->channels[i] == chan) { 4346 4344 found = 1; 4347 4345 pos = i; ··· 4368 4366 */ 4369 4367 static int __init netdev_dma_register(void) 4370 4368 { 4369 4369 + net_dma.channels = kzalloc(nr_cpu_ids * sizeof(struct net_dma), 4370 4370 + GFP_KERNEL); 4371 4371 + if (unlikely(!net_dma.channels)) { 4372 4372 + printk(KERN_NOTICE 4373 4373 + "netdev_dma: no memory for net_dma.channels\n"); 4374 4374 + return -ENOMEM; 4375 4375 + } 4371 4376 spin_lock_init(&net_dma.lock); 4372 4377 dma_cap_set(DMA_MEMCPY, net_dma.client.cap_mask); 4373 4378 dma_async_client_register(&net_dma.client);

+2 -2

net/core/filter.c

reviewed

··· 213 213 load_w: 214 214 ptr = load_pointer(skb, k, 4, &tmp); 215 215 if (ptr != NULL) { 216 216 - A = ntohl(get_unaligned((__be32 *)ptr)); 216 216 + A = get_unaligned_be32(ptr); 217 217 continue; 218 218 } 219 219 break; ··· 222 222 load_h: 223 223 ptr = load_pointer(skb, k, 2, &tmp); 224 224 if (ptr != NULL) { 225 225 - A = ntohs(get_unaligned((__be16 *)ptr)); 225 225 + A = get_unaligned_be16(ptr); 226 226 continue; 227 227 } 228 228 break;

+2 -3

net/core/neighbour.c

reviewed

··· 1430 1430 panic("cannot create neighbour cache statistics"); 1431 1431 1432 1432 #ifdef CONFIG_PROC_FS 1433 1433 - tbl->pde = proc_create(tbl->id, 0, init_net.proc_net_stat, 1434 1434 - &neigh_stat_seq_fops); 1433 1433 + tbl->pde = proc_create_data(tbl->id, 0, init_net.proc_net_stat, 1434 1434 + &neigh_stat_seq_fops, tbl); 1435 1435 if (!tbl->pde) 1436 1436 panic("cannot create neighbour proc dir entry"); 1437 1437 - tbl->pde->data = tbl; 1438 1437 #endif 1439 1438 1440 1439 tbl->hash_mask = 1;

+6 -1

net/core/net-sysfs.c

reviewed

··· 449 449 struct device *dev = &(net->dev); 450 450 struct attribute_group **groups = net->sysfs_groups; 451 451 452 452 - device_initialize(dev); 453 452 dev->class = &net_class; 454 453 dev->platform_data = net; 455 454 dev->groups = groups; ··· 467 468 #endif /* CONFIG_SYSFS */ 468 469 469 470 return device_add(dev); 471 471 + } 472 472 + 473 473 + void netdev_initialize_kobject(struct net_device *net) 474 474 + { 475 475 + struct device *device = &(net->dev); 476 476 + device_initialize(device); 470 477 } 471 478 472 479 int netdev_kobject_init(void)

+1 -1

net/core/net-sysfs.h

reviewed

··· 4 4 int netdev_kobject_init(void); 5 5 int netdev_register_kobject(struct net_device *); 6 6 void netdev_unregister_kobject(struct net_device *); 7 7 - 7 7 + void netdev_initialize_kobject(struct net_device *); 8 8 #endif

+4 -8

net/core/pktgen.c

reviewed

··· 3570 3570 if (err) 3571 3571 goto out1; 3572 3572 3573 3573 - pkt_dev->entry = proc_create(ifname, 0600, 3574 3574 - pg_proc_dir, &pktgen_if_fops); 3573 3573 + pkt_dev->entry = proc_create_data(ifname, 0600, pg_proc_dir, 3574 3574 + &pktgen_if_fops, pkt_dev); 3575 3575 if (!pkt_dev->entry) { 3576 3576 printk(KERN_ERR "pktgen: cannot create %s/%s procfs entry.\n", 3577 3577 PG_PROC_DIR, ifname); 3578 3578 err = -EINVAL; 3579 3579 goto out2; 3580 3580 } 3581 3581 - pkt_dev->entry->data = pkt_dev; 3582 3581 #ifdef CONFIG_XFRM 3583 3582 pkt_dev->ipsmode = XFRM_MODE_TRANSPORT; 3584 3583 pkt_dev->ipsproto = IPPROTO_ESP; ··· 3627 3628 kthread_bind(p, cpu); 3628 3629 t->tsk = p; 3629 3630 3630 3630 - pe = proc_create(t->tsk->comm, 0600, pg_proc_dir, &pktgen_thread_fops); 3631 3631 + pe = proc_create_data(t->tsk->comm, 0600, pg_proc_dir, 3632 3632 + &pktgen_thread_fops, t); 3631 3633 if (!pe) { 3632 3634 printk(KERN_ERR "pktgen: cannot create %s/%s procfs entry.\n", 3633 3635 PG_PROC_DIR, t->tsk->comm); ··· 3637 3637 kfree(t); 3638 3638 return -EINVAL; 3639 3639 } 3640 3640 - 3641 3641 - pe->data = t; 3642 3640 3643 3641 wake_up_process(p); 3644 3642 ··· 3713 3715 proc_net_remove(&init_net, PG_PROC_DIR); 3714 3716 return -EINVAL; 3715 3717 } 3716 3716 - 3717 3717 - pe->data = NULL; 3718 3718 3719 3719 /* Register us to receive netdevice events */ 3720 3720 register_netdevice_notifier(&pktgen_notifier_block);

+2 -1

net/core/sock.c

reviewed

··· 228 228 static int warned __read_mostly; 229 229 230 230 *timeo_p = 0; 231 231 - if (warned < 10 && net_ratelimit()) 231 231 + if (warned < 10 && net_ratelimit()) { 232 232 warned++; 233 233 printk(KERN_INFO "sock_set_timeout: `%s' (pid %d) " 234 234 "tries to set negative timeout\n", 235 235 current->comm, task_pid_nr(current)); 236 236 + } 236 237 return 0; 237 238 } 238 239 *timeo_p = MAX_SCHEDULE_TIMEOUT;

+1 -1

net/dccp/ccids/ccid2.c

reviewed

··· 716 716 * packets for new connections, following the rules from [RFC3390]". 717 717 * We need to convert the bytes of RFC3390 into the packets of RFC 4341. 718 718 */ 719 719 - hctx->ccid2hctx_cwnd = min(4U, max(2U, 4380U / dp->dccps_mss_cache)); 719 719 + hctx->ccid2hctx_cwnd = clamp(4380U / dp->dccps_mss_cache, 2U, 4U); 720 720 721 721 /* Make sure that Ack Ratio is enabled and within bounds. */ 722 722 max_ratio = DIV_ROUND_UP(hctx->ccid2hctx_cwnd, 2);

+2 -2

net/dccp/ccids/ccid3.c

reviewed

··· 88 88 static inline u64 rfc3390_initial_rate(struct sock *sk) 89 89 { 90 90 const struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 91 91 - const __u32 w_init = min_t(__u32, 4 * hctx->ccid3hctx_s, 92 92 - max_t(__u32, 2 * hctx->ccid3hctx_s, 4380)); 91 91 + const __u32 w_init = clamp_t(__u32, 4380U, 92 92 + 2 * hctx->ccid3hctx_s, 4 * hctx->ccid3hctx_s); 93 93 94 94 return scaled_div(w_init << 6, hctx->ccid3hctx_rtt); 95 95 }

+8 -10

net/ipv4/cipso_ipv4.c

reviewed

··· 983 983 return -EFAULT; 984 984 985 985 for (iter = 0; iter < enumcat_len; iter += 2) { 986 986 - cat = ntohs(get_unaligned((__be16 *)&enumcat[iter])); 986 986 + cat = get_unaligned_be16(&enumcat[iter]); 987 987 if (cat <= cat_prev) 988 988 return -EFAULT; 989 989 cat_prev = cat; ··· 1052 1052 1053 1053 for (iter = 0; iter < net_cat_len; iter += 2) { 1054 1054 ret_val = netlbl_secattr_catmap_setbit(secattr->attr.mls.cat, 1055 1055 - ntohs(get_unaligned((__be16 *)&net_cat[iter])), 1055 1055 + get_unaligned_be16(&net_cat[iter]), 1056 1056 GFP_ATOMIC); 1057 1057 if (ret_val != 0) 1058 1058 return ret_val; ··· 1086 1086 return -EFAULT; 1087 1087 1088 1088 for (iter = 0; iter < rngcat_len; iter += 4) { 1089 1089 - cat_high = ntohs(get_unaligned((__be16 *)&rngcat[iter])); 1089 1089 + cat_high = get_unaligned_be16(&rngcat[iter]); 1090 1090 if ((iter + 4) <= rngcat_len) 1091 1091 - cat_low = ntohs( 1092 1092 - get_unaligned((__be16 *)&rngcat[iter + 2])); 1091 1091 + cat_low = get_unaligned_be16(&rngcat[iter + 2]); 1093 1092 else 1094 1093 cat_low = 0; 1095 1094 ··· 1187 1188 u16 cat_high; 1188 1189 1189 1190 for (net_iter = 0; net_iter < net_cat_len; net_iter += 4) { 1190 1190 - cat_high = ntohs(get_unaligned((__be16 *)&net_cat[net_iter])); 1191 1191 + cat_high = get_unaligned_be16(&net_cat[net_iter]); 1191 1192 if ((net_iter + 4) <= net_cat_len) 1192 1192 - cat_low = ntohs( 1193 1193 - get_unaligned((__be16 *)&net_cat[net_iter + 2])); 1193 1193 + cat_low = get_unaligned_be16(&net_cat[net_iter + 2]); 1194 1194 else 1195 1195 cat_low = 0; 1196 1196 ··· 1560 1562 } 1561 1563 1562 1564 rcu_read_lock(); 1563 1563 - doi_def = cipso_v4_doi_search(ntohl(get_unaligned((__be32 *)&opt[2]))); 1565 1565 + doi_def = cipso_v4_doi_search(get_unaligned_be32(&opt[2])); 1564 1566 if (doi_def == NULL) { 1565 1567 err_offset = 2; 1566 1568 goto validate_return_locked; ··· 1841 1843 if (cipso_v4_cache_check(cipso, cipso[1], secattr) == 0) 1842 1844 return 0; 1843 1845 1844 1844 - doi = ntohl(get_unaligned((__be32 *)&cipso[2])); 1846 1846 + doi = get_unaligned_be32(&cipso[2]); 1845 1847 rcu_read_lock(); 1846 1848 doi_def = cipso_v4_doi_search(doi); 1847 1849 if (doi_def == NULL)

+3 -3

net/ipv4/netfilter/ipt_CLUSTERIP.c

reviewed

··· 169 169 170 170 /* create proc dir entry */ 171 171 sprintf(buffer, "%u.%u.%u.%u", NIPQUAD(ip)); 172 172 - c->pde = proc_create(buffer, S_IWUSR|S_IRUSR, 173 173 - clusterip_procdir, &clusterip_proc_fops); 172 172 + c->pde = proc_create_data(buffer, S_IWUSR|S_IRUSR, 173 173 + clusterip_procdir, 174 174 + &clusterip_proc_fops, c); 174 175 if (!c->pde) { 175 176 kfree(c); 176 177 return NULL; 177 178 } 178 179 } 179 179 - c->pde->data = c; 180 180 #endif 181 181 182 182 write_lock_bh(&clusterip_lock);

+4 -2

net/ipv4/tcp_hybla.c

reviewed

··· 101 101 if (!tcp_is_cwnd_limited(sk, in_flight)) 102 102 return; 103 103 104 104 - if (!ca->hybla_en) 105 105 - return tcp_reno_cong_avoid(sk, ack, in_flight); 104 104 + if (!ca->hybla_en) { 105 105 + tcp_reno_cong_avoid(sk, ack, in_flight); 106 106 + return; 107 107 + } 106 108 107 109 if (ca->rho == 0) 108 110 hybla_recalc_param(sk);

+9 -9

net/ipv4/tcp_input.c

reviewed

··· 1172 1172 struct tcp_sack_block_wire *sp, int num_sacks, 1173 1173 u32 prior_snd_una) 1174 1174 { 1175 1175 - u32 start_seq_0 = ntohl(get_unaligned(&sp[0].start_seq)); 1176 1176 - u32 end_seq_0 = ntohl(get_unaligned(&sp[0].end_seq)); 1175 1175 + u32 start_seq_0 = get_unaligned_be32(&sp[0].start_seq); 1176 1176 + u32 end_seq_0 = get_unaligned_be32(&sp[0].end_seq); 1177 1177 int dup_sack = 0; 1178 1178 1179 1179 if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) { ··· 1181 1181 tcp_dsack_seen(tp); 1182 1182 NET_INC_STATS_BH(LINUX_MIB_TCPDSACKRECV); 1183 1183 } else if (num_sacks > 1) { 1184 1184 - u32 end_seq_1 = ntohl(get_unaligned(&sp[1].end_seq)); 1185 1185 - u32 start_seq_1 = ntohl(get_unaligned(&sp[1].start_seq)); 1184 1184 + u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq); 1185 1185 + u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq); 1186 1186 1187 1187 if (!after(end_seq_0, end_seq_1) && 1188 1188 !before(start_seq_0, start_seq_1)) { ··· 1453 1453 for (i = 0; i < num_sacks; i++) { 1454 1454 int dup_sack = !i && found_dup_sack; 1455 1455 1456 1456 - sp[used_sacks].start_seq = ntohl(get_unaligned(&sp_wire[i].start_seq)); 1457 1457 - sp[used_sacks].end_seq = ntohl(get_unaligned(&sp_wire[i].end_seq)); 1456 1456 + sp[used_sacks].start_seq = get_unaligned_be32(&sp_wire[i].start_seq); 1457 1457 + sp[used_sacks].end_seq = get_unaligned_be32(&sp_wire[i].end_seq); 1458 1458 1459 1459 if (!tcp_is_sackblock_valid(tp, dup_sack, 1460 1460 sp[used_sacks].start_seq, ··· 3340 3340 switch (opcode) { 3341 3341 case TCPOPT_MSS: 3342 3342 if (opsize == TCPOLEN_MSS && th->syn && !estab) { 3343 3343 - u16 in_mss = ntohs(get_unaligned((__be16 *)ptr)); 3343 3343 + u16 in_mss = get_unaligned_be16(ptr); 3344 3344 if (in_mss) { 3345 3345 if (opt_rx->user_mss && 3346 3346 opt_rx->user_mss < in_mss) ··· 3369 3369 ((estab && opt_rx->tstamp_ok) || 3370 3370 (!estab && sysctl_tcp_timestamps))) { 3371 3371 opt_rx->saw_tstamp = 1; 3372 3372 - opt_rx->rcv_tsval = ntohl(get_unaligned((__be32 *)ptr)); 3373 3373 - opt_rx->rcv_tsecr = ntohl(get_unaligned((__be32 *)(ptr+4))); 3372 3372 + opt_rx->rcv_tsval = get_unaligned_be32(ptr); 3373 3373 + opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4); 3374 3374 } 3375 3375 break; 3376 3376 case TCPOPT_SACK_PERM:

+3 -7

net/ipv4/tcp_ipv4.c

reviewed

··· 2214 2214 struct tcp_iter_state *s; 2215 2215 int err; 2216 2216 2217 2217 - if (unlikely(afinfo == NULL)) 2218 2218 - return -EINVAL; 2219 2219 - 2220 2217 err = seq_open_net(inode, file, &afinfo->seq_ops, 2221 2218 sizeof(struct tcp_iter_state)); 2222 2219 if (err < 0) ··· 2238 2241 afinfo->seq_ops.next = tcp_seq_next; 2239 2242 afinfo->seq_ops.stop = tcp_seq_stop; 2240 2243 2241 2241 - p = proc_net_fops_create(net, afinfo->name, S_IRUGO, &afinfo->seq_fops); 2242 2242 - if (p) 2243 2243 - p->data = afinfo; 2244 2244 - else 2244 2244 + p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net, 2245 2245 + &afinfo->seq_fops, afinfo); 2246 2246 + if (!p) 2245 2247 rc = -ENOMEM; 2246 2248 return rc; 2247 2249 }

+4 -2

net/ipv4/tcp_vegas.c

reviewed

··· 167 167 struct tcp_sock *tp = tcp_sk(sk); 168 168 struct vegas *vegas = inet_csk_ca(sk); 169 169 170 170 - if (!vegas->doing_vegas_now) 171 171 - return tcp_reno_cong_avoid(sk, ack, in_flight); 170 170 + if (!vegas->doing_vegas_now) { 171 171 + tcp_reno_cong_avoid(sk, ack, in_flight); 172 172 + return; 173 173 + } 172 174 173 175 /* The key players are v_beg_snd_una and v_beg_snd_nxt. 174 176 *

+4 -2

net/ipv4/tcp_veno.c

reviewed

··· 119 119 struct tcp_sock *tp = tcp_sk(sk); 120 120 struct veno *veno = inet_csk_ca(sk); 121 121 122 122 - if (!veno->doing_veno_now) 123 123 - return tcp_reno_cong_avoid(sk, ack, in_flight); 122 122 + if (!veno->doing_veno_now) { 123 123 + tcp_reno_cong_avoid(sk, ack, in_flight); 124 124 + return; 125 125 + } 124 126 125 127 /* limited by applications */ 126 128 if (!tcp_is_cwnd_limited(sk, in_flight))

+3 -4

net/ipv4/udp.c

reviewed

··· 1605 1605 afinfo->seq_ops.next = udp_seq_next; 1606 1606 afinfo->seq_ops.stop = udp_seq_stop; 1607 1607 1608 1608 - p = proc_net_fops_create(net, afinfo->name, S_IRUGO, &afinfo->seq_fops); 1609 1609 - if (p) 1610 1610 - p->data = afinfo; 1611 1611 - else 1608 1608 + p = proc_create_data(afinfo->name, S_IRUGO, net->proc_net, 1609 1609 + &afinfo->seq_fops, afinfo); 1610 1610 + if (!p) 1612 1611 rc = -ENOMEM; 1613 1612 return rc; 1614 1613 }

+2 -4

net/ipv6/proc.c

reviewed

··· 247 247 if (!proc_net_devsnmp6) 248 248 return -ENOENT; 249 249 250 250 - p = proc_create(idev->dev->name, S_IRUGO, 251 251 - proc_net_devsnmp6, &snmp6_seq_fops); 250 250 + p = proc_create_data(idev->dev->name, S_IRUGO, 251 251 + proc_net_devsnmp6, &snmp6_seq_fops, idev); 252 252 if (!p) 253 253 return -ENOMEM; 254 254 - 255 255 - p->data = idev; 256 254 257 255 idev->stats.proc_dir_entry = p; 258 256 return 0;

+3 -1

net/ipv6/reassembly.c

reviewed

··· 197 197 { 198 198 struct frag_queue *fq; 199 199 struct net_device *dev = NULL; 200 200 + struct net *net; 200 201 201 202 fq = container_of((struct inet_frag_queue *)data, struct frag_queue, q); 202 203 ··· 208 207 209 208 fq_kill(fq); 210 209 211 211 - dev = dev_get_by_index(&init_net, fq->iif); 210 210 + net = container_of(fq->q.net, struct net, ipv6.frags); 211 211 + dev = dev_get_by_index(net, fq->iif); 212 212 if (!dev) 213 213 goto out; 214 214

+5 -3

net/irda/iriap.c

reviewed

··· 451 451 n = 2; 452 452 453 453 /* Get length, MSB first */ 454 454 - len = be16_to_cpu(get_unaligned((__be16 *)(fp+n))); n += 2; 454 454 + len = get_unaligned_be16(fp + n); 455 455 + n += 2; 455 456 456 457 IRDA_DEBUG(4, "%s(), len=%d\n", __func__, len); 457 458 458 459 /* Get object ID, MSB first */ 459 459 - obj_id = be16_to_cpu(get_unaligned((__be16 *)(fp+n))); n += 2; 460 460 + obj_id = get_unaligned_be16(fp + n); 461 461 + n += 2; 460 462 461 463 type = fp[n++]; 462 464 IRDA_DEBUG(4, "%s(), Value type = %d\n", __func__, type); ··· 508 506 value = irias_new_string_value(fp+n); 509 507 break; 510 508 case IAS_OCT_SEQ: 511 511 - value_len = be16_to_cpu(get_unaligned((__be16 *)(fp+n))); 509 509 + value_len = get_unaligned_be16(fp + n); 512 510 n += 2; 513 511 514 512 /* Will truncate to IAS_MAX_OCTET_STRING bytes */

+1 -1

net/mac80211/ieee80211_i.h

reviewed

··· 354 354 int preq_queue_len; 355 355 struct mesh_stats mshstats; 356 356 struct mesh_config mshcfg; 357 357 - u8 mesh_seqnum[3]; 357 357 + u32 mesh_seqnum; 358 358 bool accepting_plinks; 359 359 #endif 360 360 u16 aid;

+29 -18

net/mac80211/main.c

reviewed

··· 255 255 256 256 switch (sdata->vif.type) { 257 257 case IEEE80211_IF_TYPE_WDS: 258 258 - if (is_zero_ether_addr(sdata->u.wds.remote_addr)) 258 258 + if (!is_valid_ether_addr(sdata->u.wds.remote_addr)) 259 259 return -ENOLINK; 260 260 - 261 261 - /* Create STA entry for the WDS peer */ 262 262 - sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, 263 263 - GFP_KERNEL); 264 264 - if (!sta) 265 265 - return -ENOMEM; 266 266 - 267 267 - sta->flags |= WLAN_STA_AUTHORIZED; 268 268 - 269 269 - res = sta_info_insert(sta); 270 270 - if (res) { 271 271 - /* STA has been freed */ 272 272 - return res; 273 273 - } 274 260 break; 275 261 case IEEE80211_IF_TYPE_VLAN: 276 262 if (!sdata->u.vlan.ap) ··· 323 337 conf.type = sdata->vif.type; 324 338 conf.mac_addr = dev->dev_addr; 325 339 res = local->ops->add_interface(local_to_hw(local), &conf); 326 326 - if (res && !local->open_count && local->ops->stop) 327 327 - local->ops->stop(local_to_hw(local)); 328 340 if (res) 329 329 - return res; 341 341 + goto err_stop; 330 342 331 343 ieee80211_if_config(dev); 332 344 ieee80211_reset_erp_info(dev); ··· 337 353 netif_carrier_on(dev); 338 354 } 339 355 356 356 + if (sdata->vif.type == IEEE80211_IF_TYPE_WDS) { 357 357 + /* Create STA entry for the WDS peer */ 358 358 + sta = sta_info_alloc(sdata, sdata->u.wds.remote_addr, 359 359 + GFP_KERNEL); 360 360 + if (!sta) { 361 361 + res = -ENOMEM; 362 362 + goto err_del_interface; 363 363 + } 364 364 + 365 365 + sta->flags |= WLAN_STA_AUTHORIZED; 366 366 + 367 367 + res = sta_info_insert(sta); 368 368 + if (res) { 369 369 + /* STA has been freed */ 370 370 + goto err_del_interface; 371 371 + } 372 372 + } 373 373 + 340 374 if (local->open_count == 0) { 341 375 res = dev_open(local->mdev); 342 376 WARN_ON(res); 377 377 + if (res) 378 378 + goto err_del_interface; 343 379 tasklet_enable(&local->tx_pending_tasklet); 344 380 tasklet_enable(&local->tasklet); 345 381 } ··· 394 390 netif_start_queue(dev); 395 391 396 392 return 0; 393 393 + err_del_interface: 394 394 + local->ops->remove_interface(local_to_hw(local), &conf); 395 395 + err_stop: 396 396 + if (!local->open_count && local->ops->stop) 397 397 + local->ops->stop(local_to_hw(local)); 398 398 + return res; 397 399 } 398 400 399 401 static int ieee80211_stop(struct net_device *dev) ··· 985 975 conf.ssid_len = sdata->u.sta.ssid_len; 986 976 } else if (ieee80211_vif_is_mesh(&sdata->vif)) { 987 977 conf.beacon = beacon; 978 978 + conf.beacon_control = control; 988 979 ieee80211_start_mesh(dev); 989 980 } else if (sdata->vif.type == IEEE80211_IF_TYPE_AP) { 990 981 conf.ssid = sdata->u.ap.ssid;

+5 -12

net/mac80211/mesh.c

reviewed

··· 8 8 * published by the Free Software Foundation. 9 9 */ 10 10 11 11 + #include <asm/unaligned.h> 11 12 #include "ieee80211_i.h" 12 13 #include "mesh.h" 13 14 ··· 168 167 struct rmc_entry *p, *n; 169 168 170 169 /* Don't care about endianness since only match matters */ 171 171 - memcpy(&seqnum, mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum)); 172 172 - idx = mesh_hdr->seqnum[0] & rmc->idx_mask; 170 170 + memcpy(&seqnum, &mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum)); 171 171 + idx = le32_to_cpu(mesh_hdr->seqnum) & rmc->idx_mask; 173 172 list_for_each_entry_safe(p, n, &rmc->bucket[idx].list, list) { 174 173 ++entries; 175 174 if (time_after(jiffies, p->exp_time) || ··· 394 393 { 395 394 meshhdr->flags = 0; 396 395 meshhdr->ttl = sdata->u.sta.mshcfg.dot11MeshTTL; 397 397 - 398 398 - meshhdr->seqnum[0] = sdata->u.sta.mesh_seqnum[0]++; 399 399 - meshhdr->seqnum[1] = sdata->u.sta.mesh_seqnum[1]; 400 400 - meshhdr->seqnum[2] = sdata->u.sta.mesh_seqnum[2]; 401 401 - 402 402 - if (sdata->u.sta.mesh_seqnum[0] == 0) { 403 403 - sdata->u.sta.mesh_seqnum[1]++; 404 404 - if (sdata->u.sta.mesh_seqnum[1] == 0) 405 405 - sdata->u.sta.mesh_seqnum[2]++; 406 406 - } 396 396 + put_unaligned(cpu_to_le32(sdata->u.sta.mesh_seqnum), &meshhdr->seqnum); 397 397 + sdata->u.sta.mesh_seqnum++; 407 398 408 399 return 5; 409 400 }

+1 -1

net/mac80211/mesh.h

reviewed

··· 140 140 141 141 struct mesh_rmc { 142 142 struct rmc_entry bucket[RMC_BUCKETS]; 143 143 - u8 idx_mask; 143 143 + u32 idx_mask; 144 144 }; 145 145 146 146

+2 -4

net/mac80211/tkip.c

reviewed

··· 230 230 231 231 iv16 = data[hdr_len] << 8; 232 232 iv16 += data[hdr_len + 2]; 233 233 - iv32 = data[hdr_len + 4] + 234 234 - (data[hdr_len + 5] >> 8) + 235 235 - (data[hdr_len + 6] >> 16) + 236 236 - (data[hdr_len + 7] >> 24); 233 233 + iv32 = data[hdr_len + 4] | (data[hdr_len + 5] << 8) | 234 234 + (data[hdr_len + 6] << 16) | (data[hdr_len + 7] << 24); 237 235 238 236 #ifdef CONFIG_TKIP_DEBUG 239 237 printk(KERN_DEBUG "TKIP encrypt: iv16 = 0x%04x, iv32 = 0x%08x\n",

+3 -3

net/netfilter/nf_conntrack_standalone.c

reviewed

··· 296 296 pde = proc_net_fops_create(&init_net, "nf_conntrack", 0440, &ct_file_ops); 297 297 if (!pde) 298 298 goto out_nf_conntrack; 299 299 - pde = create_proc_entry("nf_conntrack", S_IRUGO, init_net.proc_net_stat); 299 299 + 300 300 + pde = proc_create("nf_conntrack", S_IRUGO, init_net.proc_net_stat, 301 301 + &ct_cpu_seq_fops); 300 302 if (!pde) 301 303 goto out_stat_nf_conntrack; 302 302 - pde->proc_fops = &ct_cpu_seq_fops; 303 303 - pde->owner = THIS_MODULE; 304 304 return 0; 305 305 306 306 out_stat_nf_conntrack:

+6 -7

net/netfilter/x_tables.c

reviewed

··· 936 936 #ifdef CONFIG_PROC_FS 937 937 strlcpy(buf, xt_prefix[af], sizeof(buf)); 938 938 strlcat(buf, FORMAT_TABLES, sizeof(buf)); 939 939 - proc = proc_net_fops_create(net, buf, 0440, &xt_table_ops); 939 939 + proc = proc_create_data(buf, 0440, net->proc_net, &xt_table_ops, 940 940 + (void *)(unsigned long)af); 940 941 if (!proc) 941 942 goto out; 942 942 - proc->data = (void *)(unsigned long)af; 943 943 - 944 943 945 944 strlcpy(buf, xt_prefix[af], sizeof(buf)); 946 945 strlcat(buf, FORMAT_MATCHES, sizeof(buf)); 947 947 - proc = proc_net_fops_create(net, buf, 0440, &xt_match_ops); 946 946 + proc = proc_create_data(buf, 0440, net->proc_net, &xt_match_ops, 947 947 + (void *)(unsigned long)af); 948 948 if (!proc) 949 949 goto out_remove_tables; 950 950 - proc->data = (void *)(unsigned long)af; 951 950 952 951 strlcpy(buf, xt_prefix[af], sizeof(buf)); 953 952 strlcat(buf, FORMAT_TARGETS, sizeof(buf)); 954 954 - proc = proc_net_fops_create(net, buf, 0440, &xt_target_ops); 953 953 + proc = proc_create_data(buf, 0440, net->proc_net, &xt_target_ops, 954 954 + (void *)(unsigned long)af); 955 955 if (!proc) 956 956 goto out_remove_matches; 957 957 - proc->data = (void *)(unsigned long)af; 958 957 #endif 959 958 960 959 return 0;

+6 -6

net/netfilter/xt_hashlimit.c

reviewed

··· 237 237 hinfo->family = family; 238 238 hinfo->rnd_initialized = 0; 239 239 spin_lock_init(&hinfo->lock); 240 240 - hinfo->pde = proc_create(minfo->name, 0, 240 240 + hinfo->pde = 241 241 + proc_create_data(minfo->name, 0, 241 242 family == AF_INET ? hashlimit_procdir4 : 242 243 hashlimit_procdir6, 243 243 - &dl_file_ops); 244 244 + &dl_file_ops, hinfo); 244 245 if (!hinfo->pde) { 245 246 vfree(hinfo); 246 247 return -1; 247 248 } 248 248 - hinfo->pde->data = hinfo; 249 249 250 250 setup_timer(&hinfo->timer, htable_gc, (unsigned long )hinfo); 251 251 hinfo->timer.expires = jiffies + msecs_to_jiffies(hinfo->cfg.gc_interval); ··· 301 301 hinfo->rnd_initialized = 0; 302 302 spin_lock_init(&hinfo->lock); 303 303 304 304 - hinfo->pde = proc_create(minfo->name, 0, 304 304 + hinfo->pde = 305 305 + proc_create_data(minfo->name, 0, 305 306 family == AF_INET ? hashlimit_procdir4 : 306 307 hashlimit_procdir6, 307 307 - &dl_file_ops); 308 308 + &dl_file_ops, hinfo); 308 309 if (hinfo->pde == NULL) { 309 310 vfree(hinfo); 310 311 return -1; 311 312 } 312 312 - hinfo->pde->data = hinfo; 313 313 314 314 setup_timer(&hinfo->timer, htable_gc, (unsigned long)hinfo); 315 315 hinfo->timer.expires = jiffies + msecs_to_jiffies(hinfo->cfg.gc_interval);

+4 -4

net/rose/rose_route.c

reviewed

··· 1066 1066 #ifdef CONFIG_PROC_FS 1067 1067 1068 1068 static void *rose_node_start(struct seq_file *seq, loff_t *pos) 1069 1069 - __acquires(rose_neigh_list_lock) 1069 1069 + __acquires(rose_node_list_lock) 1070 1070 { 1071 1071 struct rose_node *rose_node; 1072 1072 int i = 1; 1073 1073 1074 1074 - spin_lock_bh(&rose_neigh_list_lock); 1074 1074 + spin_lock_bh(&rose_node_list_lock); 1075 1075 if (*pos == 0) 1076 1076 return SEQ_START_TOKEN; 1077 1077 ··· 1090 1090 } 1091 1091 1092 1092 static void rose_node_stop(struct seq_file *seq, void *v) 1093 1093 - __releases(rose_neigh_list_lock) 1093 1093 + __releases(rose_node_list_lock) 1094 1094 { 1095 1095 - spin_unlock_bh(&rose_neigh_list_lock); 1095 1095 + spin_unlock_bh(&rose_node_list_lock); 1096 1096 } 1097 1097 1098 1098 static int rose_node_show(struct seq_file *seq, void *v)

+2 -1

net/rxrpc/ar-transport.c

reviewed

··· 184 184 ASSERTCMP(atomic_read(&trans->usage), >, 0); 185 185 186 186 trans->put_time = get_seconds(); 187 187 - if (unlikely(atomic_dec_and_test(&trans->usage))) 187 187 + if (unlikely(atomic_dec_and_test(&trans->usage))) { 188 188 _debug("zombie"); 189 189 /* let the reaper determine the timeout to avoid a race with 190 190 * overextending the timeout if the reaper is running at the 191 191 * same time */ 192 192 rxrpc_queue_delayed_work(&rxrpc_transport_reap, 0); 193 193 + } 193 194 _leave(""); 194 195 } 195 196

+1

net/sched/sch_generic.c

reviewed

··· 219 219 printk(KERN_INFO "NETDEV WATCHDOG: %s: transmit timed out\n", 220 220 dev->name); 221 221 dev->tx_timeout(dev); 222 222 + WARN_ON_ONCE(1); 222 223 } 223 224 if (!mod_timer(&dev->watchdog_timer, round_jiffies(jiffies + dev->watchdog_timeo))) 224 225 dev_hold(dev);

+6 -9

net/sunrpc/cache.c

reviewed

··· 316 316 cd->proc_ent->owner = cd->owner; 317 317 cd->channel_ent = cd->content_ent = NULL; 318 318 319 319 - p = proc_create("flush", S_IFREG|S_IRUSR|S_IWUSR, 320 320 - cd->proc_ent, &cache_flush_operations); 319 319 + p = proc_create_data("flush", S_IFREG|S_IRUSR|S_IWUSR, 320 320 + cd->proc_ent, &cache_flush_operations, cd); 321 321 cd->flush_ent = p; 322 322 if (p == NULL) 323 323 goto out_nomem; 324 324 p->owner = cd->owner; 325 325 - p->data = cd; 326 325 327 326 if (cd->cache_request || cd->cache_parse) { 328 328 - p = proc_create("channel", S_IFREG|S_IRUSR|S_IWUSR, 329 329 - cd->proc_ent, &cache_file_operations); 327 327 + p = proc_create_data("channel", S_IFREG|S_IRUSR|S_IWUSR, 328 328 + cd->proc_ent, &cache_file_operations, cd); 330 329 cd->channel_ent = p; 331 330 if (p == NULL) 332 331 goto out_nomem; 333 332 p->owner = cd->owner; 334 334 - p->data = cd; 335 333 } 336 334 if (cd->cache_show) { 337 337 - p = proc_create("content", S_IFREG|S_IRUSR|S_IWUSR, 338 338 - cd->proc_ent, &content_file_operations); 335 335 + p = proc_create_data("content", S_IFREG|S_IRUSR|S_IWUSR, 336 336 + cd->proc_ent, &content_file_operations, cd); 339 337 cd->content_ent = p; 340 338 if (p == NULL) 341 339 goto out_nomem; 342 340 p->owner = cd->owner; 343 343 - p->data = cd; 344 341 } 345 342 return 0; 346 343 out_nomem:

+1 -7

net/sunrpc/stats.c

reviewed

··· 224 224 static inline struct proc_dir_entry * 225 225 do_register(const char *name, void *data, const struct file_operations *fops) 226 226 { 227 227 - struct proc_dir_entry *ent; 228 228 - 229 227 rpc_proc_init(); 230 228 dprintk("RPC: registering /proc/net/rpc/%s\n", name); 231 229 232 232 - ent = proc_create(name, 0, proc_net_rpc, fops); 233 233 - if (ent) { 234 234 - ent->data = data; 235 235 - } 236 236 - return ent; 230 230 + return proc_create_data(name, 0, proc_net_rpc, fops, data); 237 231 } 238 232 239 233 struct proc_dir_entry *

+1 -1

net/sysctl_net.c

reviewed

··· 82 82 83 83 void unregister_net_sysctl_table(struct ctl_table_header *header) 84 84 { 85 85 - return unregister_sysctl_table(header); 85 85 + unregister_sysctl_table(header); 86 86 } 87 87 EXPORT_SYMBOL_GPL(unregister_net_sysctl_table);