Arch Linux Planet Italia

Notizie • Utenti Java: intervento manuale richiesto prima dell'aggiornamento

13-10-2014 10:30

Per evitare un problema di file in conflitto, è richiesto un intervento manuale solo se sul sistema è installato il pacchetto java-common. Questa condizione può essere verificata tramite il comando:
Code:
$ pacman -Q java-common
java-common ...

Nel caso il pacchetto risultasse installato, si prega di eseguire questa procedura prima di effettuare l'aggiornamento:
Code:
# archlinux-java unset
# pacman -Sydd --asdeps java-runtime-common
:: java-runtime-common and java-common are in conflict. Remove java-common? [y/N] y
# archlinux-java fix

È ora possibile proseguire con l'aggiornamento:
Code:
# pacman Su

Si prega di tenere presente che il nuovo pacchetto java-runtime-common non supporta la forzatura della variabile JAVA_HOME come il vecchio pacchetto java-common. Consultare la la pagina wiki riferita a Java per ulteriori informazioni.

Statistiche: Inviato da 4javier — 13 ottobre 2014, 12:30


4javier@Arch News

Gimp 2.9 verso il 2.10

29-04-2014 16:34

Splash Screen di Gimp 2.9

È da un po di tempo che sto usando Gimp 2.9 senza problemi di sorta.  Quindi penso che per gli utenti di questo software sarebbe bello da compilare.

Come compilare Gimp 2.9 su ArchLinux:

  • Per prima cosa bisogna compilare ed installare babl-git che può essere usato anche con gimp 2.8.
  • Dopo aver installato babl-git serve gegl-git, ovvero il nuovo motore grafico di Gimp 2.10, che va compilato ed installato.
  • Ora c’è tutto quello che serve, e si può procedere con Gimp 2.9, ed in questo serve il panchetto gimp-git ed una volta compilato va installato.

Tutto finito.

I pacchetti possono essere installati con yaourt, o meglio installandoli compilandoli a mano col makepkg. Unica cosa per la loro compilazione è necessario l’applicativo git. Se in fase di compilazione vi vengono richieste alcune dipendenze mancanti non dovete far altro che installarle, sono tutte presenti nei repo ufficiali.

Se tutto è andato bene, dando il comando gimp, o cercando la entry nel menu delle applicazioni partirà gimp 2.9.

Lo spashscreen (vedi sopra) non è molto rassicurante, ma nella pratica, al momento in cui scrivo l’applicativo è stabile ed usabile con un rischio molto basso di crash.

L’unico vero problema che ho è una integrazione coi la GUI dei filtri G’MIC ancora problematica.

Le maggiori novità che saltano subito all’occhio sono le funzioni gegl marcate con una G nei menu, la possibilita di usare una profondità di colore fino a 32 bit per canale e la funzione warp. Un altra novità di rilievo è sicuramente la possibilità di regolare la temperatura del colore. Inoltre alcuni filtri ora possono funzionare con OpenCL e la GPU.

Oltre a questo ci sono nuovi e più preformanti algoritmi per il rescaling delle immagini. E altre novità ….

In conclusione posso solo dire che l’attuale Gimp 2.9 funziona bene e per chi ha voglia di compilare è più che consigliabile.


firef@Barone Rosso

Notizie • BBS, Wiki ed AUR fuori servizio

17-02-2014 16:36

Il 17/02/2014 la BBS, la Wiki ed AUR saranno fuori servizio per circa due ore, a causa di un po' di manutenzione necessaria ed altre attività.

Aggiornamento: la BBS, la Wiki ed AUR dovrebbero essere ritornati online e funzionanti.

Dan McGee

Statistiche: Inviato da Giovanni — 17 febbraio 2014, 18:36


Giovanni@Arch News

Notizie • /etc/sysctl.conf è deprecato

17-09-2013 06:24

A partire dalla versione 207, systemd non applicherà più le impostazioni lette da /etc/sysctl.conf: applicherà solo quelle lette da /etc/sysctl.d/*. Dato che le attuali impostazioni nel file /etc/sysctl.conf, installato dal pacchetto procs-ng, sono diventate di default nell'attuale kernel abbiamo deciso di deprecare tale file.

All'aggiornamento di procps-ng-3.3.8-3, vi sarà richiesto di ricopiare ogni modifica fatta in /etc/sysctl.conf in un qualsiasi file nella directory /etc/sysctl.d. Il modo più semplice per fare ciò è:

Code:
# pacman -Syu
# mv /etc/sysctl.conf.pacsave /etc/sysctl.d/99-sysctl.conf


Se non avete mai modificato /etc/sysctl.conf, allora potete ignorare questo annuncio.

Gaetan Bisson

Statistiche: Inviato da ilpianista — 17 settembre 2013, 8:24


ilpianista@Arch News

Notizie • PHP 5.5 è disponibile nel repository [extra]

07-09-2013 07:53

PHP 5.5 è finalmente disponibile nel nostro repository [extra]. La guida alla migrazione contiene informazioni sui cambiamenti apportati dalla versione 5.4. Un elenco dettagliato puo' essere trovato nel Changelog di PHP.

Il pacchetto APC sarà sostituito da APCu. APCu fornisce soltanto la cache di dati dell'utente. Per l'opcode caching, usate la nuova estensione opcache. In alternativa, forniamo una versione di sviluppo di XCache che include sia un opcode, sia una cache di dati dell'utente.

La maggior parte delle applicazioni funzioneranno senza modifiche, ma fate attenzione agli avvisi presenti nel backup dei file di log.

Pierre Schmitz

Statistiche: Inviato da Giovanni — 7 settembre 2013, 9:53


Giovanni@Arch News

Toshiba Portégé R600-11B Scheda Tecnica

03-09-2013 23:47

Scheda Tecnica del portatile Toshiva Portégé R600-11B

Portege R600
Generale
marca

Toshiba

modello

Portege R600-11B

Tecnologia piattaforma Intel Centrino 2 with vPro Technology
Tipo di sistema Notebook
Dispositivi integrati Altoparlanti stereo, antenna wireless LAN, antenna Bluetooth, antenna cellulare
Larghezza 28.3 cm
Profondità 21.6 cm
Altezza 2.6 cm
Peso 1.11 kg
Localizzazione Italia
Processore
Processore Intel Core 2 Duo SU9400 / 1.4 GHz
Tecnologia Multi-Core Dual-Core
Calcolo a 64 bit
Velocità bus dati 800 MHz
Caratteristiche Enhanced SpeedStep technology, funzionalità Execute Disable Bit, Intel Virtualization Technology
Tipo chipset Mobile Intel GS45 Express
Memoria cache
Tipo L2
Dim. installata 3 MB
RAM
Memoria installata 3 GB / 5 GB (max)
Tecnologia DDR2 SDRAM – 800 MHz
Caratteristiche configurazione 1 x 2 GB + 1 GB (integrati)
Storage controller
Tipo Serial ATA
Interfaccia Serial ATA Serial ATA-150
Memoria
Disco rigido Segate ST95005620AS – 500GB – 7200RPM – SATA 300 – 3.0Gbps – Cache 32MB
Caratteristiche
Accelerometer for HDD protection:Yes
Memorizzazione ottica
Modello Matshita UJ-844S
Tipo DVD±RW / DVD-RAM
Velocità di lettura 24x (CD) / 8x (DVD)
Velocità di scrittura 24x (CD) / 8x (DVD±R)
Velocità di riscrittura 10x (CD) / 4x (DVD±RW) / 3x (DVD-RAM)
Lettore di schede
Tipo Lettore di schede
Schede Flash Memory supportate Scheda di memoria SD
Schermo
Tipo schermo 12.1″ TFT
Risoluzione max 1280 x 800 ( WXGA )
Widescreen Display
Caratteristiche Transflective, LED retroilluminato
Video
Processore grafico / fornitore Intel GMA 4500MHD Dynamic Video Memory Technology 5.0
Memoria grafica totale disponibile 1332 MB
Audio
Uscita audio Scheda audio
Standard di conformità High Definition Audio
Ingresso audio Microfono
Videocamera per notebook
Tipo telecamera Integrata
Risoluzione sensore 0,3 Megapixel
Dispositivi di input
Tipo Tastiera, touchpad
Caratteristiche A prova di liquidi
Telecomubicazioni
Modem Modem cellulare wireless
Velocità max trasferimento 7.2 Mbps
Protocollo di ottimizzazione per linee cellulari Supporto Network : UMTS/HSPA at 2100 MHz and GSM/GPRS/EDGE quad bands at 850/900/1800/1900 MHz
Networking
Networking Scheda di rete
Wireless LAN supportata
Wireless NIC Intel WiFi Link 5100
Data Link Protocol Ethernet, Fast Ethernet, Gigabit Ethernet, IEEE 802.11b, IEEE 802.11a, IEEE 802.11g, IEEE 802.11n, Bluetooth 2.1 EDR
Standard di conformità IEEE 802.11b, IEEE 802.11a, IEEE 802.11g, Wi-Fi CERTIFIED, IEEE 802.11n, Bluetooth 2.1
Espansione/connettività
Slot di espansione totali (liberi) 1 ( 0 ) x memoria ¦ 1 ( 1 ) x ExpressCard
Interfacce 1 x display / video – VGA – D-Sub HD 15 pin (HD-15) ¦ 1 x rete – Ethernet 10Base-T/100Base-TX/1000Base-T – RJ-45 ¦ 1 x microfono – input – jack da 3,5 mm ¦ 1 x cuffie – output – jack stereo da 3,5 mm ¦ 2 x Hi-Speed USB – USB Tipo A 4 pin ¦ 1 x storage / Hi-Speed USB – Hi-Speed USB / eSATA ¦ 1 x duplicatore di porte / docking
Alimentazione
Dispositivi di alimentazione Esterno
Tensione richiesta 120/230 V c.a. ( 50/60 Hz )
exbyte@Exbyte

Script per gestire il modem Toshiba Corp. F3507g Mobile Broadband Module

08-08-2013 08:21

Questo script serve per gestire il modem Toshiba Corp. F3507g Mobile Broadband Module ed ha le seguenti funzioni:

  • Accendere il modem
  • Spegnere il modem
  • Stabilire la connessione dati
  • Disconnettere la connessione dati
  • Abilitare GPS
  • Disabilitare GPS
#!/bin/bash
#######################################################################
# Script per la gestione modem Toshiba F3507g Mobile Broadband Module #
# creato da Aleci Bruno <brunoaleci @gmail.com>                        #
#######################################################################

USB_ID="0930:130b"
PIN=""
APN="internet.wind"

GPSDPID="/var/run/gpsd.pid"

RFKILL_DEVICE=$(
  for n in /sys/devices/platform/toshiba_acpi/rfkill/rfkill*; 
      do 
         if [ "$(cat $n/name)" = "Toshiba WWAN" ]; then 
           echo $n/state;
         fi; 
      done
)

CONTROL_DEVICE () { 
  echo /dev/$(
    for n in /sys/class/tty/ttyACM*/device/interface;
        do 
        if [ "$(cat $n)" = "Toshiba F3507g Mobile Broadband Data Modem" ]; then 
           echo $n|awk -F '/' '{print $5}'; 
        fi; 
    done;
    )
}

GPS_DEVICE () { 
  echo /dev/$(
    for n in /sys/class/tty/ttyACM*/device/interface;
        do 
        if [ "$(cat $n)" = "Toshiba F3507g Mobile Broadband GPS Port" ]; then 
          echo $n|awk -F '/' '{print $5}';
        fi; 
    done
    )
}

function waitmodem() {
  /usr/sbin/chat -v "" "OK" "*EMRDY: 1"  < $(CONTROL_DEVICE);    
}


function checkroot() {
   if [[ $(whoami) != root ]]; then {
      sudo $0 $*
      exit 0
   } fi
}

powerup_F3507g () {
	echo -n "Powering up F3507g card "
	echo 1 > $RFKILL_DEVICE
	while [ -z "$(lsusb -d $USB_ID)" ]; do sleep 0.5; echo -n "."; done
	waitmodem

	echo "done"
	echo -n "Turning on F3507g card on ..."
	sleep 3
	if [ -n "$PIN" ]; then
	    /usr/sbin/chat -v "" "AT+CPIN?" "SIM PIN" "AT" "OK" "AT+CPIN=\"$PIN\"" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	fi
	/usr/sbin/chat -v "" "AT+CFUN=1" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	echo "done"
}

