Lines Matching refs:hw
30 static void ipw_send_setup_packet(struct ipw_hardware *hw);
36 static void handle_received_CTRL_packet(struct ipw_hardware *hw,
238 /* Flag if hw is ready to send next packet */
403 static void do_send_fragment(struct ipw_hardware *hw, unsigned char *data,
410 BUG_ON(length > hw->ll_mtu);
415 spin_lock_irqsave(&hw->lock, flags);
417 hw->tx_ready = 0;
420 if (hw->hw_version == HW_VERSION_1) {
421 outw((unsigned short) length, hw->base_port + IODWR);
430 outw(raw_data, hw->base_port + IODWR);
433 outw(DCR_TXDONE, hw->base_port + IODCR);
434 } else if (hw->hw_version == HW_VERSION_2) {
435 outw((unsigned short) length, hw->base_port);
444 outw(raw_data, hw->base_port);
447 outw((unsigned short) 0xDEAD, hw->base_port);
450 writew(MEMRX_RX, &hw->memory_info_regs->memreg_rx);
453 spin_unlock_irqrestore(&hw->lock, flags);
458 static void do_send_packet(struct ipw_hardware *hw, struct ipw_tx_packet *packet)
469 fragment_data_len = hw->ll_mtu - header_size;
475 * to le just before it goes to hw
498 do_send_fragment(hw, pkt.rawpkt, header_size + fragment_data_len);
508 spin_lock_irqsave(&hw->lock, flags);
509 list_add(&packet->queue, &hw->tx_queue[0]);
510 hw->tx_queued++;
511 spin_unlock_irqrestore(&hw->lock, flags);
520 static void ipw_setup_hardware(struct ipw_hardware *hw)
524 spin_lock_irqsave(&hw->lock, flags);
525 if (hw->hw_version == HW_VERSION_1) {
527 outw(DCR_RXRESET, hw->base_port + IODCR);
529 outw(DCR_TXRESET, hw->base_port + IODCR);
532 outw(IER_TXENABLED | IER_RXENABLED, hw->base_port + IOIER);
538 unsigned short csr = readw(&hw->memregs_CCR->reg_config_and_status);
541 writew(csr, &hw->memregs_CCR->reg_config_and_status);
543 spin_unlock_irqrestore(&hw->lock, flags);
554 static struct ipw_rx_packet *pool_allocate(struct ipw_hardware *hw,
562 spin_lock_irqsave(&hw->lock, flags);
563 if (!list_empty(&hw->rx_pool)) {
564 packet = list_first_entry(&hw->rx_pool,
566 hw->rx_pool_size--;
567 spin_unlock_irqrestore(&hw->lock, flags);
571 ipwireless_ppp_mru(hw->network) + 2;
574 spin_unlock_irqrestore(&hw->lock, flags);
608 static void pool_free(struct ipw_hardware *hw, struct ipw_rx_packet *packet)
610 if (hw->rx_pool_size > 6)
613 hw->rx_pool_size++;
614 list_add(&packet->queue, &hw->rx_pool);
618 static void queue_received_packet(struct ipw_hardware *hw,
640 &hw->packet_assembler[channel_idx];
646 (*assem) = pool_allocate(hw, *assem, length);
664 spin_lock_irqsave(&hw->lock, flags);
665 hw->rx_bytes_queued += packet->length;
666 spin_unlock_irqrestore(&hw->lock, flags);
670 packet = pool_allocate(hw, NULL, length);
688 spin_lock_irqsave(&hw->lock, flags);
689 list_add_tail(&packet->queue, &hw->rx_queue);
691 hw->blocking_rx =
692 (hw->rx_bytes_queued >= IPWIRELESS_RX_QUEUE_SIZE);
694 spin_unlock_irqrestore(&hw->lock, flags);
695 schedule_work(&hw->work_rx);
704 struct ipw_hardware *hw =
708 spin_lock_irqsave(&hw->lock, flags);
709 while (!list_empty(&hw->rx_queue)) {
711 list_first_entry(&hw->rx_queue,
714 if (hw->shutting_down)
724 if (hw->network != NULL) {
726 spin_unlock_irqrestore(&hw->lock, flags);
732 hw->network,
737 spin_lock_irqsave(&hw->lock, flags);
740 hw->rx_bytes_queued -= packet->length;
746 handle_received_CTRL_packet(hw, packet->channel_idx,
751 pool_free(hw, packet);
756 hw->blocking_rx =
757 hw->rx_bytes_queued >= IPWIRELESS_RX_QUEUE_SIZE;
758 if (hw->shutting_down)
761 spin_unlock_irqrestore(&hw->lock, flags);
764 static void handle_received_CTRL_packet(struct ipw_hardware *hw,
798 hw->control_lines[channel_idx] |= changed_mask;
800 hw->control_lines[channel_idx] &= ~changed_mask;
801 if (hw->network)
803 hw->network,
805 hw->control_lines[channel_idx],
810 static void handle_received_packet(struct ipw_hardware *hw,
831 queue_received_packet(hw, protocol, address, data, data_len,
835 handle_received_SETUP_packet(hw, address, data, data_len,
841 static void acknowledge_data_read(struct ipw_hardware *hw)
843 if (hw->hw_version == HW_VERSION_1)
844 outw(DCR_RXDONE, hw->base_port + IODCR);
847 &hw->memory_info_regs->memreg_pc_interrupt_ack);
853 static void do_receive_packet(struct ipw_hardware *hw)
861 if (hw->hw_version == HW_VERSION_1) {
862 len = inw(hw->base_port + IODRR);
863 if (len > hw->ll_mtu) {
866 outw(DCR_RXDONE | DCR_RXRESET, hw->base_port + IODCR);
871 __le16 raw_data = inw(hw->base_port + IODRR);
878 len = inw(hw->base_port);
879 if (len > hw->ll_mtu) {
883 &hw->memory_info_regs->memreg_pc_interrupt_ack);
888 __le16 raw_data = inw(hw->base_port);
896 inw(hw->base_port);
901 acknowledge_data_read(hw);
908 handle_received_packet(hw, (union nl_packet *) pkt, len);
913 static int get_current_packet_priority(struct ipw_hardware *hw)
921 return (hw->to_setup || hw->initializing
926 * return 1 if something has been received from hw
928 static int get_packets_from_hw(struct ipw_hardware *hw)
933 spin_lock_irqsave(&hw->lock, flags);
934 while (hw->rx_ready && !hw->blocking_rx) {
936 hw->rx_ready--;
937 spin_unlock_irqrestore(&hw->lock, flags);
939 do_receive_packet(hw);
941 spin_lock_irqsave(&hw->lock, flags);
943 spin_unlock_irqrestore(&hw->lock, flags);
954 static int send_pending_packet(struct ipw_hardware *hw, int priority_limit)
959 spin_lock_irqsave(&hw->lock, flags);
960 if (hw->tx_queued && hw->tx_ready) {
966 if (!list_empty(&hw->tx_queue[priority])) {
968 &hw->tx_queue[priority],
972 hw->tx_queued--;
979 hw->tx_queued = 0;
980 spin_unlock_irqrestore(&hw->lock, flags);
984 spin_unlock_irqrestore(&hw->lock, flags);
987 do_send_packet(hw, packet);
990 spin_lock_irqsave(&hw->lock, flags);
992 if (!list_empty(&hw->tx_queue[priority])) {
998 hw->tx_queued = 0;
1000 spin_unlock_irqrestore(&hw->lock, flags);
1010 struct ipw_hardware *hw = (struct ipw_hardware *) hw_;
1013 spin_lock_irqsave(&hw->lock, flags);
1014 if (hw->shutting_down) {
1015 spin_unlock_irqrestore(&hw->lock, flags);
1019 if (hw->to_setup == 1) {
1023 hw->to_setup = 2;
1024 spin_unlock_irqrestore(&hw->lock, flags);
1026 ipw_setup_hardware(hw);
1027 ipw_send_setup_packet(hw);
1029 send_pending_packet(hw, PRIO_SETUP + 1);
1030 get_packets_from_hw(hw);
1032 int priority_limit = get_current_packet_priority(hw);
1035 spin_unlock_irqrestore(&hw->lock, flags);
1038 again = send_pending_packet(hw, priority_limit);
1039 again |= get_packets_from_hw(hw);
1047 static int is_card_present(struct ipw_hardware *hw)
1049 if (hw->hw_version == HW_VERSION_1)
1050 return inw(hw->base_port + IOIR) != 0xFFFF;
1052 return readl(&hw->memory_info_regs->memreg_card_present) ==
1057 struct ipw_hardware *hw)
1061 irqn = inw(hw->base_port + IOIR);
1073 spin_lock_irqsave(&hw->lock, flags);
1074 hw->tx_ready = 1;
1075 spin_unlock_irqrestore(&hw->lock, flags);
1080 spin_lock_irqsave(&hw->lock, flags);
1081 hw->rx_ready++;
1082 spin_unlock_irqrestore(&hw->lock, flags);
1085 outw(ack, hw->base_port + IOIR);
1086 tasklet_schedule(&hw->tasklet);
1093 static void acknowledge_pcmcia_interrupt(struct ipw_hardware *hw)
1095 unsigned short csr = readw(&hw->memregs_CCR->reg_config_and_status);
1098 writew(csr, &hw->memregs_CCR->reg_config_and_status);
1102 struct ipw_hardware *hw)
1112 unsigned short memtx = readw(hw->memreg_tx);
1115 readw(&hw->memory_info_regs->memreg_rx_done);
1123 if (hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {
1124 memtx = readw(&hw->memory_info_regs->memreg_tx_old);
1128 hw->memreg_tx =
1129 &hw->memory_info_regs->memreg_tx_old;
1141 if (!is_card_present(hw)) {
1142 acknowledge_pcmcia_interrupt(hw);
1148 writew(memtx_serial, hw->memreg_tx);
1150 if (hw->serial_number_detected) {
1151 if (memtx_serial != hw->last_memtx_serial) {
1152 hw->last_memtx_serial = memtx_serial;
1153 spin_lock_irqsave(&hw->lock, flags);
1154 hw->rx_ready++;
1155 spin_unlock_irqrestore(&hw->lock, flags);
1166 hw->serial_number_detected = 1;
1170 spin_lock_irqsave(&hw->lock, flags);
1171 hw->rx_ready++;
1172 spin_unlock_irqrestore(&hw->lock, flags);
1178 writew(0, &hw->memory_info_regs->memreg_rx_done);
1179 spin_lock_irqsave(&hw->lock, flags);
1180 hw->tx_ready = 1;
1181 spin_unlock_irqrestore(&hw->lock, flags);
1186 &hw->memory_info_regs->memreg_pc_interrupt_ack);
1188 acknowledge_pcmcia_interrupt(hw);
1191 tasklet_schedule(&hw->tasklet);
1193 if (hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {
1194 if (hw->serial_number_detected)
1200 hw->memreg_tx =
1201 &hw->memory_info_regs->memreg_tx_old;
1224 static void flush_packets_to_hw(struct ipw_hardware *hw)
1229 spin_lock_irqsave(&hw->lock, flags);
1230 priority_limit = get_current_packet_priority(hw);
1231 spin_unlock_irqrestore(&hw->lock, flags);
1233 while (send_pending_packet(hw, priority_limit));
1236 static void send_packet(struct ipw_hardware *hw, int priority,
1241 spin_lock_irqsave(&hw->lock, flags);
1242 list_add_tail(&packet->queue, &hw->tx_queue[priority]);
1243 hw->tx_queued++;
1244 spin_unlock_irqrestore(&hw->lock, flags);
1246 flush_packets_to_hw(hw);
1293 int ipwireless_send_packet(struct ipw_hardware *hw, unsigned int channel_idx,
1309 send_packet(hw, PRIO_DATA, packet);
1313 static int set_control_line(struct ipw_hardware *hw, int prio,
1328 send_packet(hw, prio, &packet->header);
1333 static int set_DTR(struct ipw_hardware *hw, int priority,
1337 hw->control_lines[channel_idx] |= IPW_CONTROL_LINE_DTR;
1339 hw->control_lines[channel_idx] &= ~IPW_CONTROL_LINE_DTR;
1341 return set_control_line(hw, priority, channel_idx, COMCTRL_DTR, state);
1344 static int set_RTS(struct ipw_hardware *hw, int priority,
1348 hw->control_lines[channel_idx] |= IPW_CONTROL_LINE_RTS;
1350 hw->control_lines[channel_idx] &= ~IPW_CONTROL_LINE_RTS;
1352 return set_control_line(hw, priority, channel_idx, COMCTRL_RTS, state);
1355 int ipwireless_set_DTR(struct ipw_hardware *hw, unsigned int channel_idx,
1358 return set_DTR(hw, PRIO_CTRL, channel_idx, state);
1361 int ipwireless_set_RTS(struct ipw_hardware *hw, unsigned int channel_idx,
1364 return set_RTS(hw, PRIO_CTRL, channel_idx, state);
1398 static void __handle_setup_get_version_rsp(struct ipw_hardware *hw)
1420 send_packet(hw, PRIO_SETUP, &config_packet->header);
1430 send_packet(hw, PRIO_SETUP, &config_done_packet->header);
1443 send_packet(hw, PRIO_SETUP, &open_packet->header);
1449 ret = set_DTR(hw, PRIO_SETUP, channel_idx,
1450 (hw->control_lines[channel_idx] &
1458 set_RTS(hw, PRIO_SETUP, channel_idx,
1459 (hw->control_lines [channel_idx] &
1482 send_packet(hw, PRIO_SETUP, &info_packet->header);
1485 hw->to_setup = 0;
1492 hw->to_setup = -1;
1495 static void handle_setup_get_version_rsp(struct ipw_hardware *hw,
1498 del_timer(&hw->setup_timer);
1499 hw->initializing = 0;
1503 __handle_setup_get_version_rsp(hw);
1510 static void ipw_send_setup_packet(struct ipw_hardware *hw)
1523 send_packet(hw, PRIO_SETUP, &ver_packet->header);
1526 static void handle_received_SETUP_packet(struct ipw_hardware *hw,
1541 if (hw->to_setup)
1542 handle_setup_get_version_rsp(hw,
1563 if (hw->to_setup)
1577 send_packet(hw, PRIO_SETUP, &packet->header);
1578 if (hw->reboot_callback)
1579 hw->reboot_callback(hw->reboot_callback_data);
1590 static void do_close_hardware(struct ipw_hardware *hw)
1594 if (hw->hw_version == HW_VERSION_1) {
1596 outw(0, hw->base_port + IOIER);
1599 irqn = inw(hw->base_port + IOIR);
1601 outw(IR_TXINTR, hw->base_port + IOIR);
1603 outw(IR_RXINTR, hw->base_port + IOIR);
1605 synchronize_irq(hw->irq);
1612 struct ipw_hardware *hw =
1615 if (!hw)
1618 hw->irq = -1;
1619 hw->initializing = 1;
1620 hw->tx_ready = 1;
1621 hw->rx_bytes_queued = 0;
1622 hw->rx_pool_size = 0;
1623 hw->last_memtx_serial = (unsigned short) 0xffff;
1625 INIT_LIST_HEAD(&hw->tx_queue[i]);
1627 INIT_LIST_HEAD(&hw->rx_queue);
1628 INIT_LIST_HEAD(&hw->rx_pool);
1629 spin_lock_init(&hw->lock);
1630 tasklet_init(&hw->tasklet, ipwireless_do_tasklet, (unsigned long) hw);
1631 INIT_WORK(&hw->work_rx, ipw_receive_data_work);
1632 setup_timer(&hw->setup_timer, ipwireless_setup_timer,
1633 (unsigned long) hw);
1635 return hw;
1638 void ipwireless_init_hardware_v1(struct ipw_hardware *hw,
1646 if (hw->removed) {
1647 hw->removed = 0;
1648 enable_irq(hw->irq);
1650 hw->base_port = base_port;
1651 hw->hw_version = (is_v2_card ? HW_VERSION_2 : HW_VERSION_1);
1652 hw->ll_mtu = (hw->hw_version == HW_VERSION_1 ? LL_MTU_V1 : LL_MTU_V2);
1653 hw->memregs_CCR = (struct MEMCCR __iomem *)
1655 hw->memory_info_regs = (struct MEMINFREG __iomem *) common_memory;
1656 hw->memreg_tx = &hw->memory_info_regs->memreg_tx_new;
1657 hw->reboot_callback = reboot_callback;
1658 hw->reboot_callback_data = reboot_callback_data;
1661 void ipwireless_init_hardware_v2_v3(struct ipw_hardware *hw)
1663 hw->initializing = 1;
1664 hw->init_loops = 0;
1667 ipwireless_setup_timer((unsigned long) hw);
1672 struct ipw_hardware *hw = (struct ipw_hardware *) data;
1674 hw->init_loops++;
1676 if (hw->init_loops == TL_SETUP_MAX_VERSION_QRY &&
1677 hw->hw_version == HW_VERSION_2 &&
1678 hw->memreg_tx == &hw->memory_info_regs->memreg_tx_new) {
1682 hw->memreg_tx = &hw->memory_info_regs->memreg_tx_old;
1683 hw->init_loops = 0;
1686 if (hw->init_loops == TL_SETUP_MAX_VERSION_QRY) {
1689 hw->initializing = 0;
1692 if (is_card_present(hw)) {
1695 spin_lock_irqsave(&hw->lock, flags);
1696 hw->to_setup = 1;
1697 hw->tx_ready = 1;
1698 spin_unlock_irqrestore(&hw->lock, flags);
1699 tasklet_schedule(&hw->tasklet);
1702 mod_timer(&hw->setup_timer,
1712 void ipwireless_stop_interrupts(struct ipw_hardware *hw)
1714 if (!hw->shutting_down) {
1716 hw->shutting_down = 1;
1717 del_timer(&hw->setup_timer);
1720 do_close_hardware(hw);
1724 void ipwireless_hardware_free(struct ipw_hardware *hw)
1730 ipwireless_stop_interrupts(hw);
1735 if (hw->packet_assembler[i] != NULL)
1736 kfree(hw->packet_assembler[i]);
1739 list_for_each_entry_safe(tp, tq, &hw->tx_queue[i], queue) {
1744 list_for_each_entry_safe(rp, rq, &hw->rx_queue, queue) {
1749 list_for_each_entry_safe(rp, rq, &hw->rx_pool, queue) {
1753 kfree(hw);
1760 void ipwireless_associate_network(struct ipw_hardware *hw,
1763 hw->network = network;