mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-21 19:41:34 +07:00
96292c89cf
Due to the 80-cols restrictions, and latter due to checkpatch
warnings, several strings were broken into multiple lines. This
is not considered a good practice anymore, as it makes harder
to grep for strings at the source code.
As we're right now fixing other drivers due to KERN_CONT, we need
to be able to identify what printk strings don't end with a "\n".
It is a way easier to detect those if we don't break long lines.
So, join those continuation lines.
The patch was generated via the script below, and manually
adjusted if needed.
</script>
use Text::Tabs;
while (<>) {
if ($next ne "") {
$c=$_;
if ($c =~ /^\s+\"(.*)/) {
$c2=$1;
$next =~ s/\"\n$//;
$n = expand($next);
$funpos = index($n, '(');
$pos = index($c2, '",');
if ($funpos && $pos > 0) {
$s1 = substr $c2, 0, $pos + 2;
$s2 = ' ' x ($funpos + 1) . substr $c2, $pos + 2;
$s2 =~ s/^\s+//;
$s2 = ' ' x ($funpos + 1) . $s2 if ($s2 ne "");
print unexpand("$next$s1\n");
print unexpand("$s2\n") if ($s2 ne "");
} else {
print "$next$c2\n";
}
$next="";
next;
} else {
print $next;
}
$next="";
} else {
if (m/\"$/) {
if (!m/\\n\"$/) {
$next=$_;
next;
}
}
}
print $_;
}
</script>
Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
154 lines
4.4 KiB
C
154 lines
4.4 KiB
C
/*
|
|
*
|
|
*
|
|
* Copyright (C) 2005 Mike Isely <isely@pobox.com>
|
|
* Copyright (C) 2004 Aurelien Alleaume <slts@free.fr>
|
|
*
|
|
* 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
|
|
*
|
|
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
#include <linux/slab.h>
|
|
#include "pvrusb2-eeprom.h"
|
|
#include "pvrusb2-hdw-internal.h"
|
|
#include "pvrusb2-debug.h"
|
|
|
|
#define trace_eeprom(...) pvr2_trace(PVR2_TRACE_EEPROM,__VA_ARGS__)
|
|
|
|
|
|
|
|
/*
|
|
|
|
Read and analyze data in the eeprom. Use tveeprom to figure out
|
|
the packet structure, since this is another Hauppauge device and
|
|
internally it has a family resemblance to ivtv-type devices
|
|
|
|
*/
|
|
|
|
#include <media/tveeprom.h>
|
|
|
|
/* We seem to only be interested in the last 128 bytes of the EEPROM */
|
|
#define EEPROM_SIZE 128
|
|
|
|
/* Grab EEPROM contents, needed for direct method. */
|
|
static u8 *pvr2_eeprom_fetch(struct pvr2_hdw *hdw)
|
|
{
|
|
struct i2c_msg msg[2];
|
|
u8 *eeprom;
|
|
u8 iadd[2];
|
|
u8 addr;
|
|
u16 eepromSize;
|
|
unsigned int offs;
|
|
int ret;
|
|
int mode16 = 0;
|
|
unsigned pcnt,tcnt;
|
|
eeprom = kmalloc(EEPROM_SIZE,GFP_KERNEL);
|
|
if (!eeprom) {
|
|
pvr2_trace(PVR2_TRACE_ERROR_LEGS,
|
|
"Failed to allocate memory required to read eeprom");
|
|
return NULL;
|
|
}
|
|
|
|
trace_eeprom("Value for eeprom addr from controller was 0x%x",
|
|
hdw->eeprom_addr);
|
|
addr = hdw->eeprom_addr;
|
|
/* Seems that if the high bit is set, then the *real* eeprom
|
|
address is shifted right now bit position (noticed this in
|
|
newer PVR USB2 hardware) */
|
|
if (addr & 0x80) addr >>= 1;
|
|
|
|
/* FX2 documentation states that a 16bit-addressed eeprom is
|
|
expected if the I2C address is an odd number (yeah, this is
|
|
strange but it's what they do) */
|
|
mode16 = (addr & 1);
|
|
eepromSize = (mode16 ? 4096 : 256);
|
|
trace_eeprom("Examining %d byte eeprom at location 0x%x using %d bit addressing",
|
|
eepromSize, addr,
|
|
mode16 ? 16 : 8);
|
|
|
|
msg[0].addr = addr;
|
|
msg[0].flags = 0;
|
|
msg[0].len = mode16 ? 2 : 1;
|
|
msg[0].buf = iadd;
|
|
msg[1].addr = addr;
|
|
msg[1].flags = I2C_M_RD;
|
|
|
|
/* We have to do the actual eeprom data fetch ourselves, because
|
|
(1) we're only fetching part of the eeprom, and (2) if we were
|
|
getting the whole thing our I2C driver can't grab it in one
|
|
pass - which is what tveeprom is otherwise going to attempt */
|
|
memset(eeprom,0,EEPROM_SIZE);
|
|
for (tcnt = 0; tcnt < EEPROM_SIZE; tcnt += pcnt) {
|
|
pcnt = 16;
|
|
if (pcnt + tcnt > EEPROM_SIZE) pcnt = EEPROM_SIZE-tcnt;
|
|
offs = tcnt + (eepromSize - EEPROM_SIZE);
|
|
if (mode16) {
|
|
iadd[0] = offs >> 8;
|
|
iadd[1] = offs;
|
|
} else {
|
|
iadd[0] = offs;
|
|
}
|
|
msg[1].len = pcnt;
|
|
msg[1].buf = eeprom+tcnt;
|
|
if ((ret = i2c_transfer(&hdw->i2c_adap,
|
|
msg,ARRAY_SIZE(msg))) != 2) {
|
|
pvr2_trace(PVR2_TRACE_ERROR_LEGS,
|
|
"eeprom fetch set offs err=%d",ret);
|
|
kfree(eeprom);
|
|
return NULL;
|
|
}
|
|
}
|
|
return eeprom;
|
|
}
|
|
|
|
|
|
/* Directly call eeprom analysis function within tveeprom. */
|
|
int pvr2_eeprom_analyze(struct pvr2_hdw *hdw)
|
|
{
|
|
u8 *eeprom;
|
|
struct tveeprom tvdata;
|
|
|
|
memset(&tvdata,0,sizeof(tvdata));
|
|
|
|
eeprom = pvr2_eeprom_fetch(hdw);
|
|
if (!eeprom) return -EINVAL;
|
|
|
|
{
|
|
struct i2c_client fake_client;
|
|
/* Newer version expects a useless client interface */
|
|
fake_client.addr = hdw->eeprom_addr;
|
|
fake_client.adapter = &hdw->i2c_adap;
|
|
tveeprom_hauppauge_analog(&fake_client,&tvdata,eeprom);
|
|
}
|
|
|
|
trace_eeprom("eeprom assumed v4l tveeprom module");
|
|
trace_eeprom("eeprom direct call results:");
|
|
trace_eeprom("has_radio=%d",tvdata.has_radio);
|
|
trace_eeprom("tuner_type=%d",tvdata.tuner_type);
|
|
trace_eeprom("tuner_formats=0x%x",tvdata.tuner_formats);
|
|
trace_eeprom("audio_processor=%d",tvdata.audio_processor);
|
|
trace_eeprom("model=%d",tvdata.model);
|
|
trace_eeprom("revision=%d",tvdata.revision);
|
|
trace_eeprom("serial_number=%d",tvdata.serial_number);
|
|
trace_eeprom("rev_str=%s",tvdata.rev_str);
|
|
hdw->tuner_type = tvdata.tuner_type;
|
|
hdw->tuner_updated = !0;
|
|
hdw->serial_number = tvdata.serial_number;
|
|
hdw->std_mask_eeprom = tvdata.tuner_formats;
|
|
|
|
kfree(eeprom);
|
|
|
|
return 0;
|
|
}
|