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],
402 static void _ipw_write_indirect(struct ipw_priv *priv, u32 addr, u8 * data,
651 error->elem[i].link2, error->elem[i].data);
655 error->log[i].data, error->log[i].event);
685 * This is a very simple table with the data directly
719 * representing starting addr for the data (which is
749 * - dword containing the starting offset of the data
1269 log[i].time, log[i].event, log[i].data);
1298 priv->error->elem[i].data);
1307 priv->error->log[i].data);
2235 const void *data)
2240 .param = data,
2319 static void ipw_scan_check(void *data)
2321 struct ipw_priv *priv = data;
2551 * various data like the MAC address. Usually the firmware has exclusive
2557 * The following is a simplified implementation for pulling data out of the
2559 * the per device private data's copy of the eeprom.
2563 * just about any data sheet for a Microwire compatible EEPROM.
2567 static inline void eeprom_write_reg(struct ipw_priv *p, u32 data)
2569 ipw_write_reg32(p, FW_MEM_REG_EEPROM_ACCESS, data);
2628 u32 data = 0;
2631 data = ipw_read_reg32(priv, FW_MEM_REG_EEPROM_ACCESS);
2632 r = (r << 1) | ((data & EEPROM_BIT_DO) ? 1 : 0);
2643 /* data's copy of the eeprom data */
2665 * load eeprom data into the designated region in SRAM. If neither
2678 If the data looks correct, then copy it to our private
2683 IPW_DEBUG_INFO("Writing EEPROM data into SRAM\n");
2685 /* write the eeprom data to sram */
2689 /* Do not load eeprom data on fatal error or suspend */
2694 /* Load eeprom data on fatal error or suspend */
3027 static int ipw_load_ucode(struct ipw_priv *priv, u8 * data, size_t len)
3033 image = (__le16 *) data;
3073 * store data to indirect data register in the loop.
3090 /* poll for incoming data */
3138 static int ipw_load_firmware(struct ipw_priv *priv, u8 * data, size_t len)
3183 chunk = (struct fw_chunk *)(data + offset);
3186 start = data + offset;
3206 /* dma to chunk->address, the chunk->length bytes from data +
3342 u8 data[];
3363 fw = (void *)(*raw)->data;
3469 fw = (void *)raw->data;
3470 boot_img = &fw->data[0];
3471 ucode_img = &fw->data[le32_to_cpu(fw->boot_size)];
3472 fw_img = &fw->data[le32_to_cpu(fw->boot_size) +
3586 /* read eeprom data */
3638 * and four transmit queues for data.
3643 * we only utilize the first data transmit queue (queue1).
3765 if (le32_to_cpu(bd->u.data.num_chunks) > NUM_TFD_CHUNKS) {
3767 le32_to_cpu(bd->u.data.num_chunks));
3773 for (i = 0; i < le32_to_cpu(bd->u.data.num_chunks); i++) {
3775 le32_to_cpu(bd->u.data.chunk_ptr[i]),
3776 le16_to_cpu(bd->u.data.chunk_len[i]),
3929 static int ipw_disassociate(void *data)
3931 struct ipw_priv *priv = data;
3934 ipw_send_disassociate(data, 0);
4405 wrqu.data.length = 0;
4406 wrqu.data.flags = 0;
4757 * We don't send the received data on the event because
4760 * Use a request to extract the data.
4763 * sync on periodic scan to get fresh data...
5031 * good data.
5037 * The queue is empty (no good data) if WRITE = READ - 1, and is full if
5120 /* If we've added more space for the firmware to place data, tell it */
5131 static void ipw_rx_queue_replenish(void *data)
5133 struct ipw_priv *priv = data;
5155 dma_map_single(&priv->pci_dev->dev, rxb->skb->data,
5970 static void ipw_adhoc_check(void *data)
5972 struct ipw_priv *priv = data;
6476 if (wrqu->data.length > MAX_WPA_IE_LEN ||
6477 (wrqu->data.length && extra == NULL))
6480 if (wrqu->data.length) {
6481 buf = kmemdup(extra, wrqu->data.length, GFP_KERNEL);
6489 ieee->wpa_ie_len = wrqu->data.length;
6511 wrqu->data.length = 0;
6515 if (wrqu->data.length < ieee->wpa_ie_len) {
6520 wrqu->data.length = ieee->wpa_ie_len;
7109 u8 *daddr = skb->data + ETH_ALEN;
7373 * we have to be sure and update our priviate data first.
7398 static void ipw_roam(void *data)
7400 struct ipw_priv *priv = data;
7472 static int ipw_associate(void *data)
7474 struct ipw_priv *priv = data;
7592 hdr = (struct ieee80211_hdr *)skb->data;
7602 memmove(skb->data + LIBIPW_3ADDR_LEN,
7603 skb->data + LIBIPW_3ADDR_LEN + 8,
7611 memmove(skb->data + LIBIPW_3ADDR_LEN,
7612 skb->data + LIBIPW_3ADDR_LEN + 4,
7631 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7633 /* We received data from the HW, so stop the watchdog */
7636 /* We only process data packets if the
7651 /* Advance skb->data to the start of the actual payload */
7652 skb_reserve(rxb->skb, offsetof(struct ipw_rx_packet, u.frame.data));
7660 hdr = (struct libipw_hdr_4addr *)rxb->skb->data;
7680 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7683 /* initial pull of some data */
7696 /* We received data from the HW, so stop the watchdog */
7699 /* We only process data packets if the
7725 memmove(rxb->skb->data + sizeof(struct ipw_rt_hdr),
7726 rxb->skb->data + IPW_RX_FRAME_SIZE, len);
7728 ipw_rt = (struct ipw_rt_hdr *)rxb->skb->data;
7732 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(struct ipw_rt_hdr)); /* total header+data */
7755 /* Convert the channel data and set the flags */
7857 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)rxb->skb->data;
7878 /* We received data from the HW, so stop the watchdog */
7887 /* We only process data packets if the interface is open */
7903 hdr = (void *)rxb->skb->data + IPW_RX_FRAME_SIZE;
7928 /* copy the frame data to write after where the radiotap header goes */
7929 ipw_rt = (void *)skb->data;
7938 ipw_rt->rt_hdr.it_len = cpu_to_le16(sizeof(*ipw_rt)); /* total header+data */
7964 /* Convert the channel data and set the flags */
8152 struct ipw_rx_packet *pkt = (struct ipw_rx_packet *)skb->data;
8154 (skb->data + IPW_RX_FRAME_SIZE);
8226 pkt = (struct ipw_rx_packet *)rxb->skb->data;
8286 data +
8771 wrqu->data.length = sizeof(*range);
8996 if (wrqu->data.length > IW_ESSID_MAX_SIZE)
8999 wrqu->data.length = min_t(size_t, wrqu->data.length, sizeof(priv->nick));
9001 memcpy(priv->nick, extra, wrqu->data.length);
9015 wrqu->data.length = strlen(priv->nick);
9016 memcpy(extra, priv->nick, wrqu->data.length);
9017 wrqu->data.flags = 1; /* active */
9398 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
9399 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
9581 wrqu->data.length = p - extra + 1;
9687 wrqu->data.length = strlen(extra) + 1;
10044 txb->fragments[0]->data;
10068 IPW_WARNING("Attempt to send data to "
10086 tfd->u.data.station_number = id;
10091 tfd->u.data.cmd_id = DINO_CMD_TX;
10092 tfd->u.data.len = cpu_to_le16(txb->payload_size);
10095 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_CCK;
10097 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_MODE_OFDM;
10100 tfd->u.data.tx_flags |= DCT_FLAG_SHORT_PREAMBLE;
10105 memcpy(&tfd->u.data.tfd.tfd_24.mchdr, hdr, hdr_len);
10108 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10113 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10120 tfd->u.data.tx_flags |= DCT_FLAG_ACK_REQD;
10122 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10123 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_CCM;
10124 tfd->u.data.key_index = 0;
10125 tfd->u.data.key_index |= DCT_WEP_INDEX_USE_IMMEDIATE;
10128 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10130 tfd->u.data.tx_flags &= ~DCT_FLAG_NO_WEP;
10131 tfd->u.data.tx_flags_ext |= DCT_FLAG_EXT_SECURITY_TKIP;
10132 tfd->u.data.key_index = DCT_WEP_INDEX_USE_IMMEDIATE;
10135 tfd->u.data.tfd.tfd_24.mchdr.frame_ctl |=
10137 tfd->u.data.key_index = priv->ieee->crypt_info.tx_keyidx;
10140 tfd->u.data.key_index |= DCT_WEP_KEY_64Bit;
10142 tfd->u.data.key_index |= DCT_WEP_KEY_128Bit;
10153 tfd->u.data.tx_flags |= DCT_FLAG_NO_WEP;
10157 ipw_qos_set_tx_queue_command(priv, pri, &(tfd->u.data));
10161 tfd->u.data.num_chunks = cpu_to_le32(min((u8) (NUM_TFD_CHUNKS - 2),
10164 txb->nr_frags, le32_to_cpu(tfd->u.data.num_chunks));
10165 for (i = 0; i < le32_to_cpu(tfd->u.data.num_chunks); i++) {
10167 i, le32_to_cpu(tfd->u.data.num_chunks),
10170 i, tfd->u.data.num_chunks,
10172 printk_buf(IPW_DL_TX, txb->fragments[i]->data + hdr_len,
10175 tfd->u.data.chunk_ptr[i] =
10177 txb->fragments[i]->data + hdr_len,
10180 tfd->u.data.chunk_len[i] =
10196 tfd->u.data.chunk_len[i] = cpu_to_le16(remaining_bytes);
10203 txb->fragments[j]->data + hdr_len,
10208 tfd->u.data.chunk_ptr[i] =
10210 skb->data,
10214 le32_add_cpu(&tfd->u.data.num_chunks, 1);
10265 hdr = (void *)txb->fragments[0]->data;
10290 hdr = (void *)src->data;
10446 static irqreturn_t ipw_isr(int irq, void *data)
10448 struct ipw_priv *priv = data;