linux owc 驱动

最新推荐文章于 2020-05-26 15:03:34 发布
最新推荐文章于 2020-05-26 15:03:34 发布
阅读量195 收藏
点赞数
分类专栏： linux owc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lihuaxing2012/article/details/98480914
版权
linux 同时被 2 个专栏收录
6 篇文章 0 订阅
订阅专栏
owc
2 篇文章 0 订阅
订阅专栏

/*
 * drivers/char/sunxi-owc/sunxi-owc.c
 *
 * Copyright (C) 2016-2020 Allwinner.
 * lihuaxing <lihuaxing@allwinnertech.com>
 *
 * SUNXI OWC Controller Driver
 *
 * 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 of
 * the License, or (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/err.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/major.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/gpio.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <asm/irq.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/sched.h>

#include <asm/io.h>

#include "sunxi-owc.h"
#include "../w1.h"
#include "../w1_int.h"

/* ====================  For debug  =============================== */
#define OWC_ENTER()    pr_info("%s()%d - %s\n", __func__, __LINE__, "Enter ...")
#define OWC_EXIT()        pr_info("%s()%d - %s\n", __func__, __LINE__, "Exit")
#define OWC_DBG(fmt, arg...) pr_debug("%s()%d - "fmt, __func__, __LINE__, ##arg)
#define OWC_INFO(fmt, arg...) pr_info("%s()%d - "fmt, __func__, __LINE__, ##arg)
#define OWC_WARN(fmt, arg...) pr_warn("%s()%d - "fmt, __func__, __LINE__, ##arg)
#define OWC_ERR(fmt, arg...)   pr_err("%s()%d - "fmt, __func__, __LINE__, ##arg)

static struct sunxi_owc *powc;
/* clear control and status register */

static void owc_standard_setting(void __iomem *base_addr)
{
    /* select standard mode */
    u32 reg_val = readl(base_addr + OW_CTL);
    reg_val &= ~(0x01 << 1);
    writel(reg_val, base_addr + OW_CTL);

    /* timing control register setting */
    reg_val = 0;
    reg_val |= (TSU & 0x3) << 29;
    reg_val |= (TREC & 0xF) << 24;
    reg_val |= (TRDV & 0x1F) << 18;
    reg_val |= (TLOW0 & 0x7F) << 11;
    reg_val |= (TLOW1 & 0xF) << 7;
    reg_val |= (TSLOT & 0x7F) << 0;
    writel(reg_val, base_addr + SM_WR_RD_TCTL);

    /* reset presence timing control setting */
    reg_val = 0;
    reg_val |= (TPDL & 0xFF) << 24;
    reg_val |= (TPDH & 0x3F) << 18;
    reg_val |= (TRSTL & 0x1FF) << 9;
    reg_val |= (TRSTH & 0x1FF) << 0;
    writel(reg_val, base_addr + SM_RST_PRESENCE_TCTL);
}

static void owc_enable_irq(void __iomem *base_addr, u32 bitmap)
{
    u32 reg_val = readl(base_addr + OW_INT_CTL);

    reg_val |= bitmap;
    writel(reg_val, base_addr + OW_INT_CTL);
}

#if 0
static void owc_disable_irq(void __iomem *base_addr, u32 bitmap)
{
    u32 reg_val = readl(base_addr + OW_INT_CTL);

    reg_val &= ~bitmap;
    writel(reg_val, base_addr + OW_INT_CTL);
}
#endif

static void owc_config(void __iomem *base_addr)
{
    u32 reg_val = readl(base_addr + OW_CTL);

    reg_val |= 1 << 0;
    reg_val |= 1 << 9;
    writel(reg_val, base_addr + OW_CTL);
}

static void owc_fclk(void __iomem *base_addr, u32 fclk)
{
    u32 reg_val = readl(base_addr + OW_FCLK);

    reg_val &= ~OW_FCLK_MASK;
    reg_val |= (fclk & 0x1F) << 16;
    writel(reg_val, base_addr + OW_FCLK);
}

