litmus-rt-edfsc.git - LITMUS^RT with the EDF-SC plugin for Real-Time Systems journal paper

diff options

author	Ira W. Snyder <iws@ovro.caltech.edu>	2010-05-27 13:59:02 -0400
committer	Jean Delvare <khali@linux-fr.org>	2010-05-27 13:59:02 -0400
commit	df16dd53c575d0cb9dbee20a3149927c862a9ff6 (patch)
tree	767244e8aaa1d9bcb996e4fc83637eb100ff7868 /drivers/hwmon/ltc4245.c
parent	ea694431f9c862bd409c90ba1cb3bdc6fdde8635 (diff)

hwmon: (ltc4245) Read only one GPIO pin

Read only one of the GPIO pins as an analog voltage. The ADC can be switched to a different GPIO pin at runtime, but this is not supported. Previously, this driver would report the analog voltage of the currently selected GPIO pin as all three GPIO voltages: in9_input, in10_input and in11_input. Signed-off-by: Ira W. Snyder <iws@ovro.caltech.edu> Signed-off-by: Jean Delvare <khali@linux-fr.org> Cc: stable@kernel.org

Diffstat (limited to 'drivers/hwmon/ltc4245.c')

-rw-r--r--

drivers/hwmon/ltc4245.c

1 files changed, 5 insertions, 13 deletions

         LTC4245_VEEIN                   = 0x19,
         LTC4245_VEESENSE                = 0x1a,
         LTC4245_VEEOUT                  = 0x1b,
-        LTC4245_GPIOADC1                = 0x1c,
+        LTC4245_GPIOADC                 = 0x1c,
-        LTC4245_GPIOADC2                = 0x1d,
-        LTC4245_GPIOADC3                = 0x1e,
 };
 struct ltc4245_data {
         u8 cregs[0x08];
         /* Voltage registers */
-        u8 vregs[0x0f];
+        u8 vregs[0x0d];
 };
 static struct ltc4245_data *ltc4245_update_device(struct device *dev)
                                 data->cregs[i] = val;
                 }
