云终端linux系统,让同方安全的云终端运行于Linux系统之上(二)

最新推荐文章于 2022-09-07 13:23:08 发布
最新推荐文章于 2022-09-07 13:23:08 发布
阅读量213 收藏
点赞数
文章标签： 云终端linux系统

4、显示驱动

与云终端显示相关的硬件包括多层控制器(MLC)及显示控制器(DPC)。MLC对应的修改的程序是mlc.c、mlc.h、main.c,

DPC对应修改的程序为dpc_config.h、dpc_ioctl.h及main.c。修改主要涉及MLC顶层的初始设置、显示LOGO设置、及系统默认显示分辨率的设置、及与Pollux硬件相关的系统设置。对于DPC部分的修改主要为系统默认显示分辨率的设置及与其相关的控制信号HSYNC_SWIDTH、HSYNC_FRONT_PORCH、HSYNC_BACK_PORCH、HSYNC_ACTIVEHIGH、VSYNC_SWIDTH、VSYNC_FRONT_PORCH、DISPLAY_VID_PRI_VCLK_SOURCE、DPC_DESIRED_CLOCK_HZ等设置。

5、 I2C系统总线

参考系统使用了一条I2C总线，而Pollux系统使用使用了两条系统总线，一条连接到加密芯片、另一条连接到声音的i2S。所以修改驱动为识别及支持两条系统总线。以下为驱动程序。

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

#define

I2C_CHANNEL CONFIG_I2C_LF1000_CHANNEL

#define LF1000_I2C_TIMEOUT 10

#define LF1000_I2C_RATE_HZ 100000

#ifdef CPU_LF1000

#define I2C_SCL0_PORT GPIO_PORT_A

#define I2C_SCL0_PIN 26

#define I2C_SCL0_FN GPIO_ALT1

#define I2C_SDA0_PORT GPIO_PORT_A

#define I2C_SDA0_PIN 27

#define I2C_SDA0_FN GPIO_ALT1

#define I2C_SCL1_PORT GPIO_PORT_A

#define I2C_SCL1_PIN 28

#define I2C_SCL1_FN GPIO_ALT1

#define I2C_SDA1_PORT GPIO_PORT_A

#define I2C_SDA1_PIN 29

#define I2C_SDA1_FN GPIO_ALT1

#endif

enum lf1000_i2c_state {

I2C_SEND_ADDR,

I2C_SEND_DATA,

I2C_SEND_DONE,

};

struct lf1000_i2c {

void __iomem *base;

int irq;

int div;

wait_queue_head_t wait;

int ready;

wait_queue_head_t bus_access;

int busy;

};

static struct lf1000_i2c dev[2] = {

{

.base = NULL,

.irq = -1,

.ready = 0,

.div = 16,

.busy = 0

},

{

.base = NULL,

.irq = -1,

.ready = 0,

.div = 16,

.busy = 0

}

};

static irqreturn_t lf1000_i2c_irq(int irq, void *dev_id)