static void sunxi_owc_setup(struct sunxi_owc *powc)
{
    /* set simple mode, enable inner pull-up */
    owc_config(powc->reg_base);

    /* set ow_fclk */
    powc->func_clk = powc->clk_freq/1000000;
    owc_fclk(powc->reg_base, powc->func_clk);

    /* set standrad mode timing */
    owc_standard_setting(powc->reg_base);

    /* enable standard_mode irq */
    owc_enable_irq(powc->reg_base, INTEN_DGCH|INTEN_ST_CRC_FINI
    |INTEN_WR_CPL|INTEN_RD_CPL|INTEN_SP_TIME_OUT|INTEN_ST_INIT_SP_CPL);

}

#if 0
static void standard_crc_start(struct sunxi_owc *powc, bool crc_16, bool write)
{
    u32 reg_val = readl(powc->reg_base + OW_SMSC);

    if (crc_16)
        reg_val |= (1 << 2);
    else
        reg_val &= ~(1 << 2);

    if (write)
        reg_val |= (1 << 1);
    else
        reg_val |= (1 << 0);

    writel(reg_val, powc->reg_base + OW_SMSC);
}

static void standard_crc_stop(struct sunxi_owc *powc, bool write)
{
    u32 reg_val = readl(powc->reg_base + OW_SMSC);

    if (write)
        reg_val &= ~(1 << 1);
    else
        reg_val &= ~(1 << 0);

    writel(reg_val, powc->reg_base + OW_SMSC);
}

static int standard_crc_compare(struct sunxi_owc *powc)
{
    u8 timeout = 0;
    u32 reg_val = readl(powc->reg_base + OW_SMSC);

    reg_val |= (1 << 3);
    writel(reg_val, powc->reg_base + OW_SMSC);

    timeout = wait_for_completion_timeout(&powc->done, usecs_to_jiffies(TIMEOUT));
    if (timeout == 0) {
        OWC_ERR("write timeout\n");
        return -1;
    } else {
        reg_val = readl(powc->reg_base + OW_SMSC);
        if (reg_val & (1 << 5))
            return -1;
        else
            return 0;
    }
}
#endif

static void standard_write(struct sunxi_owc *powc, u8 data)
{
    u8 timeout = 0;
    /* direction: 1-write, 0-read*/
    u32 reg_val = readl(powc->reg_base + OW_CTL);
    reg_val |= (1 << 2);
    writel(reg_val, powc->reg_base + OW_CTL);

    /* write data */
    writel(data, powc->reg_base + OW_DATA);

    /* start to send */
    reg_val |= (1 << 4);
    writel(reg_val, powc->reg_base + OW_CTL);

    timeout = wait_for_completion_timeout(&powc->done, usecs_to_jiffies(TIMEOUT));
    if (timeout == 0) {
        OWC_ERR("write byte timeout\n");
    }
}

static void write_bit(struct sunxi_owc *powc, u8 data)
{
    u8 timeout = 0;
    /* direction: 1-write, 0-read*/
    u32 reg_val = readl(powc->reg_base + OW_CTL);
    reg_val |= (1 << 2);
    reg_val |= (1 << 5);
    writel(reg_val, powc->reg_base + OW_CTL);

    /* write data */
    data &= 0x01;
    writel(data, powc->reg_base + OW_DATA);

    /* start to send */
    reg_val |= (1 << 4);
    writel(reg_val, powc->reg_base + OW_CTL);

    timeout = wait_for_completion_timeout(&powc->done, usecs_to_jiffies(TIMEOUT));
    if (timeout == 0) {
        OWC_ERR("write bit timeout\n");
    }
}

