Lines Matching defs:data
221 const u8 * data, u32 len, u32 ofs)
232 data[(i * 8 + j)]);
241 c = data[(i * 8 + j)];
255 static void printk_buf(int level, const u8 * data, u32 len)
263 snprint_line(line, sizeof(line), &data[ofs],
271 static int snprintk_buf(u8 * output, size_t size, const u8 * data, size_t len)
278 out = snprint_line(output, size, &data[ofs],
415 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
664 error->elem[i].link2, error->elem[i].data);
668 error->log[i].data, error->log[i].event);
698 * This is a very simple table with the data directly
732 * representing starting addr for the data (which is
762 * - dword containing the starting offset of the data
1286 log[i].time, log[i].event, log[i].data);
1315 priv->error->elem[i].data);
1324 priv->error->log[i].data);
2267 void *data)
2272 .param = data,
2351 static void ipw_scan_check(void *data)
2353 struct ipw_priv *priv = data;
2583 * various data like the MAC address. Usually the firmware has exclusive
2589 * The following is a simplified implementation for pulling data out of the
2591 * the per device private data's copy of the eeprom.
2595 * just about any data sheet for a Microwire compatible EEPROM.
2599 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2601 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2660 u32 data = 0;
2663 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2664 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2675 /* data's copy of the eeprom data */
2697 * load eeprom data into the designated region in SRAM. If neither
2710 If the data looks correct, then copy it to our private
2715 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2717 /* write the eeprom data to sram */
2721 /* Do not load eeprom data on fatal error or suspend */
2726 /* Load eeprom data on fatal error or suspend */
3073 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
3079 image = (__le16 *) data;
3119 * store data to indirect data register in the loop.
3136 /* poll for incoming data */
3184 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
3229 chunk = (struct fw_chunk *)(data + offset);
3232 start = data + offset;
3252 /* dma to chunk->address, the chunk->length bytes from data +
3388 u8 data[];
3409 fw = (void *)(*raw)->data;
3515 fw = (void *)raw->data;
3516 boot_img = &fw->data[0];
3517 ucode_img = &fw->data[le32_to_cpu(fw->boot_size)];
3518 fw_img = &fw->data[le32_to_cpu(fw->boot_size) +
3632 /* read eeprom data */
3684 * and four transmit queues for data.
3689 * we only utilize the first data transmit queue (queue1).
3811 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3813 le32_to_cpu(bd->u.data.num_chunks));
3819 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3821 le32_to_cpu(bd->u.data.chunk_ptr[i]),
3822 le16_to_cpu(bd->u.data.chunk_len[i]),
3975 static int ipw_disassociate(void *data)
3977 struct ipw_priv *priv = data;
3980 ipw_send_disassociate(data, 0);
4451 wrqu.data.length = 0;
4452 wrqu.data.flags = 0;
4803 * We don't send the received data on the event because
4806 * Use a request to extract the data.
4809 * sync on periodic scan to get fresh data...
5077 * good data.
5083 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
5166 /* If we've added more space for the firmware to place data, tell it */
5177 static void ipw_rx_queue_replenish(void *data)
5179 struct ipw_priv *priv = data;
5201 dma_map_single(&priv->pci_dev->dev, rxb->skb->data,
6016 static void ipw_adhoc_check(void *data)
6018 struct ipw_priv *priv = data;
6522 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6523 (wrqu->data.length && extra == NULL))
6526 if (wrqu->data.length) {
6527 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
6535 ieee->wpa_ie_len = wrqu->data.length;
6557 wrqu->data.length = 0;
6561 if (wrqu->data.length < ieee->wpa_ie_len) {
6566 wrqu->data.length = ieee->wpa_ie_len;
7155 u8 *daddr = skb->data + ETH_ALEN;
7419 * we have to be sure and update our priviate data first.
7444 static void ipw_roam(void *data)
7446 struct ipw_priv *priv = data;
7518 static int ipw_associate(void *data)
7520 struct ipw_priv *priv = data;
7638 hdr = (struct ieee80211_hdr *)skb->data;
7648 memmove(skb->data + LIBIPW_3ADDR_LEN,
7649 skb->data + LIBIPW_3ADDR_LEN + 8,
7657 memmove(skb->data + LIBIPW_3ADDR_LEN,
7658 skb->data + LIBIPW_3ADDR_LEN + 4,
7677 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7679 /* We received data from the HW, so stop the watchdog */
7682 /* We only process data packets if the
7697 /* Advance skb->data to the start of the actual payload */
7698 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7706 hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
7726 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7729 /* initial pull of some data */
7742 /* We received data from the HW, so stop the watchdog */
7745 /* We only process data packets if the
7771 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7772 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7774 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7778 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total header+data */
7801 /* Convert the channel data and set the flags */
7903 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7924 /* We received data from the HW, so stop the watchdog */
7933 /* We only process data packets if the interface is open */
7949 hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
7974 /* copy the frame data to write after where the radiotap header goes */
7975 ipw_rt = (void *)skb->data;
7984 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt)); /* total header+data */
8010 /* Convert the channel data and set the flags */
8198 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
8200 (skb->data + IPW_RX_FRAME_SIZE);
8272 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8332 data +
8817 wrqu->data.length = sizeof(*range);
9042 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
9045 wrqu->data.length = min_t(size_t, wrqu->data.length, sizeof(priv->nick));
9047 memcpy(priv->nick, extra, wrqu->data.length);
9061 wrqu->data.length = strlen(priv->nick);
9062 memcpy(extra, priv->nick, wrqu->data.length);
9063 wrqu->data.flags = 1; /* active */
9444 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
9445 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9627 wrqu->data.length = p - extra + 1;
9733 wrqu->data.length = strlen(extra) + 1;
10090 txb->fragments[0]->data;
10114 IPW_WARNING("Attempt to send data to "
10132 tfd->u.data.station_number = id;
10137 tfd->u.data.cmd_id = DINO_CMD_TX;
10138 tfd->u.data.len = cpu_to_le16(txb->payload_size);
10141 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
10143 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
10146 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
10151 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10154 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10159 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10166 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10168 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10169 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10170 tfd->u.data.key_index = 0;
10171 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10174 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10176 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10177 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10178 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10181 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10183 tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10186 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10188 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10199 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10203 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
10207 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10210 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10211 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10213 i, le32_to_cpu(tfd->u.data.num_chunks),
10216 i, tfd->u.data.num_chunks,
10218 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
10221 tfd->u.data.chunk_ptr[i] =
10223 txb->fragments[i]->data + hdr_len,
10226 tfd->u.data.chunk_len[i] =
10242 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
10249 txb->fragments[j]->data + hdr_len,
10254 tfd->u.data.chunk_ptr[i] =
10256 skb->data,
10260 le32_add_cpu(&tfd->u.data.num_chunks, 1);
10311 hdr = (void *)txb->fragments[0]->data;
10336 hdr = (void *)src->data;
10492 static irqreturn_t ipw_isr(int irq, void *data)
10494 struct ipw_priv *priv = data;