{

struct platform_device *pdev = dev_id;

int ch = pdev->id;

u32 tmp = ioread32(dev[ch].base+IRQ_PEND);

if(!(tmp &

(1<

return IRQ_NONE;

tmp |=

(1<

iowrite32(tmp, dev[ch].base+IRQ_PEND);

dev[ch].ready = 1;

wake_up_interruptible(&dev[ch].wait);

return IRQ_HANDLED;

}

static int lf1000_i2c_wait(struct i2c_adapter *adap)

{

struct platform_device *pdev =

to_platform_device(adap->dev.parent);

int ch =

pdev->id;

int ret =

wait_event_interruptible_timeout(dev[ch].wait,

(dev[ch].ready),

LF1000_I2C_TIMEOUT);

if(unlikely(ret < 0))

printk(KERN_INFO "i2c:

interrupted\n");

else if(unlikely(!(dev[ch].ready)))

return -ETIMEDOUT;

dev[ch].ready = 0;

return 0;

}

static int i2c_bus_available(struct i2c_adapter *adap)

{

unsigned long flags;

int ret;

struct platform_device *pdev =

to_platform_device(adap->dev.parent);

int ch =

pdev->id;

spin_lock_irqsave(&dev[ch].bus_access,

flags);

ret = !(dev[ch].busy);

spin_unlock_irqrestore(&dev[ch].bus_access,

flags);

return ret;

}

static void start_stop_condition(struct i2c_adapter *adap)

{

struct platform_device *pdev =

to_platform_device(adap->dev.parent);

int ch =

pdev->id;

u32 tmp = ioread32(dev[ch].base+IRQ_PEND);

tmp |=

(1<

iowrite32(tmp, dev[ch].base+IRQ_PEND);

}

static void lf1000_i2c_clock(char en, struct i2c_adapter

*adap)

{

struct platform_device *pdev =

to_platform_device(adap->dev.parent);

int ch =

pdev->id;

u32 tmp = ioread32(dev[ch].base+I2C_CLKENB);

en ? BIT_SET(tmp, 3) :BIT_CLR(tmp, 3);

iowrite32(tmp, dev[ch].base+I2C_CLKENB);

}

static void lf1000_i2c_hwinit(struct i2c_adapter *adap)

{

struct platform_device *pdev =

to_platform_device(adap->dev.parent);

int ch =

pdev->id;

iowrite32(0, dev[ch].base+ICCR);

#ifdef CPU_MF2530F

iowrite32(0, dev.base+BURST_CTRL);

#endif

iowrite32((1<

dev[ch].base+ICCR);

iowrite32((1<

dev[ch].base+QCNT_MAX);

iowrite32(0x1010, dev[ch].base+ICSR);

start_stop_condition(adap); }

static int xfer_write(struct i2c_adapter *adap, unsigned char *buf,

int length)

{

u32 tmp;

int ret;

enum lf1000_i2c_state state =

I2C_SEND_ADDR;

struct platform_device *pdev =

to_platform_device(adap->dev.parent);

int ch =

pdev->id;

tmp = (ioread32(dev[ch].base+ICSR)

& 0x10F0);

tmp |=

((1<

(1<

iowrite32(tmp, dev[ch].base+ICSR);

start_stop_condition(adap);

while(1) {

switch(state) {

case

I2C_SEND_ADDR:

ret =

lf1000_i2c_wait(adap);

if(ret !=

0)

goto

done_write;

tmp =

ioread32(dev[ch].base+ICSR);

if(tmp

& (1<

{

printk(KERN_INFO

"i2c: no ACK in xfer_write\n");

ret

= -EFAULT;

goto

done_write;

}

state =

I2C_SEND_DATA;

break;

case

I2C_SEND_DATA:

iowrite32(*buf++,

dev[ch].base+IDSR);

start_stop_condition(adap);

ret =

lf1000_i2c_wait(adap);

if(ret !=

0)

goto

done_write;

if(--length

<= 0)

state

= I2C_SEND_DONE;

break;

case

I2C_SEND_DONE:

ret =

0;

goto

done_write;

}

}

done_write:

tmp = (ioread32(dev[ch].base+ICSR)

& 0x1F0F);

tmp |=

((1<

iowrite32(tmp, dev[ch].base+ICSR);

start_stop_condition(adap);

iowrite32(0, dev[ch].base+ICSR);

return 0;

}

static int xfer_read(struct i2c_adapter *adap, unsigned char *buf,

int length)

{

u32 tmp;

int ret;

enum lf1000_i2c_state state =

I2C_SEND_ADDR;

struct platform_device *pdev =

to_platform_device(adap->dev.parent);

int ch =

pdev->id;

tmp = (ioread32(dev[ch].base+ICSR)

& 0x1F0F);

tmp |=

((1<

(1<

iowrite32(tmp, dev[ch].base+ICSR);

start_stop_condition(adap);

while(1) {

switch(state) {

case

I2C_SEND_ADDR:

ret =

lf1000_i2c_wait(adap);

if(ret !=

0)

goto

done_read;

tmp =

ioread32(dev[ch].base+ICSR);

if(tmp

& (1<

{

printk(KERN_INFO

"i2c: no ACK in xfer_read\n");

ret

= -EFAULT;

goto

done_read;

}

state =

I2C_SEND_DATA;

break;

case

I2C_SEND_DATA:

*buf++ =

ioread32(dev[ch].base+IDSR);

start_stop_condition(adap);

ret =

lf1000_i2c_wait(adap);

if(ret !=

0)

goto

done_read;

if(--length

<= 0)

state

= I2C_SEND_DONE;

break;

case

I2C_SEND_DONE:

ret =

0;

goto

done_read;

}

}

done_read:

tmp = ioread32(dev[ch].base+ICSR);

tmp &= ~(0x1F0F);

tmp |=

((1<

iowrite32(tmp, dev[ch].base+ICSR);

start_stop_condition(adap);

iowrite32(0, dev[ch].base+ICSR);

return ret;

}

static int lf1000_xfer(struct i2c_adapter *adap, struct i2c_msg

*pmsg, int num)

{

int i, ret;

unsigned long flags;

struct platform_device *pdev =

to_platform_device(adap->dev.parent);

int ch =

pdev->id;

spin_lock_irqsave(&dev[ch].bus_access,

flags);

while(dev[ch].busy) {

spin_unlock_irqrestore(&dev[ch].bus_access,

flags);

if(wait_event_interruptible(dev[ch].bus_access,

i2c_bus_available(adap))) {

dev[ch].busy

= 0;

spin_unlock_irqrestore(&dev[ch].bus_access,

flags);

return

-ERESTARTSYS;

}

spin_lock_irqsave(&dev[ch].bus_access,

flags);

}

dev[ch].busy = 1;

spin_unlock_irqrestore(&dev[ch].bus_access,

flags);

lf1000_i2c_clock(1,adap);

for(i = 0; i < num; i++)

{

lf1000_i2c_hwinit(adap);

iowrite32(pmsg->addr

| ((pmsg->flags & I2C_M_RD) ? 1 :

0),

dev[ch].base+IDSR);

if(pmsg->len

&& pmsg->buf)

{

if(pmsg->flags

& I2C_M_RD)

ret

= xfer_read(adap, pmsg->buf,

pmsg->len);

else

ret

= xfer_write(adap, pmsg->buf,

pmsg->len);

if(ret !=

0)

goto

xfer_done;

}

pmsg++;

}

ret = i;

xfer_done:

lf1000_i2c_clock(0,adap);

spin_lock_irqsave(&dev[ch].bus_access,

flags);

dev[ch].busy = 0;

spin_unlock_irqrestore(&dev[ch].bus_access,

flags);

return ret;

}

static u32 lf1000_func(struct i2c_adapter *adapter)

{

return

I2C_FUNC_I2C;

}

static struct i2c_algorithm lf1000_algorithm = {

.master_xfer = lf1000_xfer,

.functionality = lf1000_func,

};

static int lf1000_i2c_probe(struct platform_device *pdev)

{

struct resource *res;

struct i2c_adapter *adapter;

int ret = 0;

unsigned int pclk_hz;

int ch =

pdev->id;

res = platform_get_resource(pdev,

IORESOURCE_MEM, I2C_CHANNEL);

if(!res) {

printk(KERN_ERR "i2c: failed to

get resource\n");

return -ENXIO;

}

if(!request_mem_region(res->start,

(res->end - res->start) + 1,

"lf1000_i2c")) {

printk(KERN_ERR "i2c: failed to

request_mem_region\n");

return -EBUSY;

}

dev[ch].base =

ioremap(res->start, (res->end -

res->start) + 1);

if(dev[ch].base == NULL) {

printk(KERN_ERR "i2c: failed to

ioremap\n");

ret = -ENOMEM;

goto fail_remap;

}

adapter = kzalloc(sizeof(struct i2c_adapter),

GFP_KERNEL);

if(adapter == NULL) {

printk(KERN_ERR "i2c: failed to

allocate interface\n");

ret = -ENOMEM;

goto fail_adapter;

}

sprintf(adapter->name,

"LF1000");

adapter->algo =

&lf1000_algorithm;

adapter->class =

I2C_CLASS_HWMON;

adapter->dev.parent =

&pdev->dev;

platform_set_drvdata(pdev, adapter);

dev[ch].irq = platform_get_irq(pdev,

I2C_CHANNEL);

if(dev[ch].irq < 0) {

printk(KERN_ERR "i2c: failed to

get an IRQ\n");

ret = dev[ch].irq;

goto fail_irq;

}

ret = request_irq(dev[ch].irq,

lf1000_i2c_irq,

SA_INTERRUPT|SA_SAMPLE_RANDOM,

"i2c", pdev);

if(ret) {

printk(KERN_ERR "i2c:

requesting IRQ failed\n" );

goto fail_irq;

}

init_waitqueue_head(&dev[ch].wait);

init_waitqueue_head(&dev[ch].bus_access);

pclk_hz =

get_pll_freq(PCLK_PLL)/BCLK_DIV/2;

dev[ch].div = lf1000_CalcDivider(pclk_hz/256,

LF1000_I2C_RATE_HZ);

if(dev[ch].div < 0) {

printk(KERN_ALERT "i2c: failed

to get divider, using 16\n");

dev[ch].div = 16;

}

else if(dev[ch].div > 16) {

printk(KERN_ALERT "i2c: divider

too high, using 16\n");

dev[ch].div = 16;

}

if (pclk_hz/256/dev[ch].div <

LF1000_I2C_RATE_HZ)

dev[ch].div--;

else if (pclk_hz/256/dev[ch].div >

1000*1000 )

printk("i2c: 2IC bus frequency too high\n");

printk("I2C bus %d frequency set to %d KHz,

address at %x IRQ %d\n", ch,

pclk_hz/256/dev[ch].div/1000, res->start,

dev[ch].irq);

if(ch == 0 ) {

#ifdef I2C_SCL0_PORT

gpio_configure_pin(I2C_SCL0_PORT, I2C_SCL0_PIN,

I2C_SCL0_FN, 1, 0, 0);

#endif

#ifdef I2C_SDA0_PORT

gpio_configure_pin(I2C_SDA0_PORT, I2C_SDA0_PIN,

I2C_SDA0_FN, 1, 0, 0);

#endif

}

else if (ch == 1) {

#ifdef I2C_SCL1_PORT

gpio_configure_pin(I2C_SCL1_PORT, I2C_SCL1_PIN,

I2C_SCL1_FN, 1, 0, 0);

#endif

#ifdef I2C_SDA1_PORT

gpio_configure_pin(I2C_SDA1_PORT, I2C_SDA1_PIN,

I2C_SDA1_FN, 1, 0, 0);

#endif

}

lf1000_i2c_hwinit(adapter);

lf1000_i2c_clock(1,adapter);

ret = i2c_add_adapter(adapter);

if(ret != 0) {

printk(KERN_ERR "i2c: failed to

add adapter\n");

goto fail_register;

}

printk("I2C adapter %s registered\n",

adapter->dev.bus_id);

return 0;

fail_register:

lf1000_i2c_clock(0,adapter);

platform_set_drvdata(pdev, NULL);

kfree(adapter);

fail_irq:

free_irq(dev[ch].irq, NULL);

dev[ch].irq = -1;

fail_adapter:

iounmap(dev[ch].base);

fail_remap:

release_mem_region(res->start,

(res->end - res->start) + 1);

return ret;

}

static int lf1000_i2c_remove(struct platform_device *pdev)

{

struct i2c_adapter *adapter =

platform_get_drvdata(pdev);

struct resource *res;

int ret;

int ch = pdev->id;

if(adapter != NULL) {

lf1000_i2c_clock(0,adapter);

ret =

i2c_del_adapter(adapter);

platform_set_drvdata(pdev,

NULL);

res =

platform_get_resource(pdev, IORESOURCE_MEM, 0);

iounmap(dev[ch].base);

release_mem_region(res->start,

(res->end - res->start) + 1);

return ret;

}

return 0;

}

#ifdef CONFIG_PM

static int lf1000_i2c_suspend(struct platform_device *pdev,

pm_message_t mesg)

{

struct i2c_adapter *adap =

i2c_get_adapter(pdev->id);

lf1000_i2c_clock(0, adap);

return 0;

}

static int lf1000_i2c_resume(struct platform_device *pdev)

{

struct i2c_adapter *adap =

i2c_get_adapter(pdev->id);

lf1000_i2c_clock(1, adap);

return 0;

}

#else

#define lf1000_i2c_suspend NULL

#define lf1000_i2c_resume NULL

#endif

static struct platform_driver lf1000_i2c_driver = {

.probe = lf1000_i2c_probe,

.remove = lf1000_i2c_remove,

.suspend = lf1000_i2c_suspend,

.resume = lf1000_i2c_resume,

.driver = {

.name = "lf1000-i2c",

.owner =

THIS_MODULE,

},

};

static int __init lf1000_i2c_init(void)

{

return

platform_driver_register(&lf1000_i2c_driver);

}

static void __exit lf1000_i2c_exit(void)

{

return

platform_driver_unregister(&lf1000_i2c_driver);

}

module_init(lf1000_i2c_init);

module_exit(lf1000_i2c_exit);

MODULE_AUTHOR("Andrey Yurovsky");

MODULE_DESCRIPTION("I2C driver for LF1000");

MODULE_LICENSE("GPL");

weixin_39595621
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
云终端操作系统
zhangfanlong的博客
03-28 2474
云终端操作系统,即Cloud Terminal Operating System，简称为CTOS。        随着互联网技术和云计算技术的高速发展，Web的处理能力也越来越强，出现了 许多功能强大的Web应用程序(Web apps),也出现了一种全新的操作系统概念Web OS。 Web apps和Web OS以Web技术为基础，并与云计算技术紧密结合，在云端响应和处理 用户的各种请
云终端linux,云终端详细介绍，看完你就都懂了
weixin_34938347的博客
05-05 530
原标题：云终端详细介绍，看完你就都懂了随着云计算技术的不断成熟和发展，云桌面被越来越多的人所熟知和使用，我们知道云桌面主要有云终端和服务器这两大硬件所组成。而今天我们要说的就是这个只有手机大小的云终端。因为云终端虽然看上去很简单，但是通过调查发现并不是所有人都了解它的。所以这里我们就来详细介绍下的。首先产品架构，市场上虽然有不同品牌和不同厂家生产的云终端，但是我们按它的架构分的话，主要可以把云终端...
云终端计算机系统,云终端是什么？
weixin_39621060的博客
06-26 1330
一：从含义上看云终端云终端是一种精巧别致的网络计算机，既可以作为迷你PC单独运行，进行网页浏览，又可以构架共享计算网络，以创新的成本优势开展业务运营网络.所谓“云”，其实指的是后端(服务器端)，平时我们很少能够看到的那一端，正因为平时难得看到，所以有一种虚无缥缈的感觉，也许就是因为这个原因，才被称为“云”吧。我们平时能够看到的是什么呢，当然是自己用的PC和手机这些东西了，也就是所谓的“客户端”。云...
云终端系统设置及视频放置说明
tongshuai888888的博客
12-09 1805
1.视频放置目录在： 系统根目录新建mv的文件夹，将视频文件拷贝进去，等待程序退出可播放即可 视频下载地址：
基于Android与Linux的云终端实现方案.pdf
09-06
基于Android与Linux的云终端实现方案.pdf
云终端服务器软件
03-25
云终端桌面软件，远程控制文件 激活多用户软件
串口实现linux系统的终端
08-10
标题所述的"串口实现Linux系统的终端"是指在嵌入式系统中，通过串行通信接口（Serial Port）模拟Linux系统的命令行终端。在没有显示器的情况下，我们可以利用串口将嵌入式设备与个人计算机（PC）连接，通过PC来显示...
linux系统终端修改字体的方法
09-15
总的来说，Linux系统终端的字体修改可以通过命令行工具直接配置或利用服务进行，具体选择取决于用户的偏好和技术熟练程度。记住，调整字体是为了提高工作效率和阅读体验，所以找到最舒适的字体和大小至关重要。在...
基于Linux系统的嵌入式终端可信安全方案.pdf
09-06
《基于Linux系统的嵌入式终端可信安全方案》 在当今数字化时代，嵌入式系统已经渗透到我们生活和工作的各个领域，从智能家居设备到工业控制系统，无处不在。随着物联网和中国制造2025战略的推进，嵌入式产品的安全...
基于ARM和Linux的智能广告终端系统的开发-论文
05-18
基于ARM和Linux的智能广告终端系统的开发
云桌面远程linux安装tds.docx
09-19
云桌面远程linux安装，利用X-win32 建立图形化界面，也可以使用xshell 启动mannager 进行配置。 文档包括配置x-win32,和安装db2，配置instance和webAdmin等
瘦客户机系统thinsysOS
04-18
瘦客户机系统thinsysOS，镜像文件，可以拿老机器做瘦客户机
将旧电脑改造成云终端瘦客户机教程
03-20
JYOS支持常用的云终端X86处理器，例如：1037U、J1900、J1800、Z8350、J3160、I3/I5/I7…等等，JYOS瘦客户机（云终端） 软件系统采用嵌入式Linux内核, 安装简单，系统稳定，容易使用，无需投入太多人力维护，使用JYOS软件系统可以轻松的将您的PC或者迷你PC转化为安全可靠的瘦客户机（云终端）。
mlc_v3.9.tgz
12-03
Intel Memory Latency Checker(Intel MLC)是一个测试内存延迟和带宽的工具，并且可以测试延迟和带宽随着系统负载增加的变化。这个工具也提供了一些选项用于更好细粒度调查从特定处理器核心到缓存或内存的一系列选项的测试。
深信服 云桌面 linux,深信服桌面云-深信服桌面云下载 v3.0官方版--pc6下载站
weixin_33037051的博客
05-08 1471
深信服桌面云是基于互联网的云上虚拟windows桌面服务，即可在线体验大屏超清画质视频，在线一键配置升级，无需其它硬件，一个账号可满足家庭成员各类需求。深信服桌面云具有多平台、稳定性好、维护安装过程简化等特点。相关软件软件大小版本说明下载地址深信服桌面云是基于互联网的云上虚拟windows桌面服务，即可在线体验大屏超清画质视频，在线一键配置升级，无需其它硬件，一个账号可满足家庭成员各类需求。深信服...
简单介绍下云终端的正确操作方法
chunduitian3860的博客
01-10 900
我们知道云终端的使用可分为两种的：一种是可单独使用的云终端，还有一种就是可通过各种协议连接服务器使用的，单独使用的话很简单和我们平时使用电脑一样用就可以了，在这里我们主要是介绍下另外一种也是常用的，就是云终端通过各种协议连接服务器使用时的正确操作方法。 第一步，在服务器上安装好桌面系统，我们...
自己动手轻松制作一台linux瘦客户机（云终端）
weixin_34352449的博客
10-22 3595
瘦客户机简化了IT管理的复杂程度，因此很多有远见的企业及IT决策者开始使用瘦客户机+桌面虚拟化方案来替换传统的PC，对于一个全新的IT环境，全部使用易管理，零维护的瘦客户机当然没有任何问题，但是对于还想继续利旧，但又不想管理复杂的操作系统环境的IT来说，能够将普通的PC变成一台瘦客户机是一件多么惬意的事情。本文介绍的是由瑞恩科技提供的瘦客户端系统，而且是完全免费的。你可以登录...
小睿家庭云可以刷linux系统吗,小睿私人云 篇二：小睿私人云刷机
weixin_30488835的博客
05-02 4901
小睿私人云 篇二：小睿私人云刷机2019-11-04 16:49:2811点赞69收藏43评论刷机目的：原版系统系统温度过高，感觉不利于可持续发展。然后作为NAS方案的话，DEBIAN是最为稳妥的选择，OMV，可道云…皆可。而且LINUX的配置要求极低，RTD1296完全可以满足系统需求，有TF卡的扩展刷写系统的话大有可玩。一、 工具：1. TTL编程器：什么都可以，最便宜的车估计就是C...
如何快速使用云服务器安装并使用Linux操作系统 (搭建Linux环境-梦开始的地方)
最新发布
qq_63992711的博客
09-07 2175
Linux作为开源,高效,安全且免费的优秀操作系统, 被现如今许多企业选中并使用, 同时也作为重要的操作系统内核, 基于此衍生出了许多的操作系统发行版本, 比如centos, redhat等等。学习Linux操作系统的重要性也不言而喻,如何安装并使用Linux操作系统,便成为了我们程序员不可离开的"基本功 ",本文将采用XShell连接云服务器的方式来完成对Linux环境的搭建。
linux下基于TCP协议的远程终端管理系统
05-27
Linux下基于TCP协议的远程终端管理系统 Linux 下基于 TCP 协议的远程终端管理系统是指使用 TCP 协议在 Linux 操作系统中实现的远程终端管理系统。该系统采用 C/S 架构，分为客户端和服务端两个部分。服务端采用 I/O...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值