static int read_bit(struct sunxi_owc *powc)
{
    u8 timeout = 0;
    u8 data = 0;
    /* direction: 1-write, 0-read*/
    u32 reg_val = readl(powc->reg_base + OW_CTL);
    reg_val &= ~(1 << 2);
    reg_val |= (1 << 5);
    writel(reg_val, powc->reg_base + OW_CTL);

    /* start to send */
    reg_val |= (1 << 4);
    writel(reg_val, powc->reg_base + OW_CTL);

    timeout = wait_for_completion_timeout(&powc->done, usecs_to_jiffies(TIMEOUT));
    if (timeout == 0) {
        OWC_ERR("read bit timeout\n");
        return -ENOMEM;
    } else {
        reg_val = readl(powc->reg_base + OW_DATA) & 0xFF;
        data = (u8)reg_val;
    }

    return data;
}

static int standard_read(struct sunxi_owc *powc)
{
    u8 timeout = 0;
    u8 data = 0;
    /* direction: 1-write, 0-read*/
    u32 reg_val = readl(powc->reg_base + OW_CTL);
    reg_val &= ~(1 << 2);
    writel(reg_val, powc->reg_base + OW_CTL);

    /* start to send */
    reg_val |= (1 << 4);
    writel(reg_val, powc->reg_base + OW_CTL);

    timeout = wait_for_completion_timeout(&powc->done, usecs_to_jiffies(TIMEOUT));
    if (timeout == 0) {
        OWC_ERR("read byte timeout\n");
        return -ENOMEM;
    } else {
        reg_val = readl(powc->reg_base + OW_DATA) & 0xFF;
        data = (u8)reg_val;
    }

    return data;
}

static int sunxi_owc_initialization(struct sunxi_owc *powc)
{
    u32 reg_val = readl(powc->reg_base + OW_CTL);
    u8 timeout = 0;

    /* send initilization pulse */
    reg_val |= (0x01 << 3);
    writel(reg_val, powc->reg_base + OW_CTL);
    reg_val |= (0x01 << 4);
    writel(reg_val, powc->reg_base + OW_CTL);
    timeout = wait_for_completion_timeout(&powc->done, usecs_to_jiffies(TIMEOUT));
    if (powc->init_status) {
        powc->init_status = 0;
    }
    if (timeout == 0) {
        OWC_ERR("presence timeout\n");
        return 1;
    }

    return 0;
}

/* get all interrupt status */
static u32 owc_get_interrupt_status(void __iomem *base_addr)
{
    return readl(base_addr + OW_INT_STATUS);
}

/* clear interrupt status */
static void owc_clear_interrupt_status(void __iomem *base_addr, u32 bitmap)
{
    writel(bitmap, base_addr + OW_INT_STATUS);
}

static irqreturn_t sunxi_owc_interrupt(int irqmun, void *dev_id)
{
    struct sunxi_owc *powc = (struct sunxi_owc *)dev_id;
    u32 irq_status = 0;

    irq_status = owc_get_interrupt_status(powc->reg_base);
    owc_clear_interrupt_status(powc->reg_base, irq_status);
    /* standrad initilization Pulse finish */
    if (irq_status & INT_ST_INIT_SP_CPL) {
        powc->init_status = 1;
        complete(&powc->done);
    }

    /* HDQ time out */
    if (irq_status & INT_SP_TIME_OUT) {
    }

    /* standard/HDQ read completed */
    if (irq_status & INT_OW_RD_CPL) {
        complete(&powc->done);
    }

    /* standard/HDQ write completed */
    if (irq_status & INT_OW_WR_CPL) {
        complete(&powc->done);
    }

    /* standard CRC completed */
    if (irq_status & INT_ST_CRC_FINI) {
        complete(&powc->done);
    }

    /* deglitch detected */
    if (irq_status & INT_DGCH_OCCUR) {
        powc->presence_status = 1;
    }

    return IRQ_HANDLED;
}

