linux/drivers/fmc/fmc-write-eeprom.c at master · bufferoverflow/linux · GitHub

History

176 lines (158 loc) · 4.14 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

* Author: Alessandro Rubini <rubini@gnudd.com>

* Released according to the GNU GPL, version 2 or any later version.

* This work is part of the White Rabbit project, a research effort led

* by CERN, the European Institute for Nuclear Research.

#include <linux/module.h>

#include <linux/string.h>

#include <linux/firmware.h>

#include <linux/init.h>

#include <linux/fmc.h>

#include <asm/unaligned.h>

* This module uses the firmware loader to program the whole or part

* of the FMC eeprom. The meat is in the _run functions. However, no

* default file name is provided, to avoid accidental mishaps. Also,

* you must pass the busid argument

static struct fmc_driver fwe_drv;

FMC_PARAM_BUSID(fwe_drv);

/* The "file=" is like the generic "gateware=" used elsewhere */

static char *fwe_file[FMC_MAX_CARDS];

static int fwe_file_n;

module_param_array_named(file, fwe_file, charp, &fwe_file_n, 444);

static int fwe_run_tlv(struct fmc_device *fmc, const struct firmware *fw,

int write)

{

const uint8_t *p = fw->data;

int len = fw->size;

uint16_t thislen, thisaddr;

int err;

/* format is: 'w' addr16 len16 data... */

while (len > 5) {

thisaddr = get_unaligned_le16(p+1);

thislen = get_unaligned_le16(p+3);

if (p[0] != 'w' || thislen + 5 > len) {

dev_err(&fmc->dev, "invalid tlv at offset %ti\n",

p - fw->data);

return -EINVAL;

}

err = 0;

if (write) {

dev_info(&fmc->dev, "write %i bytes at 0x%04x\n",

thislen, thisaddr);

err = fmc->op->write_ee(fmc, thisaddr, p + 5, thislen);

}

if (err < 0) {

dev_err(&fmc->dev, "write failure @0x%04x\n",

thisaddr);

return err;

}

p += 5 + thislen;

len -= 5 + thislen;

}

if (write)

dev_info(&fmc->dev, "write_eeprom: success\n");

return 0;

}

static int fwe_run_bin(struct fmc_device *fmc, const struct firmware *fw)

{

int ret;

dev_info(&fmc->dev, "programming %zi bytes\n", fw->size);

ret = fmc->op->write_ee(fmc, 0, (void *)fw->data, fw->size);

if (ret < 0) {

dev_info(&fmc->dev, "write_eeprom: error %i\n", ret);

return ret;

}

dev_info(&fmc->dev, "write_eeprom: success\n");

return 0;

}

static int fwe_run(struct fmc_device *fmc, const struct firmware *fw, char *s)

{

char *last4 = s + strlen(s) - 4;

int err;

if (!strcmp(last4, ".bin"))

return fwe_run_bin(fmc, fw);

if (!strcmp(last4, ".tlv")) {

err = fwe_run_tlv(fmc, fw, 0);

if (!err)

err = fwe_run_tlv(fmc, fw, 1);

return err;

}

dev_err(&fmc->dev, "invalid file name \"%s\"\n", s);

return -EINVAL;

}

* Programming is done at probe time. Morever, only those listed with

* busid= are programmed.

* card is probed for, only one is programmed. Unfortunately, it's

* difficult to know in advance when probing the first card if others

* are there.

static int fwe_probe(struct fmc_device *fmc)

{

int err, index = 0;

const struct firmware *fw;

struct device *dev = &fmc->dev;

char *s;

if (!fwe_drv.busid_n) {

dev_err(dev, "%s: no busid passed, refusing all cards\n",

KBUILD_MODNAME);

return -ENODEV;

}

if (fmc->op->validate)

index = fmc->op->validate(fmc, &fwe_drv);

if (index < 0) {

pr_err("%s: refusing device \"%s\"\n", KBUILD_MODNAME,

dev_name(dev));

return -ENODEV;

}

if (index >= fwe_file_n) {

pr_err("%s: no filename for device index %i\n",

KBUILD_MODNAME, index);

return -ENODEV;

}

s = fwe_file[index];

if (!s) {

pr_err("%s: no filename for \"%s\" not programming\n",

KBUILD_MODNAME, dev_name(dev));

return -ENOENT;

}

err = request_firmware(&fw, s, dev);

if (err < 0) {

dev_err(&fmc->dev, "request firmware \"%s\": error %i\n",

s, err);

return err;

}

fwe_run(fmc, fw, s);

release_firmware(fw);

return 0;

}

static int fwe_remove(struct fmc_device *fmc)

{

return 0;

}

static struct fmc_driver fwe_drv = {

.version = FMC_VERSION,

.driver.name = KBUILD_MODNAME,

.probe = fwe_probe,

.remove = fwe_remove,

/* no table, as the current match just matches everything */

};

static int fwe_init(void)

{

int ret;

ret = fmc_driver_register(&fwe_drv);

return ret;

}

static void fwe_exit(void)

{

fmc_driver_unregister(&fwe_drv);

}

module_init(fwe_init);

module_exit(fwe_exit);

MODULE_LICENSE("GPL");

linux/drivers/fmc/fmc-write-eeprom.c at master · bufferoverflow/linux · GitHub

Expand file tree

Breadcrumbs

fmc-write-eeprom.c

Latest commit

History

Breadcrumbs

fmc-write-eeprom.c

File metadata and controls