powerdown_F3507g () {
	echo -n "Turning off F3507g card on ..."
	/usr/sbin/chat -v "" "AT+CFUN=4" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	echo "done"
	echo -n "Powering down F3507g card ..."
	echo 0 > $RFKILL_DEVICE
	while [ -n "$(lsusb -d $USB_ID)" ]; do sleep 0.5; echo -n "."; done
	echo "done"
}

configure_GPS () {
	/usr/sbin/chat -v "" "AT*E2GPSCTL=$1,$2,$3" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
}

turnon_GPS () {
	echo -n "Starting NMEA stream on ..."
	configure_GPS 1 1 1
	sleep 1
	/usr/sbin/chat -v "" "AT*E2GPSNPD" "GPGGA" > $(GPS_DEVICE) < $(GPS_DEVICE)
	start-stop-daemon --start --exec /usr/sbin/gpsd -- -P $GPSDPID $(GPS_DEVICE)
	echo "done"
}

turnoff_GPS () {
	echo -n "Stopping NMEA stream on ..."
	start-stop-daemon --stop --pidfile $GPSDPID
	configure_GPS 0 1 0
	echo "done"
}

turnon_WWAN () {
	echo -n "Starting WWAN connection on ..."
	/usr/sbin/chat -v "" "AT+CGDCONT=1,\"IP\",\"$APN\"" "OK" "AT*ENAP=1,1" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	echo "done"
}

turnoff_WWAN () {
	echo -n "Stopping WWAN connection on ..."
	/usr/sbin/chat -v "" "AT*ENAP=0" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	echo "done"
}

if [[ $1 == powerup ]]; then {
   checkroot $*
   powerup_F3507g 
} fi
if [[ $1 == powerdown ]]; then {
   checkroot $*
   powerdown_F3507g
} fi

if [[ $1 == on_gps ]]; then {
   checkroot $*
   turnon_GPS  
} fi
if [[ $1 == off_gps ]]; then {
   checkroot $*
   turnoff_GPS  
} fi

if [[ $1 == on_wwan ]]; then {
   checkroot $*
   turnon_WWAN  
} fi
if [[ $1 == off_wwan ]]; then {
   checkroot $*
   turnoff_WWAN  
} fi


if [ $# -ne 1 ]
then
  echo "Uso: `basename $0` [AZIONE]"
  echo "AZIONE: "
  echo -e "\tpowerup accendere il modem"
  echo -e "\tpowerdown spegnere il modem"
  echo -e "\ton_gps accendere il GPS"
  echo -e "\toff_gps spegnere il GPS"
  echo -e "\ton_wwan connetti alla rete $APN"
  echo -e "\toff_wwan disconetti dalla rere $APN"
 
  exit $E_BADARGS
fi

admin@Exbyte

Modulo Toshiba ACPI

07-08-2013 16:05

Modulo Toshiba ACPI per gestire le periferiche del portatibile Toshiba R66-11B

/*
 *  toshiba_acpi.c - Toshiba Laptop ACPI Extras
 *
 *
 *  Copyright (C) 2002-2004 John Belmonte
 *  Copyright (C) 2008 Philip Langdale
 *
 *  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.
 *
 *  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
 *
 *
 *  The devolpment page for this driver is located at
 *  http://memebeam.org/toys/ToshibaAcpiDriver.
 *
 *  Credits:
 *    Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
 *    	engineering the Windows drivers
 *	Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
 *	Rob Miller - TV out and hotkeys help
 *
 *
 *  TODO
 *
 *  WWAN Support / 3G+GPS Killswitch for Toshiba Tecra A10
 *
 *
 */

#define TOSHIBA_ACPI_VERSION	"0.19"
#define PROC_INTERFACE_VERSION	1

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/backlight.h>
#include <linux/platform_device.h>
#include <linux/rfkill.h>
#include <linux/input.h>
#include <linux/slab.h>

#include <asm/uaccess.h>

#include <acpi/acpi_drivers.h>

MODULE_AUTHOR("John Belmonte");
MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
MODULE_LICENSE("GPL");

#define MY_LOGPREFIX "toshiba_acpi: "
#define MY_ERR KERN_ERR MY_LOGPREFIX
#define MY_NOTICE KERN_NOTICE MY_LOGPREFIX
#define MY_INFO KERN_INFO MY_LOGPREFIX

/* Toshiba ACPI method paths */
#define METHOD_LCD_BRIGHTNESS	"\\_SB_.PCI0.VGA_.LCD_._BCM"
#define TOSH_INTERFACE_1	"\\_SB_.VALD"
#define TOSH_INTERFACE_2	"\\_SB_.VALZ"
#define METHOD_VIDEO_OUT	"\\_SB_.VALX.DSSX"
#define GHCI_METHOD		".GHCI"

/* Toshiba HCI interface definitions
 *
 * HCI is Toshiba's "Hardware Control Interface" which is supposed to
 * be uniform across all their models.  Ideally we would just call
 * dedicated ACPI methods instead of using this primitive interface.
 * However the ACPI methods seem to be incomplete in some areas (for
 * example they allow setting, but not reading, the LCD brightness value),
 * so this is still useful.
 */

#define HCI_WORDS			6

/* operations */
#define HCI_SET				0xff00
#define HCI_GET				0xfe00

/* return codes */
#define HCI_SUCCESS			0x0000
#define HCI_FAILURE			0x1000
#define HCI_NOT_SUPPORTED		0x8000
#define HCI_EMPTY			0x8c00

/* registers */
#define HCI_FAN				0x0004
#define HCI_SYSTEM_EVENT		0x0016
#define HCI_VIDEO_OUT			0x001c
#define HCI_HOTKEY_EVENT		0x001e
#define HCI_LCD_BRIGHTNESS		0x002a
#define HCI_WIRELESS			0x0056

/* field definitions */
#define HCI_LCD_BRIGHTNESS_BITS		3
#define HCI_LCD_BRIGHTNESS_SHIFT	(16-HCI_LCD_BRIGHTNESS_BITS)
#define HCI_LCD_BRIGHTNESS_LEVELS	(1 << HCI_LCD_BRIGHTNESS_BITS)
#define HCI_VIDEO_OUT_LCD		0x1
#define HCI_VIDEO_OUT_CRT		0x2
#define HCI_VIDEO_OUT_TV		0x4
#define HCI_WIRELESS_KILL_SWITCH	0x01
#define HCI_WIRELESS_BT_PRESENT		0x0f
#define HCI_WIRELESS_BT_ATTACH		0x40
#define HCI_WIRELESS_BT_POWER		0x80

// WWAN Support / 3G+GPS Killswitch
// tested on Toshiba Tecra A10

#define HCI_WIRELESS_WWAN_PRESENT              0x0f
#define HCI_WIRELESS_WWAN_ATTACH               0x4000
#define HCI_WIRELESS_WWAN_POWER                0x2000



static const struct acpi_device_id toshiba_device_ids[] = {
	{"TOS6200", 0},
	{"TOS6208", 0},
	{"TOS1900", 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);

struct key_entry {
	char type;
	u16 code;
	u16 keycode;
};

enum {KE_KEY, KE_END};

static struct key_entry toshiba_acpi_keymap[]  = {
	{KE_KEY, 0x101, KEY_MUTE},
	{KE_KEY, 0x13b, KEY_COFFEE},
	{KE_KEY, 0x13c, KEY_BATTERY},
	{KE_KEY, 0x13d, KEY_SLEEP},
	{KE_KEY, 0x13e, KEY_SUSPEND},
	{KE_KEY, 0x13f, KEY_SWITCHVIDEOMODE},
	{KE_KEY, 0x140, KEY_BRIGHTNESSDOWN},
	{KE_KEY, 0x141, KEY_BRIGHTNESSUP},
	{KE_KEY, 0x142, KEY_WLAN},
	{KE_KEY, 0x143, KEY_PROG1},
	{KE_KEY, 0xb05, KEY_PROG2},
	{KE_KEY, 0xb06, KEY_WWW},
	{KE_KEY, 0xb07, KEY_MAIL},
	{KE_KEY, 0xb30, KEY_STOP},
	{KE_KEY, 0xb31, KEY_PREVIOUSSONG},
	{KE_KEY, 0xb32, KEY_NEXTSONG},
	{KE_KEY, 0xb33, KEY_PLAYPAUSE},
	{KE_KEY, 0xb5a, KEY_MEDIA},
	{KE_END, 0, 0},
};

/* utility
 */

static __inline__ void _set_bit(u32 * word, u32 mask, int value)
{
	*word = (*word & ~mask) | (mask * value);
}

/* acpi interface wrappers
 */

static int is_valid_acpi_path(const char *methodName)
{
	acpi_handle handle;
	acpi_status status;

	status = acpi_get_handle(NULL, (char *)methodName, &handle);
	return !ACPI_FAILURE(status);
}

static int write_acpi_int(const char *methodName, int val)
{
	struct acpi_object_list params;
	union acpi_object in_objs[1];
	acpi_status status;

	params.count = ARRAY_SIZE(in_objs);
	params.pointer = in_objs;
	in_objs[0].type = ACPI_TYPE_INTEGER;
	in_objs[0].integer.value = val;

	status = acpi_evaluate_object(NULL, (char *)methodName, &params, NULL);
	return (status == AE_OK);
}

#if 0
static int read_acpi_int(const char *methodName, int *pVal)
{
	struct acpi_buffer results;
	union acpi_object out_objs[1];
	acpi_status status;

	results.length = sizeof(out_objs);
	results.pointer = out_objs;

	status = acpi_evaluate_object(0, (char *)methodName, 0, &results);
	*pVal = out_objs[0].integer.value;

	return (status == AE_OK) && (out_objs[0].type == ACPI_TYPE_INTEGER);
}
#endif

static const char *method_hci /*= 0*/ ;

/* Perform a raw HCI call.  Here we don't care about input or output buffer
 * format.
 */
static acpi_status hci_raw(const u32 in[HCI_WORDS], u32 out[HCI_WORDS])
{
	struct acpi_object_list params;
	union acpi_object in_objs[HCI_WORDS];
	struct acpi_buffer results;
	union acpi_object out_objs[HCI_WORDS + 1];
	acpi_status status;
	int i;

	params.count = HCI_WORDS;
	params.pointer = in_objs;
	for (i = 0; i < HCI_WORDS; ++i) {
		in_objs[i].type = ACPI_TYPE_INTEGER;
		in_objs[i].integer.value = in[i];
	}

	results.length = sizeof(out_objs);
	results.pointer = out_objs;

	status = acpi_evaluate_object(NULL, (char *)method_hci, &params,
				      &results);
	if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) {
		for (i = 0; i < out_objs->package.count; ++i) {
			out[i] = out_objs->package.elements[i].integer.value;
		}
	}

	return status;
}

/* common hci tasks (get or set one or two value)
 *
 * In addition to the ACPI status, the HCI system returns a result which
 * may be useful (such as "not supported").
 */

static acpi_status hci_write1(u32 reg, u32 in1, u32 * result)
{
	u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
	u32 out[HCI_WORDS];
	acpi_status status = hci_raw(in, out);
	*result = (status == AE_OK) ? out[0] : HCI_FAILURE;
	return status;
}

static acpi_status hci_read1(u32 reg, u32 * out1, u32 * result)
{
	u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
	u32 out[HCI_WORDS];
	acpi_status status = hci_raw(in, out);
	*out1 = out[2];
	*result = (status == AE_OK) ? out[0] : HCI_FAILURE;
	return status;
}

static acpi_status hci_write2(u32 reg, u32 in1, u32 in2, u32 *result)
{
	u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 };
	u32 out[HCI_WORDS];
	acpi_status status = hci_raw(in, out);
	*result = (status == AE_OK) ? out[0] : HCI_FAILURE;
	return status;
}

static acpi_status hci_read2(u32 reg, u32 *out1, u32 *out2, u32 *result)
{
	u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
	u32 out[HCI_WORDS];
	acpi_status status = hci_raw(in, out);
	*out1 = out[2];
	*out2 = out[3];
	*result = (status == AE_OK) ? out[0] : HCI_FAILURE;
	return status;
}

struct toshiba_acpi_dev {
	struct platform_device *p_dev;
	struct rfkill *bt_rfk;
	struct rfkill *wwan_rfk;
	struct input_dev *hotkey_dev;
	acpi_handle handle;

	const char *bt_name;
	const char *wwan_name;

	struct mutex mutex;
};

static struct toshiba_acpi_dev toshiba_acpi = {
	.bt_name = "Toshiba Bluetooth",
	.wwan_name = "Toshiba WWAN",
};

/* Bluetooth rfkill handlers */