static uint32_t sunxi_owc_clk_init(struct sunxi_owc *powc)
{
    struct platform_device *pdev = powc->pdev;
    struct device_node *node = pdev->dev.of_node;

    if (NULL == pdev || !of_device_is_available(node)) {
        OWC_ERR("platform_device invalid!\n");
        return -EINVAL;
    }

    powc->pclk = of_clk_get(node, 0);
    if (!powc->pclk || IS_ERR(powc->pclk)) {
        OWC_ERR("err: try to get pclk clock fail!\n");
        return -EINVAL;
    }

    powc->mclk = of_clk_get(node, 1);
    if (!powc->mclk || IS_ERR(powc->mclk)) {
        OWC_ERR("err: try to get mclk clock fail!\n");
        return -EINVAL;
    }

    if (clk_set_parent(powc->mclk, powc->pclk)) {
        OWC_ERR("set mclk parent to pclk fail!\n");
        return -EINVAL;
    }

    if (of_property_read_u32(node, "clock-frequency", &powc->clk_freq)) {
        OWC_INFO("get clock-frequency fail! use default 24Mhz\n");
        powc->clk_freq = 24000000;
    }

    if (clk_set_rate(powc->mclk, powc->clk_freq)) {
        OWC_ERR("set owc_clk freq  failed!\n");
        return -EINVAL;
    }

    if (clk_prepare_enable(powc->mclk)) {
        OWC_ERR("try to enable owc_clk failed!\n");
        return -EINVAL;
    }

    return 0;
}

static uint32_t sunxi_owc_clk_exit(struct sunxi_owc *powc)
{
    if (NULL == powc->mclk || IS_ERR(powc->mclk)) {
        OWC_ERR("owc_clk handle is invalid, just return!\n");
        return -EINVAL;
    } else {
        clk_disable_unprepare(powc->mclk);
        clk_put(powc->mclk);
        powc->mclk = NULL;
    }
    if (NULL == powc->pclk || IS_ERR(powc->pclk)) {
        OWC_ERR("owc pclk handle is invalid, just return!\n");
        return -EINVAL;
    } else {
        clk_put(powc->pclk);
        powc->pclk = NULL;
    }

    return 0;
}


static int owc_request_gpio(struct sunxi_owc *powc)
{
    int ret = 0;
    struct pinctrl_state *pctrl_state = NULL;

    powc->pctrl = devm_pinctrl_get(&(powc->pdev->dev));
    if (IS_ERR_OR_NULL(powc->pctrl)) {
        OWC_ERR("request pinctrl handle fail!\n");
        return -EINVAL;
    }

    pctrl_state = pinctrl_lookup_state(powc->pctrl, PINCTRL_STATE_DEFAULT);
    if (IS_ERR(pctrl_state)) {
        OWC_ERR("look_up_state fail!\n");
        return -EINVAL;
    }

    ret = pinctrl_select_state(powc->pctrl, pctrl_state);
    if (ret < 0) {
        OWC_ERR("select_state fail!\n");
        return -EINVAL;
    }

    return ret;
}

static void owc_release_gpio(struct sunxi_owc *powc)
{
    if (!IS_ERR_OR_NULL(powc->pctrl))
        devm_pinctrl_put(powc->pctrl);
    powc->pctrl = NULL;
}


static u8 owc_read_bit(void *data)
{
    struct sunxi_owc *powc = (struct sunxi_owc *)data;

    return read_bit(powc);
}

static void owc_write_bit(void *data, u8 bit)
{
    struct sunxi_owc *powc = (struct sunxi_owc *)data;

    write_bit(powc, bit);
}

static u8 owc_read_byte(void *data)
{
    struct sunxi_owc *powc = (struct sunxi_owc *)data;

    return standard_read(powc);
}

static void owc_write_byte(void *data, u8 byte)
{
    struct sunxi_owc *powc = (struct sunxi_owc *)data;

    standard_write(powc, byte);
}

static u8 owc_reset_bus(void *data)
{
    struct sunxi_owc *powc = (struct sunxi_owc *)data;
    int ret;

    ret = sunxi_owc_initialization(powc);

    return ret;
}

static struct w1_bus_master sunxi_owc_master = {
    .read_bit   = owc_read_bit,
    .write_bit  = owc_write_bit,
    .read_byte  = owc_read_byte,
    .write_byte = owc_write_byte,
    .reset_bus  = owc_reset_bus,
};

static int sunxi_owc_probe(struct platform_device *pdev)
{
    struct device_node *node = pdev->dev.of_node;
    struct resource *mem_res = NULL;
    int ret = 0;

    OWC_ENTER();

    powc = kzalloc(sizeof(struct sunxi_owc), GFP_KERNEL);
    if (!powc) {
        OWC_ERR("kzalloc struct sunxi_owc fail!\n");
        return -ENOMEM;
    }

    powc->pdev = pdev;

    if (!of_device_is_available(node)) {
        OWC_ERR("invalid node!\n");
        ret = -EINVAL;
        goto emloc;
    }

    if (sunxi_owc_clk_init(powc)) {
        OWC_ERR("sunxi_owc_clk_init fail!\n");
        ret = -EINVAL;
        goto eclk;
    }

    powc->irq_num = platform_get_irq(pdev, 0);
    if (powc->irq_num < 0) {
        OWC_ERR("get irq number fail!\n");
        ret = -EINVAL;
        goto eclk;
    }

    mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    if (mem_res == NULL) {
        OWC_ERR("failed to get MEM res\n");
        ret = -ENXIO;
        goto eclk;
    }

    if (!request_mem_region(mem_res->start,
        resource_size(mem_res), mem_res->name)) {
        OWC_ERR("failed to request mem region\n");
        ret = -EINVAL;
        goto eclk;
    }

    powc->reg_base = ioremap(mem_res->start, resource_size(mem_res));
    if (!powc->reg_base) {
        OWC_ERR("failed to io remap\n");
        ret = -EIO;
        goto eiomem;
    }
    powc->mem_res = mem_res;

    if (request_irq(powc->irq_num, sunxi_owc_interrupt,
            IRQF_TRIGGER_NONE, "owc", powc)) {
        OWC_ERR("request irq fail!\n");
        ret = -EINVAL;
        goto eiomap;
    }

    if (owc_request_gpio(powc)) {
        OWC_ERR("failed to request gpio\n");
        ret = -EINVAL;
        goto eirq;
    }


    spin_lock_init(&powc->owc_lock);
    init_completion(&powc->done);
    sunxi_owc_setup(powc);

    sunxi_owc_master.data = (void *)powc;
    ret = w1_add_master_device(&sunxi_owc_master);
    platform_set_drvdata(pdev, powc);

    return 0;


eirq:
    free_irq(powc->irq_num, powc);

eiomap:
    iounmap(powc->reg_base);

eiomem:
    release_mem_region(mem_res->start, resource_size(mem_res));

eclk:
    sunxi_owc_clk_exit(powc);

emloc:
    kfree(powc);

    return ret;

}

static int sunxi_owc_remove(struct platform_device *pdev)
{
    struct sunxi_owc *powc = platform_get_drvdata(pdev);

    w1_remove_master_device(&sunxi_owc_master);
    free_irq(powc->irq_num, powc);
    iounmap(powc->reg_base);
    release_mem_region(powc->mem_res->start,
               resource_size(powc->mem_res));
    owc_release_gpio(powc);
    sunxi_owc_clk_exit(powc);


    OWC_EXIT();

    return 0;
}

#ifdef CONFIG_PM
static int sunxi_owc_suspend(struct device *dev)
{
    struct platform_device *pdev = to_platform_device(dev);
    struct sunxi_owc *powc = platform_get_drvdata(pdev);
    struct pinctrl_state *pctrl_state = NULL;

    powc->suspended = true;

    if (sunxi_owc_clk_exit(powc)) {
        OWC_ERR("OWC suspend failed !\n");
        powc->suspended = false;
        return -1;
    }

    if (!IS_ERR_OR_NULL(powc->pctrl)) {
        pctrl_state = pinctrl_lookup_state(powc->pctrl,
                            PINCTRL_STATE_SLEEP);
        if (IS_ERR(pctrl_state)) {
            OWC_ERR("OWC pinctrl lookup sleep fail\n");
            return -1;
        }

        if (pinctrl_select_state(powc->pctrl, pctrl_state) < 0) {
            OWC_ERR("OWC pinctrl select sleep fail\n");
            return -1;
        }
    }

    disable_irq_nosync(powc->irq_num);

    OWC_DBG("OWC suspend okay\n");
    return 0;
}

static int sunxi_owc_resume(struct device *dev)
{
    struct platform_device *pdev = to_platform_device(dev);
    struct sunxi_owc *powc = platform_get_drvdata(pdev);
    struct pinctrl_state *pctrl_state = NULL;


    powc->suspended = false;

    if (sunxi_owc_clk_init(powc)) {
        OWC_ERR("OWC resume failed !\n");
        return -1;
    }

    if (!IS_ERR_OR_NULL(powc->pctrl)) {
        pctrl_state = pinctrl_lookup_state(powc->pctrl,
                            PINCTRL_STATE_DEFAULT);
        if (IS_ERR(pctrl_state)) {
            OWC_ERR("OWC pinctrl lookup default fail\n");
            return -1;
        }

        if (pinctrl_select_state(powc->pctrl, pctrl_state) < 0) {
            OWC_ERR("OWC pinctrl select default fail\n");
            return -1;
        }
    }

    enable_irq(powc->irq_num);

    OWC_DBG("OWC resume okay\n");
    return 0;
}

static const struct dev_pm_ops sunxi_owc_dev_pm_ops = {
    .suspend = sunxi_owc_suspend,
    .resume = sunxi_owc_resume,
};

#define SUNXI_OWC_DEV_PM_OPS (&sunxi_owc_dev_pm_ops)
#else
#define SUNXI_OWC_DEV_PM_OPS NULL
#endif

static const struct of_device_id sunxi_owc_match[] = {
    {.compatible = "allwinner,sunxi-owc",},
    {},
};

MODULE_DEVICE_TABLE(of, sunxi_owc_match);

static struct platform_driver owc_platform_driver = {
    .probe = sunxi_owc_probe,
    .remove = sunxi_owc_remove,
    .driver = {
           .name = OWC_MODULE_NAME,
           .owner = THIS_MODULE,
           .pm = SUNXI_OWC_DEV_PM_OPS,
           .of_match_table = sunxi_owc_match,
           },
};

static int __init sunxi_owc_init(void)
{
    return platform_driver_register(&owc_platform_driver);
}

static void __exit sunxi_owc_exit(void)
{
    platform_driver_unregister(&owc_platform_driver);
}

module_init(sunxi_owc_init);
module_exit(sunxi_owc_exit);
MODULE_DESCRIPTION("One Wire Driver");
MODULE_AUTHOR("lihuaxing");
MODULE_LICENSE("GPL");

好客吧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
在imx53CPU下添加ds2417芯片
IPUV3的博客
07-14 744
（单总线的部分归单总线，RTC的部分归RTC，不可混淆）        DS2417是一个时间管理芯片，通过单总线和CPU相连。        linux内核版本使用的是2.6.35，CPU使用飞思卡尔imx53。        首先单总线驱动程序位于/kernel/drivers/w1，这个目录下有两个文件夹，分别是masters和slaves。imx53CPU单总线控制器部分代码在m
T5557 读写卡详解
diandiao4618的博客
07-24 3890
T5557的基本信息就不在这里详细介绍，不了解的可以去看T5557的收据手册。 一上来直接开始讲操作 存在七种操作，我们重点介绍四种，Standard Write，Protected Write，Direct access(PWD = 0)和Direct access(PWD = 1)。 Standard Write和Direct access(PWD...
Linux spi驱动分析(一)----总线驱动
辉辉308
03-18 3525
本文讲述了一款芯片的SPI总线驱动，在驱动中，使用了queue和taslet机制来实现多message和多transfer的传输。 本文作为SPI的第一篇文章，后面会继续讲述spi核心，spidev和SPI设备驱动等。
AM3354增加DS18B20
Zorry的专栏
06-22 927
AM335x 平台下 Linux 1-wire总线驱动DS18B20
Linux是否能在 8 位 MCU 上运行？
李肖遥的专栏
04-02 236
我们经常可以看到初学者在单片机论坛中询问他们是否可以在他们微不足道的小的8位微机中运行Linux。这些问题的结果通常是带来笑声。我们也经常看到，在Linux论坛中，询问Linux运行的最...
linux0.99网络模块-物理层(中断处理)
wyc的专栏
10-18 690
前面《linux0.99网络模块-网络设备初始化》的分析中wd8003注册了中断处理函数wd8003_sigaction（irqaction (dev->irq, &wd8003_sigaction)）。当网络设备接收到数据报之后就会触发中断，然后就会调用该函数。 net/tcp/we.c： 639 static struct sigaction wd8003_sigaction =
渗透之——Metasploit命令及模块
热门推荐
冰河的专栏
01-26 3万+
show exploits 列出metasploit框架中的所有渗透攻击模块。 show payloads 列出metasploit框架中的所有攻击载荷。 show auxiliary 列出metasploit框架中的所有辅助攻击载荷。 search name 查找metasploit框架中所有的渗透攻击和其他模块。 info 展示出制定渗透攻击或模块的相关信息。 use name 装载一个渗透攻...
如何安装Oracle WebCenter Suite 11g
Oracle Fusion Manager
08-25 369
how to install Oracle WebCenter Suite 11g （11.1.1.5.0） 环境： OS：RHEL5.4 64bit OS User：owc:oinstall WebCenter11g的安装过程很简单，现简单介绍其步骤： 1、install Oracle DB 11g （11.2.0.1.0） WebCenter对数据库的版本有
owc11 安装包
07-13
标题中的“owc11 安装包”指的是Office Web Components 2003的安装程序，这是一个由Microsoft开发的组件集，允许Web应用程序在浏览器中显示和编辑Microsoft Office文件，如Excel工作表、Word文档和PowerPoint演示...
Owc11组件驱动
08-10
**Owc11组件驱动详解** OWC11（Office Web Components 2003）是微软在Office 2003版本中引入的一组基于Web的组件，它提供了用于在网页或者应用程序中嵌入Excel、Word和PowerPoint功能的能力。这些组件允许开发者在...
OWC.rar_OWC
09-20
在"OWC.rar_OWC"这个压缩包中，包含的"OWC.txt"文件很可能是关于OWC类中地址与位置互相转换的代码示例或者详细解释。 地址与位置的互相转换在编程中是一个常见的需求，特别是在处理大型数据结构或电子表格时。在OWC...
C# OWC生成图表
10-29
最近做一个项目，按客户需求，需要生成一些报表，OWC是比较合适的组件.
linux ir(模拟红外发射)
李华兴的好客吧
08-05 1649
/* * drivers/pwm/pwm-sunxi-dev.c * * Allwinnertech pulse-width-modulation controller driver * * Copyright (C) 2018 AllWinner * * * This file is licensed under the terms of the GNU General Publ...
Linux pwm(应用)
李华兴的好客吧
08-05 1569
/****************************.c*****************************************/ /* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License")...
nsi的检测和使用驱动
李华兴的好客吧
05-26 1488
一、主体文件 /* * SUNXI NSI driver * * Copyright (C) 2015 AllWinnertech Ltd. * Author: xiafeng <xiafeng@allwinnertech.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public Licen...
Linux pwm (设备驱动)
李华兴的好客吧
08-05 803
/* * drivers/pwm/pwm-sunxi-dev.c * * Allwinnertech pulse-width-modulation controller driver * * Copyright (C) 2018 AllWinner * * * This file is licensed under the terms of the GNU General Publ...
owc与office版本
最新发布
09-22
OWC是指Office Web Components，是微软Office套件中的一部分，用于在网页上嵌入和展示Excel、Access和PowerPoint等文档的工具。OWC可以作为一个ActiveX控件使用，使得开发者可以通过网页来访问和操作Microsoft ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值