Lines Matching defs:card
50 /* The card ID and card revision, as reported by the hardware. */
77 /* True is card suspended */
81 static void free_if_spi_card(struct if_spi_card *card)
86 list_for_each_safe(cursor, next, &card->cmd_packet_list) {
91 list_for_each_safe(cursor, next, &card->data_packet_list) {
96 spi_set_drvdata(card->spi, NULL);
97 kfree(card);
134 static void spu_transaction_init(struct if_spi_card *card)
136 if (!time_after(jiffies, card->prev_xfer_time + 1)) {
145 static void spu_transaction_finish(struct if_spi_card *card)
147 card->prev_xfer_time = jiffies;
154 static int spu_write(struct if_spi_card *card, u16 reg, const u8 *buf, int len)
170 spu_transaction_init(card);
182 err = spi_sync(card->spi, &m);
183 spu_transaction_finish(card);
187 static inline int spu_write_u16(struct if_spi_card *card, u16 reg, u16 val)
192 return spu_write(card, reg, (u8 *)&buff, sizeof(u16));
207 static int spu_read(struct if_spi_card *card, u16 reg, u8 *buf, int len)
223 spu_transaction_init(card);
235 delay = spu_reg_is_port_reg(reg) ? card->spu_port_delay :
236 card->spu_reg_delay;
237 if (card->use_dummy_writes) {
252 err = spi_sync(card->spi, &m);
253 spu_transaction_finish(card);
258 static inline int spu_read_u16(struct if_spi_card *card, u16 reg, u16 *val)
263 ret = spu_read(card, reg, (u8 *)&buf, sizeof(buf));
273 static int spu_read_u32(struct if_spi_card *card, u16 reg, u32 *val)
278 err = spu_read(card, reg, (u8 *)&buf, sizeof(buf));
293 static int spu_wait_for_u16(struct if_spi_card *card, u16 reg,
300 err = spu_read_u16(card, reg, &val);
323 static int spu_wait_for_u32(struct if_spi_card *card, u32 reg, u32 target)
328 err = spu_read_u32(card, reg, &val);
338 static int spu_set_interrupt_mode(struct if_spi_card *card,
349 err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG, 0);
353 err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG,
367 * trigger a card interrupt.
370 err = spu_write_u16(card, IF_SPI_HOST_INT_CTRL_REG,
378 err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_MASK_REG, 0);
385 static int spu_get_chip_revision(struct if_spi_card *card,
390 err = spu_read_u32(card, IF_SPI_DEVICEID_CTRL_REG, &dev_ctrl);
398 static int spu_set_bus_mode(struct if_spi_card *card, u16 mode)
403 err = spu_write_u16(card, IF_SPI_SPU_BUS_MODE_REG, mode);
407 err = spu_read_u16(card, IF_SPI_SPU_BUS_MODE_REG, &rval);
417 static int spu_init(struct if_spi_card *card, int use_dummy_writes)
426 card->use_dummy_writes = 0;
427 err = spu_set_bus_mode(card,
433 card->spu_port_delay = 1000;
434 card->spu_reg_delay = 1000;
435 err = spu_read_u32(card, IF_SPI_DELAY_READ_REG, &delay);
438 card->spu_port_delay = delay & 0x0000ffff;
439 card->spu_reg_delay = (delay & 0xffff0000) >> 16;
443 card->use_dummy_writes = 1;
444 err = spu_set_bus_mode(card,
454 card->spu_port_delay, card->spu_reg_delay);
462 static int if_spi_prog_helper_firmware(struct if_spi_card *card,
472 err = spu_set_interrupt_mode(card, 1, 0);
485 err = spu_write_u16(card, IF_SPI_SCRATCH_1_REG,
490 err = spu_wait_for_u16(card, IF_SPI_HOST_INT_STATUS_REG,
504 err = spu_write(card, IF_SPI_CMD_RDWRPORT_REG,
510 err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
513 err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG,
526 err = spu_write_u16(card, IF_SPI_SCRATCH_1_REG, FIRMWARE_DNLD_OK);
529 err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
532 err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG,
545 static int if_spi_prog_main_firmware_check_len(struct if_spi_card *card,
555 err = spu_wait_for_u16(card, IF_SPI_HOST_INT_STATUS_REG,
564 err = spu_read_u16(card, IF_SPI_SCRATCH_1_REG, &len);
583 static int if_spi_prog_main_firmware(struct if_spi_card *card,
586 struct lbs_private *priv = card->priv;
594 err = spu_set_interrupt_mode(card, 1, 0);
598 err = spu_wait_for_u16(card, IF_SPI_SCRATCH_1_REG, 0, 0);
610 while ((len = if_spi_prog_main_firmware_check_len(card, &crc_err))) {
637 memset(card->cmd_buffer, 0, len);
638 memcpy(card->cmd_buffer, fw, bytes);
640 memcpy(card->cmd_buffer, fw, len);
642 err = spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG, 0);
645 err = spu_write(card, IF_SPI_CMD_RDWRPORT_REG,
646 card->cmd_buffer, len);
649 err = spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG ,
660 err = spu_wait_for_u32(card, IF_SPI_SCRATCH_4_REG,
680 /* Move a command from the card to the host */
681 static int if_spi_c2h_cmd(struct if_spi_card *card)
683 struct lbs_private *priv = card->priv;
706 err = spu_read_u16(card, IF_SPI_SCRATCH_2_REG, &len);
710 netdev_err(priv->dev, "%s: error: card has no data for host\n",
723 err = spu_read(card, IF_SPI_CMD_RDWRPORT_REG,
724 card->cmd_buffer, ALIGN(len, 4));
732 memcpy(priv->resp_buf[i], card->cmd_buffer, len);
743 /* Move data from the card to the host */
744 static int if_spi_c2h_data(struct if_spi_card *card)
746 struct lbs_private *priv = card->priv;
755 err = spu_read_u16(card, IF_SPI_SCRATCH_1_REG, &len);
759 netdev_err(priv->dev, "%s: error: card has no data for host\n",
765 "%s: error: card has %d bytes of data, but our maximum skb size is %zu\n",
781 err = spu_read(card, IF_SPI_DATA_RDWRPORT_REG, data, ALIGN(len, 4));
786 err = lbs_process_rxed_packet(card->priv, skb);
802 /* Move data or a command from the host to the card. */
803 static void if_spi_h2c(struct if_spi_card *card,
806 struct lbs_private *priv = card->priv;
826 /* Write the data to the card */
827 err = spu_write(card, port_reg, packet->buffer, packet->blen);
838 /* Inform the host about a card event */
839 static void if_spi_e2h(struct if_spi_card *card)
843 struct lbs_private *priv = card->priv;
845 err = spu_read_u32(card, IF_SPI_SCRATCH_3_REG, &cause);
849 /* re-enable the card event interrupt */
850 spu_write_u16(card, IF_SPI_HOST_INT_STATUS_REG,
853 /* generate a card interrupt */
854 spu_write_u16(card, IF_SPI_CARD_INT_CAUSE_REG, IF_SPI_CIC_HOST_EVENT);
865 struct if_spi_card *card;
871 card = container_of(work, struct if_spi_card, packet_work);
872 priv = card->priv;
880 err = spu_read_u16(card, IF_SPI_HOST_INT_STATUS_REG,
888 err = if_spi_c2h_cmd(card);
893 err = if_spi_c2h_data(card);
899 * workaround: in PS mode, the card does not set the Command
903 (card->priv->psstate != PS_STATE_FULL_POWER &&
907 * if there was a previous command sent, the card has
912 lbs_host_to_card_done(card->priv);
916 spin_lock_irqsave(&card->buffer_lock, flags);
917 if (!list_empty(&card->cmd_packet_list)) {
918 packet = (struct if_spi_packet *)(card->
922 spin_unlock_irqrestore(&card->buffer_lock, flags);
925 if_spi_h2c(card, packet, MVMS_CMD);
930 spin_lock_irqsave(&card->buffer_lock, flags);
931 if (!list_empty(&card->data_packet_list)) {
932 packet = (struct if_spi_packet *)(card->
936 spin_unlock_irqrestore(&card->buffer_lock, flags);
939 if_spi_h2c(card, packet, MVMS_DAT);
942 if_spi_e2h(card);
962 struct if_spi_card *card = priv->card;
987 spin_lock_irqsave(&card->buffer_lock, flags);
988 list_add_tail(&packet->list, &card->cmd_packet_list);
989 spin_unlock_irqrestore(&card->buffer_lock, flags);
993 spin_lock_irqsave(&card->buffer_lock, flags);
994 list_add_tail(&packet->list, &card->data_packet_list);
995 spin_unlock_irqrestore(&card->buffer_lock, flags);
1006 queue_work(card->workqueue, &card->packet_work);
1020 struct if_spi_card *card = dev_id;
1022 queue_work(card->workqueue, &card->packet_work);
1031 static int if_spi_init_card(struct if_spi_card *card)
1033 struct lbs_private *priv = card->priv;
1041 err = spu_init(card, card->pdata->use_dummy_writes);
1044 err = spu_get_chip_revision(card, &card->card_id, &card->card_rev);
1048 err = spu_read_u32(card, IF_SPI_SCRATCH_4_REG, &scratch);
1055 /* Check if we support this card */
1057 if (card->card_id == fw_table[i].model)
1062 card->card_id);
1067 err = lbs_get_firmware(&card->spi->dev, NULL, NULL,
1068 card->card_id, &fw_table[0], &helper,
1080 card->card_id, card->card_rev,
1081 card->spi->master->bus_num,
1082 card->spi->chip_select,
1083 card->spi->max_speed_hz);
1084 err = if_spi_prog_helper_firmware(card, helper);
1087 err = if_spi_prog_main_firmware(card, mainfw);
1093 err = spu_set_interrupt_mode(card, 0, 1);
1110 struct if_spi_card *card;
1112 card = container_of(work, struct if_spi_card, resume_work);
1114 if (card->suspended) {
1115 if (card->pdata->setup)
1116 card->pdata->setup(card->spi);
1118 /* Init card ... */
1119 if_spi_init_card(card);
1121 enable_irq(card->spi->irq);
1124 lbs_resume(card->priv);
1126 card->suspended = 0;
1132 struct if_spi_card *card;
1150 /* Allocate card structure to represent this specific device */
1151 card = kzalloc(sizeof(struct if_spi_card), GFP_KERNEL);
1152 if (!card) {
1156 spi_set_drvdata(spi, card);
1157 card->pdata = pdata;
1158 card->spi = spi;
1159 card->prev_xfer_time = jiffies;
1161 INIT_LIST_HEAD(&card->cmd_packet_list);
1162 INIT_LIST_HEAD(&card->data_packet_list);
1163 spin_lock_init(&card->buffer_lock);
1168 err = if_spi_init_card(card);
1173 * Register our card with libertas.
1176 priv = lbs_add_card(card, &spi->dev);
1181 card->priv = priv;
1183 priv->card = card;
1191 card->workqueue = create_workqueue("libertas_spi");
1192 INIT_WORK(&card->packet_work, if_spi_host_to_card_worker);
1193 INIT_WORK(&card->resume_work, if_spi_resume_worker);
1196 IRQF_TRIGGER_FALLING, "libertas_spi", card);
1203 * Start the card.
1217 free_irq(spi->irq, card);
1219 flush_workqueue(card->workqueue);
1220 destroy_workqueue(card->workqueue);
1223 free_if_spi_card(card);
1234 struct if_spi_card *card = spi_get_drvdata(spi);
1235 struct lbs_private *priv = card->priv;
1240 cancel_work_sync(&card->resume_work);
1245 free_irq(spi->irq, card);
1246 flush_workqueue(card->workqueue);
1247 destroy_workqueue(card->workqueue);
1248 if (card->pdata->teardown)
1249 card->pdata->teardown(spi);
1250 free_if_spi_card(card);
1258 struct if_spi_card *card = spi_get_drvdata(spi);
1260 if (!card->suspended) {
1261 lbs_suspend(card->priv);
1262 flush_workqueue(card->workqueue);
1265 if (card->pdata->teardown)
1266 card->pdata->teardown(spi);
1267 card->suspended = 1;
1276 struct if_spi_card *card = spi_get_drvdata(spi);
1279 schedule_work(&card->resume_work);