static u32 hci_get_bt_present(bool *present)
{
	u32 hci_result;
	u32 value, value2;

	value = 0;
	value2 = 0;
	hci_read2(HCI_WIRELESS, &value, &value2, &hci_result);
	if (hci_result == HCI_SUCCESS)
		*present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;

	return hci_result;
}

static u32 hci_get_radio_state(bool *radio_state)
{
	u32 hci_result;
	u32 value, value2;

	value = 0;
	value2 = 0x0001;
	hci_read2(HCI_WIRELESS, &value, &value2, &hci_result);

	*radio_state = value & HCI_WIRELESS_KILL_SWITCH;
	return hci_result;
}

static int bt_rfkill_set_block(void *data, bool blocked)
{
	struct toshiba_acpi_dev *dev = data;
	u32 result1, result2;
	u32 value;
	int err;
	bool radio_state;

	value = (blocked == false);

	mutex_lock(&dev->mutex);
	if (hci_get_radio_state(&radio_state) != HCI_SUCCESS) {
		err = -EBUSY;
		goto out;
	}

	if (!radio_state) {
		err = 0;
		goto out;
	}

	hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1);
	hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2);

	if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
		err = -EBUSY;
	else
		err = 0;
 out:
	mutex_unlock(&dev->mutex);
	return err;
}

static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
{
	bool new_rfk_state;
	bool value;
	u32 hci_result;
	struct toshiba_acpi_dev *dev = data;

	mutex_lock(&dev->mutex);

	hci_result = hci_get_radio_state(&value);
	if (hci_result != HCI_SUCCESS) {
		/* Can't do anything useful */
		mutex_unlock(&dev->mutex);
		return;
	}

	new_rfk_state = value;

	mutex_unlock(&dev->mutex);

	if (rfkill_set_hw_state(rfkill, !new_rfk_state))
		bt_rfkill_set_block(data, true);
}

/*----------------------------------------------------------------*/


static u32 hci_get_wwan_present(bool *present)
{
	u32 hci_result;
	u32 value, value2;

	value = 0;
	value2 = 0;
	hci_read2(HCI_WIRELESS, &value, &value2, &hci_result);
	if (hci_result == HCI_SUCCESS)
		*present = (value & HCI_WIRELESS_WWAN_PRESENT) ? true : false;

	return hci_result;
}

static int wwan_rfkill_set_block(void *data, bool blocked)
{
	struct toshiba_acpi_dev *dev = data;
	u32 result1, result2;
	u32 value;
	int err;
	bool radio_state;

	value = (blocked == false);

	mutex_lock(&dev->mutex);
	if (hci_get_radio_state(&radio_state) != HCI_SUCCESS) {
		err = -EBUSY;
		goto out;
	}

	if (!radio_state) {
		err = 0;
		goto out;
	}

	hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_WWAN_POWER, &result1);
	hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_WWAN_ATTACH, &result2);

	if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
		err = -EBUSY;
	else
		err = 0;
 out:
	mutex_unlock(&dev->mutex);
	return err;
}

static void wwan_rfkill_poll(struct rfkill *rfkill, void *data)
{
	bool new_rfk_state;
	bool value;
	u32 hci_result;
	struct toshiba_acpi_dev *dev = data;

	mutex_lock(&dev->mutex);

	hci_result = hci_get_radio_state(&value);
	if (hci_result != HCI_SUCCESS) {
		/* Can't do anything useful */
		mutex_unlock(&dev->mutex);
		return;
	}

	new_rfk_state = value;

	mutex_unlock(&dev->mutex);

	if (rfkill_set_hw_state(rfkill, !new_rfk_state))
		wwan_rfkill_set_block(data, true);
}

/* ------------------------------------------------------- */

static const struct rfkill_ops toshiba_rfk_ops = {
	.set_block = bt_rfkill_set_block,
	.poll = bt_rfkill_poll,
};

static const struct rfkill_ops toshiba_rfk_ops_wwan = {
	.set_block = wwan_rfkill_set_block,
	.poll = wwan_rfkill_poll,
};


static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
static struct backlight_device *toshiba_backlight_device;
static int force_fan;
static int last_key_event;
static int key_event_valid;

static int get_lcd(struct backlight_device *bd)
{
	u32 hci_result;
	u32 value;

	hci_read1(HCI_LCD_BRIGHTNESS, &value, &hci_result);
	if (hci_result == HCI_SUCCESS) {
		return (value >> HCI_LCD_BRIGHTNESS_SHIFT);
	} else
		return -EFAULT;
}

static int lcd_proc_show(struct seq_file *m, void *v)
{
	int value = get_lcd(NULL);

	if (value >= 0) {
		seq_printf(m, "brightness:              %d\n", value);
		seq_printf(m, "brightness_levels:       %d\n",
			     HCI_LCD_BRIGHTNESS_LEVELS);
	} else {
		printk(MY_ERR "Error reading LCD brightness\n");
	}

	return 0;
}

static int lcd_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, lcd_proc_show, NULL);
}

static int set_lcd(int value)
{
	u32 hci_result;

	value = value << HCI_LCD_BRIGHTNESS_SHIFT;
	hci_write1(HCI_LCD_BRIGHTNESS, value, &hci_result);
	if (hci_result != HCI_SUCCESS)
		return -EFAULT;

	return 0;
}

static int set_lcd_status(struct backlight_device *bd)
{
	return set_lcd(bd->props.brightness);
}

static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
			      size_t count, loff_t *pos)
{
	char cmd[42];
	size_t len;
	int value;
	int ret;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	if (sscanf(cmd, " brightness : %i", &value) == 1 &&
	    value >= 0 && value < HCI_LCD_BRIGHTNESS_LEVELS) {
		ret = set_lcd(value);
		if (ret == 0)
			ret = count;
	} else {
		ret = -EINVAL;
	}
	return ret;
}

static const struct file_operations lcd_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= lcd_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= lcd_proc_write,
};

static int video_proc_show(struct seq_file *m, void *v)
{
	u32 hci_result;
	u32 value;

	hci_read1(HCI_VIDEO_OUT, &value, &hci_result);
	if (hci_result == HCI_SUCCESS) {
		int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
		int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
		int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
		seq_printf(m, "lcd_out:                 %d\n", is_lcd);
		seq_printf(m, "crt_out:                 %d\n", is_crt);
		seq_printf(m, "tv_out:                  %d\n", is_tv);
	} else {
		printk(MY_ERR "Error reading video out status\n");
	}

	return 0;
}

static int video_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, video_proc_show, NULL);
}

static ssize_t video_proc_write(struct file *file, const char __user *buf,
				size_t count, loff_t *pos)
{
	char *cmd, *buffer;
	int value;
	int remain = count;
	int lcd_out = -1;
	int crt_out = -1;
	int tv_out = -1;
	u32 hci_result;
	u32 video_out;

	cmd = kmalloc(count + 1, GFP_KERNEL);
	if (!cmd)
		return -ENOMEM;
	if (copy_from_user(cmd, buf, count)) {
		kfree(cmd);
		return -EFAULT;
	}
	cmd[count] = '\0';

	buffer = cmd;

	/* scan expression.  Multiple expressions may be delimited with ;
	 *
	 *  NOTE: to keep scanning simple, invalid fields are ignored
	 */
	while (remain) {
		if (sscanf(buffer, " lcd_out : %i", &value) == 1)
			lcd_out = value & 1;
		else if (sscanf(buffer, " crt_out : %i", &value) == 1)
			crt_out = value & 1;
		else if (sscanf(buffer, " tv_out : %i", &value) == 1)
			tv_out = value & 1;
		/* advance to one character past the next ; */
		do {
			++buffer;
			--remain;
		}
		while (remain && *(buffer - 1) != ';');
	}

	kfree(cmd);

	hci_read1(HCI_VIDEO_OUT, &video_out, &hci_result);
	if (hci_result == HCI_SUCCESS) {
		unsigned int new_video_out = video_out;
		if (lcd_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
		if (crt_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
		if (tv_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
		/* To avoid unnecessary video disruption, only write the new
		 * video setting if something changed. */
		if (new_video_out != video_out)
			write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
	} else {
		return -EFAULT;
	}

	return count;
}

static const struct file_operations video_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= video_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= video_proc_write,
};

static int fan_proc_show(struct seq_file *m, void *v)
{
	u32 hci_result;
	u32 value;

	hci_read1(HCI_FAN, &value, &hci_result);
	if (hci_result == HCI_SUCCESS) {
		seq_printf(m, "running:                 %d\n", (value > 0));
		seq_printf(m, "force_on:                %d\n", force_fan);
	} else {
		printk(MY_ERR "Error reading fan status\n");
	}

	return 0;
}

static int fan_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, fan_proc_show, NULL);
}

static ssize_t fan_proc_write(struct file *file, const char __user *buf,
			      size_t count, loff_t *pos)
{
	char cmd[42];
	size_t len;
	int value;
	u32 hci_result;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	if (sscanf(cmd, " force_on : %i", &value) == 1 &&
	    value >= 0 && value <= 1) {
		hci_write1(HCI_FAN, value, &hci_result);
		if (hci_result != HCI_SUCCESS)
			return -EFAULT;
		else
			force_fan = value;
	} else {
		return -EINVAL;
	}

	return count;
}

static const struct file_operations fan_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= fan_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= fan_proc_write,
};

static int keys_proc_show(struct seq_file *m, void *v)
{
	u32 hci_result;
	u32 value;

	if (!key_event_valid) {
		hci_read1(HCI_SYSTEM_EVENT, &value, &hci_result);
		if (hci_result == HCI_SUCCESS) {
			key_event_valid = 1;
			last_key_event = value;
		} else if (hci_result == HCI_EMPTY) {
			/* better luck next time */
		} else if (hci_result == HCI_NOT_SUPPORTED) {
			/* This is a workaround for an unresolved issue on
			 * some machines where system events sporadically
			 * become disabled. */
			hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
			printk(MY_NOTICE "Re-enabled hotkeys\n");
		} else {
			printk(MY_ERR "Error reading hotkey status\n");
			goto end;
		}
	}

	seq_printf(m, "hotkey_ready:            %d\n", key_event_valid);
	seq_printf(m, "hotkey:                  0x%04x\n", last_key_event);
end:
	return 0;
}

static int keys_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, keys_proc_show, NULL);
}

static ssize_t keys_proc_write(struct file *file, const char __user *buf,
			       size_t count, loff_t *pos)
{
	char cmd[42];
	size_t len;
	int value;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
		key_event_valid = 0;
	} else {
		return -EINVAL;
	}

	return count;
}

static const struct file_operations keys_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= keys_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= keys_proc_write,
};

static int version_proc_show(struct seq_file *m, void *v)
{
	seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
	seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
	return 0;
}

static int version_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, version_proc_show, PDE(inode)->data);
}

static const struct file_operations version_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= version_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

/* proc and module init
 */

#define PROC_TOSHIBA		"toshiba"

static acpi_status __init add_device(void)
{
	proc_create("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir, &lcd_proc_fops);
	proc_create("video", S_IRUGO | S_IWUSR, toshiba_proc_dir, &video_proc_fops);
	proc_create("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir, &fan_proc_fops);
	proc_create("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir, &keys_proc_fops);
	proc_create("version", S_IRUGO, toshiba_proc_dir, &version_proc_fops);

	return AE_OK;
}

static acpi_status remove_device(void)
{
	remove_proc_entry("lcd", toshiba_proc_dir);
	remove_proc_entry("video", toshiba_proc_dir);
	remove_proc_entry("fan", toshiba_proc_dir);
	remove_proc_entry("keys", toshiba_proc_dir);
	remove_proc_entry("version", toshiba_proc_dir);
	return AE_OK;
}

static struct backlight_ops toshiba_backlight_data = {
        .get_brightness = get_lcd,
        .update_status  = set_lcd_status,
};

static struct key_entry *toshiba_acpi_get_entry_by_scancode(unsigned int code)
{
	struct key_entry *key;

	for (key = toshiba_acpi_keymap; key->type != KE_END; key++)
		if (code == key->code)
			return key;

	return NULL;
}

static struct key_entry *toshiba_acpi_get_entry_by_keycode(unsigned int code)
{
	struct key_entry *key;

	for (key = toshiba_acpi_keymap; key->type != KE_END; key++)
		if (code == key->keycode && key->type == KE_KEY)
			return key;

	return NULL;
}

static int toshiba_acpi_getkeycode(struct input_dev *dev,
				   unsigned int scancode, unsigned int *keycode)
{
	struct key_entry *key = toshiba_acpi_get_entry_by_scancode(scancode);

	if (key && key->type == KE_KEY) {
		*keycode = key->keycode;
		return 0;
	}

	return -EINVAL;
}

static int toshiba_acpi_setkeycode(struct input_dev *dev,
				   unsigned int scancode, unsigned int keycode)
{
	struct key_entry *key;
	unsigned int old_keycode;

	key = toshiba_acpi_get_entry_by_scancode(scancode);
	if (key && key->type == KE_KEY) {
		old_keycode = key->keycode;
		key->keycode = keycode;
		set_bit(keycode, dev->keybit);
		if (!toshiba_acpi_get_entry_by_keycode(old_keycode))
			clear_bit(old_keycode, dev->keybit);
		return 0;
	}

	return -EINVAL;
}

static void toshiba_acpi_notify(acpi_handle handle, u32 event, void *context)
{
	u32 hci_result, value;
	struct key_entry *key;

	if (event != 0x80)
		return;
	do {
		hci_read1(HCI_SYSTEM_EVENT, &value, &hci_result);
		if (hci_result == HCI_SUCCESS) {
			if (value == 0x100)
				continue;
			/* act on key press; ignore key release */
			if (value & 0x80)
				continue;

			key = toshiba_acpi_get_entry_by_scancode
				(value);
			if (!key) {
				printk(MY_INFO "Unknown key %x\n",
				       value);
				continue;
			}
			input_report_key(toshiba_acpi.hotkey_dev,
					 key->keycode, 1);
			input_sync(toshiba_acpi.hotkey_dev);
			input_report_key(toshiba_acpi.hotkey_dev,
					 key->keycode, 0);
			input_sync(toshiba_acpi.hotkey_dev);
		} else if (hci_result == HCI_NOT_SUPPORTED) {
			/* This is a workaround for an unresolved issue on
			 * some machines where system events sporadically
			 * become disabled. */
			hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
			printk(MY_NOTICE "Re-enabled hotkeys\n");
		}
	} while (hci_result != HCI_EMPTY);
}

static int toshiba_acpi_setup_keyboard(char *device)
{
	acpi_status status;
	acpi_handle handle;
	int result;
	const struct key_entry *key;

	status = acpi_get_handle(NULL, device, &handle);
	if (ACPI_FAILURE(status)) {
		printk(MY_INFO "Unable to get notification device\n");
		return -ENODEV;
	}

	toshiba_acpi.handle = handle;

	status = acpi_evaluate_object(handle, "ENAB", NULL, NULL);
	if (ACPI_FAILURE(status)) {
		printk(MY_INFO "Unable to enable hotkeys\n");
		return -ENODEV;
	}

	status = acpi_install_notify_handler(handle, ACPI_DEVICE_NOTIFY,
					      toshiba_acpi_notify, NULL);
	if (ACPI_FAILURE(status)) {
		printk(MY_INFO "Unable to install hotkey notification\n");
		return -ENODEV;
	}

	toshiba_acpi.hotkey_dev = input_allocate_device();
	if (!toshiba_acpi.hotkey_dev) {
		printk(MY_INFO "Unable to register input device\n");
		return -ENOMEM;
	}

	toshiba_acpi.hotkey_dev->name = "Toshiba input device";
	toshiba_acpi.hotkey_dev->phys = device;
	toshiba_acpi.hotkey_dev->id.bustype = BUS_HOST;
	toshiba_acpi.hotkey_dev->getkeycode = toshiba_acpi_getkeycode;
	toshiba_acpi.hotkey_dev->setkeycode = toshiba_acpi_setkeycode;

	for (key = toshiba_acpi_keymap; key->type != KE_END; key++) {
		set_bit(EV_KEY, toshiba_acpi.hotkey_dev->evbit);
		set_bit(key->keycode, toshiba_acpi.hotkey_dev->keybit);
	}

	result = input_register_device(toshiba_acpi.hotkey_dev);
	if (result) {
		printk(MY_INFO "Unable to register input device\n");
		return result;
	}

	return 0;
}

static void toshiba_acpi_exit(void)
{
	if (toshiba_acpi.hotkey_dev)
		input_unregister_device(toshiba_acpi.hotkey_dev);

	if (toshiba_acpi.bt_rfk) {
		rfkill_unregister(toshiba_acpi.bt_rfk);
		rfkill_destroy(toshiba_acpi.bt_rfk);
	}

	if (toshiba_acpi.wwan_rfk) {
		rfkill_unregister(toshiba_acpi.wwan_rfk);
		rfkill_destroy(toshiba_acpi.wwan_rfk);
	}

	if (toshiba_backlight_device)
		backlight_device_unregister(toshiba_backlight_device);

	remove_device();

	if (toshiba_proc_dir)
		remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);

	acpi_remove_notify_handler(toshiba_acpi.handle, ACPI_DEVICE_NOTIFY,
				   toshiba_acpi_notify);

	platform_device_unregister(toshiba_acpi.p_dev);

	return;
}

static int __init toshiba_acpi_init(void)
{
	acpi_status status = AE_OK;
	u32 hci_result;
	bool bt_present;
	bool wwan_present;
	int ret = 0;
	struct backlight_properties props;

	if (acpi_disabled)
		return -ENODEV;

	/* simple device detection: look for HCI method */
	if (is_valid_acpi_path(TOSH_INTERFACE_1 GHCI_METHOD)) {
		method_hci = TOSH_INTERFACE_1 GHCI_METHOD;
		if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_1))
			printk(MY_INFO "Unable to activate hotkeys\n");
	} else if (is_valid_acpi_path(TOSH_INTERFACE_2 GHCI_METHOD)) {
		method_hci = TOSH_INTERFACE_2 GHCI_METHOD;
		if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_2))
			printk(MY_INFO "Unable to activate hotkeys\n");
	} else
		return -ENODEV;

	printk(MY_INFO "Toshiba Laptop ACPI Extras version %s\n",
	       TOSHIBA_ACPI_VERSION);
	printk(MY_INFO "    HCI method: %s\n", method_hci);

	mutex_init(&toshiba_acpi.mutex);

	toshiba_acpi.p_dev = platform_device_register_simple("toshiba_acpi",
							      -1, NULL, 0);
	if (IS_ERR(toshiba_acpi.p_dev)) {
		ret = PTR_ERR(toshiba_acpi.p_dev);
		printk(MY_ERR "unable to register platform device\n");
		toshiba_acpi.p_dev = NULL;
		toshiba_acpi_exit();
		return ret;
	}

	force_fan = 0;
	key_event_valid = 0;

	/* enable event fifo */
	hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);

	toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
	if (!toshiba_proc_dir) {
		toshiba_acpi_exit();
		return -ENODEV;
	} else {
		status = add_device();
		if (ACPI_FAILURE(status)) {
			toshiba_acpi_exit();
			return -ENODEV;
		}
	}

	props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
	toshiba_backlight_device = backlight_device_register("toshiba",
							     &toshiba_acpi.p_dev->dev,
							     NULL,
							     &toshiba_backlight_data,
							     &props);
        if (IS_ERR(toshiba_backlight_device)) {
		ret = PTR_ERR(toshiba_backlight_device);

		printk(KERN_ERR "Could not register toshiba backlight device\n");
		toshiba_backlight_device = NULL;
		toshiba_acpi_exit();
		return ret;
	}

	/* Register rfkill switch for Bluetooth */
	if (hci_get_bt_present(&bt_present) == HCI_SUCCESS && bt_present) {
		toshiba_acpi.bt_rfk = rfkill_alloc(toshiba_acpi.bt_name,
						   &toshiba_acpi.p_dev->dev,
						   RFKILL_TYPE_BLUETOOTH,
						   &toshiba_rfk_ops,
						   &toshiba_acpi);
		if (!toshiba_acpi.bt_rfk) {
			printk(MY_ERR "unable to allocate rfkill device\n");
			toshiba_acpi_exit();
			return -ENOMEM;
		}

		ret = rfkill_register(toshiba_acpi.bt_rfk);
		if (ret) {
			printk(MY_ERR "unable to register rfkill device\n");
			rfkill_destroy(toshiba_acpi.bt_rfk);
			toshiba_acpi_exit();
			return ret;
		}
	}
exbyte@Exbyte

Il mito della frammentazione del progetto GNU/Linux

19-07-2013 10:20

L’utente che non consce il mondo Linux di regola come prima cosa va su distrowatch guarda la lista delle distro e scopre che ne sono state registrate 303,  se poi va a dare un occhiata alla pagina wikipedia http://it.wikipedia.org/wiki/Distribuzione_Linux  la situazione in apparenza è ancora più frammentata, creando un enorme dispersione di energie.

Ma guardiamo alla realtà, una distribuzione è solo l’ultimo tassello del progetto GNU / Linux  e prima di arrivare a questa sono necessari molti altri componenti software ed in genere molto più sofisticati di una distro:

Il Kernel Linux è gestito come progetto unico e molto centralizzato.
GCC è il compilatore standard ed è un progetto unico e senza reali concorrenti nel mondo GNU / Linux
systemd è ormai uno standard su Linux e è di fatto unico.
Xorg è lo standard e al momento non ha rivali.

e molti altri componenti fondamentali del sistema sono di fatto gestiti in modo centralizzato.

Resta la particolarità di KDE e GNOME e tutti gli altri WM, ma anche in questo caso oltre ai due progetti dominanti l’unico che riesce ad avere una base consistetene di utenti è Xfce. Oltre al fatto che questi 3 WM coprono differenti richiese ed esigenze degli utenti.

Nei software specifici la situazione è molto più frammentata, ma per l’appunto restano prodotti specifici e coprono le esigenze particolari degli utenti (nel mondo Win la situazione in questo settore è molto simile).

Ma se si torna alle distribuzioni, si scopre in poco tempo che di fatto  il 90% degli utenti Linux è coperto al massimo una decina di distribuzioni (Arch compresa).

Quindi anche in questo caso mi sembra che la maggior parte degli sforzi si concentrino su un numero molto limitato di distribuzioni, diciamo Ubuntu, Mint, Fedoda, OpenSuse, ArchLinux, Debian e poche altre. Che poi nella pratica sono tutte distribuzioni sviluppate con filosofie differenti fra di loro e che vanno a coprire richieste differenti.

E tutte le altre distro? Si tratta del mondo open source quindi ognuno può fare quello che vuole ed è libero di sperimentare le sue idee e se sono buone un giorno potrà entrare nella top-10 con la sua distro.

[Quando cominciai ad usare Arch  nel 2006, era considerata una distro minore e con pochissimi utenti, ma molto innovativa; il tempo gli ha dato ragione!].

Come unica conclusione posso solo dire che gli sforzi per lo sviluppo del progetto GNU/Linux sono di fatto uniti e ben distribuiti sui vari componenti; sfatando il mito della frammentazione.


firef@Barone Rosso

Sorgente modulo kernel toshiba_acpi

07-07-2013 11:45

Sorgente del modulo kernel toshiba_acpi che permette di abilitare il modulo 3G del mio portatile

/*
 *  toshiba_acpi.c - Toshiba Laptop ACPI Extras
 *
 *
 *  Copyright (C) 2002-2004 John Belmonte
 *  Copyright (C) 2008 Philip Langdale
 *
 *  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.
 *
 *  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
 *
 *
 *  The devolpment page for this driver is located at
 *  http://memebeam.org/toys/ToshibaAcpiDriver.
 *
 *  Credits:
 *    Jonathan A. Buzzard - Toshiba HCI info, and critical tips on reverse
 *		engineering the Windows drivers
 *	Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
 *	Rob Miller - TV out and hotkeys help
 *
 *
 *  TODO
 *
 *  WWAN Support / 3G+GPS Killswitch for Toshiba Tecra A10
 *
 *
 */

#define TOSHIBA_ACPI_VERSION	"0.19"
#define PROC_INTERFACE_VERSION	1

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/backlight.h>
#include <linux/platform_device.h>
#include <linux/rfkill.h>
#include <linux/input.h>
#include <linux/slab.h>

#include <asm/uaccess.h>

#include <acpi/acpi_drivers.h>

MODULE_AUTHOR("John Belmonte");
MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
MODULE_LICENSE("GPL");

#define MY_LOGPREFIX "toshiba_acpi: "
#define MY_ERR KERN_ERR MY_LOGPREFIX
#define MY_NOTICE KERN_NOTICE MY_LOGPREFIX
#define MY_INFO KERN_INFO MY_LOGPREFIX

/* Toshiba ACPI method paths */
#define METHOD_LCD_BRIGHTNESS	"\\_SB_.PCI0.VGA_.LCD_._BCM"
#define TOSH_INTERFACE_1	"\\_SB_.VALD"
#define TOSH_INTERFACE_2	"\\_SB_.VALZ"
#define METHOD_VIDEO_OUT	"\\_SB_.VALX.DSSX"
#define GHCI_METHOD		".GHCI"

/* Toshiba HCI interface definitions
 *
 * HCI is Toshiba's "Hardware Control Interface" which is supposed to
 * be uniform across all their models.  Ideally we would just call
 * dedicated ACPI methods instead of using this primitive interface.
 * However the ACPI methods seem to be incomplete in some areas (for
 * example they allow setting, but not reading, the LCD brightness value),
 * so this is still useful.
 */

#define HCI_WORDS			6

/* operations */
#define HCI_SET				0xff00
#define HCI_GET				0xfe00

/* return codes */
#define HCI_SUCCESS			0x0000
#define HCI_FAILURE			0x1000
#define HCI_NOT_SUPPORTED		0x8000
#define HCI_EMPTY			0x8c00

/* registers */
#define HCI_FAN				0x0004
#define HCI_SYSTEM_EVENT		0x0016
#define HCI_VIDEO_OUT			0x001c
#define HCI_HOTKEY_EVENT		0x001e
#define HCI_LCD_BRIGHTNESS		0x002a
#define HCI_WIRELESS			0x0056

/* field definitions */
#define HCI_LCD_BRIGHTNESS_BITS		3
#define HCI_LCD_BRIGHTNESS_SHIFT	(16-HCI_LCD_BRIGHTNESS_BITS)
#define HCI_LCD_BRIGHTNESS_LEVELS	(1 << HCI_LCD_BRIGHTNESS_BITS)
#define HCI_VIDEO_OUT_LCD		0x1
#define HCI_VIDEO_OUT_CRT		0x2
#define HCI_VIDEO_OUT_TV		0x4
#define HCI_WIRELESS_KILL_SWITCH	0x01
#define HCI_WIRELESS_BT_PRESENT		0x0f
#define HCI_WIRELESS_BT_ATTACH		0x40
#define HCI_WIRELESS_BT_POWER		0x80

// WWAN Support / 3G+GPS Killswitch
// tested on Toshiba Tecra A10

#define HCI_WIRELESS_WWAN_PRESENT              0x0f
#define HCI_WIRELESS_WWAN_ATTACH               0x4000
#define HCI_WIRELESS_WWAN_POWER                0x2000



static const struct acpi_device_id toshiba_device_ids[] = {
	{"TOS6200", 0},
	{"TOS6208", 0},
	{"TOS1900", 0},
	{"", 0},
};
MODULE_DEVICE_TABLE(acpi, toshiba_device_ids);

struct key_entry {
	char type;
	u16 code;
	u16 keycode;
};

enum {KE_KEY, KE_END};

static struct key_entry toshiba_acpi_keymap[]  = {
	{KE_KEY, 0x101, KEY_MUTE},
	{KE_KEY, 0x13b, KEY_COFFEE},
	{KE_KEY, 0x13c, KEY_BATTERY},
	{KE_KEY, 0x13d, KEY_SLEEP},
	{KE_KEY, 0x13e, KEY_SUSPEND},
	{KE_KEY, 0x13f, KEY_SWITCHVIDEOMODE},
	{KE_KEY, 0x140, KEY_BRIGHTNESSDOWN},
	{KE_KEY, 0x141, KEY_BRIGHTNESSUP},
	{KE_KEY, 0x142, KEY_WLAN},
	{KE_KEY, 0x143, KEY_PROG1},
	{KE_KEY, 0xb05, KEY_PROG2},
	{KE_KEY, 0xb06, KEY_WWW},
	{KE_KEY, 0xb07, KEY_MAIL},
	{KE_KEY, 0xb30, KEY_STOP},
	{KE_KEY, 0xb31, KEY_PREVIOUSSONG},
	{KE_KEY, 0xb32, KEY_NEXTSONG},
	{KE_KEY, 0xb33, KEY_PLAYPAUSE},
	{KE_KEY, 0xb5a, KEY_MEDIA},
	{KE_END, 0, 0},
};

/* utility
 */

static __inline__ void _set_bit(u32 * word, u32 mask, int value)
{
	*word = (*word & ~mask) | (mask * value);
}

/* acpi interface wrappers
 */

static int is_valid_acpi_path(const char *methodName)
{
	acpi_handle handle;
	acpi_status status;

	status = acpi_get_handle(NULL, (char *)methodName, &handle);
	return !ACPI_FAILURE(status);
}

static int write_acpi_int(const char *methodName, int val)
{
	struct acpi_object_list params;
	union acpi_object in_objs[1];
	acpi_status status;

	params.count = ARRAY_SIZE(in_objs);
	params.pointer = in_objs;
	in_objs[0].type = ACPI_TYPE_INTEGER;
	in_objs[0].integer.value = val;

	status = acpi_evaluate_object(NULL, (char *)methodName, &params, NULL);
	return (status == AE_OK);
}

#if 0
static int read_acpi_int(const char *methodName, int *pVal)
{
	struct acpi_buffer results;
	union acpi_object out_objs[1];
	acpi_status status;

	results.length = sizeof(out_objs);
	results.pointer = out_objs;

	status = acpi_evaluate_object(0, (char *)methodName, 0, &results);
	*pVal = out_objs[0].integer.value;

	return (status == AE_OK) && (out_objs[0].type == ACPI_TYPE_INTEGER);
}
#endif

static const char *method_hci /*= 0*/ ;

/* Perform a raw HCI call.  Here we don't care about input or output buffer
 * format.
 */
static acpi_status hci_raw(const u32 in[HCI_WORDS], u32 out[HCI_WORDS])
{
	struct acpi_object_list params;
	union acpi_object in_objs[HCI_WORDS];
	struct acpi_buffer results;
	union acpi_object out_objs[HCI_WORDS + 1];
	acpi_status status;
	int i;

	params.count = HCI_WORDS;
	params.pointer = in_objs;
	for (i = 0; i < HCI_WORDS; ++i) {
		in_objs[i].type = ACPI_TYPE_INTEGER;
		in_objs[i].integer.value = in[i];
	}

	results.length = sizeof(out_objs);
	results.pointer = out_objs;

	status = acpi_evaluate_object(NULL, (char *)method_hci, &params,
				      &results);
	if ((status == AE_OK) && (out_objs->package.count <= HCI_WORDS)) {
		for (i = 0; i < out_objs->package.count; ++i) {
			out[i] = out_objs->package.elements[i].integer.value;
		}
	}

	return status;
}

/* common hci tasks (get or set one or two value)
 *
 * In addition to the ACPI status, the HCI system returns a result which
 * may be useful (such as "not supported").
 */

static acpi_status hci_write1(u32 reg, u32 in1, u32 * result)
{
	u32 in[HCI_WORDS] = { HCI_SET, reg, in1, 0, 0, 0 };
	u32 out[HCI_WORDS];
	acpi_status status = hci_raw(in, out);
	*result = (status == AE_OK) ? out[0] : HCI_FAILURE;
	return status;
}

static acpi_status hci_read1(u32 reg, u32 * out1, u32 * result)
{
	u32 in[HCI_WORDS] = { HCI_GET, reg, 0, 0, 0, 0 };
	u32 out[HCI_WORDS];
	acpi_status status = hci_raw(in, out);
	*out1 = out[2];
	*result = (status == AE_OK) ? out[0] : HCI_FAILURE;
	return status;
}

static acpi_status hci_write2(u32 reg, u32 in1, u32 in2, u32 *result)
{
	u32 in[HCI_WORDS] = { HCI_SET, reg, in1, in2, 0, 0 };
	u32 out[HCI_WORDS];
	acpi_status status = hci_raw(in, out);
	*result = (status == AE_OK) ? out[0] : HCI_FAILURE;
	return status;
}

static acpi_status hci_read2(u32 reg, u32 *out1, u32 *out2, u32 *result)
{
	u32 in[HCI_WORDS] = { HCI_GET, reg, *out1, *out2, 0, 0 };
	u32 out[HCI_WORDS];
	acpi_status status = hci_raw(in, out);
	*out1 = out[2];
	*out2 = out[3];
	*result = (status == AE_OK) ? out[0] : HCI_FAILURE;
	return status;
}

struct toshiba_acpi_dev {
	struct platform_device *p_dev;
	struct rfkill *bt_rfk;
	struct rfkill *wwan_rfk;
	struct input_dev *hotkey_dev;
	acpi_handle handle;

	const char *bt_name;
	const char *wwan_name;

	struct mutex mutex;
};

static struct toshiba_acpi_dev toshiba_acpi = {
	.bt_name = "Toshiba Bluetooth",
	.wwan_name = "Toshiba WWAN",
};

/* Bluetooth rfkill handlers */

static u32 hci_get_bt_present(bool *present)
{
	u32 hci_result;
	u32 value, value2;

	value = 0;
	value2 = 0;
	hci_read2(HCI_WIRELESS, &value, &value2, &hci_result);
	if (hci_result == HCI_SUCCESS)
		*present = (value & HCI_WIRELESS_BT_PRESENT) ? true : false;

	return hci_result;
}

static u32 hci_get_radio_state(bool *radio_state)
{
	u32 hci_result;
	u32 value, value2;

	value = 0;
	value2 = 0x0001;
	hci_read2(HCI_WIRELESS, &value, &value2, &hci_result);

	*radio_state = value & HCI_WIRELESS_KILL_SWITCH;
	return hci_result;
}

static int bt_rfkill_set_block(void *data, bool blocked)
{
	struct toshiba_acpi_dev *dev = data;
	u32 result1, result2;
	u32 value;
	int err;
	bool radio_state;

	value = (blocked == false);

	mutex_lock(&dev->mutex);
	if (hci_get_radio_state(&radio_state) != HCI_SUCCESS) {
		err = -EBUSY;
		goto out;
	}

	if (!radio_state) {
		err = 0;
		goto out;
	}

	hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_BT_POWER, &result1);
	hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_BT_ATTACH, &result2);

	if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
		err = -EBUSY;
	else
		err = 0;
 out:
	mutex_unlock(&dev->mutex);
	return err;
}

static void bt_rfkill_poll(struct rfkill *rfkill, void *data)
{
	bool new_rfk_state;
	bool value;
	u32 hci_result;
	struct toshiba_acpi_dev *dev = data;

	mutex_lock(&dev->mutex);

	hci_result = hci_get_radio_state(&value);
	if (hci_result != HCI_SUCCESS) {
		/* Can't do anything useful */
		mutex_unlock(&dev->mutex);
		return;
	}

	new_rfk_state = value;

	mutex_unlock(&dev->mutex);

	if (rfkill_set_hw_state(rfkill, !new_rfk_state))
		bt_rfkill_set_block(data, true);
}

/*----------------------------------------------------------------*/


static u32 hci_get_wwan_present(bool *present)
{
	u32 hci_result;
	u32 value, value2;

	value = 0;
	value2 = 0;
	hci_read2(HCI_WIRELESS, &value, &value2, &hci_result);
	if (hci_result == HCI_SUCCESS)
		*present = (value & HCI_WIRELESS_WWAN_PRESENT) ? true : false;

	return hci_result;
}

static int wwan_rfkill_set_block(void *data, bool blocked)
{
	struct toshiba_acpi_dev *dev = data;
	u32 result1, result2;
	u32 value;
	int err;
	bool radio_state;

	value = (blocked == false);

	mutex_lock(&dev->mutex);
	if (hci_get_radio_state(&radio_state) != HCI_SUCCESS) {
		err = -EBUSY;
		goto out;
	}

	if (!radio_state) {
		err = 0;
		goto out;
	}

	hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_WWAN_POWER, &result1);
	hci_write2(HCI_WIRELESS, value, HCI_WIRELESS_WWAN_ATTACH, &result2);

	if (result1 != HCI_SUCCESS || result2 != HCI_SUCCESS)
		err = -EBUSY;
	else
		err = 0;
 out:
	mutex_unlock(&dev->mutex);
	return err;
}

static void wwan_rfkill_poll(struct rfkill *rfkill, void *data)
{
	bool new_rfk_state;
	bool value;
	u32 hci_result;
	struct toshiba_acpi_dev *dev = data;

	mutex_lock(&dev->mutex);

	hci_result = hci_get_radio_state(&value);
	if (hci_result != HCI_SUCCESS) {
		/* Can't do anything useful */
		mutex_unlock(&dev->mutex);
		return;
	}

	new_rfk_state = value;

	mutex_unlock(&dev->mutex);

	if (rfkill_set_hw_state(rfkill, !new_rfk_state))
		wwan_rfkill_set_block(data, true);
}

/* ------------------------------------------------------- */

static const struct rfkill_ops toshiba_rfk_ops = {
	.set_block = bt_rfkill_set_block,
	.poll = bt_rfkill_poll,
};

static const struct rfkill_ops toshiba_rfk_ops_wwan = {
	.set_block = wwan_rfkill_set_block,
	.poll = wwan_rfkill_poll,
};


static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
static struct backlight_device *toshiba_backlight_device;
static int force_fan;
static int last_key_event;
static int key_event_valid;

static int get_lcd(struct backlight_device *bd)
{
	u32 hci_result;
	u32 value;

	hci_read1(HCI_LCD_BRIGHTNESS, &value, &hci_result);
	if (hci_result == HCI_SUCCESS) {
		return (value >> HCI_LCD_BRIGHTNESS_SHIFT);
	} else
		return -EFAULT;
}

static int lcd_proc_show(struct seq_file *m, void *v)
{
	int value = get_lcd(NULL);

	if (value >= 0) {
		seq_printf(m, "brightness:              %d\n", value);
		seq_printf(m, "brightness_levels:       %d\n",
			     HCI_LCD_BRIGHTNESS_LEVELS);
	} else {
		printk(MY_ERR "Error reading LCD brightness\n");
	}

	return 0;
}

static int lcd_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, lcd_proc_show, NULL);
}

static int set_lcd(int value)
{
	u32 hci_result;

	value = value << HCI_LCD_BRIGHTNESS_SHIFT;
	hci_write1(HCI_LCD_BRIGHTNESS, value, &hci_result);
	if (hci_result != HCI_SUCCESS)
		return -EFAULT;

	return 0;
}

static int set_lcd_status(struct backlight_device *bd)
{
	return set_lcd(bd->props.brightness);
}

static ssize_t lcd_proc_write(struct file *file, const char __user *buf,
			      size_t count, loff_t *pos)
{
	char cmd[42];
	size_t len;
	int value;
	int ret;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	if (sscanf(cmd, " brightness : %i", &value) == 1 &&
	    value >= 0 && value < HCI_LCD_BRIGHTNESS_LEVELS) {
		ret = set_lcd(value);
		if (ret == 0)
			ret = count;
	} else {
		ret = -EINVAL;
	}
	return ret;
}

static const struct file_operations lcd_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= lcd_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= lcd_proc_write,
};

static int video_proc_show(struct seq_file *m, void *v)
{
	u32 hci_result;
	u32 value;

	hci_read1(HCI_VIDEO_OUT, &value, &hci_result);
	if (hci_result == HCI_SUCCESS) {
		int is_lcd = (value & HCI_VIDEO_OUT_LCD) ? 1 : 0;
		int is_crt = (value & HCI_VIDEO_OUT_CRT) ? 1 : 0;
		int is_tv = (value & HCI_VIDEO_OUT_TV) ? 1 : 0;
		seq_printf(m, "lcd_out:                 %d\n", is_lcd);
		seq_printf(m, "crt_out:                 %d\n", is_crt);
		seq_printf(m, "tv_out:                  %d\n", is_tv);
	} else {
		printk(MY_ERR "Error reading video out status\n");
	}

	return 0;
}

static int video_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, video_proc_show, NULL);
}

static ssize_t video_proc_write(struct file *file, const char __user *buf,
				size_t count, loff_t *pos)
{
	char *cmd, *buffer;
	int value;
	int remain = count;
	int lcd_out = -1;
	int crt_out = -1;
	int tv_out = -1;
	u32 hci_result;
	u32 video_out;

	cmd = kmalloc(count + 1, GFP_KERNEL);
	if (!cmd)
		return -ENOMEM;
	if (copy_from_user(cmd, buf, count)) {
		kfree(cmd);
		return -EFAULT;
	}
	cmd[count] = '\0';

	buffer = cmd;

	/* scan expression.  Multiple expressions may be delimited with ;
	 *
	 *  NOTE: to keep scanning simple, invalid fields are ignored
	 */
	while (remain) {
		if (sscanf(buffer, " lcd_out : %i", &value) == 1)
			lcd_out = value & 1;
		else if (sscanf(buffer, " crt_out : %i", &value) == 1)
			crt_out = value & 1;
		else if (sscanf(buffer, " tv_out : %i", &value) == 1)
			tv_out = value & 1;
		/* advance to one character past the next ; */
		do {
			++buffer;
			--remain;
		}
		while (remain && *(buffer - 1) != ';');
	}

	kfree(cmd);

	hci_read1(HCI_VIDEO_OUT, &video_out, &hci_result);
	if (hci_result == HCI_SUCCESS) {
		unsigned int new_video_out = video_out;
		if (lcd_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_LCD, lcd_out);
		if (crt_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_CRT, crt_out);
		if (tv_out != -1)
			_set_bit(&new_video_out, HCI_VIDEO_OUT_TV, tv_out);
		/* To avoid unnecessary video disruption, only write the new
		 * video setting if something changed. */
		if (new_video_out != video_out)
			write_acpi_int(METHOD_VIDEO_OUT, new_video_out);
	} else {
		return -EFAULT;
	}

	return count;
}

static const struct file_operations video_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= video_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= video_proc_write,
};

static int fan_proc_show(struct seq_file *m, void *v)
{
	u32 hci_result;
	u32 value;

	hci_read1(HCI_FAN, &value, &hci_result);
	if (hci_result == HCI_SUCCESS) {
		seq_printf(m, "running:                 %d\n", (value > 0));
		seq_printf(m, "force_on:                %d\n", force_fan);
	} else {
		printk(MY_ERR "Error reading fan status\n");
	}

	return 0;
}

static int fan_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, fan_proc_show, NULL);
}

static ssize_t fan_proc_write(struct file *file, const char __user *buf,
			      size_t count, loff_t *pos)
{
	char cmd[42];
	size_t len;
	int value;
	u32 hci_result;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	if (sscanf(cmd, " force_on : %i", &value) == 1 &&
	    value >= 0 && value <= 1) {
		hci_write1(HCI_FAN, value, &hci_result);
		if (hci_result != HCI_SUCCESS)
			return -EFAULT;
		else
			force_fan = value;
	} else {
		return -EINVAL;
	}

	return count;
}

static const struct file_operations fan_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= fan_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= fan_proc_write,
};

static int keys_proc_show(struct seq_file *m, void *v)
{
	u32 hci_result;
	u32 value;

	if (!key_event_valid) {
		hci_read1(HCI_SYSTEM_EVENT, &value, &hci_result);
		if (hci_result == HCI_SUCCESS) {
			key_event_valid = 1;
			last_key_event = value;
		} else if (hci_result == HCI_EMPTY) {
			/* better luck next time */
		} else if (hci_result == HCI_NOT_SUPPORTED) {
			/* This is a workaround for an unresolved issue on
			 * some machines where system events sporadically
			 * become disabled. */
			hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
			printk(MY_NOTICE "Re-enabled hotkeys\n");
		} else {
			printk(MY_ERR "Error reading hotkey status\n");
			goto end;
		}
	}

	seq_printf(m, "hotkey_ready:            %d\n", key_event_valid);
	seq_printf(m, "hotkey:                  0x%04x\n", last_key_event);
end:
	return 0;
}

static int keys_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, keys_proc_show, NULL);
}

static ssize_t keys_proc_write(struct file *file, const char __user *buf,
			       size_t count, loff_t *pos)
{
	char cmd[42];
	size_t len;
	int value;

	len = min(count, sizeof(cmd) - 1);
	if (copy_from_user(cmd, buf, len))
		return -EFAULT;
	cmd[len] = '\0';

	if (sscanf(cmd, " hotkey_ready : %i", &value) == 1 && value == 0) {
		key_event_valid = 0;
	} else {
		return -EINVAL;
	}

	return count;
}

static const struct file_operations keys_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= keys_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
	.write		= keys_proc_write,
};

static int version_proc_show(struct seq_file *m, void *v)
{
	seq_printf(m, "driver:                  %s\n", TOSHIBA_ACPI_VERSION);
	seq_printf(m, "proc_interface:          %d\n", PROC_INTERFACE_VERSION);
	return 0;
}

static int version_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, version_proc_show, PDE(inode)->data);
}

static const struct file_operations version_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= version_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

/* proc and module init
 */

#define PROC_TOSHIBA		"toshiba"

static acpi_status __init add_device(void)
{
	proc_create("lcd", S_IRUGO | S_IWUSR, toshiba_proc_dir, &lcd_proc_fops);
	proc_create("video", S_IRUGO | S_IWUSR, toshiba_proc_dir, &video_proc_fops);
	proc_create("fan", S_IRUGO | S_IWUSR, toshiba_proc_dir, &fan_proc_fops);
	proc_create("keys", S_IRUGO | S_IWUSR, toshiba_proc_dir, &keys_proc_fops);
	proc_create("version", S_IRUGO, toshiba_proc_dir, &version_proc_fops);

	return AE_OK;
}

static acpi_status remove_device(void)
{
	remove_proc_entry("lcd", toshiba_proc_dir);
	remove_proc_entry("video", toshiba_proc_dir);
	remove_proc_entry("fan", toshiba_proc_dir);
	remove_proc_entry("keys", toshiba_proc_dir);
	remove_proc_entry("version", toshiba_proc_dir);
	return AE_OK;
}

static struct backlight_ops toshiba_backlight_data = {
        .get_brightness = get_lcd,
        .update_status  = set_lcd_status,
};

static struct key_entry *toshiba_acpi_get_entry_by_scancode(unsigned int code)
{
	struct key_entry *key;

	for (key = toshiba_acpi_keymap; key->type != KE_END; key++)
		if (code == key->code)
			return key;

	return NULL;
}

static struct key_entry *toshiba_acpi_get_entry_by_keycode(unsigned int code)
{
	struct key_entry *key;

	for (key = toshiba_acpi_keymap; key->type != KE_END; key++)
		if (code == key->keycode && key->type == KE_KEY)
			return key;

	return NULL;
}

static int toshiba_acpi_getkeycode(struct input_dev *dev,
				   unsigned int scancode, unsigned int *keycode)
{
	struct key_entry *key = toshiba_acpi_get_entry_by_scancode(scancode);

	if (key && key->type == KE_KEY) {
		*keycode = key->keycode;
		return 0;
	}

	return -EINVAL;
}

static int toshiba_acpi_setkeycode(struct input_dev *dev,
				   unsigned int scancode, unsigned int keycode)
{
	struct key_entry *key;
	unsigned int old_keycode;

	key = toshiba_acpi_get_entry_by_scancode(scancode);
	if (key && key->type == KE_KEY) {
		old_keycode = key->keycode;
		key->keycode = keycode;
		set_bit(keycode, dev->keybit);
		if (!toshiba_acpi_get_entry_by_keycode(old_keycode))
			clear_bit(old_keycode, dev->keybit);
		return 0;
	}

	return -EINVAL;
}

static void toshiba_acpi_notify(acpi_handle handle, u32 event, void *context)
{
	u32 hci_result, value;
	struct key_entry *key;

	if (event != 0x80)
		return;
	do {
		hci_read1(HCI_SYSTEM_EVENT, &value, &hci_result);
		if (hci_result == HCI_SUCCESS) {
			if (value == 0x100)
				continue;
			/* act on key press; ignore key release */
			if (value & 0x80)
				continue;

			key = toshiba_acpi_get_entry_by_scancode
				(value);
			if (!key) {
				printk(MY_INFO "Unknown key %x\n",
				       value);
				continue;
			}
			input_report_key(toshiba_acpi.hotkey_dev,
					 key->keycode, 1);
			input_sync(toshiba_acpi.hotkey_dev);
			input_report_key(toshiba_acpi.hotkey_dev,
					 key->keycode, 0);
			input_sync(toshiba_acpi.hotkey_dev);
		} else if (hci_result == HCI_NOT_SUPPORTED) {
			/* This is a workaround for an unresolved issue on
			 * some machines where system events sporadically
			 * become disabled. */
			hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
			printk(MY_NOTICE "Re-enabled hotkeys\n");
		}
	} while (hci_result != HCI_EMPTY);
}

static int toshiba_acpi_setup_keyboard(char *device)
{
	acpi_status status;
	acpi_handle handle;
	int result;
	const struct key_entry *key;

	status = acpi_get_handle(NULL, device, &handle);
	if (ACPI_FAILURE(status)) {
		printk(MY_INFO "Unable to get notification device\n");
		return -ENODEV;
	}

	toshiba_acpi.handle = handle;

	status = acpi_evaluate_object(handle, "ENAB", NULL, NULL);
	if (ACPI_FAILURE(status)) {
		printk(MY_INFO "Unable to enable hotkeys\n");
		return -ENODEV;
	}

	status = acpi_install_notify_handler(handle, ACPI_DEVICE_NOTIFY,
					      toshiba_acpi_notify, NULL);
	if (ACPI_FAILURE(status)) {
		printk(MY_INFO "Unable to install hotkey notification\n");
		return -ENODEV;
	}

	toshiba_acpi.hotkey_dev = input_allocate_device();
	if (!toshiba_acpi.hotkey_dev) {
		printk(MY_INFO "Unable to register input device\n");
		return -ENOMEM;
	}

	toshiba_acpi.hotkey_dev->name = "Toshiba input device";
	toshiba_acpi.hotkey_dev->phys = device;
	toshiba_acpi.hotkey_dev->id.bustype = BUS_HOST;
	toshiba_acpi.hotkey_dev->getkeycode = toshiba_acpi_getkeycode;
	toshiba_acpi.hotkey_dev->setkeycode = toshiba_acpi_setkeycode;

	for (key = toshiba_acpi_keymap; key->type != KE_END; key++) {
		set_bit(EV_KEY, toshiba_acpi.hotkey_dev->evbit);
		set_bit(key->keycode, toshiba_acpi.hotkey_dev->keybit);
	}

	result = input_register_device(toshiba_acpi.hotkey_dev);
	if (result) {
		printk(MY_INFO "Unable to register input device\n");
		return result;
	}

	return 0;
}

static void toshiba_acpi_exit(void)
{
	if (toshiba_acpi.hotkey_dev)
		input_unregister_device(toshiba_acpi.hotkey_dev);

	if (toshiba_acpi.bt_rfk) {
		rfkill_unregister(toshiba_acpi.bt_rfk);
		rfkill_destroy(toshiba_acpi.bt_rfk);
	}

	if (toshiba_acpi.wwan_rfk) {
		rfkill_unregister(toshiba_acpi.wwan_rfk);
		rfkill_destroy(toshiba_acpi.wwan_rfk);
	}

	if (toshiba_backlight_device)
		backlight_device_unregister(toshiba_backlight_device);

	remove_device();

	if (toshiba_proc_dir)
		remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);

	acpi_remove_notify_handler(toshiba_acpi.handle, ACPI_DEVICE_NOTIFY,
				   toshiba_acpi_notify);

	platform_device_unregister(toshiba_acpi.p_dev);

	return;
}

static int __init toshiba_acpi_init(void)
{
	acpi_status status = AE_OK;
	u32 hci_result;
	bool bt_present;
	bool wwan_present;
	int ret = 0;
	struct backlight_properties props;

	if (acpi_disabled)
		return -ENODEV;

	/* simple device detection: look for HCI method */
	if (is_valid_acpi_path(TOSH_INTERFACE_1 GHCI_METHOD)) {
		method_hci = TOSH_INTERFACE_1 GHCI_METHOD;
		if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_1))
			printk(MY_INFO "Unable to activate hotkeys\n");
	} else if (is_valid_acpi_path(TOSH_INTERFACE_2 GHCI_METHOD)) {
		method_hci = TOSH_INTERFACE_2 GHCI_METHOD;
		if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_2))
			printk(MY_INFO "Unable to activate hotkeys\n");
	} else
		return -ENODEV;

	printk(MY_INFO "Toshiba Laptop ACPI Extras version %s\n",
	       TOSHIBA_ACPI_VERSION);
	printk(MY_INFO "    HCI method: %s\n", method_hci);

	mutex_init(&toshiba_acpi.mutex);

	toshiba_acpi.p_dev = platform_device_register_simple("toshiba_acpi",
							      -1, NULL, 0);
	if (IS_ERR(toshiba_acpi.p_dev)) {
		ret = PTR_ERR(toshiba_acpi.p_dev);
		printk(MY_ERR "unable to register platform device\n");
		toshiba_acpi.p_dev = NULL;
		toshiba_acpi_exit();
		return ret;
	}

	force_fan = 0;
	key_event_valid = 0;

	/* enable event fifo */
	hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);

	toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
	if (!toshiba_proc_dir) {
		toshiba_acpi_exit();
		return -ENODEV;
	} else {
		status = add_device();
		if (ACPI_FAILURE(status)) {
			toshiba_acpi_exit();
			return -ENODEV;
		}
	}

	props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;
	toshiba_backlight_device = backlight_device_register("toshiba",
							     &toshiba_acpi.p_dev->dev,
							     NULL,
							     &toshiba_backlight_data,
							     &props);
        if (IS_ERR(toshiba_backlight_device)) {
		ret = PTR_ERR(toshiba_backlight_device);

		printk(KERN_ERR "Could not register toshiba backlight device\n");
		toshiba_backlight_device = NULL;
		toshiba_acpi_exit();
		return ret;
	}

	/* Register rfkill switch for Bluetooth */
	if (hci_get_bt_present(&bt_present) == HCI_SUCCESS && bt_present) {
		toshiba_acpi.bt_rfk = rfkill_alloc(toshiba_acpi.bt_name,
						   &toshiba_acpi.p_dev->dev,
						   RFKILL_TYPE_BLUETOOTH,
						   &toshiba_rfk_ops,
						   &toshiba_acpi);
		if (!toshiba_acpi.bt_rfk) {
			printk(MY_ERR "unable to allocate rfkill device\n");
			toshiba_acpi_exit();
			return -ENOMEM;
		}

		ret = rfkill_register(toshiba_acpi.bt_rfk);
		if (ret) {
			printk(MY_ERR "unable to register rfkill device\n");
			rfkill_destroy(toshiba_acpi.bt_rfk);
			toshiba_acpi_exit();
			return ret;
		}
	}

	/* Register rfkill switch for WWAN */
	if (hci_get_wwan_present(&wwan_present) == HCI_SUCCESS && wwan_present) {
		toshiba_acpi.wwan_rfk = rfkill_alloc(toshiba_acpi.wwan_name,
						   &toshiba_acpi.p_dev->dev,
						   RFKILL_TYPE_WWAN,
						   &toshiba_rfk_ops_wwan,
						   &toshiba_acpi);
		if (!toshiba_acpi.wwan_rfk) {
			printk(MY_ERR "unable to allocate WWAN rfkill device\n");
			toshiba_acpi_exit();
			return -ENOMEM;
		}

		ret = rfkill_register(toshiba_acpi.wwan_rfk);
		if (ret) {
			printk(MY_ERR "unable to register WWAN rfkill device\n");
			rfkill_destroy(toshiba_acpi.wwan_rfk);
			toshiba_acpi_exit();
			return ret;
		}
	}





	return 0;
}

module_init(toshiba_acpi_init);
module_exit(toshiba_acpi_exit);

The post Sorgente modulo kernel toshiba_acpi appeared first on Esperto Informatico - Bruno Aleci.

admin@Exbyte

Rekonq … sempre meglio.

02-07-2013 19:01

Rekonq (2.3.2) nato come browser per l’ambiente KDE, si sta rivelando un ottimo browser (basato su WebKit) sempre più stabile, veloce e ricco di feauires. Il progetto nato grazie ad Andrea Diamantini ha un agguerrito gruppo di sviluppatori che stanno portando avanti un ottimo lavoro.

Fra le features notiamo il tab browsing (ormai assimilato da tutti), la navigazione in incognito e l’integrazione degli ad-block.

Di originale dobbiamo notare la preview sui tab (cosa che nessun altro browser offre) ed una pagina iniziale molto più dinamica e personalizzabile rispetto a quelle di firefox o chrome. La barra di navigazione non ha ancora tutte le funzionalità della concorrenza, in particolare manca ancora la possibilità di scrivere un termine di ricerca (ma non penso che dobbiamo aspettare ancora molto).

Che manca davvero a rekonq sono le estensioni, sopratutto non sarebbe male avere l’integrazione con quelle di altri browser. Ma anche su questo fronte si stanno muovendo verso il supporto delle estensioni di chrome: http://adjamblog.wordpress.com/2013/05/21/rekonq-working-on-extension-support/

Per quanto riguarda la navigazione e l’interpretazione delle pagine, posso solo dire che non si notano errori di rendering e la velocità è più che buona e che è migliorata di molto rispetto alle prime versioni.

Qualche problema persiste ancora con WebGl, in particolare con le demo di chromeexperimets, mentre con le demo ufficiali non ho notato problemi di sorta, ed in genere posso dire che con WebGl la velocità di rendering è migliore rispetto a firefox.

L’unica conclusione da fare è che  se va avanti cosi stiamo per avere un browser open-source indipendente  per piattaforma Linux che potrà affiancarsi senza complessi ai più blasonati firefox o chrome.

Per gli sviluppi futuri dobbiamo solo vedere se vorranno restare su WebKik o passare a quello che sembra essere il suo successore: Blink.


firef@Barone Rosso

Script gestione modem Toshiba F3507g Mobile Broadband Module

26-06-2013 23:20

Questo script serve per gestire il modem Toshiba  F3507g Mobile Broadband Module

#!/bin/bash
#######################################################################
# Script per la gestione modem Toshiba F3507g Mobile Broadband Module #
# creato da Aleci Bruno <brunoaleci@gmail.com>                        #
#######################################################################

USB_ID="0930:130b"
PIN=""
APN="web.omnitel.it"

GPSDPID="/var/run/gpsd.pid"

RFKILL_DEVICE=$(
  for n in /sys/devices/platform/toshiba_acpi/rfkill/rfkill*; 
      do 
         if [ "$(cat $n/name)" = "Toshiba WWAN" ]; then 
           echo $n/state;
         fi; 
      done
)

CONTROL_DEVICE () { 
  echo /dev/$(
    for n in /sys/class/tty/ttyACM*/device/interface;
        do 
        if [ "$(cat $n)" = "Toshiba F3507g Mobile Broadband Data Modem" ]; then 
           echo $n|awk -F '/' '{print $5}'; 
        fi; 
    done;
    )
}

GPS_DEVICE () { 
  echo /dev/$(
    for n in /sys/class/tty/ttyACM*/device/interface;
        do 
        if [ "$(cat $n)" = "Toshiba F3507g Mobile Broadband GPS Port" ]; then 
          echo $n|awk -F '/' '{print $5}';
        fi; 
    done
    )
}

function waitmodem() {
  /usr/sbin/chat -v "" "OK" "*EMRDY: 1"  < $(CONTROL_DEVICE);	
}


function checkroot() {
   if [[ $(whoami) != root ]]; then {
      sudo $0 $*
      exit 0
   } fi
}

powerup_F3507g () {
	echo -n "Powering up F3507g card "
	echo 1 > $RFKILL_DEVICE
	while [ -z "$(lsusb -d $USB_ID)" ]; do sleep 0.5; echo -n "."; done
	waitmodem

	echo "done"
	echo -n "Turning on F3507g card on ..."
	sleep 3
	if [ -n "$PIN" ]; then
	    /usr/sbin/chat -v "" "AT+CPIN?" "SIM PIN" "AT" "OK" "AT+CPIN=\"$PIN\"" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	fi
	/usr/sbin/chat -v "" "AT+CFUN=1" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	echo "done"
}

powerdown_F3507g () {
	echo -n "Turning off F3507g card on ..."
	/usr/sbin/chat -v "" "AT+CFUN=4" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	echo "done"
	echo -n "Powering down F3507g card ..."
	echo 0 > $RFKILL_DEVICE
	while [ -n "$(lsusb -d $USB_ID)" ]; do sleep 0.5; echo -n "."; done
	echo "done"
}

configure_GPS () {
	/usr/sbin/chat -v "" "AT*E2GPSCTL=$1,$2,$3" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
}

turnon_GPS () {
	echo -n "Starting NMEA stream on ..."
	configure_GPS 1 1 1
	sleep 1
	/usr/sbin/chat -v "" "AT*E2GPSNPD" "GPGGA" > $(GPS_DEVICE) < $(GPS_DEVICE)
	start-stop-daemon --start --exec /usr/sbin/gpsd -- -P $GPSDPID $(GPS_DEVICE)
	echo "done"
}

turnoff_GPS () {
	echo -n "Stopping NMEA stream on ..."
	start-stop-daemon --stop --pidfile $GPSDPID
	configure_GPS 0 1 0
	echo "done"
}

turnon_WWAN () {
	echo -n "Starting WWAN connection on ..."
	/usr/sbin/chat -v "" "AT+CGDCONT=1,\"IP\",\"$APN\"" "OK" "AT*ENAP=1,1" "OK" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	echo "done"
}

turnoff_WWAN () {
	echo -n "Stopping WWAN connection on ..."
	/usr/sbin/chat -v "" "AT*ENAP=0" > $(CONTROL_DEVICE) < $(CONTROL_DEVICE)
	echo "done"
}

if [[ $1 == powerup ]]; then {
   checkroot $*
   powerup_F3507g 
} fi
if [[ $1 == powerdown ]]; then {
   checkroot $*
   powerdown_F3507g
} fi

if [[ $1 == on_gps ]]; then {
   checkroot $*
   turnon_GPS  
} fi
if [[ $1 == off_gps ]]; then {
   checkroot $*
   turnoff_GPS  
} fi

if [[ $1 == on_wwan ]]; then {
   checkroot $*
   turnon_WWAN  
} fi
if [[ $1 == off_wwan ]]; then {
   checkroot $*
   turnoff_WWAN  
} fi


if [ $# -ne 1 ]
then
  echo "Uso: `basename $0` [AZIONE]"
  echo "AZIONE: "
  echo -e "\tpowerup accendere il modem"
  echo -e "\tpowerdown spegnere il modem"
  echo -e "\ton_gps accendere il GPS"
  echo -e "\toff_gps spegnere il GPS"
  echo -e "\ton_wwan connetti alla rete $APN"
  echo -e "\toff_wwan disconetti dalla rere $APN"
 
  exit $E_BADARGS
fi

The post Script gestione modem Toshiba F3507g Mobile Broadband Module appeared first on Esperto Informatico - Bruno Aleci.

admin@Exbyte

Notizie • Aggiornamento a nuova versione Grub 2.00

23-06-2013 14:30

Con l'aggiornamelo alla nuova versione di GRUB v2.00 vengono eliminati i pacchetti grub-bios e grub-common. I file di configurazione /etc/default/grub e /boot/grub.cfg verranno salvati come /etc/default/grub.pacsave e /boot/grub.cfg.pacsave , ma solo quest'ultimo verrà ri-copiato in modo da preservare le configurazioni, in modo tale da non avere problemi al successivo riavvio.

Nel caso utilizziate kernel personalizzati dovrete controllare /etc/default/grub e confrontarlo con /etc/default/grub.pacsave, nel caso modificarlo in base alle vostre esigenze e rigenerare un nuovo grub.cfg se necessario.


Buona Arch.

Statistiche: Inviato da veleno77 — 23 giugno 2013, 16:30


veleno77@Arch News

Notizie • Lo spostamento dei file binari in /usr/bin richiede un intervento manuale dell'utente durante l'aggiornamento.

04-06-2013 12:29

Durante il prossimo aggiornamento, verrà visualizzato un messaggio del tipo:
Code:
error: failed to commit transaction (conflicting files)
filesystem: /bin exists in filesystem

Questo aggiornamento unifica tutte le directory di file binari all'interno di /usr/bin. Questo passaggio elimina una distinzione che è sempre stata inutile per un sistema Arch e facilita la manutenzione dei pacchetti. Consultare questo post per avere un'idea delle ragioni che hanno portato a questo cambiamento.

Le seguenti istruzioni dovrebbero garantire un aggiornamento senza intoppi:

1) sistemare ogni pacchetto non ufficiale contenente file in /bin, /sbin o /usr/sbin facendo in modo che li installi tutti all'interno di /usr/bin. La lista dei pacchetti che non sono in un repo e che devono essere modificati può essere generata con:
Code:
$ pacman -Qqo /bin /sbin /usr/sbin | pacman -Qm -

2) Assicurarsi che ogni pacchetto in IgnorePkg ed IgnoreGroup non abbia file all'interno di /bin, /sbin, o /usr/sbin. Correggerli se necessario.
3) Se sono presenti file all'interno di /bin, /sbin, o /usr/sbin che non appartengono ad alcun pacchetto, è necessario spostarli. Per ottenerne una lista, eseguire:
Code:
$ find /bin /sbin /usr/sbin -exec pacman -Qo -- {} + >/dev/null

4) Assicurarsi che tutte le partizioni siano montate se si utilizza autofs. Il loro montaggio automatico potrebbe non funzionare correttamente quando richiesto in una fase successiva del'aggiornamento.
5) Aggiornare il sistema.
Prima di eseguire questo aggiornamento, è consigliabile mantenere aperto un secondo terminale con privilegi da superutente, nella sfortunata evenienza qualcosa dovesse andare storto, sopratutto se si sta effettuando un aggiornamento da SSH.
Code:
# pacman -Syu --ignore filesystem,bash
# pacman -S bash
# pacman -Su

Statistiche: Inviato da 4javier — 4 giugno 2013, 14:29


4javier@Arch News

Arch Linux e l’ultimo aggiornamento: note sparse

03-06-2013 23:10

Qualche decina di minuti fa, preso da un irrefrenabile impulso per le cose pericolosamente fighe a mezzanotte e mezza con un occhio aperto e uno chiuso, mi sono preso il portatile e carezzandolo amorevolmente ho aggiornato Arch Linux, eseguendo l’update di cui si vociferava in giro che accorpa un sacco di roba (al momento non ho ricordi precisi, ho sonno) tra cui le varie /usr/bin, /usr/sbin, /vattelapesca/soreta/sbin, in un’unica directory.

Linux

Visto che è una roba strana e pericolosa, e che a me come al solito è andata parecchio liscia, lascio qualche nota sparsa ai “bambini meno fortunati di me”, come li chiamava mia nonna, perché è sempre bene indicare la via ai nuovi adepti (dato che altrove gli archer vengono tacciati di essere una setta, e dato che probabilmente lo siamo: la setta dei Tafazzi).

  • Occhio a quello che fate: questo aggiornamento vi può spaccare il sistema e se non sapete quello che state facendo con ogni singolo comando della procedura, lo dico per voi, cambiate spassionatamente distro oppure passate direttamente a Windows che fate prima;
  • Occhio ai pacchetti che lasciano roba dentro le directory di cui fare il merge: potete controllare di non avere nemmeno un capello fuori posto con dei check specifici elencati nella news di riferimento;
  • Se l’aggiornamento non vuole proseguire non è perché avete un computer capriccioso: non forzate assolutamente l’upgrade o rischiate di trovarvi davanti alla faccia un fermacarte, nel mio caso con un ottimo monitor da 15″ e una ottima tastiera a isola. Ma se non aggiustate poi con parecchie bestemmie, rimane un fermacarte. Anche se è vero che, se forzate l’upgrade in circostanze simili, forse dovreste pensare a una conseguenza come quella del punto 1 (si, lo so, non li sto numerando ma tanto fate voi).

Adesso vado a letto ché c’ho sonno e voglio leggermi un po’ dei libri di Martin. Mi raccomando, non spaccate il PC, voglio continuare a credere nella bontà del genere umano.

Sinceramente, a titolo del tutto personale, vorrei sperare di non ritrovarmi ugualmente domani con un fermacarte in mano: Arch Linux mi piace, ma questi aggiornamenti un po’ buttati così (premesso che ho voglia di gestirli, comunque) certe volte fanno girare las pelotas, e non poco.

Photo courtesy of Richard Alexander Caraballo

Bl@ster@Blaster

Notizie • netctl è adesso in [core]

10-04-2013 15:32

netctl è un programma CLI basato su profili di rete che utilizza systemd. Nel prossimo futuro, il vecchio netcfg sarà rimosso da [core]. Chiunque ancora lo utilizzi, è invitato ad installare netctl. La migrazione richiede un processo manuale durante il quale potreste non avere accesso ad internet, per cui fate attenzione e leggete le pagine man (netctl (1), netctl.profile (5) e netctl.special (7)).

Il design di netctl è tale che gli appassionati di systemd apprezzeranno il suo utilizzo e gli utenti di netcfg avranno familiarità con i suoi file di configurazione. Con netctl viene fornito anche un assistente di connessione wifi ncurses-based, chiamato wifi-menu.

Quando installerete netctl, netcfg sarà rimosso, ma i servizi systemd abilitati rimarranno fino a quando non saranno disattivati manualmente. Il wiki di netctl contiene alcune informazioni aggiuntive inerenti alla migrazione da netcfg.

Florian Pritz

Statistiche: Inviato da Giovanni — 10 aprile 2013, 17:32


Giovanni@Arch News

Notizie • MariaDB rimpiazza MySQL nei repository

26-03-2013 16:25

MariaDB è adesso ufficialmente la nostra implementazione di default di MySQL. MariaDB è quasi un rimpiazzo, per cui dovrebbe essere possibile sostituirlo senza particolari problemi. Tuttavia, a causa di problemi di compatibilità rimanenti, non è possibile sostituirlo automaticamente.

L'aggiornamento è consigliato a tutti gli utenti. Nell'arco di un mese, MySQL sarà spostato dai repository ufficiali ad AUR.

Gli utenti che intendono passare a MariaDB devono installare mariadb, libmariadbclient o mariadb-clients ed eseguire mysql_upgrade.

Esempio di migrazione:

# systemctl stop mysqld
# pacman -S mariadb libmariadbclient mariadb-clients
# systemctl start mysqld
# mysql_upgrade -p

percona-server è un altro fork di MySQL disponibile in [community]. Dovrebbe essere simile ad Oracle MySQL Enterprise, ma mancano le nuove funzionalità incluse in MariaDB.

Insieme a mysql 5.5.30-7 in [extra], tutti i pacchetti che dipendono da esso sono stati ricompilati con MariaDB. I manutentori dei pacchetti dovrebbero modificare le loro dipendenze per i pacchetti di MariaDB.

Maggiori informazioni possono essere trovate nella nostra mailing list.

Bartłomiej Piotrowski

Statistiche: Inviato da Giovanni — 26 marzo 2013, 18:25


Giovanni@Arch News

Notizie • qt4 rimpiazza qt

01-03-2013 20:15

Un nuovo pacchetto, qt4, è in [extra]. Rimpiazzerà l'attuale pacchetto qt.

Tutti i pacchetti che dipendono da qt devono essere ricompilati per usare qt4. Abbiamo ricompilato tutti i pacchetti nei repository ufficiali, ma voi dovrete ricompilare quelli installati tramite AUR e che dipendono da qt.

Inoltre, Qt 5.x è ora disponibile in [extra]. Quando installate sia qt5-base che qt4 nel vostro sistema, qualsiasi strumento di qt farà riferimento alla versione 5.x. Per questo motivo, sono disponibili dei link simbolici *-qt4, in modo da forzare esplicitatamente la versione 4.x, quando ne avete bisogno.

Andrea Scarpino

Statistiche: Inviato da ilpianista — 1 marzo 2013, 22:15


ilpianista@Arch News

Terminali Drop Down GTK2 -> GTK3

24-02-2013 13:54

Se state pensando di migrare a un sistema only GTK3, o anche se solo volete avere 2 alternative per terminali drop down (per me indispensabili) che usano le famose librerie nella versione “classica” o in quella “moderna”,
personalmente mi trovo molto bene con

Tilda (GTK2) – presente in Community e AUR per la versione git
e il nuovo
Terra (GTK3) – presente in AUR la sola versione bzr (è ancora in via di sviluppo)

molto simili, rapidi e leggeri. Perfetti secondo me

berseker86@Berseker

Notizie • Modifiche a LVM

12-02-2013 17:19

Con lvm2 2.02.98-3, ora utilizziamo lvmetad per attivare automaticamente i volumi LVM. Ciò implica le seguenti modifiche:

1) l'hook initramfs di lvm2 adesso richiede l'hook udev.
2) use_lvmetad = 1 deve essere impostato in /etc/lvm/lvm.conf. Questo adesso è il valore di default, se avete un file lvm.conf.pacnew, dovete apportare questa modifica.
3) Potete limitare i volumi che sono attivati automaticamente, impostando l'opzione auto_activation_volume_list in /etc/lvm/lvm.conf. In caso di dubbio, lasciate questa opzione commentata.
4) Se avete bisogno di monitorare (necessario per gli snapshot), eseguite systemctl enable lvm-monitoring.service.
5) L'opzione della riga di comando del kernel lvmwait non è più necessaria e non ha effetto.

Thomas Bächler

Statistiche: Inviato da Giovanni — 12 febbraio 2013, 19:19


Giovanni@Arch News

Arch Linux Planet Italia

Arch Linux Planet Italia è una finestra sul mondo, vita e lavoro degli sviluppatori e degli hacker di Arch Linux.

Ultimo aggiornamento: 23-10-2014 14:21. Tutti gli orari sono espressi in UTC.