-                /* Read voltage registers -- 0x10 to 0x1f */
+                /* Read voltage registers -- 0x10 to 0x1c */
                 for (i = 0; i < ARRAY_SIZE(data->vregs); i++) {
                         val = i2c_smbus_read_byte_data(client, i+0x10);
                         if (unlikely(val < 0))
         case LTC4245_VEEOUT:
                 voltage = regval * -55;
                 break;
-        case LTC4245_GPIOADC1:
+        case LTC4245_GPIOADC:
-        case LTC4245_GPIOADC2:
-        case LTC4245_GPIOADC3:
                 voltage = regval * 10;
                 break;
         default:
 LTC4245_ALARM(in8_min_alarm,    (1 << 3),       LTC4245_FAULT2);
 /* GPIO voltages */
-LTC4245_VOLTAGE(in9_input,                      LTC4245_GPIOADC1);
+LTC4245_VOLTAGE(in9_input,                      LTC4245_GPIOADC);
-LTC4245_VOLTAGE(in10_input,                     LTC4245_GPIOADC2);
-LTC4245_VOLTAGE(in11_input,                     LTC4245_GPIOADC3);
 /* Power Consumption (virtual) */
 LTC4245_POWER(power1_input,                     LTC4245_12VSENSE);
         &sensor_dev_attr_in8_min_alarm.dev_attr.attr,
         &sensor_dev_attr_in9_input.dev_attr.attr,
-        &sensor_dev_attr_in10_input.dev_attr.attr,
-        &sensor_dev_attr_in11_input.dev_attr.attr,
         &sensor_dev_attr_power1_input.dev_attr.attr,
         &sensor_dev_attr_power2_input.dev_attr.attr,

/* * PS3 gelic network driver. * * Copyright (C) 2007 Sony Computer Entertainment Inc. * Copyright 2006, 2007 Sony Corporation * * This file is based on: spider_net.c * * (C) Copyright IBM Corp. 2005 * * Authors : Utz Bacher <utz.bacher@de.ibm.com> * Jens Osterkamp <Jens.Osterkamp@de.ibm.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #undef DEBUG #include <linux/kernel.h> #include <linux/module.h> #include <linux/etherdevice.h> #include <linux/ethtool.h> #include <linux/if_vlan.h> #include <linux/in.h> #include <linux/ip.h> #include <linux/tcp.h> #include <linux/dma-mapping.h> #include <net/checksum.h> #include <asm/firmware.h> #include <asm/ps3.h> #include <asm/lv1call.h> #include "ps3_gelic_net.h" #include "ps3_gelic_wireless.h" #define DRV_NAME "Gelic Network Driver" #define DRV_VERSION "2.0" MODULE_AUTHOR("SCE Inc."); MODULE_DESCRIPTION("Gelic Network driver"); MODULE_LICENSE("GPL"); static inline void gelic_card_enable_rxdmac(struct gelic_card *card); static inline void gelic_card_disable_rxdmac(struct gelic_card *card); static inline void gelic_card_disable_txdmac(struct gelic_card *card); static inline void gelic_card_reset_chain(struct gelic_card *card, struct gelic_descr_chain *chain, struct gelic_descr *start_descr); /* set irq_mask */ int gelic_card_set_irq_mask(struct gelic_card *card, u64 mask) { int status; status = lv1_net_set_interrupt_mask(bus_id(card), dev_id(card), mask, 0); if (status) dev_info(ctodev(card), "%s failed %d\n", __func__, status); return status; } static inline void gelic_card_rx_irq_on(struct gelic_card *card) { card->irq_mask |= GELIC_CARD_RXINT; gelic_card_set_irq_mask(card, card->irq_mask); } static inline void gelic_card_rx_irq_off(struct gelic_card *card) { card->irq_mask &= ~GELIC_CARD_RXINT; gelic_card_set_irq_mask(card, card->irq_mask); } static void gelic_card_get_ether_port_status(struct gelic_card *card, int inform) { u64 v2; struct net_device *ether_netdev; lv1_net_control(bus_id(card), dev_id(card), GELIC_LV1_GET_ETH_PORT_STATUS, GELIC_LV1_VLAN_TX_ETHERNET, 0, 0, &card->ether_port_status, &v2); if (inform) { ether_netdev = card->netdev[GELIC_PORT_ETHERNET]; if (card->ether_port_status & GELIC_LV1_ETHER_LINK_UP) netif_carrier_on(ether_netdev); else netif_carrier_off(ether_netdev); } } void gelic_card_up(struct gelic_card *card) { pr_debug("%s: called\n", __func__); mutex_lock(&card->updown_lock); if (atomic_inc_return(&card->users) == 1) { pr_debug("%s: real do\n", __func__); /* enable irq */ gelic_card_set_irq_mask(card, card->irq_mask); /* start rx */ gelic_card_enable_rxdmac(card); napi_enable(&card->napi); } mutex_unlock(&card->updown_lock); pr_debug("%s: done\n", __func__); } void gelic_card_down(struct gelic_card *card) { u64 mask; pr_debug("%s: called\n", __func__); mutex_lock(&card->updown_lock); if (atomic_dec_if_positive(&card->users) == 0) { pr_debug("%s: real do\n", __func__); napi_disable(&card->napi); /* * Disable irq. Wireless interrupts will * be disabled later if any */ mask = card->irq_mask & (GELIC_CARD_WLAN_EVENT_RECEIVED | GELIC_CARD_WLAN_COMMAND_COMPLETED); gelic_card_set_irq_mask(card, mask); /* stop rx */ gelic_card_disable_rxdmac(card); gelic_card_reset_chain(card, &card->rx_chain, card->descr + GELIC_NET_TX_DESCRIPTORS); /* stop tx */ gelic_card_disable_txdmac(card); } mutex_unlock(&card->updown_lock); pr_debug("%s: done\n", __func__); } /** * gelic_descr_get_status -- returns the status of a descriptor * @descr: descriptor to look at * * returns the status as in the dmac_cmd_status field of the descriptor */ static enum gelic_descr_dma_status gelic_descr_get_status(struct gelic_descr *descr) { return be32_to_cpu(descr->dmac_cmd_status) & GELIC_DESCR_DMA_STAT_MASK; } /** * gelic_descr_set_status -- sets the status of a descriptor * @descr: descriptor to change * @status: status to set in the descriptor * * changes the status to the specified value. Doesn't change other bits * in the status */ static void gelic_descr_set_status(struct gelic_descr *descr, enum gelic_descr_dma_status status) { descr->dmac_cmd_status = cpu_to_be32(status | (be32_to_cpu(descr->dmac_cmd_status) & ~GELIC_DESCR_DMA_STAT_MASK)); /* * dma_cmd_status field is used to indicate whether the descriptor * is valid or not. * Usually caller of this function wants to inform that to the * hardware, so we assure here the hardware sees the change. */ wmb(); } /** * gelic_card_free_chain - free descriptor chain * @card: card structure * @descr_in: address of desc */ static void gelic_card_free_chain(struct gelic_card *card, struct gelic_descr *descr_in) { struct gelic_descr *descr; for (descr = descr_in; descr && descr->bus_addr; descr = descr->next) { dma_unmap_single(ctodev(card), descr->bus_addr, GELIC_DESCR_SIZE, DMA_BIDIRECTIONAL); descr->bus_addr = 0; } } /** * gelic_card_init_chain - links descriptor chain * @card: card structure * @chain: address of chain * @start_descr: address of descriptor array * @no: number of descriptors * * we manage a circular list that mirrors the hardware structure, * except that the hardware uses bus addresses. * * returns 0 on success, <0 on failure */ static int __devinit gelic_card_init_chain(struct gelic_card *card, struct gelic_descr_chain *chain, struct gelic_descr *start_descr, int no) { int i; struct gelic_descr *descr; descr = start_descr; memset(descr, 0, sizeof(*descr) * no); /* set up the hardware pointers in each descriptor */ for (i = 0; i < no; i++, descr++) { gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE); descr->bus_addr = dma_map_single(ctodev(card), descr, GELIC_DESCR_SIZE, DMA_BIDIRECTIONAL); if (!descr->bus_addr) goto iommu_error; descr->next = descr + 1; descr->prev = descr - 1; } /* make them as ring */ (descr - 1)->next = start_descr; start_descr->prev = (descr - 1); /* chain bus addr of hw descriptor */ descr = start_descr; for (i = 0; i < no; i++, descr++) { descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr); } chain->head = start_descr; chain->tail = start_descr; /* do not chain last hw descriptor */ (descr - 1)->next_descr_addr = 0; return 0; iommu_error: for (i--, descr--; 0 <= i; i--, descr--) if (descr->bus_addr) dma_unmap_single(ctodev(card), descr->bus_addr, GELIC_DESCR_SIZE, DMA_BIDIRECTIONAL); return -ENOMEM; } /** * gelic_card_reset_chain - reset status of a descriptor chain * @card: card structure * @chain: address of chain * @start_descr: address of descriptor array * * Reset the status of dma descriptors to ready state * and re-initialize the hardware chain for later use */ static void gelic_card_reset_chain(struct gelic_card *card, struct gelic_descr_chain *chain, struct gelic_descr *start_descr) { struct gelic_descr *descr; for (descr = start_descr; start_descr != descr->next; descr++) { gelic_descr_set_status(descr, GELIC_DESCR_DMA_CARDOWNED); descr->next_descr_addr = cpu_to_be32(descr->next->bus_addr); } chain->head = start_descr; chain->tail = (descr - 1); (descr - 1)->next_descr_addr = 0; } /** * gelic_descr_prepare_rx - reinitializes a rx descriptor * @card: card structure * @descr: descriptor to re-init * * return 0 on succes, <0 on failure * * allocates a new rx skb, iommu-maps it and attaches it to the descriptor. * Activate the descriptor state-wise */ static int gelic_descr_prepare_rx(struct gelic_card *card, struct gelic_descr *descr) { int offset; unsigned int bufsize; if (gelic_descr_get_status(descr) != GELIC_DESCR_DMA_NOT_IN_USE) dev_info(ctodev(card), "%s: ERROR status \n", __func__); /* we need to round up the buffer size to a multiple of 128 */ bufsize = ALIGN(GELIC_NET_MAX_MTU, GELIC_NET_RXBUF_ALIGN); /* and we need to have it 128 byte aligned, therefore we allocate a * bit more */ descr->skb = dev_alloc_skb(bufsize + GELIC_NET_RXBUF_ALIGN - 1); if (!descr->skb) { descr->buf_addr = 0; /* tell DMAC don't touch memory */ dev_info(ctodev(card), "%s:allocate skb failed !!\n", __func__); return -ENOMEM; } descr->buf_size = cpu_to_be32(bufsize); descr->dmac_cmd_status = 0; descr->result_size = 0; descr->valid_size = 0; descr->data_error = 0; offset = ((unsigned long)descr->skb->data) & (GELIC_NET_RXBUF_ALIGN - 1); if (offset) skb_reserve(descr->skb, GELIC_NET_RXBUF_ALIGN - offset); /* io-mmu-map the skb */ descr->buf_addr = cpu_to_be32(dma_map_single(ctodev(card), descr->skb->data, GELIC_NET_MAX_MTU, DMA_FROM_DEVICE)); if (!descr->buf_addr) { dev_kfree_skb_any(descr->skb); descr->skb = NULL; dev_info(ctodev(card), "%s:Could not iommu-map rx buffer\n", __func__); gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE); return -ENOMEM; } else { gelic_descr_set_status(descr, GELIC_DESCR_DMA_CARDOWNED); return 0; } } /** * gelic_card_release_rx_chain - free all skb of rx descr * @card: card structure * */ static void gelic_card_release_rx_chain(struct gelic_card *card) { struct gelic_descr *descr = card->rx_chain.head; do { if (descr->skb) { dma_unmap_single(ctodev(card), be32_to_cpu(descr->buf_addr), descr->skb->len, DMA_FROM_DEVICE); descr->buf_addr = 0; dev_kfree_skb_any(descr->skb); descr->skb = NULL; gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE); } descr = descr->next; } while (descr != card->rx_chain.head); } /** * gelic_card_fill_rx_chain - fills descriptors/skbs in the rx chains * @card: card structure * * fills all descriptors in the rx chain: allocates skbs * and iommu-maps them. * returns 0 on success, < 0 on failure */ static int gelic_card_fill_rx_chain(struct gelic_card *card) { struct gelic_descr *descr = card->rx_chain.head; int ret; do { if (!descr->skb) { ret = gelic_descr_prepare_rx(card, descr); if (ret) goto rewind; } descr = descr->next; } while (descr != card->rx_chain.head); return 0; rewind: gelic_card_release_rx_chain(card); return ret; } /** * gelic_card_alloc_rx_skbs - allocates rx skbs in rx descriptor chains * @card: card structure * * returns 0 on success, < 0 on failure */ static int __devinit gelic_card_alloc_rx_skbs(struct gelic_card *card) { struct gelic_descr_chain *chain; int ret; chain = &card->rx_chain; ret = gelic_card_fill_rx_chain(card); chain->tail = card->rx_top->prev; /* point to the last */ return ret; } /** * gelic_descr_release_tx - processes a used tx descriptor * @card: card structure * @descr: descriptor to release * * releases a used tx descriptor (unmapping, freeing of skb) */ static void gelic_descr_release_tx(struct gelic_card *card, struct gelic_descr *descr) { struct sk_buff *skb = descr->skb; BUG_ON(!(be32_to_cpu(descr->data_status) & GELIC_DESCR_TX_TAIL)); dma_unmap_single(ctodev(card), be32_to_cpu(descr->buf_addr), skb->len, DMA_TO_DEVICE); dev_kfree_skb_any(skb); descr->buf_addr = 0; descr->buf_size = 0; descr->next_descr_addr = 0; descr->result_size = 0; descr->valid_size = 0; descr->data_status = 0; descr->data_error = 0; descr->skb = NULL; /* set descr status */ gelic_descr_set_status(descr, GELIC_DESCR_DMA_NOT_IN_USE); } static void gelic_card_stop_queues(struct gelic_card *card) { netif_stop_queue(card->netdev[GELIC_PORT_ETHERNET]); if (card->netdev[GELIC_PORT_WIRELESS]) netif_stop_queue(card->netdev[GELIC_PORT_WIRELESS]); } static void gelic_card_wake_queues(struct gelic_card *card) { netif_wake_queue(card->netdev[GELIC_PORT_ETHERNET]); if (card->netdev[GELIC_PORT_WIRELESS]) netif_wake_queue(card->netdev[GELIC_PORT_WIRELESS]); } /** * gelic_card_release_tx_chain - processes sent tx descriptors * @card: adapter structure * @stop: net_stop sequence * * releases the tx descriptors that gelic has finished with */ static void gelic_card_release_tx_chain(struct gelic_card *card, int stop) { struct gelic_descr_chain *tx_chain; enum gelic_descr_dma_status status; struct net_device *netdev; int release = 0; for (tx_chain = &card->tx_chain; tx_chain->head != tx_chain->tail && tx_chain->tail; tx_chain->tail = tx_chain->tail->next) { status = gelic_descr_get_status(tx_chain->tail); netdev = tx_chain->tail->skb->dev; switch (status) { case GELIC_DESCR_DMA_RESPONSE_ERROR: case GELIC_DESCR_DMA_PROTECTION_ERROR: case GELIC_DESCR_DMA_FORCE_END: if (printk_ratelimit()) dev_info(ctodev(card), "%s: forcing end of tx descriptor " \ "with status %x\n", __func__, status); netdev->stats.tx_dropped++; break; case GELIC_DESCR_DMA_COMPLETE: if (tx_chain->tail->skb) { netdev->stats.tx_packets++; netdev->stats.tx_bytes += tx_chain->tail->skb->len; } break; case GELIC_DESCR_DMA_CARDOWNED: /* pending tx request */ default: /* any other value (== GELIC_DESCR_DMA_NOT_IN_USE) */ if (!stop) goto out; } gelic_descr_release_tx(card, tx_chain->tail); release ++; } out: if (!stop && release) gelic_card_wake_queues(card); } /** * gelic_net_set_multi - sets multicast addresses and promisc flags * @netdev: interface device structure * * gelic_net_set_multi configures multicast addresses as needed for the * netdev interface. It also sets up multicast, allmulti and promisc * flags appropriately


context:
space:
mode: